mirror of
https://github.com/winfsp/winfsp.git
synced 2025-07-26 20:42:50 -05:00
Major refactoring: WIP
This commit is contained in:
20
src0/dll/debug.c
Normal file
20
src0/dll/debug.c
Normal file
@@ -0,0 +1,20 @@
|
||||
/**
|
||||
* @file dll/debug.c
|
||||
*
|
||||
* @copyright 2015 Bill Zissimopoulos
|
||||
*/
|
||||
|
||||
#include <dll/library.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
FSP_API VOID FspDebugLog(const char *format, ...)
|
||||
{
|
||||
char buf[1024];
|
||||
/* DbgPrint has a 512 byte limit, but wvsprintf is only safe with a 1024 byte buffer */
|
||||
va_list ap;
|
||||
va_start(ap, format);
|
||||
wvsprintfA(buf, format, ap);
|
||||
va_end(ap);
|
||||
buf[sizeof buf - 1] = '\0';
|
||||
OutputDebugStringA(buf);
|
||||
}
|
268
src0/dll/fsctl.c
Normal file
268
src0/dll/fsctl.c
Normal file
@@ -0,0 +1,268 @@
|
||||
/**
|
||||
* @file dll/fsctl.c
|
||||
*
|
||||
* @copyright 2015 Bill Zissimopoulos
|
||||
*/
|
||||
|
||||
#include <dll/library.h>
|
||||
#if !defined(NDEBUG)
|
||||
#include <sddl.h>
|
||||
#endif
|
||||
|
||||
#define GLOBALROOT L"\\\\?\\GLOBALROOT"
|
||||
|
||||
static inline VOID GlobalDevicePath(PWCHAR DevicePathBuf, SIZE_T DevicePathSize, PWSTR DevicePath)
|
||||
{
|
||||
PWSTR DeviceRoot = L'\\' == DevicePath[0] ? GLOBALROOT : GLOBALROOT "\\Device\\";
|
||||
SIZE_T RootSize = lstrlenW(DeviceRoot) * sizeof(WCHAR);
|
||||
SIZE_T PathSize = lstrlenW(DevicePath) * sizeof(WCHAR) + sizeof(WCHAR);
|
||||
|
||||
if (RootSize + PathSize <= DevicePathSize)
|
||||
{
|
||||
memcpy(DevicePathBuf, DeviceRoot, RootSize);
|
||||
memcpy((PUINT8)DevicePathBuf + RootSize, DevicePath, PathSize);
|
||||
}
|
||||
else
|
||||
/* we should be doing assert(sizeof(WCHAR) <= DevicePathSize), but we don't have assert! */
|
||||
DevicePathBuf[0] = L'\0';
|
||||
}
|
||||
|
||||
static NTSTATUS CreateSelfRelativeSecurityDescriptor(PSECURITY_DESCRIPTOR SecurityDescriptor,
|
||||
PSECURITY_DESCRIPTOR *PSelfRelativeSecurityDescriptor, PDWORD PSelfRelativeSecurityDescriptorSize)
|
||||
{
|
||||
NTSTATUS Result;
|
||||
BOOLEAN Success;
|
||||
PSECURITY_DESCRIPTOR SelfRelativeSecurityDescriptor = 0;
|
||||
DWORD SelfRelativeSecurityDescriptorSize;
|
||||
SECURITY_DESCRIPTOR_CONTROL SecurityDescriptorControl;
|
||||
DWORD SecurityDescriptorRevision;
|
||||
SECURITY_DESCRIPTOR SecurityDescriptorStruct;
|
||||
PTOKEN_USER User = 0;
|
||||
PACL Acl = 0;
|
||||
DWORD UserSize = 0;
|
||||
DWORD AclSize = 0;
|
||||
HANDLE Token = 0;
|
||||
|
||||
*PSelfRelativeSecurityDescriptor = 0;
|
||||
*PSelfRelativeSecurityDescriptorSize = 0;
|
||||
|
||||
if (0 == SecurityDescriptor)
|
||||
{
|
||||
Success =
|
||||
OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &Token) &&
|
||||
(GetTokenInformation(Token, TokenUser, 0, 0, &UserSize) ||
|
||||
ERROR_INSUFFICIENT_BUFFER == GetLastError()) &&
|
||||
(User = MemAllocSLE(UserSize)) &&
|
||||
GetTokenInformation(Token, TokenUser, User, UserSize, &UserSize) &&
|
||||
(AclSize = sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE) + GetLengthSid(User->User.Sid) - sizeof(DWORD)) &&
|
||||
(Acl = MemAllocSLE(AclSize)) &&
|
||||
InitializeAcl(Acl, AclSize, ACL_REVISION) &&
|
||||
AddAccessAllowedAce(Acl, ACL_REVISION, FILE_ALL_ACCESS, User->User.Sid) &&
|
||||
InitializeSecurityDescriptor(&SecurityDescriptorStruct, SECURITY_DESCRIPTOR_REVISION) &&
|
||||
SetSecurityDescriptorDacl(&SecurityDescriptorStruct, TRUE, Acl, FALSE) &&
|
||||
SetSecurityDescriptorControl(&SecurityDescriptorStruct, SE_DACL_PROTECTED, SE_DACL_PROTECTED);
|
||||
if (!Success)
|
||||
{
|
||||
Result = FspNtStatusFromWin32(GetLastError());
|
||||
goto exit;
|
||||
}
|
||||
SecurityDescriptor = &SecurityDescriptorStruct;
|
||||
}
|
||||
|
||||
if (!GetSecurityDescriptorControl(SecurityDescriptor,
|
||||
&SecurityDescriptorControl, &SecurityDescriptorRevision))
|
||||
{
|
||||
Result = FspNtStatusFromWin32(GetLastError());
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (SecurityDescriptorControl & SE_SELF_RELATIVE)
|
||||
{
|
||||
SelfRelativeSecurityDescriptorSize = GetSecurityDescriptorLength(SecurityDescriptor);
|
||||
Success =
|
||||
(SelfRelativeSecurityDescriptor = MemAllocSLE(SelfRelativeSecurityDescriptorSize)) &&
|
||||
memcpy(SelfRelativeSecurityDescriptor, SecurityDescriptor, SelfRelativeSecurityDescriptorSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
SelfRelativeSecurityDescriptorSize = 0;
|
||||
Success =
|
||||
(MakeSelfRelativeSD(SecurityDescriptor, 0, &SelfRelativeSecurityDescriptorSize) ||
|
||||
ERROR_INSUFFICIENT_BUFFER == GetLastError()) &&
|
||||
(SelfRelativeSecurityDescriptor = MemAllocSLE(SelfRelativeSecurityDescriptorSize)) &&
|
||||
(MakeSelfRelativeSD(SecurityDescriptor, SelfRelativeSecurityDescriptor, &SelfRelativeSecurityDescriptorSize));
|
||||
}
|
||||
if (!Success)
|
||||
{
|
||||
Result = FspNtStatusFromWin32(GetLastError());
|
||||
goto exit;
|
||||
}
|
||||
|
||||
*PSelfRelativeSecurityDescriptor = SelfRelativeSecurityDescriptor;
|
||||
*PSelfRelativeSecurityDescriptorSize = SelfRelativeSecurityDescriptorSize;
|
||||
Result = STATUS_SUCCESS;
|
||||
|
||||
exit:
|
||||
if (0 != Token)
|
||||
CloseHandle(Token);
|
||||
|
||||
MemFree(Acl);
|
||||
MemFree(User);
|
||||
|
||||
if (STATUS_SUCCESS != Result)
|
||||
MemFree(SelfRelativeSecurityDescriptor);
|
||||
|
||||
return Result;
|
||||
}
|
||||
|
||||
FSP_API NTSTATUS FspFsctlCreateVolume(PWSTR DevicePath,
|
||||
const FSP_FSCTL_VOLUME_PARAMS *Params, PSECURITY_DESCRIPTOR SecurityDescriptor,
|
||||
PWCHAR VolumePathBuf, SIZE_T VolumePathSize)
|
||||
{
|
||||
NTSTATUS Result = STATUS_SUCCESS;
|
||||
PSECURITY_DESCRIPTOR SelfRelativeSecurityDescriptor = 0;
|
||||
DWORD SelfRelativeSecurityDescriptorSize;
|
||||
FSP_FSCTL_VOLUME_PARAMS *ParamsBuf = 0;
|
||||
WCHAR DevicePathBuf[MAX_PATH];
|
||||
HANDLE DeviceHandle = INVALID_HANDLE_VALUE;
|
||||
DWORD Bytes;
|
||||
|
||||
if (sizeof(WCHAR) <= VolumePathSize)
|
||||
VolumePathBuf[0] = L'\0';
|
||||
|
||||
Result = CreateSelfRelativeSecurityDescriptor(SecurityDescriptor,
|
||||
&SelfRelativeSecurityDescriptor, &SelfRelativeSecurityDescriptorSize);
|
||||
if (!NT_SUCCESS(Result))
|
||||
goto exit;
|
||||
|
||||
ParamsBuf = MemAlloc(FSP_FSCTL_VOLUME_PARAMS_SIZE + SelfRelativeSecurityDescriptorSize);
|
||||
if (0 == ParamsBuf)
|
||||
{
|
||||
Result = STATUS_INSUFFICIENT_RESOURCES;
|
||||
goto exit;
|
||||
}
|
||||
memset(ParamsBuf, 0, FSP_FSCTL_VOLUME_PARAMS_SIZE);
|
||||
*ParamsBuf = *Params;
|
||||
memcpy((PUINT8)ParamsBuf + FSP_FSCTL_VOLUME_PARAMS_SIZE,
|
||||
SelfRelativeSecurityDescriptor, SelfRelativeSecurityDescriptorSize);
|
||||
|
||||
GlobalDevicePath(DevicePathBuf, sizeof DevicePathBuf, DevicePath);
|
||||
|
||||
#if !defined(NDEBUG)
|
||||
{
|
||||
PSTR Sddl;
|
||||
if (ConvertSecurityDescriptorToStringSecurityDescriptorA(SelfRelativeSecurityDescriptor,
|
||||
SDDL_REVISION_1,
|
||||
OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
|
||||
&Sddl, 0))
|
||||
{
|
||||
DEBUGLOG("Device=\"%S\", Sddl=\"%s\", SdSize=%lu",
|
||||
DevicePathBuf, Sddl, SelfRelativeSecurityDescriptorSize);
|
||||
LocalFree(Sddl);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
DeviceHandle = CreateFileW(DevicePathBuf,
|
||||
0, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
|
||||
if (INVALID_HANDLE_VALUE == DeviceHandle)
|
||||
{
|
||||
Result = FspNtStatusFromWin32(GetLastError());
|
||||
if (STATUS_OBJECT_NAME_NOT_FOUND == Result)
|
||||
Result = STATUS_NO_SUCH_DEVICE;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!DeviceIoControl(DeviceHandle, FSP_FSCTL_CREATE,
|
||||
ParamsBuf, FSP_FSCTL_VOLUME_PARAMS_SIZE + SelfRelativeSecurityDescriptorSize,
|
||||
VolumePathBuf, (DWORD)VolumePathSize,
|
||||
&Bytes, 0))
|
||||
{
|
||||
Result = FspNtStatusFromWin32(GetLastError());
|
||||
goto exit;
|
||||
}
|
||||
|
||||
exit:
|
||||
|
||||
if (INVALID_HANDLE_VALUE != DeviceHandle)
|
||||
CloseHandle(DeviceHandle);
|
||||
|
||||
MemFree(ParamsBuf);
|
||||
MemFree(SelfRelativeSecurityDescriptor);
|
||||
|
||||
return Result;
|
||||
}
|
||||
|
||||
FSP_API NTSTATUS FspFsctlOpenVolume(PWSTR VolumePath,
|
||||
PHANDLE PVolumeHandle)
|
||||
{
|
||||
NTSTATUS Result = STATUS_SUCCESS;
|
||||
WCHAR DevicePathBuf[MAX_PATH];
|
||||
HANDLE VolumeHandle;
|
||||
|
||||
*PVolumeHandle = 0;
|
||||
|
||||
GlobalDevicePath(DevicePathBuf, sizeof DevicePathBuf, VolumePath);
|
||||
|
||||
DEBUGLOG("Device=\"%S\"", DevicePathBuf);
|
||||
|
||||
VolumeHandle = CreateFileW(DevicePathBuf,
|
||||
0, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
|
||||
if (INVALID_HANDLE_VALUE == VolumeHandle)
|
||||
{
|
||||
Result = FspNtStatusFromWin32(GetLastError());
|
||||
if (STATUS_OBJECT_NAME_NOT_FOUND == Result)
|
||||
Result = STATUS_NO_SUCH_DEVICE;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
*PVolumeHandle = VolumeHandle;
|
||||
|
||||
exit:
|
||||
return Result;
|
||||
}
|
||||
|
||||
FSP_API NTSTATUS FspFsctlDeleteVolume(HANDLE VolumeHandle)
|
||||
{
|
||||
NTSTATUS Result = STATUS_SUCCESS;
|
||||
DWORD Bytes;
|
||||
|
||||
if (!DeviceIoControl(VolumeHandle, FSP_FSCTL_DELETE,
|
||||
0, 0, 0, 0,
|
||||
&Bytes, 0))
|
||||
{
|
||||
Result = FspNtStatusFromWin32(GetLastError());
|
||||
goto exit;
|
||||
}
|
||||
|
||||
exit:
|
||||
return Result;
|
||||
}
|
||||
|
||||
FSP_API NTSTATUS FspFsctlTransact(HANDLE VolumeHandle,
|
||||
PVOID ResponseBuf, SIZE_T ResponseBufSize,
|
||||
PVOID RequestBuf, SIZE_T *PRequestBufSize)
|
||||
{
|
||||
NTSTATUS Result = STATUS_SUCCESS;
|
||||
DWORD Bytes = 0;
|
||||
|
||||
if (0 != PRequestBufSize)
|
||||
{
|
||||
Bytes = (DWORD)*PRequestBufSize;
|
||||
*PRequestBufSize = 0;
|
||||
}
|
||||
|
||||
if (!DeviceIoControl(VolumeHandle, FSP_FSCTL_TRANSACT,
|
||||
ResponseBuf, (DWORD)ResponseBufSize, RequestBuf, Bytes,
|
||||
&Bytes, 0))
|
||||
{
|
||||
Result = FspNtStatusFromWin32(GetLastError());
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (0 != PRequestBufSize)
|
||||
*PRequestBufSize = Bytes;
|
||||
|
||||
exit:
|
||||
return Result;
|
||||
}
|
31
src0/dll/library.c
Normal file
31
src0/dll/library.c
Normal file
@@ -0,0 +1,31 @@
|
||||
/**
|
||||
* @file dll/library.c
|
||||
*
|
||||
* @copyright 2015 Bill Zissimopoulos
|
||||
*/
|
||||
|
||||
#include <dll/library.h>
|
||||
|
||||
HANDLE ProcessHeap;
|
||||
|
||||
BOOL WINAPI DllMain(HINSTANCE Instance, DWORD Reason, PVOID Reserved)
|
||||
{
|
||||
switch (Reason)
|
||||
{
|
||||
case DLL_PROCESS_ATTACH:
|
||||
ProcessHeap = GetProcessHeap();
|
||||
if (0 == ProcessHeap)
|
||||
return FALSE;
|
||||
break;
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/* see comments in library.h */
|
||||
#if defined(WINFSP_DLL_NODEFAULTLIB)
|
||||
BOOL WINAPI _DllMainCRTStartup(HINSTANCE Instance, DWORD Reason, PVOID Reserved)
|
||||
{
|
||||
return DllMain(Instance, Reason, Reserved);
|
||||
}
|
||||
#endif
|
75
src0/dll/library.h
Normal file
75
src0/dll/library.h
Normal file
@@ -0,0 +1,75 @@
|
||||
/**
|
||||
* @file dll/library.h
|
||||
*
|
||||
* @copyright 2015 Bill Zissimopoulos
|
||||
*/
|
||||
|
||||
#ifndef WINFSP_DLL_LIBRARY_H_INCLUDED
|
||||
#define WINFSP_DLL_LIBRARY_H_INCLUDED
|
||||
|
||||
#define WINFSP_DLL_INTERNAL
|
||||
#include <winfsp/winfsp.h>
|
||||
#include <strsafe.h>
|
||||
|
||||
#define LIBRARY_NAME "WinFsp"
|
||||
|
||||
/* DEBUGLOG */
|
||||
#if !defined(NDEBUG)
|
||||
#define DEBUGLOG(fmt, ...) \
|
||||
FspDebugLog("[U] " LIBRARY_NAME "!" __FUNCTION__ ": " fmt "\n", __VA_ARGS__)
|
||||
#else
|
||||
#define DEBUGLOG(fmt, ...) ((void)0)
|
||||
#endif
|
||||
|
||||
static inline PVOID MemAlloc(SIZE_T Size)
|
||||
{
|
||||
extern HANDLE ProcessHeap;
|
||||
return HeapAlloc(ProcessHeap, 0, Size);
|
||||
}
|
||||
static inline PVOID MemAllocSLE(SIZE_T Size)
|
||||
{
|
||||
extern HANDLE ProcessHeap;
|
||||
PVOID Pointer = HeapAlloc(ProcessHeap, 0, Size);
|
||||
if (0 == Pointer)
|
||||
SetLastError(ERROR_NO_SYSTEM_RESOURCES);
|
||||
return Pointer;
|
||||
}
|
||||
static inline VOID MemFree(PVOID Pointer)
|
||||
{
|
||||
extern HANDLE ProcessHeap;
|
||||
if (0 != Pointer)
|
||||
HeapFree(ProcessHeap, 0, Pointer);
|
||||
}
|
||||
|
||||
/*
|
||||
* Define WINFSP_DLL_NODEFAULTLIB to eliminate dependency on the MSVCRT libraries.
|
||||
*
|
||||
* For this to work the following project settings must be set:
|
||||
* - "C/C++ > General > SDL checks" must be empty (not "Yes" or "No").
|
||||
* - "C/C++ > Code Generation > Basic Runtime Checks" must be set to "Default"
|
||||
* - "C/C++ > Code Generation > Security Check" must be disabled (/GS-).
|
||||
* - "Linker > Input > Ignore All Default Libraries" must be "Yes".
|
||||
*/
|
||||
#if defined(WINFSP_DLL_NODEFAULTLIB)
|
||||
#undef RtlFillMemory
|
||||
#undef RtlMoveMemory
|
||||
NTSYSAPI VOID NTAPI RtlFillMemory(VOID *Destination, DWORD Length, BYTE Fill);
|
||||
NTSYSAPI VOID NTAPI RtlMoveMemory(VOID *Destination, CONST VOID *Source, DWORD Length);
|
||||
|
||||
#pragma function(memcpy)
|
||||
#pragma function(memset)
|
||||
static inline
|
||||
void *memcpy(void *dst, const void *src, size_t siz)
|
||||
{
|
||||
RtlMoveMemory(dst, src, (DWORD)siz);
|
||||
return dst;
|
||||
}
|
||||
static inline
|
||||
void *memset(void *dst, int val, size_t siz)
|
||||
{
|
||||
RtlFillMemory(dst, (DWORD)siz, val);
|
||||
return dst;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
173
src0/dll/loop.c
Normal file
173
src0/dll/loop.c
Normal file
@@ -0,0 +1,173 @@
|
||||
/**
|
||||
* @file dll/loop.c
|
||||
*
|
||||
* @copyright 2015 Bill Zissimopoulos
|
||||
*/
|
||||
|
||||
#include <dll/library.h>
|
||||
|
||||
typedef struct _FSP_WORK_ITEM
|
||||
{
|
||||
FSP_FILE_SYSTEM *FileSystem;
|
||||
__declspec(align(MEMORY_ALLOCATION_ALIGNMENT)) UINT8 RequestBuf[];
|
||||
} FSP_WORK_ITEM;
|
||||
|
||||
FSP_API NTSTATUS FspFileSystemCreate(PWSTR DevicePath,
|
||||
const FSP_FSCTL_VOLUME_PARAMS *Params, FSP_FILE_SYSTEM_PROCESSREQ *ProcessRequest,
|
||||
FSP_FILE_SYSTEM **PFileSystem)
|
||||
{
|
||||
NTSTATUS Result;
|
||||
WCHAR VolumePathBuf[MAX_PATH];
|
||||
HANDLE VolumeHandle = INVALID_HANDLE_VALUE;
|
||||
FSP_FILE_SYSTEM *FileSystem = 0;
|
||||
|
||||
*PFileSystem = 0;
|
||||
|
||||
if (0 == ProcessRequest)
|
||||
ProcessRequest = FspProcessRequestDirect;
|
||||
|
||||
FileSystem = MemAlloc(sizeof *FileSystem);
|
||||
if (0 == FileSystem)
|
||||
{
|
||||
Result = STATUS_INSUFFICIENT_RESOURCES;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
Result = FspFsctlCreateVolume(DevicePath, Params, 0, VolumePathBuf, sizeof VolumePathBuf);
|
||||
if (!NT_SUCCESS(Result))
|
||||
goto exit;
|
||||
|
||||
Result = FspFsctlOpenVolume(VolumePathBuf, &VolumeHandle);
|
||||
if (!NT_SUCCESS(Result))
|
||||
goto exit;
|
||||
|
||||
memset(FileSystem, 0, sizeof *FileSystem);
|
||||
FileSystem->VolumeHandle = VolumeHandle;
|
||||
FileSystem->ProcessRequest = ProcessRequest;
|
||||
*PFileSystem = FileSystem;
|
||||
|
||||
Result = STATUS_SUCCESS;
|
||||
|
||||
exit:
|
||||
if (!NT_SUCCESS(Result))
|
||||
{
|
||||
if (INVALID_HANDLE_VALUE != VolumeHandle)
|
||||
CloseHandle(VolumeHandle);
|
||||
MemFree(FileSystem);
|
||||
}
|
||||
|
||||
return Result;
|
||||
}
|
||||
|
||||
FSP_API VOID FspFileSystemDelete(FSP_FILE_SYSTEM *FileSystem)
|
||||
{
|
||||
if (INVALID_HANDLE_VALUE != FileSystem->VolumeHandle)
|
||||
CloseHandle(FileSystem->VolumeHandle);
|
||||
MemFree(FileSystem);
|
||||
}
|
||||
|
||||
FSP_API NTSTATUS FspFileSystemLoop(FSP_FILE_SYSTEM *FileSystem)
|
||||
{
|
||||
NTSTATUS Result;
|
||||
PUINT8 RequestBuf, RequestBufEnd;
|
||||
SIZE_T RequestBufSize;
|
||||
FSP_FSCTL_TRANSACT_REQ *Request, *NextRequest;
|
||||
|
||||
RequestBuf = MemAlloc(FSP_FSCTL_TRANSACT_REQ_BUFFER_SIZEMIN);
|
||||
if (0 == RequestBuf)
|
||||
return STATUS_INSUFFICIENT_RESOURCES;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
RequestBufSize = FSP_FSCTL_TRANSACT_REQ_BUFFER_SIZEMIN;
|
||||
Result = FspFsctlTransact(FileSystem->VolumeHandle, 0, 0, RequestBuf, &RequestBufSize);
|
||||
if (!NT_SUCCESS(Result))
|
||||
goto exit;
|
||||
RequestBufEnd = RequestBuf + RequestBufSize;
|
||||
|
||||
Request = (PVOID)RequestBuf;
|
||||
for (;;)
|
||||
{
|
||||
NextRequest = FspFsctlTransactConsumeRequest(Request, RequestBufEnd);
|
||||
if (0 == NextRequest)
|
||||
break;
|
||||
|
||||
Result = FileSystem->ProcessRequest(FileSystem, Request);
|
||||
if (!NT_SUCCESS(Result))
|
||||
goto exit;
|
||||
|
||||
Request = NextRequest;
|
||||
}
|
||||
}
|
||||
|
||||
exit:
|
||||
MemFree(RequestBuf);
|
||||
|
||||
return Result;
|
||||
}
|
||||
|
||||
FSP_API NTSTATUS FspProcessRequestDirect(FSP_FILE_SYSTEM *FileSystem,
|
||||
FSP_FSCTL_TRANSACT_REQ *Request)
|
||||
{
|
||||
if (FspFsctlTransactKindCount <= Request->Kind || 0 == FileSystem->Operations[Request->Kind])
|
||||
return FspProduceResponseWithStatus(FileSystem, Request, STATUS_INVALID_DEVICE_REQUEST);
|
||||
|
||||
FileSystem->Operations[Request->Kind](FileSystem, Request);
|
||||
return STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
static DWORD WINAPI FspProcessRequestInPoolWorker(PVOID Param)
|
||||
{
|
||||
FSP_WORK_ITEM *WorkItem = Param;
|
||||
FSP_FSCTL_TRANSACT_REQ *Request = (PVOID)WorkItem->RequestBuf;
|
||||
|
||||
WorkItem->FileSystem->Operations[Request->Kind](WorkItem->FileSystem, Request);
|
||||
MemFree(WorkItem);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
FSP_API NTSTATUS FspProcessRequestInPool(FSP_FILE_SYSTEM *FileSystem,
|
||||
FSP_FSCTL_TRANSACT_REQ *Request)
|
||||
{
|
||||
if (FspFsctlTransactKindCount <= Request->Kind || 0 == FileSystem->Operations[Request->Kind])
|
||||
return FspProduceResponseWithStatus(FileSystem, Request, STATUS_INVALID_DEVICE_REQUEST);
|
||||
|
||||
FSP_WORK_ITEM *WorkItem;
|
||||
BOOLEAN Success;
|
||||
|
||||
WorkItem = MemAlloc(sizeof *WorkItem + Request->Size);
|
||||
if (0 == WorkItem)
|
||||
return STATUS_INSUFFICIENT_RESOURCES;
|
||||
|
||||
WorkItem->FileSystem = FileSystem;
|
||||
memcpy(WorkItem->RequestBuf, Request, Request->Size);
|
||||
|
||||
Success = QueueUserWorkItem(FspProcessRequestInPoolWorker, WorkItem, WT_EXECUTEDEFAULT);
|
||||
if (!Success)
|
||||
{
|
||||
NTSTATUS Result0 = FspNtStatusFromWin32(GetLastError());
|
||||
MemFree(WorkItem);
|
||||
return Result0;
|
||||
}
|
||||
|
||||
return STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
FSP_API NTSTATUS FspProduceResponse(FSP_FILE_SYSTEM *FileSystem,
|
||||
FSP_FSCTL_TRANSACT_RSP *Response)
|
||||
{
|
||||
return FspFsctlTransact(FileSystem->VolumeHandle, Response, Response->Size, 0, 0);
|
||||
}
|
||||
|
||||
FSP_API NTSTATUS FspProduceResponseWithStatus(FSP_FILE_SYSTEM *FileSystem,
|
||||
FSP_FSCTL_TRANSACT_REQ *Request, NTSTATUS Result)
|
||||
{
|
||||
FSP_FSCTL_TRANSACT_RSP Response;
|
||||
memset(&Response, 0, sizeof Response);
|
||||
Response.Size = sizeof Response;
|
||||
Response.Kind = Request->Kind;
|
||||
Response.Hint = Request->Hint;
|
||||
Response.IoStatus.Status = Result;
|
||||
return FspProduceResponse(FileSystem, &Response);
|
||||
}
|
17
src0/dll/ntstatus.c
Normal file
17
src0/dll/ntstatus.c
Normal file
@@ -0,0 +1,17 @@
|
||||
/**
|
||||
* @file dll/ntstatus.c
|
||||
*
|
||||
* @copyright 2015 Bill Zissimopoulos
|
||||
*/
|
||||
|
||||
#include <dll/library.h>
|
||||
|
||||
FSP_API NTSTATUS FspNtStatusFromWin32(DWORD Error)
|
||||
{
|
||||
switch (Error)
|
||||
{
|
||||
#include "ntstatus.i"
|
||||
default:
|
||||
return STATUS_ACCESS_DENIED;
|
||||
}
|
||||
}
|
621
src0/dll/ntstatus.i
Normal file
621
src0/dll/ntstatus.i
Normal file
@@ -0,0 +1,621 @@
|
||||
case EPT_S_CANT_CREATE: return EPT_NT_CANT_CREATE;
|
||||
case EPT_S_CANT_PERFORM_OP: return EPT_NT_CANT_PERFORM_OP;
|
||||
case EPT_S_INVALID_ENTRY: return EPT_NT_INVALID_ENTRY;
|
||||
case EPT_S_NOT_REGISTERED: return EPT_NT_NOT_REGISTERED;
|
||||
case ERROR_ACCESS_DENIED: return STATUS_ACCESS_DENIED;
|
||||
case ERROR_ACCESS_DISABLED_BY_POLICY: return STATUS_ACCESS_DISABLED_BY_POLICY_OTHER;
|
||||
case ERROR_ACCOUNT_DISABLED: return STATUS_ACCOUNT_DISABLED;
|
||||
case ERROR_ACCOUNT_EXPIRED: return STATUS_ACCOUNT_EXPIRED;
|
||||
case ERROR_ACCOUNT_LOCKED_OUT: return STATUS_ACCOUNT_LOCKED_OUT;
|
||||
case ERROR_ACCOUNT_RESTRICTION: return STATUS_ACCOUNT_RESTRICTION;
|
||||
case ERROR_ACTIVE_CONNECTIONS: return STATUS_ALREADY_DISCONNECTED;
|
||||
case ERROR_ADAP_HDW_ERR: return STATUS_ADAPTER_HARDWARE_ERROR;
|
||||
case ERROR_ADDRESS_ALREADY_ASSOCIATED: return STATUS_ADDRESS_ALREADY_ASSOCIATED;
|
||||
case ERROR_ADDRESS_NOT_ASSOCIATED: return STATUS_ADDRESS_NOT_ASSOCIATED;
|
||||
case ERROR_ALIAS_EXISTS: return STATUS_ALIAS_EXISTS;
|
||||
case ERROR_ALLOTTED_SPACE_EXCEEDED: return STATUS_ALLOTTED_SPACE_EXCEEDED;
|
||||
case ERROR_ALREADY_EXISTS: return STATUS_OBJECT_NAME_COLLISION;
|
||||
case ERROR_ARITHMETIC_OVERFLOW: return STATUS_INTEGER_OVERFLOW;
|
||||
case ERROR_AUDITING_DISABLED: return STATUS_AUDITING_DISABLED;
|
||||
case ERROR_BADDB: return STATUS_REGISTRY_CORRUPT;
|
||||
case ERROR_BAD_COMMAND: return STATUS_INVALID_DEVICE_STATE;
|
||||
case ERROR_BAD_DESCRIPTOR_FORMAT: return STATUS_BAD_DESCRIPTOR_FORMAT;
|
||||
case ERROR_BAD_DEV_TYPE: return STATUS_BAD_DEVICE_TYPE;
|
||||
case ERROR_BAD_DRIVER: return STATUS_DRIVER_UNABLE_TO_LOAD;
|
||||
case ERROR_BAD_EXE_FORMAT: return STATUS_INVALID_IMAGE_FORMAT;
|
||||
case ERROR_BAD_IMPERSONATION_LEVEL: return STATUS_BAD_IMPERSONATION_LEVEL;
|
||||
case ERROR_BAD_INHERITANCE_ACL: return STATUS_BAD_INHERITANCE_ACL;
|
||||
case ERROR_BAD_LENGTH: return STATUS_INFO_LENGTH_MISMATCH;
|
||||
case ERROR_BAD_LOGON_SESSION_STATE: return STATUS_BAD_LOGON_SESSION_STATE;
|
||||
case ERROR_BAD_NETPATH: return STATUS_BAD_NETWORK_PATH;
|
||||
case ERROR_BAD_NET_NAME: return STATUS_BAD_NETWORK_NAME;
|
||||
case ERROR_BAD_NET_RESP: return STATUS_INVALID_NETWORK_RESPONSE;
|
||||
case ERROR_BAD_PATHNAME: return STATUS_OBJECT_PATH_INVALID;
|
||||
case ERROR_BAD_PIPE: return STATUS_INVALID_PIPE_STATE;
|
||||
case ERROR_BAD_REM_ADAP: return STATUS_BAD_REMOTE_ADAPTER;
|
||||
case ERROR_BAD_TOKEN_TYPE: return STATUS_BAD_TOKEN_TYPE;
|
||||
case ERROR_BAD_VALIDATION_CLASS: return STATUS_BAD_VALIDATION_CLASS;
|
||||
case ERROR_BEGINNING_OF_MEDIA: return STATUS_BEGINNING_OF_MEDIA;
|
||||
case ERROR_BROKEN_PIPE: return STATUS_PIPE_BROKEN;
|
||||
case ERROR_BUSY: return STATUS_DEVICE_BUSY;
|
||||
case ERROR_BUS_RESET: return STATUS_BUS_RESET;
|
||||
case ERROR_CANNOT_IMPERSONATE: return STATUS_CANNOT_IMPERSONATE;
|
||||
case ERROR_CANNOT_MAKE: return STATUS_CANNOT_MAKE;
|
||||
case ERROR_CANT_ACCESS_DOMAIN_INFO: return STATUS_CANT_ACCESS_DOMAIN_INFO;
|
||||
case ERROR_CANT_ACCESS_FILE: return STATUS_IO_REPARSE_TAG_NOT_HANDLED;
|
||||
case ERROR_CANT_DISABLE_MANDATORY: return STATUS_CANT_DISABLE_MANDATORY;
|
||||
case ERROR_CANT_OPEN_ANONYMOUS: return STATUS_CANT_OPEN_ANONYMOUS;
|
||||
case ERROR_CANT_RESOLVE_FILENAME: return STATUS_REPARSE_POINT_NOT_RESOLVED;
|
||||
case ERROR_CHILD_MUST_BE_VOLATILE: return STATUS_CHILD_MUST_BE_VOLATILE;
|
||||
case ERROR_CLEANER_CARTRIDGE_INSTALLED: return STATUS_CLEANER_CARTRIDGE_INSTALLED;
|
||||
case ERROR_CLUSTER_INVALID_NETWORK: return STATUS_CLUSTER_INVALID_NETWORK;
|
||||
case ERROR_CLUSTER_INVALID_NETWORK_PROVIDER: return STATUS_CLUSTER_INVALID_NETWORK_PROVIDER;
|
||||
case ERROR_CLUSTER_INVALID_NODE: return STATUS_CLUSTER_INVALID_NODE;
|
||||
case ERROR_CLUSTER_INVALID_REQUEST: return STATUS_CLUSTER_INVALID_REQUEST;
|
||||
case ERROR_CLUSTER_JOIN_IN_PROGRESS: return STATUS_CLUSTER_JOIN_IN_PROGRESS;
|
||||
case ERROR_CLUSTER_JOIN_NOT_IN_PROGRESS: return STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS;
|
||||
case ERROR_CLUSTER_LOCAL_NODE_NOT_FOUND: return STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND;
|
||||
case ERROR_CLUSTER_NETINTERFACE_EXISTS: return STATUS_CLUSTER_NETINTERFACE_EXISTS;
|
||||
case ERROR_CLUSTER_NETINTERFACE_NOT_FOUND: return STATUS_CLUSTER_NETINTERFACE_NOT_FOUND;
|
||||
case ERROR_CLUSTER_NETWORK_ALREADY_OFFLINE: return STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE;
|
||||
case ERROR_CLUSTER_NETWORK_ALREADY_ONLINE: return STATUS_CLUSTER_NETWORK_ALREADY_ONLINE;
|
||||
case ERROR_CLUSTER_NETWORK_EXISTS: return STATUS_CLUSTER_NETWORK_EXISTS;
|
||||
case ERROR_CLUSTER_NETWORK_NOT_FOUND: return STATUS_CLUSTER_NETWORK_NOT_FOUND;
|
||||
case ERROR_CLUSTER_NETWORK_NOT_INTERNAL: return STATUS_CLUSTER_NETWORK_NOT_INTERNAL;
|
||||
case ERROR_CLUSTER_NODE_ALREADY_DOWN: return STATUS_CLUSTER_NODE_ALREADY_DOWN;
|
||||
case ERROR_CLUSTER_NODE_ALREADY_MEMBER: return STATUS_CLUSTER_NODE_ALREADY_MEMBER;
|
||||
case ERROR_CLUSTER_NODE_ALREADY_UP: return STATUS_CLUSTER_NODE_ALREADY_UP;
|
||||
case ERROR_CLUSTER_NODE_DOWN: return STATUS_CLUSTER_NODE_DOWN;
|
||||
case ERROR_CLUSTER_NODE_EXISTS: return STATUS_CLUSTER_NODE_EXISTS;
|
||||
case ERROR_CLUSTER_NODE_NOT_FOUND: return STATUS_CLUSTER_NODE_NOT_FOUND;
|
||||
case ERROR_CLUSTER_NODE_NOT_MEMBER: return STATUS_CLUSTER_NODE_NOT_MEMBER;
|
||||
case ERROR_CLUSTER_NODE_NOT_PAUSED: return STATUS_CLUSTER_NODE_NOT_PAUSED;
|
||||
case ERROR_CLUSTER_NODE_PAUSED: return STATUS_CLUSTER_NODE_PAUSED;
|
||||
case ERROR_CLUSTER_NODE_UNREACHABLE: return STATUS_CLUSTER_NODE_UNREACHABLE;
|
||||
case ERROR_CLUSTER_NODE_UP: return STATUS_CLUSTER_NODE_UP;
|
||||
case ERROR_CLUSTER_NO_SECURITY_CONTEXT: return STATUS_CLUSTER_NO_SECURITY_CONTEXT;
|
||||
case ERROR_COMMITMENT_LIMIT: return STATUS_COMMITMENT_LIMIT;
|
||||
case ERROR_CONNECTION_ABORTED: return STATUS_CONNECTION_ABORTED;
|
||||
case ERROR_CONNECTION_ACTIVE: return STATUS_CONNECTION_ACTIVE;
|
||||
case ERROR_CONNECTION_COUNT_LIMIT: return STATUS_CONNECTION_COUNT_LIMIT;
|
||||
case ERROR_CONNECTION_INVALID: return STATUS_CONNECTION_INVALID;
|
||||
case ERROR_CONNECTION_REFUSED: return STATUS_CONNECTION_REFUSED;
|
||||
case ERROR_CONNECTION_UNAVAIL: return STATUS_DFS_UNAVAILABLE;
|
||||
case ERROR_CONTEXT_EXPIRED: return SEC_E_CONTEXT_EXPIRED;
|
||||
case ERROR_COUNTER_TIMEOUT: return STATUS_SERIAL_COUNTER_TIMEOUT;
|
||||
case ERROR_CRC: return STATUS_CRC_ERROR;
|
||||
case ERROR_CTX_BAD_VIDEO_MODE: return STATUS_CTX_BAD_VIDEO_MODE;
|
||||
case ERROR_CTX_CLIENT_LICENSE_IN_USE: return STATUS_CTX_CLIENT_LICENSE_IN_USE;
|
||||
case ERROR_CTX_CLIENT_LICENSE_NOT_SET: return STATUS_CTX_CLIENT_LICENSE_NOT_SET;
|
||||
case ERROR_CTX_CLIENT_QUERY_TIMEOUT: return STATUS_CTX_CLIENT_QUERY_TIMEOUT;
|
||||
case ERROR_CTX_CLOSE_PENDING: return STATUS_CTX_CLOSE_PENDING;
|
||||
case ERROR_CTX_CONSOLE_CONNECT: return STATUS_CTX_CONSOLE_CONNECT;
|
||||
case ERROR_CTX_CONSOLE_DISCONNECT: return STATUS_CTX_CONSOLE_DISCONNECT;
|
||||
case ERROR_CTX_GRAPHICS_INVALID: return STATUS_CTX_GRAPHICS_INVALID;
|
||||
case ERROR_CTX_INVALID_MODEMNAME: return STATUS_CTX_INVALID_MODEMNAME;
|
||||
case ERROR_CTX_INVALID_PD: return STATUS_CTX_INVALID_PD;
|
||||
case ERROR_CTX_INVALID_WD: return STATUS_CTX_INVALID_WD;
|
||||
case ERROR_CTX_LICENSE_CLIENT_INVALID: return STATUS_CTX_LICENSE_CLIENT_INVALID;
|
||||
case ERROR_CTX_LICENSE_EXPIRED: return STATUS_CTX_LICENSE_EXPIRED;
|
||||
case ERROR_CTX_LICENSE_NOT_AVAILABLE: return STATUS_CTX_LICENSE_NOT_AVAILABLE;
|
||||
case ERROR_CTX_MODEM_INF_NOT_FOUND: return STATUS_CTX_MODEM_INF_NOT_FOUND;
|
||||
case ERROR_CTX_MODEM_RESPONSE_BUSY: return STATUS_CTX_MODEM_RESPONSE_BUSY;
|
||||
case ERROR_CTX_MODEM_RESPONSE_ERROR: return STATUS_CTX_RESPONSE_ERROR;
|
||||
case ERROR_CTX_MODEM_RESPONSE_NO_CARRIER: return STATUS_CTX_MODEM_RESPONSE_NO_CARRIER;
|
||||
case ERROR_CTX_MODEM_RESPONSE_NO_DIALTONE: return STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE;
|
||||
case ERROR_CTX_MODEM_RESPONSE_TIMEOUT: return STATUS_CTX_MODEM_RESPONSE_TIMEOUT;
|
||||
case ERROR_CTX_MODEM_RESPONSE_VOICE: return STATUS_CTX_MODEM_RESPONSE_VOICE;
|
||||
case ERROR_CTX_NOT_CONSOLE: return STATUS_CTX_NOT_CONSOLE;
|
||||
case ERROR_CTX_NO_OUTBUF: return STATUS_CTX_NO_OUTBUF;
|
||||
case ERROR_CTX_PD_NOT_FOUND: return STATUS_CTX_PD_NOT_FOUND;
|
||||
case ERROR_CTX_SHADOW_DENIED: return STATUS_CTX_SHADOW_DENIED;
|
||||
case ERROR_CTX_SHADOW_DISABLED: return STATUS_CTX_SHADOW_DISABLED;
|
||||
case ERROR_CTX_SHADOW_ENDED_BY_MODE_CHANGE: return STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE;
|
||||
case ERROR_CTX_SHADOW_INVALID: return STATUS_CTX_SHADOW_INVALID;
|
||||
case ERROR_CTX_SHADOW_NOT_RUNNING: return STATUS_CTX_SHADOW_NOT_RUNNING;
|
||||
case ERROR_CTX_TD_ERROR: return STATUS_CTX_TD_ERROR;
|
||||
case ERROR_CTX_WD_NOT_FOUND: return STATUS_CTX_WD_NOT_FOUND;
|
||||
case ERROR_CTX_WINSTATION_ACCESS_DENIED: return STATUS_CTX_WINSTATION_ACCESS_DENIED;
|
||||
case ERROR_CTX_WINSTATION_ALREADY_EXISTS: return STATUS_CTX_WINSTATION_NAME_COLLISION;
|
||||
case ERROR_CTX_WINSTATION_BUSY: return STATUS_CTX_WINSTATION_BUSY;
|
||||
case ERROR_CTX_WINSTATION_NAME_INVALID: return STATUS_CTX_WINSTATION_NAME_INVALID;
|
||||
case ERROR_CTX_WINSTATION_NOT_FOUND: return STATUS_CTX_WINSTATION_NOT_FOUND;
|
||||
case ERROR_CURRENT_DOMAIN_NOT_ALLOWED: return STATUS_CURRENT_DOMAIN_NOT_ALLOWED;
|
||||
case ERROR_DECRYPTION_FAILED: return SEC_E_DECRYPT_FAILURE;
|
||||
case ERROR_DESTINATION_ELEMENT_FULL: return STATUS_DESTINATION_ELEMENT_FULL;
|
||||
case ERROR_DEVICE_DOOR_OPEN: return STATUS_DEVICE_DOOR_OPEN;
|
||||
case ERROR_DEVICE_IN_USE: return STATUS_CONNECTION_IN_USE;
|
||||
case ERROR_DEVICE_NOT_CONNECTED: return STATUS_DEVICE_NOT_CONNECTED;
|
||||
case ERROR_DEVICE_NOT_PARTITIONED: return STATUS_DEVICE_NOT_PARTITIONED;
|
||||
case ERROR_DEVICE_REINITIALIZATION_NEEDED: return STATUS_REINITIALIZATION_NEEDED;
|
||||
case ERROR_DEVICE_REMOVED: return STATUS_DEVICE_REMOVED;
|
||||
case ERROR_DEVICE_REQUIRES_CLEANING: return STATUS_DEVICE_REQUIRES_CLEANING;
|
||||
case ERROR_DEV_NOT_EXIST: return STATUS_DEVICE_DOES_NOT_EXIST;
|
||||
case ERROR_DIRECTORY: return STATUS_NOT_A_DIRECTORY;
|
||||
case ERROR_DIR_NOT_EMPTY: return STATUS_DIRECTORY_NOT_EMPTY;
|
||||
case ERROR_DISK_CORRUPT: return STATUS_DISK_CORRUPT_ERROR;
|
||||
case ERROR_DISK_FULL: return STATUS_DISK_FULL;
|
||||
case ERROR_DISK_OPERATION_FAILED: return STATUS_DISK_OPERATION_FAILED;
|
||||
case ERROR_DISK_RECALIBRATE_FAILED: return STATUS_DISK_RECALIBRATE_FAILED;
|
||||
case ERROR_DISK_RESET_FAILED: return STATUS_DISK_RESET_FAILED;
|
||||
case ERROR_DISK_TOO_FRAGMENTED: return STATUS_MFT_TOO_FRAGMENTED;
|
||||
case ERROR_DLL_INIT_FAILED: return STATUS_DLL_INIT_FAILED;
|
||||
case ERROR_DOMAIN_CONTROLLER_NOT_FOUND: return STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
|
||||
case ERROR_DOMAIN_EXISTS: return STATUS_DOMAIN_EXISTS;
|
||||
case ERROR_DOMAIN_LIMIT_EXCEEDED: return STATUS_DOMAIN_LIMIT_EXCEEDED;
|
||||
case ERROR_DOMAIN_TRUST_INCONSISTENT: return STATUS_DOMAIN_TRUST_INCONSISTENT;
|
||||
case ERROR_DOWNGRADE_DETECTED: return STATUS_DOWNGRADE_DETECTED;
|
||||
case ERROR_DRIVER_BLOCKED: return STATUS_DRIVER_BLOCKED;
|
||||
case ERROR_DS_ADMIN_LIMIT_EXCEEDED: return STATUS_DS_ADMIN_LIMIT_EXCEEDED;
|
||||
case ERROR_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER: return STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER;
|
||||
case ERROR_DS_ATTRIBUTE_OR_VALUE_EXISTS: return STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS;
|
||||
case ERROR_DS_ATTRIBUTE_TYPE_UNDEFINED: return STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED;
|
||||
case ERROR_DS_BUSY: return STATUS_DS_BUSY;
|
||||
case ERROR_DS_CANT_MOD_OBJ_CLASS: return STATUS_DS_CANT_MOD_OBJ_CLASS;
|
||||
case ERROR_DS_CANT_MOD_PRIMARYGROUPID: return STATUS_DS_CANT_MOD_PRIMARYGROUPID;
|
||||
case ERROR_DS_CANT_ON_NON_LEAF: return STATUS_DS_CANT_ON_NON_LEAF;
|
||||
case ERROR_DS_CANT_ON_RDN: return STATUS_DS_CANT_ON_RDN;
|
||||
case ERROR_DS_CANT_START: return STATUS_DS_CANT_START;
|
||||
case ERROR_DS_CROSS_DOM_MOVE_ERROR: return STATUS_DS_CROSS_DOM_MOVE_FAILED;
|
||||
case ERROR_DS_DS_REQUIRED: return STATUS_DIRECTORY_SERVICE_REQUIRED;
|
||||
case ERROR_DS_GC_NOT_AVAILABLE: return STATUS_DS_GC_NOT_AVAILABLE;
|
||||
case ERROR_DS_GC_REQUIRED: return STATUS_DS_GC_REQUIRED;
|
||||
case ERROR_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER: return STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER;
|
||||
case ERROR_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER: return STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER;
|
||||
case ERROR_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER: return STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER;
|
||||
case ERROR_DS_HAVE_PRIMARY_MEMBERS: return STATUS_DS_HAVE_PRIMARY_MEMBERS;
|
||||
case ERROR_DS_INCORRECT_ROLE_OWNER: return STATUS_DS_INCORRECT_ROLE_OWNER;
|
||||
case ERROR_DS_INIT_FAILURE: return STATUS_DS_INIT_FAILURE;
|
||||
case ERROR_DS_INIT_FAILURE_CONSOLE: return STATUS_DS_INIT_FAILURE_CONSOLE;
|
||||
case ERROR_DS_INVALID_ATTRIBUTE_SYNTAX: return STATUS_DS_INVALID_ATTRIBUTE_SYNTAX;
|
||||
case ERROR_DS_INVALID_GROUP_TYPE: return STATUS_DS_INVALID_GROUP_TYPE;
|
||||
case ERROR_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER: return STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER;
|
||||
case ERROR_DS_LOCAL_MEMBER_OF_LOCAL_ONLY: return STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY;
|
||||
case ERROR_DS_MACHINE_ACCOUNT_CREATED_PRENT4: return STATUS_PRENT4_MACHINE_ACCOUNT;
|
||||
case ERROR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED: return STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED;
|
||||
case ERROR_DS_MEMBERSHIP_EVALUATED_LOCALLY: return STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY;
|
||||
case ERROR_DS_NO_ATTRIBUTE_OR_VALUE: return STATUS_DS_NO_ATTRIBUTE_OR_VALUE;
|
||||
case ERROR_DS_NO_FPO_IN_UNIVERSAL_GROUPS: return STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS;
|
||||
case ERROR_DS_NO_MORE_RIDS: return STATUS_DS_NO_MORE_RIDS;
|
||||
case ERROR_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN: return STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN;
|
||||
case ERROR_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN: return STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN;
|
||||
case ERROR_DS_NO_RIDS_ALLOCATED: return STATUS_DS_NO_RIDS_ALLOCATED;
|
||||
case ERROR_DS_OBJ_CLASS_VIOLATION: return STATUS_DS_OBJ_CLASS_VIOLATION;
|
||||
case ERROR_DS_RIDMGR_INIT_ERROR: return STATUS_DS_RIDMGR_INIT_ERROR;
|
||||
case ERROR_DS_SAM_INIT_FAILURE: return STATUS_DS_SAM_INIT_FAILURE;
|
||||
case ERROR_DS_SAM_INIT_FAILURE_CONSOLE: return STATUS_DS_SAM_INIT_FAILURE_CONSOLE;
|
||||
case ERROR_DS_SAM_NEED_BOOTKEY_FLOPPY: return STATUS_SAM_NEED_BOOTKEY_FLOPPY;
|
||||
case ERROR_DS_SAM_NEED_BOOTKEY_PASSWORD: return STATUS_SAM_NEED_BOOTKEY_PASSWORD;
|
||||
case ERROR_DS_SENSITIVE_GROUP_VIOLATION: return STATUS_DS_SENSITIVE_GROUP_VIOLATION;
|
||||
case ERROR_DS_SHUTTING_DOWN: return STATUS_DS_SHUTTING_DOWN;
|
||||
case ERROR_DS_UNAVAILABLE: return STATUS_DS_UNAVAILABLE;
|
||||
case ERROR_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER: return STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER;
|
||||
case ERROR_DUP_NAME: return STATUS_DUPLICATE_NAME;
|
||||
case ERROR_EAS_NOT_SUPPORTED: return STATUS_EAS_NOT_SUPPORTED;
|
||||
case ERROR_EA_LIST_INCONSISTENT: return STATUS_EA_LIST_INCONSISTENT;
|
||||
case ERROR_EFS_ALG_BLOB_TOO_BIG: return STATUS_EFS_ALG_BLOB_TOO_BIG;
|
||||
case ERROR_ENCRYPTION_FAILED: return SEC_E_ENCRYPT_FAILURE;
|
||||
case ERROR_END_OF_MEDIA: return STATUS_END_OF_MEDIA;
|
||||
case ERROR_ENVVAR_NOT_FOUND: return STATUS_VARIABLE_NOT_FOUND;
|
||||
case ERROR_EOM_OVERFLOW: return STATUS_EOM_OVERFLOW;
|
||||
case ERROR_EVENTLOG_CANT_START: return STATUS_EVENTLOG_CANT_START;
|
||||
case ERROR_EVENTLOG_FILE_CHANGED: return STATUS_EVENTLOG_FILE_CHANGED;
|
||||
case ERROR_EVENTLOG_FILE_CORRUPT: return STATUS_EVENTLOG_FILE_CORRUPT;
|
||||
case ERROR_FILEMARK_DETECTED: return STATUS_FILEMARK_DETECTED;
|
||||
case ERROR_FILENAME_EXCED_RANGE: return STATUS_NAME_TOO_LONG;
|
||||
case ERROR_FILE_CORRUPT: return STATUS_FILE_CORRUPT_ERROR;
|
||||
case ERROR_FILE_ENCRYPTED: return STATUS_FILE_ENCRYPTED;
|
||||
case ERROR_FILE_INVALID: return STATUS_FILE_INVALID;
|
||||
case ERROR_FILE_NOT_ENCRYPTED: return STATUS_FILE_NOT_ENCRYPTED;
|
||||
case ERROR_FILE_NOT_FOUND: return STATUS_OBJECT_NAME_NOT_FOUND;
|
||||
case ERROR_FILE_OFFLINE: return STATUS_FILE_IS_OFFLINE;
|
||||
case ERROR_FLOPPY_BAD_REGISTERS: return STATUS_FLOPPY_BAD_REGISTERS;
|
||||
case ERROR_FLOPPY_ID_MARK_NOT_FOUND: return STATUS_FLOPPY_ID_MARK_NOT_FOUND;
|
||||
case ERROR_FLOPPY_UNKNOWN_ERROR: return STATUS_FLOPPY_UNKNOWN_ERROR;
|
||||
case ERROR_FLOPPY_WRONG_CYLINDER: return STATUS_FLOPPY_WRONG_CYLINDER;
|
||||
case ERROR_FULLSCREEN_MODE: return STATUS_FULLSCREEN_MODE;
|
||||
case ERROR_GENERIC_NOT_MAPPED: return STATUS_GENERIC_NOT_MAPPED;
|
||||
case ERROR_GEN_FAILURE: return STATUS_UNSUCCESSFUL;
|
||||
case ERROR_GRACEFUL_DISCONNECT: return STATUS_GRACEFUL_DISCONNECT;
|
||||
case ERROR_GROUP_EXISTS: return STATUS_GROUP_EXISTS;
|
||||
case ERROR_HANDLE_EOF: return STATUS_END_OF_FILE;
|
||||
case ERROR_HOST_DOWN: return STATUS_HOST_DOWN;
|
||||
case ERROR_HOST_UNREACHABLE: return STATUS_HOST_UNREACHABLE;
|
||||
case ERROR_ILLEGAL_ELEMENT_ADDRESS: return STATUS_ILLEGAL_ELEMENT_ADDRESS;
|
||||
case ERROR_ILL_FORMED_PASSWORD: return STATUS_ILL_FORMED_PASSWORD;
|
||||
case ERROR_INSUFFICIENT_BUFFER: return STATUS_BUFFER_TOO_SMALL;
|
||||
case ERROR_INTERNAL_DB_CORRUPTION: return STATUS_INTERNAL_DB_CORRUPTION;
|
||||
case ERROR_INTERNAL_DB_ERROR: return STATUS_INTERNAL_DB_ERROR;
|
||||
case ERROR_INTERNAL_ERROR: return STATUS_INTERNAL_ERROR;
|
||||
case ERROR_INVALID_ACCOUNT_NAME: return STATUS_INVALID_ACCOUNT_NAME;
|
||||
case ERROR_INVALID_ACL: return STATUS_INVALID_ACL;
|
||||
case ERROR_INVALID_ADDRESS: return STATUS_MEMORY_NOT_ALLOCATED;
|
||||
case ERROR_INVALID_BLOCK_LENGTH: return STATUS_INVALID_BLOCK_LENGTH;
|
||||
case ERROR_INVALID_COMPUTERNAME: return STATUS_INVALID_COMPUTER_NAME;
|
||||
case ERROR_INVALID_DOMAIN_ROLE: return STATUS_INVALID_DOMAIN_ROLE;
|
||||
case ERROR_INVALID_DOMAIN_STATE: return STATUS_INVALID_DOMAIN_STATE;
|
||||
case ERROR_INVALID_EA_NAME: return STATUS_INVALID_EA_NAME;
|
||||
case ERROR_INVALID_FUNCTION: return STATUS_NOT_IMPLEMENTED;
|
||||
case ERROR_INVALID_GROUP_ATTRIBUTES: return STATUS_INVALID_GROUP_ATTRIBUTES;
|
||||
case ERROR_INVALID_HANDLE: return STATUS_INVALID_HANDLE;
|
||||
case ERROR_INVALID_ID_AUTHORITY: return STATUS_INVALID_ID_AUTHORITY;
|
||||
case ERROR_INVALID_IMPORT_OF_NON_DLL: return STATUS_INVALID_IMPORT_OF_NON_DLL;
|
||||
case ERROR_INVALID_LEVEL: return STATUS_INVALID_LEVEL;
|
||||
case ERROR_INVALID_LOGON_HOURS: return STATUS_INVALID_LOGON_HOURS;
|
||||
case ERROR_INVALID_LOGON_TYPE: return STATUS_INVALID_LOGON_TYPE;
|
||||
case ERROR_INVALID_MEMBER: return STATUS_INVALID_MEMBER;
|
||||
case ERROR_INVALID_NAME: return STATUS_OBJECT_NAME_INVALID;
|
||||
case ERROR_INVALID_NETNAME: return STATUS_INVALID_ADDRESS_COMPONENT;
|
||||
case ERROR_INVALID_OPLOCK_PROTOCOL: return STATUS_INVALID_OPLOCK_PROTOCOL;
|
||||
case ERROR_INVALID_ORDINAL: return STATUS_ORDINAL_NOT_FOUND;
|
||||
case ERROR_INVALID_OWNER: return STATUS_INVALID_OWNER;
|
||||
case ERROR_INVALID_PARAMETER: return STATUS_INVALID_PARAMETER;
|
||||
case ERROR_INVALID_PASSWORD: return STATUS_WRONG_PASSWORD;
|
||||
case ERROR_INVALID_PRIMARY_GROUP: return STATUS_INVALID_PRIMARY_GROUP;
|
||||
case ERROR_INVALID_REPARSE_DATA: return STATUS_IO_REPARSE_DATA_INVALID;
|
||||
case ERROR_INVALID_SECURITY_DESCR: return STATUS_INVALID_SECURITY_DESCR;
|
||||
case ERROR_INVALID_SERVER_STATE: return STATUS_INVALID_SERVER_STATE;
|
||||
case ERROR_INVALID_SID: return STATUS_INVALID_SID;
|
||||
case ERROR_INVALID_SUB_AUTHORITY: return STATUS_INVALID_SUB_AUTHORITY;
|
||||
case ERROR_INVALID_THREAD_ID: return STATUS_NO_LDT;
|
||||
case ERROR_INVALID_USER_BUFFER: return STATUS_INVALID_USER_BUFFER;
|
||||
case ERROR_INVALID_WORKSTATION: return STATUS_INVALID_WORKSTATION;
|
||||
case ERROR_IO_DEVICE: return STATUS_IO_DEVICE_ERROR;
|
||||
case ERROR_IO_PENDING: return STATUS_PENDING;
|
||||
case ERROR_IRQ_BUSY: return STATUS_SHARED_IRQ_BUSY;
|
||||
case ERROR_JOURNAL_DELETE_IN_PROGRESS: return STATUS_JOURNAL_DELETE_IN_PROGRESS;
|
||||
case ERROR_JOURNAL_ENTRY_DELETED: return STATUS_JOURNAL_ENTRY_DELETED;
|
||||
case ERROR_JOURNAL_NOT_ACTIVE: return STATUS_JOURNAL_NOT_ACTIVE;
|
||||
case ERROR_KEY_DELETED: return STATUS_KEY_DELETED;
|
||||
case ERROR_KEY_HAS_CHILDREN: return STATUS_KEY_HAS_CHILDREN;
|
||||
case ERROR_LABEL_TOO_LONG: return STATUS_INVALID_VOLUME_LABEL;
|
||||
case ERROR_LAST_ADMIN: return STATUS_LAST_ADMIN;
|
||||
case ERROR_LICENSE_QUOTA_EXCEEDED: return STATUS_LICENSE_QUOTA_EXCEEDED;
|
||||
case ERROR_LM_CROSS_ENCRYPTION_REQUIRED: return STATUS_LM_CROSS_ENCRYPTION_REQUIRED;
|
||||
case ERROR_LOCAL_USER_SESSION_KEY: return STATUS_LOCAL_USER_SESSION_KEY;
|
||||
case ERROR_LOCK_VIOLATION: return STATUS_LOCK_NOT_GRANTED;
|
||||
case ERROR_LOGIN_TIME_RESTRICTION: return STATUS_LOGIN_TIME_RESTRICTION;
|
||||
case ERROR_LOGIN_WKSTA_RESTRICTION: return STATUS_LOGIN_WKSTA_RESTRICTION;
|
||||
case ERROR_LOGON_FAILURE: return STATUS_LOGON_FAILURE;
|
||||
case ERROR_LOGON_NOT_GRANTED: return STATUS_LOGON_NOT_GRANTED;
|
||||
case ERROR_LOGON_SESSION_COLLISION: return STATUS_LOGON_SESSION_COLLISION;
|
||||
case ERROR_LOGON_SESSION_EXISTS: return STATUS_LOGON_SESSION_EXISTS;
|
||||
case ERROR_LOGON_TYPE_NOT_GRANTED: return STATUS_LOGON_TYPE_NOT_GRANTED;
|
||||
case ERROR_LOG_FILE_FULL: return STATUS_LOG_FILE_FULL;
|
||||
case ERROR_LUIDS_EXHAUSTED: return STATUS_LUIDS_EXHAUSTED;
|
||||
case ERROR_MAGAZINE_NOT_PRESENT: return STATUS_MAGAZINE_NOT_PRESENT;
|
||||
case ERROR_MAPPED_ALIGNMENT: return STATUS_MAPPED_ALIGNMENT;
|
||||
case ERROR_MEDIA_CHANGED: return STATUS_MEDIA_CHANGED;
|
||||
case ERROR_MEMBERS_PRIMARY_GROUP: return STATUS_MEMBERS_PRIMARY_GROUP;
|
||||
case ERROR_MEMBER_IN_ALIAS: return STATUS_MEMBER_IN_ALIAS;
|
||||
case ERROR_MEMBER_IN_GROUP: return STATUS_MEMBER_IN_GROUP;
|
||||
case ERROR_MEMBER_NOT_IN_ALIAS: return STATUS_MEMBER_NOT_IN_ALIAS;
|
||||
case ERROR_MEMBER_NOT_IN_GROUP: return STATUS_MEMBER_NOT_IN_GROUP;
|
||||
case ERROR_MOD_NOT_FOUND: return STATUS_DLL_NOT_FOUND;
|
||||
case ERROR_MORE_DATA: return STATUS_BUFFER_OVERFLOW;
|
||||
case ERROR_MORE_WRITES: return STATUS_SERIAL_MORE_WRITES;
|
||||
case ERROR_MR_MID_NOT_FOUND: return STATUS_MESSAGE_NOT_FOUND;
|
||||
case ERROR_MUTUAL_AUTH_FAILED: return STATUS_MUTUAL_AUTHENTICATION_FAILED;
|
||||
case ERROR_NETLOGON_NOT_STARTED: return STATUS_NETLOGON_NOT_STARTED;
|
||||
case ERROR_NETNAME_DELETED: return STATUS_NETWORK_NAME_DELETED;
|
||||
case ERROR_NETWORK_ACCESS_DENIED: return STATUS_NETWORK_ACCESS_DENIED;
|
||||
case ERROR_NETWORK_BUSY: return STATUS_NETWORK_BUSY;
|
||||
case ERROR_NETWORK_UNREACHABLE: return STATUS_NETWORK_UNREACHABLE;
|
||||
case ERROR_NET_WRITE_FAULT: return STATUS_NET_WRITE_FAULT;
|
||||
case ERROR_NOACCESS: return STATUS_ACCESS_VIOLATION;
|
||||
case ERROR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT: return STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT;
|
||||
case ERROR_NOLOGON_SERVER_TRUST_ACCOUNT: return STATUS_NOLOGON_SERVER_TRUST_ACCOUNT;
|
||||
case ERROR_NOLOGON_WORKSTATION_TRUST_ACCOUNT: return STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT;
|
||||
case ERROR_NONE_MAPPED: return STATUS_NONE_MAPPED;
|
||||
case ERROR_NOTIFY_ENUM_DIR: return STATUS_NOTIFY_ENUM_DIR;
|
||||
case ERROR_NOT_ALL_ASSIGNED: return STATUS_NOT_ALL_ASSIGNED;
|
||||
case ERROR_NOT_A_REPARSE_POINT: return STATUS_NOT_A_REPARSE_POINT;
|
||||
case ERROR_NOT_ENOUGH_MEMORY: return STATUS_NO_MEMORY;
|
||||
case ERROR_NOT_ENOUGH_QUOTA: return STATUS_QUOTA_EXCEEDED;
|
||||
case ERROR_NOT_ENOUGH_SERVER_MEMORY: return STATUS_INSUFF_SERVER_RESOURCES;
|
||||
case ERROR_NOT_EXPORT_FORMAT: return STATUS_NOT_EXPORT_FORMAT;
|
||||
case ERROR_NOT_FOUND: return STATUS_NOT_FOUND;
|
||||
case ERROR_NOT_LOCKED: return STATUS_NOT_LOCKED;
|
||||
case ERROR_NOT_LOGON_PROCESS: return STATUS_NOT_LOGON_PROCESS;
|
||||
case ERROR_NOT_OWNER: return STATUS_RESOURCE_NOT_OWNED;
|
||||
case ERROR_NOT_READY: return STATUS_DEVICE_NOT_READY;
|
||||
case ERROR_NOT_REGISTRY_FILE: return STATUS_NOT_REGISTRY_FILE;
|
||||
case ERROR_NOT_SAME_DEVICE: return STATUS_NOT_SAME_DEVICE;
|
||||
case ERROR_NOT_SUPPORTED: return STATUS_NOT_SUPPORTED;
|
||||
case ERROR_NOT_SUPPORTED_ON_SBS: return STATUS_NOT_SUPPORTED_ON_SBS;
|
||||
case ERROR_NO_BROWSER_SERVERS_FOUND: return STATUS_NO_BROWSER_SERVERS_FOUND;
|
||||
case ERROR_NO_DATA: return STATUS_PIPE_EMPTY;
|
||||
case ERROR_NO_DATA_DETECTED: return STATUS_NO_DATA_DETECTED;
|
||||
case ERROR_NO_IMPERSONATION_TOKEN: return STATUS_NO_IMPERSONATION_TOKEN;
|
||||
case ERROR_NO_INHERITANCE: return STATUS_NO_INHERITANCE;
|
||||
case ERROR_NO_LOGON_SERVERS: return STATUS_NO_LOGON_SERVERS;
|
||||
case ERROR_NO_LOG_SPACE: return STATUS_NO_LOG_SPACE;
|
||||
case ERROR_NO_MATCH: return STATUS_NO_MATCH;
|
||||
case ERROR_NO_MEDIA_IN_DRIVE: return STATUS_NO_MEDIA;
|
||||
case ERROR_NO_MORE_FILES: return STATUS_NO_MORE_FILES;
|
||||
case ERROR_NO_MORE_ITEMS: return STATUS_NO_MORE_ENTRIES;
|
||||
case ERROR_NO_QUOTAS_FOR_ACCOUNT: return STATUS_NO_QUOTAS_FOR_ACCOUNT;
|
||||
case ERROR_NO_SECURITY_ON_OBJECT: return STATUS_NO_SECURITY_ON_OBJECT;
|
||||
case ERROR_NO_SPOOL_SPACE: return STATUS_NO_SPOOL_SPACE;
|
||||
case ERROR_NO_SUCH_ALIAS: return STATUS_NO_SUCH_ALIAS;
|
||||
case ERROR_NO_SUCH_DOMAIN: return STATUS_NO_SUCH_DOMAIN;
|
||||
case ERROR_NO_SUCH_GROUP: return STATUS_NO_SUCH_GROUP;
|
||||
case ERROR_NO_SUCH_LOGON_SESSION: return STATUS_NO_SUCH_LOGON_SESSION;
|
||||
case ERROR_NO_SUCH_MEMBER: return STATUS_NO_SUCH_MEMBER;
|
||||
case ERROR_NO_SUCH_PACKAGE: return STATUS_NO_SUCH_PACKAGE;
|
||||
case ERROR_NO_SUCH_PRIVILEGE: return STATUS_NO_SUCH_PRIVILEGE;
|
||||
case ERROR_NO_SUCH_USER: return STATUS_NO_SUCH_USER;
|
||||
case ERROR_NO_SYSTEM_RESOURCES: return STATUS_INSUFFICIENT_RESOURCES;
|
||||
case ERROR_NO_TOKEN: return STATUS_NO_TOKEN;
|
||||
case ERROR_NO_TRACKING_SERVICE: return STATUS_NO_TRACKING_SERVICE;
|
||||
case ERROR_NO_TRUST_LSA_SECRET: return STATUS_NO_TRUST_LSA_SECRET;
|
||||
case ERROR_NO_TRUST_SAM_ACCOUNT: return STATUS_NO_TRUST_SAM_ACCOUNT;
|
||||
case ERROR_NO_UNICODE_TRANSLATION: return STATUS_UNMAPPABLE_CHARACTER;
|
||||
case ERROR_NO_USER_SESSION_KEY: return STATUS_NO_USER_SESSION_KEY;
|
||||
case ERROR_NT_CROSS_ENCRYPTION_REQUIRED: return STATUS_NT_CROSS_ENCRYPTION_REQUIRED;
|
||||
case ERROR_NULL_LM_PASSWORD: return STATUS_NULL_LM_PASSWORD;
|
||||
case ERROR_ONLY_IF_CONNECTED: return STATUS_ONLY_IF_CONNECTED;
|
||||
case ERROR_OPEN_FILES: return STATUS_FILES_OPEN;
|
||||
case ERROR_OPERATION_ABORTED: return STATUS_CANCELLED;
|
||||
case ERROR_OPLOCK_NOT_GRANTED: return STATUS_OPLOCK_NOT_GRANTED;
|
||||
case ERROR_OUTOFMEMORY: return STATUS_SECTION_NOT_EXTENDED;
|
||||
case ERROR_OUT_OF_PAPER: return STATUS_DEVICE_PAPER_EMPTY;
|
||||
case ERROR_PAGEFILE_QUOTA: return STATUS_PAGEFILE_QUOTA;
|
||||
case ERROR_PARTIAL_COPY: return STATUS_PARTIAL_COPY;
|
||||
case ERROR_PARTITION_FAILURE: return STATUS_PARTITION_FAILURE;
|
||||
case ERROR_PASSWORD_EXPIRED: return STATUS_PASSWORD_EXPIRED;
|
||||
case ERROR_PASSWORD_MUST_CHANGE: return STATUS_PASSWORD_MUST_CHANGE;
|
||||
case ERROR_PASSWORD_RESTRICTION: return STATUS_PASSWORD_RESTRICTION;
|
||||
case ERROR_PATH_NOT_FOUND: return STATUS_OBJECT_PATH_NOT_FOUND;
|
||||
case ERROR_PIPE_BUSY: return STATUS_PIPE_BUSY;
|
||||
case ERROR_PIPE_CONNECTED: return STATUS_PIPE_CONNECTED;
|
||||
case ERROR_PIPE_LISTENING: return STATUS_PIPE_LISTENING;
|
||||
case ERROR_PIPE_NOT_CONNECTED: return STATUS_PIPE_DISCONNECTED;
|
||||
case ERROR_PKINIT_FAILURE: return STATUS_PKINIT_FAILURE;
|
||||
case ERROR_POLICY_OBJECT_NOT_FOUND: return STATUS_POLICY_OBJECT_NOT_FOUND;
|
||||
case ERROR_POLICY_ONLY_IN_DS: return STATUS_POLICY_ONLY_IN_DS;
|
||||
case ERROR_PORT_UNREACHABLE: return STATUS_PORT_UNREACHABLE;
|
||||
case ERROR_POSSIBLE_DEADLOCK: return STATUS_POSSIBLE_DEADLOCK;
|
||||
case ERROR_PRINTQ_FULL: return STATUS_PRINT_QUEUE_FULL;
|
||||
case ERROR_PRINT_CANCELLED: return STATUS_PRINT_CANCELLED;
|
||||
case ERROR_PRIVILEGE_NOT_HELD: return STATUS_PRIVILEGE_NOT_HELD;
|
||||
case ERROR_PROC_NOT_FOUND: return STATUS_PROCEDURE_NOT_FOUND;
|
||||
case ERROR_PROTOCOL_UNREACHABLE: return STATUS_PROTOCOL_UNREACHABLE;
|
||||
case ERROR_REDIR_PAUSED: return STATUS_REDIRECTOR_PAUSED;
|
||||
case ERROR_REGISTRY_IO_FAILED: return STATUS_REGISTRY_IO_FAILED;
|
||||
case ERROR_REGISTRY_RECOVERED: return STATUS_REGISTRY_RECOVERED;
|
||||
case ERROR_REG_NAT_CONSUMPTION: return STATUS_REG_NAT_CONSUMPTION;
|
||||
case ERROR_REMOTE_SESSION_LIMIT_EXCEEDED: return STATUS_REMOTE_SESSION_LIMIT;
|
||||
case ERROR_REMOTE_STORAGE_MEDIA_ERROR: return STATUS_REMOTE_STORAGE_MEDIA_ERROR;
|
||||
case ERROR_REMOTE_STORAGE_NOT_ACTIVE: return STATUS_REMOTE_STORAGE_NOT_ACTIVE;
|
||||
case ERROR_REM_NOT_LIST: return STATUS_REMOTE_NOT_LISTENING;
|
||||
case ERROR_REPARSE_ATTRIBUTE_CONFLICT: return STATUS_REPARSE_ATTRIBUTE_CONFLICT;
|
||||
case ERROR_REPARSE_TAG_INVALID: return STATUS_IO_REPARSE_TAG_INVALID;
|
||||
case ERROR_REPARSE_TAG_MISMATCH: return STATUS_IO_REPARSE_TAG_MISMATCH;
|
||||
case ERROR_REQUEST_ABORTED: return STATUS_REQUEST_ABORTED;
|
||||
case ERROR_REQ_NOT_ACCEP: return STATUS_REQUEST_NOT_ACCEPTED;
|
||||
case ERROR_RESOURCE_DATA_NOT_FOUND: return STATUS_RESOURCE_DATA_NOT_FOUND;
|
||||
case ERROR_RESOURCE_LANG_NOT_FOUND: return STATUS_RESOURCE_LANG_NOT_FOUND;
|
||||
case ERROR_RESOURCE_NAME_NOT_FOUND: return STATUS_RESOURCE_NAME_NOT_FOUND;
|
||||
case ERROR_RESOURCE_TYPE_NOT_FOUND: return STATUS_RESOURCE_TYPE_NOT_FOUND;
|
||||
case ERROR_RETRY: return STATUS_RETRY;
|
||||
case ERROR_REVISION_MISMATCH: return STATUS_REVISION_MISMATCH;
|
||||
case ERROR_RXACT_COMMIT_FAILURE: return STATUS_RXACT_COMMIT_FAILURE;
|
||||
case ERROR_RXACT_INVALID_STATE: return STATUS_RXACT_INVALID_STATE;
|
||||
case ERROR_SAM_INIT_FAILURE: return STATUS_SAM_INIT_FAILURE;
|
||||
case ERROR_SECRET_TOO_LONG: return STATUS_SECRET_TOO_LONG;
|
||||
case ERROR_SECTOR_NOT_FOUND: return STATUS_NONEXISTENT_SECTOR;
|
||||
case ERROR_SEM_TIMEOUT: return STATUS_IO_TIMEOUT;
|
||||
case ERROR_SERIAL_NO_DEVICE: return STATUS_SERIAL_NO_DEVICE_INITED;
|
||||
case ERROR_SERVER_DISABLED: return STATUS_SERVER_DISABLED;
|
||||
case ERROR_SERVER_NOT_DISABLED: return STATUS_SERVER_NOT_DISABLED;
|
||||
case ERROR_SERVER_SHUTDOWN_IN_PROGRESS: return STATUS_SERVER_SHUTDOWN_IN_PROGRESS;
|
||||
case ERROR_SERVICE_ALREADY_RUNNING: return STATUS_IMAGE_ALREADY_LOADED;
|
||||
case ERROR_SERVICE_DISABLED: return STATUS_PLUGPLAY_NO_DEVICE;
|
||||
case ERROR_SESSION_CREDENTIAL_CONFLICT: return STATUS_NETWORK_CREDENTIAL_CONFLICT;
|
||||
case ERROR_SETMARK_DETECTED: return STATUS_SETMARK_DETECTED;
|
||||
case ERROR_SET_NOT_FOUND: return STATUS_PROPSET_NOT_FOUND;
|
||||
case ERROR_SHARED_POLICY: return STATUS_SHARED_POLICY;
|
||||
case ERROR_SHARING_PAUSED: return STATUS_SHARING_PAUSED;
|
||||
case ERROR_SHARING_VIOLATION: return STATUS_SHARING_VIOLATION;
|
||||
case ERROR_SHUTDOWN_IN_PROGRESS: return STATUS_SHUTDOWN_IN_PROGRESS;
|
||||
case ERROR_SIGNAL_REFUSED: return STATUS_SUSPEND_COUNT_EXCEEDED;
|
||||
case ERROR_SMARTCARD_SUBSYSTEM_FAILURE: return STATUS_SMARTCARD_SUBSYSTEM_FAILURE;
|
||||
case ERROR_SOME_NOT_MAPPED: return STATUS_SOME_NOT_MAPPED;
|
||||
case ERROR_SOURCE_ELEMENT_EMPTY: return STATUS_SOURCE_ELEMENT_EMPTY;
|
||||
case ERROR_SPECIAL_ACCOUNT: return STATUS_SPECIAL_ACCOUNT;
|
||||
case ERROR_SPECIAL_GROUP: return STATUS_SPECIAL_GROUP;
|
||||
case ERROR_SPECIAL_USER: return STATUS_SPECIAL_USER;
|
||||
case ERROR_STACK_OVERFLOW: return STATUS_STACK_OVERFLOW;
|
||||
case ERROR_SWAPERROR: return STATUS_IN_PAGE_ERROR;
|
||||
case ERROR_SXS_ACTIVATION_CONTEXT_DISABLED: return STATUS_SXS_ACTIVATION_CONTEXT_DISABLED;
|
||||
case ERROR_SXS_ASSEMBLY_NOT_FOUND: return STATUS_SXS_ASSEMBLY_NOT_FOUND;
|
||||
case ERROR_SXS_CANT_GEN_ACTCTX: return STATUS_SXS_CANT_GEN_ACTCTX;
|
||||
case ERROR_SXS_INVALID_ACTCTXDATA_FORMAT: return STATUS_SXS_INVALID_ACTCTXDATA_FORMAT;
|
||||
case ERROR_SXS_KEY_NOT_FOUND: return STATUS_SXS_KEY_NOT_FOUND;
|
||||
case ERROR_SXS_MANIFEST_FORMAT_ERROR: return STATUS_SXS_MANIFEST_FORMAT_ERROR;
|
||||
case ERROR_SXS_MANIFEST_PARSE_ERROR: return STATUS_SXS_MANIFEST_PARSE_ERROR;
|
||||
case ERROR_SXS_PROCESS_DEFAULT_ALREADY_SET: return STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET;
|
||||
case ERROR_SXS_SECTION_NOT_FOUND: return STATUS_SXS_SECTION_NOT_FOUND;
|
||||
case ERROR_SXS_THREAD_QUERIES_DISABLED: return STATUS_SXS_THREAD_QUERIES_DISABLED;
|
||||
case ERROR_SXS_WRONG_SECTION_TYPE: return STATUS_SXS_WRONG_SECTION_TYPE;
|
||||
case ERROR_TIME_SKEW: return STATUS_TIME_DIFFERENCE_AT_DC;
|
||||
case ERROR_TOKEN_ALREADY_IN_USE: return STATUS_TOKEN_ALREADY_IN_USE;
|
||||
case ERROR_TOO_MANY_CMDS: return STATUS_TOO_MANY_COMMANDS;
|
||||
case ERROR_TOO_MANY_CONTEXT_IDS: return STATUS_TOO_MANY_CONTEXT_IDS;
|
||||
case ERROR_TOO_MANY_LINKS: return STATUS_TOO_MANY_LINKS;
|
||||
case ERROR_TOO_MANY_LUIDS_REQUESTED: return STATUS_TOO_MANY_LUIDS_REQUESTED;
|
||||
case ERROR_TOO_MANY_NAMES: return STATUS_TOO_MANY_NAMES;
|
||||
case ERROR_TOO_MANY_OPEN_FILES: return STATUS_TOO_MANY_OPENED_FILES;
|
||||
case ERROR_TOO_MANY_POSTS: return STATUS_SEMAPHORE_LIMIT_EXCEEDED;
|
||||
case ERROR_TOO_MANY_SECRETS: return STATUS_TOO_MANY_SECRETS;
|
||||
case ERROR_TOO_MANY_SESS: return STATUS_TOO_MANY_SESSIONS;
|
||||
case ERROR_TOO_MANY_SIDS: return STATUS_TOO_MANY_SIDS;
|
||||
case ERROR_TRANSPORT_FULL: return STATUS_TRANSPORT_FULL;
|
||||
case ERROR_TRUSTED_DOMAIN_FAILURE: return STATUS_TRUSTED_DOMAIN_FAILURE;
|
||||
case ERROR_TRUSTED_RELATIONSHIP_FAILURE: return STATUS_TRUSTED_RELATIONSHIP_FAILURE;
|
||||
case ERROR_TRUST_FAILURE: return STATUS_TRUST_FAILURE;
|
||||
case ERROR_UNABLE_TO_LOCK_MEDIA: return STATUS_UNABLE_TO_LOCK_MEDIA;
|
||||
case ERROR_UNABLE_TO_UNLOAD_MEDIA: return STATUS_UNABLE_TO_UNLOAD_MEDIA;
|
||||
case ERROR_UNEXP_NET_ERR: return STATUS_UNEXPECTED_NETWORK_ERROR;
|
||||
case ERROR_UNKNOWN_REVISION: return STATUS_UNKNOWN_REVISION;
|
||||
case ERROR_UNRECOGNIZED_MEDIA: return STATUS_UNRECOGNIZED_MEDIA;
|
||||
case ERROR_UNRECOGNIZED_VOLUME: return STATUS_UNRECOGNIZED_VOLUME;
|
||||
case ERROR_USER_EXISTS: return STATUS_USER_EXISTS;
|
||||
case ERROR_USER_MAPPED_FILE: return STATUS_USER_MAPPED_FILE;
|
||||
case ERROR_VC_DISCONNECTED: return STATUS_VIRTUAL_CIRCUIT_CLOSED;
|
||||
case ERROR_WMI_ALREADY_DISABLED: return STATUS_WMI_ALREADY_DISABLED;
|
||||
case ERROR_WMI_ALREADY_ENABLED: return STATUS_WMI_ALREADY_ENABLED;
|
||||
case ERROR_WMI_GUID_DISCONNECTED: return STATUS_WMI_GUID_DISCONNECTED;
|
||||
case ERROR_WMI_GUID_NOT_FOUND: return STATUS_WMI_GUID_NOT_FOUND;
|
||||
case ERROR_WMI_INSTANCE_NOT_FOUND: return STATUS_WMI_INSTANCE_NOT_FOUND;
|
||||
case ERROR_WMI_ITEMID_NOT_FOUND: return STATUS_WMI_ITEMID_NOT_FOUND;
|
||||
case ERROR_WMI_READ_ONLY: return STATUS_WMI_READ_ONLY;
|
||||
case ERROR_WMI_SET_FAILURE: return STATUS_WMI_SET_FAILURE;
|
||||
case ERROR_WMI_TRY_AGAIN: return STATUS_WMI_TRY_AGAIN;
|
||||
case ERROR_WORKING_SET_QUOTA: return STATUS_WORKING_SET_QUOTA;
|
||||
case ERROR_WRITE_PROTECT: return STATUS_MEDIA_WRITE_PROTECTED;
|
||||
case ERROR_WRONG_DISK: return STATUS_WRONG_VOLUME;
|
||||
case ERROR_WRONG_TARGET_NAME: return SEC_E_WRONG_PRINCIPAL;
|
||||
case NO_ERROR: return STATUS_SUCCESS;
|
||||
case NTE_BAD_KEYSET: return STATUS_SMARTCARD_NO_KEYSET;
|
||||
case NTE_NO_KEY: return STATUS_SMARTCARD_NO_KEY_CONTAINER;
|
||||
case RPC_S_ADDRESS_ERROR: return RPC_NT_ADDRESS_ERROR;
|
||||
case RPC_S_ALREADY_LISTENING: return RPC_NT_ALREADY_LISTENING;
|
||||
case RPC_S_ALREADY_REGISTERED: return RPC_NT_ALREADY_REGISTERED;
|
||||
case RPC_S_BINDING_HAS_NO_AUTH: return RPC_NT_BINDING_HAS_NO_AUTH;
|
||||
case RPC_S_BINDING_INCOMPLETE: return RPC_NT_BINDING_INCOMPLETE;
|
||||
case RPC_S_CALL_CANCELLED: return RPC_NT_CALL_CANCELLED;
|
||||
case RPC_S_CALL_FAILED: return RPC_NT_CALL_FAILED;
|
||||
case RPC_S_CALL_FAILED_DNE: return RPC_NT_CALL_FAILED_DNE;
|
||||
case RPC_S_CALL_IN_PROGRESS: return RPC_NT_CALL_IN_PROGRESS;
|
||||
case RPC_S_CANNOT_SUPPORT: return RPC_NT_CANNOT_SUPPORT;
|
||||
case RPC_S_CANT_CREATE_ENDPOINT: return RPC_NT_CANT_CREATE_ENDPOINT;
|
||||
case RPC_S_COMM_FAILURE: return RPC_NT_COMM_FAILURE;
|
||||
case RPC_S_DUPLICATE_ENDPOINT: return RPC_NT_DUPLICATE_ENDPOINT;
|
||||
case RPC_S_ENTRY_ALREADY_EXISTS: return RPC_NT_ENTRY_ALREADY_EXISTS;
|
||||
case RPC_S_ENTRY_NOT_FOUND: return RPC_NT_ENTRY_NOT_FOUND;
|
||||
case RPC_S_FP_DIV_ZERO: return RPC_NT_FP_DIV_ZERO;
|
||||
case RPC_S_FP_OVERFLOW: return RPC_NT_FP_OVERFLOW;
|
||||
case RPC_S_FP_UNDERFLOW: return RPC_NT_FP_UNDERFLOW;
|
||||
case RPC_S_GROUP_MEMBER_NOT_FOUND: return RPC_NT_GROUP_MEMBER_NOT_FOUND;
|
||||
case RPC_S_INCOMPLETE_NAME: return RPC_NT_INCOMPLETE_NAME;
|
||||
case RPC_S_INTERFACE_NOT_FOUND: return RPC_NT_INTERFACE_NOT_FOUND;
|
||||
case RPC_S_INTERNAL_ERROR: return RPC_NT_INTERNAL_ERROR;
|
||||
case RPC_S_INVALID_ASYNC_CALL: return RPC_NT_INVALID_ASYNC_CALL;
|
||||
case RPC_S_INVALID_ASYNC_HANDLE: return RPC_NT_INVALID_ASYNC_HANDLE;
|
||||
case RPC_S_INVALID_AUTH_IDENTITY: return RPC_NT_INVALID_AUTH_IDENTITY;
|
||||
case RPC_S_INVALID_BOUND: return RPC_NT_INVALID_BOUND;
|
||||
case RPC_S_INVALID_ENDPOINT_FORMAT: return RPC_NT_INVALID_ENDPOINT_FORMAT;
|
||||
case RPC_S_INVALID_NAF_ID: return RPC_NT_INVALID_NAF_ID;
|
||||
case RPC_S_INVALID_NAME_SYNTAX: return RPC_NT_INVALID_NAME_SYNTAX;
|
||||
case RPC_S_INVALID_NETWORK_OPTIONS: return RPC_NT_INVALID_NETWORK_OPTIONS;
|
||||
case RPC_S_INVALID_NET_ADDR: return RPC_NT_INVALID_NET_ADDR;
|
||||
case RPC_S_INVALID_OBJECT: return RPC_NT_INVALID_OBJECT;
|
||||
case RPC_S_INVALID_RPC_PROTSEQ: return RPC_NT_INVALID_RPC_PROTSEQ;
|
||||
case RPC_S_INVALID_STRING_BINDING: return RPC_NT_INVALID_STRING_BINDING;
|
||||
case RPC_S_INVALID_STRING_UUID: return RPC_NT_INVALID_STRING_UUID;
|
||||
case RPC_S_INVALID_TAG: return RPC_NT_INVALID_TAG;
|
||||
case RPC_S_INVALID_TIMEOUT: return RPC_NT_INVALID_TIMEOUT;
|
||||
case RPC_S_INVALID_VERS_OPTION: return RPC_NT_INVALID_VERS_OPTION;
|
||||
case RPC_S_MAX_CALLS_TOO_SMALL: return RPC_NT_MAX_CALLS_TOO_SMALL;
|
||||
case RPC_S_NAME_SERVICE_UNAVAILABLE: return RPC_NT_NAME_SERVICE_UNAVAILABLE;
|
||||
case RPC_S_NOTHING_TO_EXPORT: return RPC_NT_NOTHING_TO_EXPORT;
|
||||
case RPC_S_NOT_ALL_OBJS_UNEXPORTED: return RPC_NT_NOT_ALL_OBJS_UNEXPORTED;
|
||||
case RPC_S_NOT_CANCELLED: return RPC_NT_NOT_CANCELLED;
|
||||
case RPC_S_NOT_LISTENING: return RPC_NT_NOT_LISTENING;
|
||||
case RPC_S_NOT_RPC_ERROR: return RPC_NT_NOT_RPC_ERROR;
|
||||
case RPC_S_NO_BINDINGS: return RPC_NT_NO_BINDINGS;
|
||||
case RPC_S_NO_CALL_ACTIVE: return RPC_NT_NO_CALL_ACTIVE;
|
||||
case RPC_S_NO_CONTEXT_AVAILABLE: return RPC_NT_NO_CONTEXT_AVAILABLE;
|
||||
case RPC_S_NO_ENDPOINT_FOUND: return RPC_NT_NO_ENDPOINT_FOUND;
|
||||
case RPC_S_NO_ENTRY_NAME: return RPC_NT_NO_ENTRY_NAME;
|
||||
case RPC_S_NO_INTERFACES: return RPC_NT_NO_INTERFACES;
|
||||
case RPC_S_NO_MORE_BINDINGS: return RPC_NT_NO_MORE_BINDINGS;
|
||||
case RPC_S_NO_MORE_MEMBERS: return RPC_NT_NO_MORE_MEMBERS;
|
||||
case RPC_S_NO_PRINC_NAME: return RPC_NT_NO_PRINC_NAME;
|
||||
case RPC_S_NO_PROTSEQS: return RPC_NT_NO_PROTSEQS;
|
||||
case RPC_S_NO_PROTSEQS_REGISTERED: return RPC_NT_NO_PROTSEQS_REGISTERED;
|
||||
case RPC_S_OBJECT_NOT_FOUND: return RPC_NT_OBJECT_NOT_FOUND;
|
||||
case RPC_S_OUT_OF_RESOURCES: return RPC_NT_OUT_OF_RESOURCES;
|
||||
case RPC_S_PROCNUM_OUT_OF_RANGE: return RPC_NT_PROCNUM_OUT_OF_RANGE;
|
||||
case RPC_S_PROTOCOL_ERROR: return RPC_NT_PROTOCOL_ERROR;
|
||||
case RPC_S_PROTSEQ_NOT_FOUND: return RPC_NT_PROTSEQ_NOT_FOUND;
|
||||
case RPC_S_PROTSEQ_NOT_SUPPORTED: return RPC_NT_PROTSEQ_NOT_SUPPORTED;
|
||||
case RPC_S_SEC_PKG_ERROR: return RPC_NT_SEC_PKG_ERROR;
|
||||
case RPC_S_SEND_INCOMPLETE: return RPC_NT_SEND_INCOMPLETE;
|
||||
case RPC_S_SERVER_TOO_BUSY: return RPC_NT_SERVER_TOO_BUSY;
|
||||
case RPC_S_SERVER_UNAVAILABLE: return RPC_NT_SERVER_UNAVAILABLE;
|
||||
case RPC_S_STRING_TOO_LONG: return RPC_NT_STRING_TOO_LONG;
|
||||
case RPC_S_TYPE_ALREADY_REGISTERED: return RPC_NT_TYPE_ALREADY_REGISTERED;
|
||||
case RPC_S_UNKNOWN_AUTHN_LEVEL: return RPC_NT_UNKNOWN_AUTHN_LEVEL;
|
||||
case RPC_S_UNKNOWN_AUTHN_SERVICE: return RPC_NT_UNKNOWN_AUTHN_SERVICE;
|
||||
case RPC_S_UNKNOWN_AUTHN_TYPE: return RPC_NT_UNKNOWN_AUTHN_TYPE;
|
||||
case RPC_S_UNKNOWN_AUTHZ_SERVICE: return RPC_NT_UNKNOWN_AUTHZ_SERVICE;
|
||||
case RPC_S_UNKNOWN_IF: return RPC_NT_UNKNOWN_IF;
|
||||
case RPC_S_UNKNOWN_MGR_TYPE: return RPC_NT_UNKNOWN_MGR_TYPE;
|
||||
case RPC_S_UNSUPPORTED_AUTHN_LEVEL: return RPC_NT_UNSUPPORTED_AUTHN_LEVEL;
|
||||
case RPC_S_UNSUPPORTED_NAME_SYNTAX: return RPC_NT_UNSUPPORTED_NAME_SYNTAX;
|
||||
case RPC_S_UNSUPPORTED_TRANS_SYN: return RPC_NT_UNSUPPORTED_TRANS_SYN;
|
||||
case RPC_S_UNSUPPORTED_TYPE: return RPC_NT_UNSUPPORTED_TYPE;
|
||||
case RPC_S_UUID_LOCAL_ONLY: return RPC_NT_UUID_LOCAL_ONLY;
|
||||
case RPC_S_UUID_NO_ADDRESS: return RPC_NT_UUID_NO_ADDRESS;
|
||||
case RPC_S_WRONG_KIND_OF_BINDING: return RPC_NT_WRONG_KIND_OF_BINDING;
|
||||
case RPC_S_ZERO_DIVIDE: return RPC_NT_ZERO_DIVIDE;
|
||||
case RPC_X_BAD_STUB_DATA: return RPC_NT_BAD_STUB_DATA;
|
||||
case RPC_X_BYTE_COUNT_TOO_SMALL: return RPC_NT_BYTE_COUNT_TOO_SMALL;
|
||||
case RPC_X_ENUM_VALUE_OUT_OF_RANGE: return RPC_NT_ENUM_VALUE_OUT_OF_RANGE;
|
||||
case RPC_X_INVALID_ES_ACTION: return RPC_NT_INVALID_ES_ACTION;
|
||||
case RPC_X_INVALID_PIPE_OBJECT: return RPC_NT_INVALID_PIPE_OBJECT;
|
||||
case RPC_X_INVALID_PIPE_OPERATION: return RPC_NT_INVALID_PIPE_OPERATION;
|
||||
case RPC_X_NO_MORE_ENTRIES: return RPC_NT_NO_MORE_ENTRIES;
|
||||
case RPC_X_NULL_REF_POINTER: return RPC_NT_NULL_REF_POINTER;
|
||||
case RPC_X_PIPE_CLOSED: return RPC_NT_PIPE_CLOSED;
|
||||
case RPC_X_PIPE_DISCIPLINE_ERROR: return RPC_NT_PIPE_DISCIPLINE_ERROR;
|
||||
case RPC_X_PIPE_EMPTY: return RPC_NT_PIPE_EMPTY;
|
||||
case RPC_X_SS_CANNOT_GET_CALL_HANDLE: return RPC_NT_SS_CANNOT_GET_CALL_HANDLE;
|
||||
case RPC_X_SS_CHAR_TRANS_OPEN_FAIL: return RPC_NT_SS_CHAR_TRANS_OPEN_FAIL;
|
||||
case RPC_X_SS_CHAR_TRANS_SHORT_FILE: return RPC_NT_SS_CHAR_TRANS_SHORT_FILE;
|
||||
case RPC_X_SS_CONTEXT_DAMAGED: return RPC_NT_SS_CONTEXT_DAMAGED;
|
||||
case RPC_X_SS_HANDLES_MISMATCH: return RPC_NT_SS_HANDLES_MISMATCH;
|
||||
case RPC_X_WRONG_ES_VERSION: return RPC_NT_WRONG_ES_VERSION;
|
||||
case RPC_X_WRONG_PIPE_VERSION: return RPC_NT_WRONG_PIPE_VERSION;
|
||||
case RPC_X_WRONG_STUB_VERSION: return RPC_NT_WRONG_STUB_VERSION;
|
||||
case SCARD_E_COMM_DATA_LOST: return STATUS_SMARTCARD_IO_ERROR;
|
||||
case SCARD_E_NO_SMARTCARD: return STATUS_SMARTCARD_NO_CARD;
|
||||
case SCARD_E_NO_SUCH_CERTIFICATE: return STATUS_SMARTCARD_NO_CERTIFICATE;
|
||||
case SCARD_W_CARD_NOT_AUTHENTICATED: return STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED;
|
||||
case SCARD_W_CHV_BLOCKED: return STATUS_SMARTCARD_CARD_BLOCKED;
|
||||
case SCARD_W_WRONG_CHV: return STATUS_SMARTCARD_WRONG_PIN;
|
||||
case SEC_E_BAD_BINDINGS: return STATUS_BAD_BINDINGS;
|
||||
case SEC_E_CRYPTO_SYSTEM_INVALID: return STATUS_CRYPTO_SYSTEM_INVALID;
|
||||
case SEC_E_ISSUING_CA_UNTRUSTED: return STATUS_ISSUING_CA_UNTRUSTED;
|
||||
case SEC_E_KDC_INVALID_REQUEST: return STATUS_KDC_INVALID_REQUEST;
|
||||
case SEC_E_KDC_UNABLE_TO_REFER: return STATUS_KDC_UNABLE_TO_REFER;
|
||||
case SEC_E_KDC_UNKNOWN_ETYPE: return STATUS_KDC_UNKNOWN_ETYPE;
|
||||
case SEC_E_MAX_REFERRALS_EXCEEDED: return STATUS_MAX_REFERRALS_EXCEEDED;
|
||||
case SEC_E_MUST_BE_KDC: return STATUS_MUST_BE_KDC;
|
||||
case SEC_E_NO_IP_ADDRESSES: return STATUS_NO_IP_ADDRESSES;
|
||||
case SEC_E_NO_KERB_KEY: return STATUS_NO_KERB_KEY;
|
||||
case SEC_E_NO_PA_DATA: return STATUS_NO_PA_DATA;
|
||||
case SEC_E_NO_TGT_REPLY: return STATUS_NO_TGT_REPLY;
|
||||
case SEC_E_PKINIT_CLIENT_FAILURE: return STATUS_PKINIT_CLIENT_FAILURE;
|
||||
case SEC_E_PKINIT_NAME_MISMATCH: return STATUS_PKINIT_NAME_MISMATCH;
|
||||
case SEC_E_REVOCATION_OFFLINE_C: return STATUS_REVOCATION_OFFLINE_C;
|
||||
case SEC_E_SMARTCARD_CERT_EXPIRED: return STATUS_SMARTCARD_CERT_EXPIRED;
|
||||
case SEC_E_SMARTCARD_CERT_REVOKED: return STATUS_SMARTCARD_CERT_REVOKED;
|
||||
case SEC_E_SMARTCARD_LOGON_REQUIRED: return STATUS_SMARTCARD_LOGON_REQUIRED;
|
||||
case SEC_E_STRONG_CRYPTO_NOT_SUPPORTED: return STATUS_STRONG_CRYPTO_NOT_SUPPORTED;
|
||||
case SEC_E_TOO_MANY_PRINCIPALS: return STATUS_TOO_MANY_PRINCIPALS;
|
||||
case SEC_E_UNFINISHED_CONTEXT_DELETED: return STATUS_UNFINISHED_CONTEXT_DELETED;
|
||||
case SEC_E_UNSUPPORTED_PREAUTH: return STATUS_UNSUPPORTED_PREAUTH;
|
||||
case SEC_E_WRONG_CREDENTIAL_HANDLE: return STATUS_WRONG_CREDENTIAL_HANDLE;
|
||||
case STATUS_DUPLICATE_OBJECTID: return STATUS_DUPLICATE_OBJECTID;
|
||||
case STATUS_OBJECTID_EXISTS: return STATUS_OBJECTID_EXISTS;
|
||||
case STG_E_CSS_AUTHENTICATION_FAILURE: return STATUS_CSS_AUTHENTICATION_FAILURE;
|
||||
case STG_E_CSS_KEY_NOT_ESTABLISHED: return STATUS_CSS_KEY_NOT_ESTABLISHED;
|
||||
case STG_E_CSS_KEY_NOT_PRESENT: return STATUS_CSS_KEY_NOT_PRESENT;
|
||||
case STG_E_CSS_REGION_MISMATCH: return STATUS_CSS_REGION_MISMATCH;
|
||||
case STG_E_CSS_SCRAMBLED_SECTOR: return STATUS_CSS_SCRAMBLED_SECTOR;
|
||||
case STG_E_RESETS_EXHAUSTED: return STATUS_CSS_RESETS_EXHAUSTED;
|
||||
case STG_E_STATUS_COPY_PROTECTION_FAILURE: return STATUS_COPY_PROTECTION_FAILURE;
|
176
src0/sys/cleanup.c
Normal file
176
src0/sys/cleanup.c
Normal file
@@ -0,0 +1,176 @@
|
||||
/**
|
||||
* @file sys/cleanup.c
|
||||
*
|
||||
* @copyright 2015 Bill Zissimopoulos
|
||||
*/
|
||||
|
||||
#include <sys/driver.h>
|
||||
|
||||
static NTSTATUS FspFsctlCleanup(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
|
||||
static NTSTATUS FspFsvrtCleanup(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
|
||||
static NTSTATUS FspFsvolCleanup(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
|
||||
FSP_IOCMPL_DISPATCH FspFsvolCleanupComplete;
|
||||
FSP_DRIVER_DISPATCH FspCleanup;
|
||||
|
||||
#ifdef ALLOC_PRAGMA
|
||||
#pragma alloc_text(PAGE, FspFsctlCleanup)
|
||||
#pragma alloc_text(PAGE, FspFsvrtCleanup)
|
||||
#pragma alloc_text(PAGE, FspFsvolCleanup)
|
||||
#pragma alloc_text(PAGE, FspFsvolCleanupComplete)
|
||||
#pragma alloc_text(PAGE, FspCleanup)
|
||||
#endif
|
||||
|
||||
static NTSTATUS FspFsctlCleanup(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
NTSTATUS Result = STATUS_SUCCESS;
|
||||
Irp->IoStatus.Information = 0;
|
||||
return Result;
|
||||
}
|
||||
|
||||
static NTSTATUS FspFsvrtCleanup(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
NTSTATUS Result = STATUS_SUCCESS;
|
||||
Irp->IoStatus.Information = 0;
|
||||
return Result;
|
||||
}
|
||||
|
||||
static NTSTATUS FspFsvolCleanup(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
/* is this a valid FileObject? */
|
||||
if (!FspFileContextIsValid(IrpSp->FileObject->FsContext))
|
||||
return STATUS_SUCCESS;
|
||||
|
||||
NTSTATUS Result;
|
||||
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
|
||||
PFILE_OBJECT FileObject = IrpSp->FileObject;
|
||||
FSP_FILE_CONTEXT *FsContext = FileObject->FsContext;
|
||||
UINT64 UserContext = FsContext->UserContext;
|
||||
UINT64 UserContext2 = (UINT_PTR)FileObject->FsContext2;
|
||||
BOOLEAN DeletePending;
|
||||
LONG OpenCount;
|
||||
|
||||
/* lock the FsContext */
|
||||
ExAcquireResourceExclusiveLite(FsContext->Header.Resource, TRUE);
|
||||
|
||||
/* propagate the FsContext DeleteOnClose to DeletePending */
|
||||
if (FsContext->DeleteOnClose)
|
||||
FsContext->DeletePending = TRUE;
|
||||
DeletePending = FsContext->DeletePending;
|
||||
|
||||
/* all handles on this FileObject are gone; decrement its FsContext->OpenCount */
|
||||
OpenCount = FspFileContextClose(FsContext);
|
||||
|
||||
/* unlock the FsContext */
|
||||
ExReleaseResourceLite(FsContext->Header.Resource);
|
||||
|
||||
/* is the FsContext going away as well? */
|
||||
if (0 == OpenCount)
|
||||
{
|
||||
/*
|
||||
* The following must be done under the file system volume device Resource,
|
||||
* because we are manipulating its GenericTable.
|
||||
*/
|
||||
ExAcquireResourceExclusiveLite(&FsvolDeviceExtension->Base.Resource, TRUE);
|
||||
try
|
||||
{
|
||||
/* remove the FsContext from the file system volume device generic table */
|
||||
FspFsvolDeviceDeleteContext(DeviceObject, FsContext->UserContext, 0);
|
||||
}
|
||||
finally
|
||||
{
|
||||
ExReleaseResourceLite(&FsvolDeviceExtension->Base.Resource);
|
||||
}
|
||||
}
|
||||
|
||||
PDEVICE_OBJECT FsvrtDeviceObject = FsvolDeviceExtension->FsvrtDeviceObject;
|
||||
if (!FspDeviceRetain(FsvrtDeviceObject))
|
||||
/* IRP_MJ_CLEANUP cannot really fail :-\ */
|
||||
return STATUS_SUCCESS;
|
||||
|
||||
try
|
||||
{
|
||||
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension = FspFsvrtDeviceExtension(FsvrtDeviceObject);
|
||||
BOOLEAN FileNameRequired = 0 != FsvrtDeviceExtension->VolumeParams.FileNameRequired;
|
||||
FSP_FSCTL_TRANSACT_REQ *Request;
|
||||
|
||||
/* create the user-mode file system request */
|
||||
Result = FspIopCreateRequest(Irp, FileNameRequired ? &FsContext->FileName : 0, 0, &Request);
|
||||
if (!NT_SUCCESS(Result))
|
||||
goto leak_exit;
|
||||
|
||||
/*
|
||||
* The new request is associated with our IRP and will be deleted during its completion.
|
||||
*/
|
||||
|
||||
/* populate the Cleanup request */
|
||||
Request->Kind = FspFsctlTransactCleanupKind;
|
||||
Request->Req.Cleanup.UserContext = UserContext;
|
||||
Request->Req.Cleanup.UserContext2 = UserContext2;
|
||||
Request->Req.Cleanup.Delete = DeletePending && 0 == OpenCount;
|
||||
|
||||
Result = STATUS_PENDING;
|
||||
|
||||
goto exit;
|
||||
|
||||
leak_exit:;
|
||||
#if DBG
|
||||
DEBUGLOG("FileObject=%p[%p:\"%wZ\"], UserContext=%llx, UserContext2=%llx: "
|
||||
"error: the user-mode file system handle will be leaked!",
|
||||
IrpSp->FileObject, IrpSp->FileObject->RelatedFileObject, IrpSp->FileObject->FileName,
|
||||
UserContext, UserContext2);
|
||||
#endif
|
||||
|
||||
/* IRP_MJ_CLEANUP cannot really fail :-\ */
|
||||
Result = STATUS_SUCCESS;
|
||||
|
||||
exit:;
|
||||
}
|
||||
finally
|
||||
{
|
||||
FspDeviceRelease(FsvrtDeviceObject);
|
||||
}
|
||||
|
||||
return Result;
|
||||
}
|
||||
|
||||
VOID FspFsvolCleanupComplete(
|
||||
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
|
||||
{
|
||||
FSP_ENTER_IOC(PAGED_CODE());
|
||||
|
||||
FSP_LEAVE_IOC("FileObject=%p", IrpSp->FileObject);
|
||||
}
|
||||
|
||||
NTSTATUS FspCleanup(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp)
|
||||
{
|
||||
FSP_ENTER_MJ(PAGED_CODE());
|
||||
|
||||
ASSERT(IRP_MJ_CLEANUP == IrpSp->MajorFunction);
|
||||
|
||||
switch (FspDeviceExtension(DeviceObject)->Kind)
|
||||
{
|
||||
case FspFsvolDeviceExtensionKind:
|
||||
FSP_RETURN(Result = FspFsvolCleanup(DeviceObject, Irp, IrpSp));
|
||||
case FspFsvrtDeviceExtensionKind:
|
||||
FSP_RETURN(Result = FspFsvrtCleanup(DeviceObject, Irp, IrpSp));
|
||||
case FspFsctlDeviceExtensionKind:
|
||||
FSP_RETURN(Result = FspFsctlCleanup(DeviceObject, Irp, IrpSp));
|
||||
default:
|
||||
FSP_RETURN(Result = STATUS_INVALID_DEVICE_REQUEST);
|
||||
}
|
||||
|
||||
FSP_LEAVE_MJ("FileObject=%p", IrpSp->FileObject);
|
||||
}
|
148
src0/sys/close.c
Normal file
148
src0/sys/close.c
Normal file
@@ -0,0 +1,148 @@
|
||||
/**
|
||||
* @file sys/close.c
|
||||
*
|
||||
* @copyright 2015 Bill Zissimopoulos
|
||||
*/
|
||||
|
||||
#include <sys/driver.h>
|
||||
|
||||
static NTSTATUS FspFsctlClose(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
|
||||
static NTSTATUS FspFsvrtClose(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
|
||||
static NTSTATUS FspFsvolClose(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
|
||||
FSP_IOCMPL_DISPATCH FspFsvolCloseComplete;
|
||||
FSP_DRIVER_DISPATCH FspClose;
|
||||
|
||||
#ifdef ALLOC_PRAGMA
|
||||
#pragma alloc_text(PAGE, FspFsctlClose)
|
||||
#pragma alloc_text(PAGE, FspFsvrtClose)
|
||||
#pragma alloc_text(PAGE, FspFsvolClose)
|
||||
#pragma alloc_text(PAGE, FspFsvolCloseComplete)
|
||||
#pragma alloc_text(PAGE, FspClose)
|
||||
#endif
|
||||
|
||||
static NTSTATUS FspFsctlClose(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
NTSTATUS Result = STATUS_SUCCESS;
|
||||
Irp->IoStatus.Information = 0;
|
||||
return Result;
|
||||
}
|
||||
|
||||
static NTSTATUS FspFsvrtClose(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
NTSTATUS Result = STATUS_SUCCESS;
|
||||
Irp->IoStatus.Information = 0;
|
||||
return Result;
|
||||
}
|
||||
|
||||
static NTSTATUS FspFsvolClose(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
/* is this a valid FileObject? */
|
||||
if (!FspFileContextIsValid(IrpSp->FileObject->FsContext))
|
||||
return STATUS_SUCCESS;
|
||||
|
||||
NTSTATUS Result;
|
||||
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
|
||||
PFILE_OBJECT FileObject = IrpSp->FileObject;
|
||||
FSP_FILE_CONTEXT *FsContext = FileObject->FsContext;
|
||||
UINT64 UserContext = FsContext->UserContext;
|
||||
UINT64 UserContext2 = (UINT_PTR)FileObject->FsContext2;
|
||||
|
||||
/* dereference the FsContext (and delete if no more references) */
|
||||
FspFileContextRelease(FsContext);
|
||||
|
||||
PDEVICE_OBJECT FsvrtDeviceObject = FsvolDeviceExtension->FsvrtDeviceObject;
|
||||
if (!FspDeviceRetain(FsvrtDeviceObject))
|
||||
/* IRP_MJ_CLOSE cannot really fail :-\ */
|
||||
return STATUS_SUCCESS;
|
||||
|
||||
try
|
||||
{
|
||||
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension = FspFsvrtDeviceExtension(FsvrtDeviceObject);
|
||||
BOOLEAN FileNameRequired = 0 != FsvrtDeviceExtension->VolumeParams.FileNameRequired;
|
||||
FSP_FSCTL_TRANSACT_REQ *Request;
|
||||
|
||||
/* create the user-mode file system request */
|
||||
Result = FspIopCreateRequest(0, FileNameRequired ? &FsContext->FileName : 0, 0, &Request);
|
||||
if (!NT_SUCCESS(Result))
|
||||
goto leak_exit;
|
||||
|
||||
/*
|
||||
* The new request is associated with our IRP and will be deleted during its completion.
|
||||
*/
|
||||
|
||||
/* populate the Close request */
|
||||
Request->Kind = FspFsctlTransactCloseKind;
|
||||
Request->Req.Close.UserContext = UserContext;
|
||||
Request->Req.Close.UserContext2 = UserContext2;
|
||||
|
||||
/* post as a work request; this allows us to complete our own IRP and return immediately! */
|
||||
if (!FspIopPostWorkRequest(DeviceObject, Request))
|
||||
/* no need to delete the request here as FspIopPostWorkRequest() will do so in all cases */
|
||||
goto leak_exit;
|
||||
|
||||
Result = STATUS_SUCCESS;
|
||||
|
||||
goto exit;
|
||||
|
||||
leak_exit:;
|
||||
#if DBG
|
||||
DEBUGLOG("FileObject=%p[%p:\"%wZ\"], UserContext=%llx, UserContext2=%llx: "
|
||||
"error: the user-mode file system handle will be leaked!",
|
||||
IrpSp->FileObject, IrpSp->FileObject->RelatedFileObject, IrpSp->FileObject->FileName,
|
||||
UserContext, UserContext2);
|
||||
#endif
|
||||
|
||||
/* IRP_MJ_CLOSE cannot really fail :-\ */
|
||||
Result = STATUS_SUCCESS;
|
||||
|
||||
exit:;
|
||||
}
|
||||
finally
|
||||
{
|
||||
FspDeviceRelease(FsvrtDeviceObject);
|
||||
}
|
||||
|
||||
return Result;
|
||||
}
|
||||
|
||||
VOID FspFsvolCloseComplete(
|
||||
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
|
||||
{
|
||||
FSP_ENTER_IOC(PAGED_CODE());
|
||||
|
||||
FSP_LEAVE_IOC("FileObject=%p", IrpSp->FileObject);
|
||||
}
|
||||
|
||||
NTSTATUS FspClose(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp)
|
||||
{
|
||||
FSP_ENTER_MJ(PAGED_CODE());
|
||||
|
||||
ASSERT(IRP_MJ_CLOSE == IrpSp->MajorFunction);
|
||||
|
||||
switch (FspDeviceExtension(DeviceObject)->Kind)
|
||||
{
|
||||
case FspFsvolDeviceExtensionKind:
|
||||
FSP_RETURN(Result = FspFsvolClose(DeviceObject, Irp, IrpSp));
|
||||
case FspFsvrtDeviceExtensionKind:
|
||||
FSP_RETURN(Result = FspFsvrtClose(DeviceObject, Irp, IrpSp));
|
||||
case FspFsctlDeviceExtensionKind:
|
||||
FSP_RETURN(Result = FspFsctlClose(DeviceObject, Irp, IrpSp));
|
||||
default:
|
||||
FSP_RETURN(Result = STATUS_INVALID_DEVICE_REQUEST);
|
||||
}
|
||||
|
||||
FSP_LEAVE_MJ("FileObject=%p", IrpSp->FileObject);
|
||||
}
|
767
src0/sys/create.c
Normal file
767
src0/sys/create.c
Normal file
@@ -0,0 +1,767 @@
|
||||
/**
|
||||
* @file sys/create.c
|
||||
*
|
||||
* @copyright 2015 Bill Zissimopoulos
|
||||
*/
|
||||
|
||||
#include <sys/driver.h>
|
||||
|
||||
static NTSTATUS FspFsctlCreate(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
|
||||
static NTSTATUS FspFsvrtCreate(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
|
||||
static NTSTATUS FspFsvolCreate(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
|
||||
FSP_IOPREP_DISPATCH FspFsvolCreatePrepare;
|
||||
FSP_IOCMPL_DISPATCH FspFsvolCreateComplete;
|
||||
static VOID FspFsvolCreateCleanupClose(
|
||||
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response);
|
||||
FSP_IOP_REQUEST_FINI FspFsvolCreateRequestFini;
|
||||
FSP_DRIVER_DISPATCH FspCreate;
|
||||
|
||||
#ifdef ALLOC_PRAGMA
|
||||
#pragma alloc_text(PAGE, FspFsctlCreate)
|
||||
#pragma alloc_text(PAGE, FspFsvrtCreate)
|
||||
#pragma alloc_text(PAGE, FspFsvolCreate)
|
||||
#pragma alloc_text(PAGE, FspFsvolCreatePrepare)
|
||||
#pragma alloc_text(PAGE, FspFsvolCreateComplete)
|
||||
#pragma alloc_text(PAGE, FspFsvolCreateCleanupClose)
|
||||
#pragma alloc_text(PAGE, FspFsvolCreateRequestFini)
|
||||
#pragma alloc_text(PAGE, FspCreate)
|
||||
#endif
|
||||
|
||||
enum
|
||||
{
|
||||
RequestFsContext = 0,
|
||||
RequestAccessToken,
|
||||
};
|
||||
|
||||
static NTSTATUS FspFsctlCreate(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
NTSTATUS Result = STATUS_SUCCESS;
|
||||
Irp->IoStatus.Information = FILE_OPENED;
|
||||
return Result;
|
||||
}
|
||||
|
||||
static NTSTATUS FspFsvrtCreate(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
NTSTATUS Result = STATUS_SUCCESS;
|
||||
Irp->IoStatus.Information = FILE_OPENED;
|
||||
return Result;
|
||||
}
|
||||
|
||||
static NTSTATUS FspFsvolCreate(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
/* open the volume object? */
|
||||
if (0 == IrpSp->FileObject->FileName.Length &&
|
||||
(0 == IrpSp->FileObject->RelatedFileObject ||
|
||||
0 == IrpSp->FileObject->RelatedFileObject->FsContext))
|
||||
{
|
||||
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
|
||||
PDEVICE_OBJECT FsvrtDeviceObject = FsvolDeviceExtension->FsvrtDeviceObject;
|
||||
|
||||
IrpSp->FileObject->Vpb = FsvrtDeviceObject->Vpb;
|
||||
Irp->IoStatus.Information = FILE_OPENED;
|
||||
return STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
NTSTATUS Result;
|
||||
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
|
||||
|
||||
PDEVICE_OBJECT FsvrtDeviceObject = FsvolDeviceExtension->FsvrtDeviceObject;
|
||||
if (!FspDeviceRetain(FsvrtDeviceObject))
|
||||
return STATUS_CANCELLED;
|
||||
|
||||
try
|
||||
{
|
||||
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension = FspFsvrtDeviceExtension(FsvrtDeviceObject);
|
||||
PFILE_OBJECT FileObject = IrpSp->FileObject;
|
||||
PFILE_OBJECT RelatedFileObject = FileObject->RelatedFileObject;
|
||||
UNICODE_STRING FileName = FileObject->FileName;
|
||||
PACCESS_STATE AccessState = IrpSp->Parameters.Create.SecurityContext->AccessState;
|
||||
ULONG CreateOptions = IrpSp->Parameters.Create.Options;
|
||||
USHORT FileAttributes = IrpSp->Parameters.Create.FileAttributes;
|
||||
PSECURITY_DESCRIPTOR SecurityDescriptor = AccessState->SecurityDescriptor;
|
||||
ULONG SecurityDescriptorSize = 0;
|
||||
LARGE_INTEGER AllocationSize = Irp->Overlay.AllocationSize;
|
||||
ACCESS_MASK DesiredAccess = IrpSp->Parameters.Create.SecurityContext->DesiredAccess;
|
||||
USHORT ShareAccess = IrpSp->Parameters.Create.ShareAccess;
|
||||
PFILE_FULL_EA_INFORMATION EaBuffer = Irp->AssociatedIrp.SystemBuffer;
|
||||
//ULONG EaLength = IrpSp->Parameters.Create.EaLength;
|
||||
ULONG Flags = IrpSp->Flags;
|
||||
KPROCESSOR_MODE RequestorMode =
|
||||
FlagOn(Flags, SL_FORCE_ACCESS_CHECK) ? UserMode : Irp->RequestorMode;
|
||||
BOOLEAN HasTraversePrivilege =
|
||||
BooleanFlagOn(AccessState->Flags, TOKEN_HAS_TRAVERSE_PRIVILEGE);
|
||||
BOOLEAN IsAbsoluteSecurityDescriptor = FALSE;
|
||||
BOOLEAN IsSelfRelativeSecurityDescriptor = FALSE;
|
||||
BOOLEAN HasTrailingBackslash = FALSE;
|
||||
FSP_FILE_CONTEXT *FsContext = 0;
|
||||
FSP_FSCTL_TRANSACT_REQ *Request;
|
||||
|
||||
/* cannot open a paging file */
|
||||
if (FlagOn(Flags, SL_OPEN_PAGING_FILE))
|
||||
{
|
||||
Result = STATUS_ACCESS_DENIED;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
/* cannot open files by fileid */
|
||||
if (FlagOn(CreateOptions, FILE_OPEN_BY_FILE_ID))
|
||||
{
|
||||
Result = STATUS_NOT_IMPLEMENTED;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
/* do we support EA? */
|
||||
if (0 != EaBuffer && !FsvrtDeviceExtension->VolumeParams.EaSupported)
|
||||
{
|
||||
Result = STATUS_EAS_NOT_SUPPORTED;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
/* check create options */
|
||||
if (FlagOn(CreateOptions, FILE_NON_DIRECTORY_FILE) &&
|
||||
FlagOn(CreateOptions, FILE_DIRECTORY_FILE))
|
||||
{
|
||||
Result = STATUS_INVALID_PARAMETER;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
/* check security descriptor validity */
|
||||
if (0 != SecurityDescriptor)
|
||||
{
|
||||
IsAbsoluteSecurityDescriptor = RtlValidSecurityDescriptor(SecurityDescriptor);
|
||||
if (IsAbsoluteSecurityDescriptor)
|
||||
{
|
||||
Result = RtlAbsoluteToSelfRelativeSD(SecurityDescriptor, 0, &SecurityDescriptorSize);
|
||||
if (STATUS_BUFFER_TOO_SMALL != Result)
|
||||
{
|
||||
Result = STATUS_INVALID_PARAMETER;
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
SecurityDescriptorSize = RtlLengthSecurityDescriptor(SecurityDescriptor);
|
||||
IsSelfRelativeSecurityDescriptor = RtlValidRelativeSecurityDescriptor(
|
||||
SecurityDescriptor, SecurityDescriptorSize, 0);
|
||||
if (!IsSelfRelativeSecurityDescriptor)
|
||||
{
|
||||
Result = STATUS_INVALID_PARAMETER;
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* according to fastfat, filenames that begin with two backslashes are ok */
|
||||
if (sizeof(WCHAR) * 2 <= FileName.Length &&
|
||||
L'\\' == FileName.Buffer[1] && L'\\' == FileName.Buffer[0])
|
||||
{
|
||||
FileName.Length -= sizeof(WCHAR);
|
||||
FileName.MaximumLength -= sizeof(WCHAR);
|
||||
FileName.Buffer++;
|
||||
|
||||
if (sizeof(WCHAR) * 2 <= FileName.Length &&
|
||||
L'\\' == FileName.Buffer[1] && L'\\' == FileName.Buffer[0])
|
||||
{
|
||||
Result = STATUS_OBJECT_NAME_INVALID;
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
|
||||
/* check for trailing backslash */
|
||||
if (sizeof(WCHAR) * 2/* not empty or root */ <= FileName.Length &&
|
||||
L'\\' == FileName.Buffer[FileName.Length / 2 - 1])
|
||||
{
|
||||
FileName.Length -= sizeof(WCHAR);
|
||||
HasTrailingBackslash = TRUE;
|
||||
|
||||
if (sizeof(WCHAR) * 2 <= FileName.Length && L'\\' == FileName.Buffer[FileName.Length / 2 - 1])
|
||||
{
|
||||
Result = STATUS_OBJECT_NAME_INVALID;
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
if (HasTrailingBackslash && !FlagOn(CreateOptions, FILE_DIRECTORY_FILE))
|
||||
{
|
||||
Result = STATUS_OBJECT_NAME_INVALID;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
/* is this a relative or absolute open? */
|
||||
if (0 != RelatedFileObject)
|
||||
{
|
||||
FSP_FILE_CONTEXT *RelatedFsContext = RelatedFileObject->FsContext;
|
||||
|
||||
/* is this a valid RelatedFileObject? */
|
||||
if (!FspFileContextIsValid(RelatedFsContext))
|
||||
{
|
||||
Result = STATUS_OBJECT_PATH_NOT_FOUND;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
/* must be a relative path */
|
||||
if (sizeof(WCHAR) <= FileName.Length && L'\\' == FileName.Buffer[0])
|
||||
{
|
||||
Result = STATUS_OBJECT_NAME_INVALID;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
/* cannot FILE_DELETE_ON_CLOSE on the root directory */
|
||||
if (sizeof(WCHAR) == RelatedFsContext->FileName.Length &&
|
||||
0 == FileName.Length &&
|
||||
FlagOn(CreateOptions, FILE_DELETE_ON_CLOSE))
|
||||
{
|
||||
Result = STATUS_CANNOT_DELETE;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
/*
|
||||
* There is no need to lock our accesses of RelatedFileObject->FsContext->FileName,
|
||||
* because RelatedFileObject->FsContext->Filename is read-only (after creation) and
|
||||
* because RelatedFileObject->FsContext is guaranteed to exist while RelatedFileObject
|
||||
* exists.
|
||||
*/
|
||||
BOOLEAN AppendBackslash =
|
||||
sizeof(WCHAR) * 2/* not empty or root */ <= RelatedFsContext->FileName.Length &&
|
||||
sizeof(WCHAR) <= FileName.Length && L':' != FileName.Buffer[0];
|
||||
Result = FspFileContextCreate(DeviceObject,
|
||||
RelatedFsContext->FileName.Length + AppendBackslash * sizeof(WCHAR) + FileName.Length,
|
||||
&FsContext);
|
||||
if (!NT_SUCCESS(Result))
|
||||
goto exit;
|
||||
|
||||
Result = RtlAppendUnicodeStringToString(&FsContext->FileName, &RelatedFsContext->FileName);
|
||||
ASSERT(NT_SUCCESS(Result));
|
||||
if (AppendBackslash)
|
||||
{
|
||||
Result = RtlAppendUnicodeToString(&FsContext->FileName, L"\\");
|
||||
ASSERT(NT_SUCCESS(Result));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* must be an absolute path */
|
||||
if (sizeof(WCHAR) <= FileName.Length && L'\\' != FileName.Buffer[0])
|
||||
{
|
||||
Result = STATUS_OBJECT_NAME_INVALID;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
/* cannot FILE_DELETE_ON_CLOSE on the root directory */
|
||||
if (sizeof(WCHAR) == FileName.Length &&
|
||||
FlagOn(CreateOptions, FILE_DELETE_ON_CLOSE))
|
||||
{
|
||||
Result = STATUS_CANNOT_DELETE;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
Result = FspFileContextCreate(DeviceObject,
|
||||
FileName.Length,
|
||||
&FsContext);
|
||||
if (!NT_SUCCESS(Result))
|
||||
goto exit;
|
||||
}
|
||||
|
||||
Result = RtlAppendUnicodeStringToString(&FsContext->FileName, &FileName);
|
||||
ASSERT(NT_SUCCESS(Result));
|
||||
|
||||
/* create the user-mode file system request */
|
||||
Result = FspIopCreateRequestEx(Irp, &FsContext->FileName, SecurityDescriptorSize,
|
||||
FspFsvolCreateRequestFini, &Request);
|
||||
if (!NT_SUCCESS(Result))
|
||||
{
|
||||
FspFileContextRelease(FsContext);
|
||||
goto exit;
|
||||
}
|
||||
|
||||
/*
|
||||
* The new request is associated with our IRP and will be deleted during its completion.
|
||||
* Go ahead and associate our FsContext with the Request as well.
|
||||
*/
|
||||
FspIopRequestContext(Request, RequestFsContext) = FsContext;
|
||||
|
||||
/* populate the Create request */
|
||||
Request->Kind = FspFsctlTransactCreateKind;
|
||||
Request->Req.Create.CreateOptions = CreateOptions;
|
||||
Request->Req.Create.FileAttributes = FileAttributes;
|
||||
Request->Req.Create.SecurityDescriptor.Offset = 0 == SecurityDescriptorSize ? 0 :
|
||||
FSP_FSCTL_DEFAULT_ALIGN_UP(Request->FileName.Size);
|
||||
Request->Req.Create.SecurityDescriptor.Size = (UINT16)SecurityDescriptorSize;
|
||||
Request->Req.Create.AllocationSize = AllocationSize.QuadPart;
|
||||
Request->Req.Create.AccessToken = 0;
|
||||
Request->Req.Create.DesiredAccess = DesiredAccess;
|
||||
Request->Req.Create.ShareAccess = ShareAccess;
|
||||
Request->Req.Create.Ea.Offset = 0;
|
||||
Request->Req.Create.Ea.Size = 0;
|
||||
Request->Req.Create.UserMode = UserMode == RequestorMode;
|
||||
Request->Req.Create.HasTraversePrivilege = HasTraversePrivilege;
|
||||
Request->Req.Create.OpenTargetDirectory = BooleanFlagOn(Flags, SL_OPEN_TARGET_DIRECTORY);
|
||||
Request->Req.Create.CaseSensitive = BooleanFlagOn(Flags, SL_CASE_SENSITIVE);
|
||||
|
||||
/* copy the security descriptor into the request */
|
||||
if (IsAbsoluteSecurityDescriptor)
|
||||
{
|
||||
Result = RtlAbsoluteToSelfRelativeSD(SecurityDescriptor,
|
||||
Request->Buffer + Request->Req.Create.SecurityDescriptor.Offset, &SecurityDescriptorSize);
|
||||
if (!NT_SUCCESS(Result))
|
||||
{
|
||||
if (STATUS_BAD_DESCRIPTOR_FORMAT == Result || STATUS_BUFFER_TOO_SMALL == Result)
|
||||
Result = STATUS_INVALID_PARAMETER; /* should not happen */
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
else if (IsSelfRelativeSecurityDescriptor)
|
||||
RtlCopyMemory(Request->Buffer + Request->Req.Create.SecurityDescriptor.Offset,
|
||||
SecurityDescriptor, SecurityDescriptorSize);
|
||||
|
||||
Result = STATUS_PENDING;
|
||||
|
||||
exit:;
|
||||
}
|
||||
finally
|
||||
{
|
||||
FspDeviceRelease(FsvrtDeviceObject);
|
||||
}
|
||||
|
||||
return Result;
|
||||
}
|
||||
|
||||
NTSTATUS FspFsvolCreatePrepare(
|
||||
PIRP Irp, FSP_FSCTL_TRANSACT_REQ *Request)
|
||||
{
|
||||
FSP_ENTER_IOP(PAGED_CODE());
|
||||
|
||||
PDEVICE_OBJECT DeviceObject = IrpSp->DeviceObject;
|
||||
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
|
||||
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension =
|
||||
FspFsvrtDeviceExtension(FsvolDeviceExtension->FsvrtDeviceObject);
|
||||
|
||||
/* is the user-mode file system doing access checks? */
|
||||
if (!FsvrtDeviceExtension->VolumeParams.NoSystemAccessCheck)
|
||||
{
|
||||
ASSERT(0 == Request->Req.Create.AccessToken);
|
||||
FSP_RETURN(Result = STATUS_SUCCESS);
|
||||
}
|
||||
|
||||
/* get a user-mode handle to the access token */
|
||||
PACCESS_STATE AccessState = IrpSp->Parameters.Create.SecurityContext->AccessState;
|
||||
HANDLE UserModeAccessToken;
|
||||
Result = ObOpenObjectByPointer(SeQuerySubjectContextToken(&AccessState->SubjectSecurityContext),
|
||||
0, 0, TOKEN_QUERY, *SeTokenObjectType, UserMode, &UserModeAccessToken);
|
||||
if (!NT_SUCCESS(Result))
|
||||
FSP_RETURN();
|
||||
|
||||
/* send the user-mode handle to the user-mode file system */
|
||||
FspIopRequestContext(Request, RequestAccessToken) = UserModeAccessToken;
|
||||
Request->Req.Create.AccessToken = (UINT_PTR)UserModeAccessToken;
|
||||
|
||||
FSP_LEAVE_IOP();
|
||||
}
|
||||
|
||||
VOID FspFsvolCreateComplete(
|
||||
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
|
||||
{
|
||||
FSP_ENTER_IOC(PAGED_CODE());
|
||||
|
||||
/*
|
||||
* NOTE:
|
||||
* In the following we may have to close the just opened file object. But we must
|
||||
* never close a file we just created, because this will leave an orphan file on
|
||||
* the disk.
|
||||
*
|
||||
* Files may have to be closed if a security access or share access check fails. In
|
||||
* both those cases we were opening an existing file and so it is safe to close it.
|
||||
*
|
||||
* Because of how IRP_MJ_CREATE works in Windows, it is difficult to improve on this
|
||||
* scheme without introducing a 2-phase Create protocol, which is undesirable as it
|
||||
* means two trips into user-mode for a single Create request.
|
||||
*/
|
||||
|
||||
PDEVICE_OBJECT DeviceObject = IrpSp->DeviceObject;
|
||||
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
|
||||
PDEVICE_OBJECT FsvrtDeviceObject = FsvolDeviceExtension->FsvrtDeviceObject;
|
||||
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension = FspFsvrtDeviceExtension(FsvrtDeviceObject);
|
||||
FSP_FSCTL_TRANSACT_REQ *Request = FspIrpRequest(Irp);
|
||||
PFILE_OBJECT FileObject = IrpSp->FileObject;
|
||||
PACCESS_STATE AccessState = IrpSp->Parameters.Create.SecurityContext->AccessState;
|
||||
ULONG CreateOptions = IrpSp->Parameters.Create.Options;
|
||||
BOOLEAN FileCreated = FILE_CREATED == Response->IoStatus.Information;
|
||||
UINT32 ResponseFileAttributes = Response->Rsp.Create.Opened.FileAttributes;
|
||||
PSECURITY_DESCRIPTOR SecurityDescriptor;
|
||||
ULONG SecurityDescriptorSize;
|
||||
UNICODE_STRING ReparseFileName;
|
||||
ACCESS_MASK DesiredAccess = IrpSp->Parameters.Create.SecurityContext->DesiredAccess;
|
||||
PPRIVILEGE_SET Privileges = 0;
|
||||
USHORT ShareAccess = IrpSp->Parameters.Create.ShareAccess;
|
||||
ULONG Flags = IrpSp->Flags;
|
||||
KPROCESSOR_MODE RequestorMode =
|
||||
FlagOn(Flags, SL_FORCE_ACCESS_CHECK) ? UserMode : Irp->RequestorMode;
|
||||
FSP_FILE_CONTEXT *FsContext = FspIopRequestContext(Request, RequestFsContext);
|
||||
ACCESS_MASK GrantedAccess;
|
||||
BOOLEAN Inserted = FALSE;
|
||||
|
||||
/* did the user-mode file system sent us a failure code? */
|
||||
if (!NT_SUCCESS(Response->IoStatus.Status))
|
||||
{
|
||||
Irp->IoStatus.Information = Response->IoStatus.Information;
|
||||
Result = Response->IoStatus.Status;
|
||||
FSP_RETURN();
|
||||
}
|
||||
|
||||
/* special case STATUS_REPARSE */
|
||||
if (STATUS_REPARSE == Result)
|
||||
{
|
||||
ReparseFileName.Buffer =
|
||||
(PVOID)(Response->Buffer + Response->Rsp.Create.Reparse.FileName.Offset);
|
||||
ReparseFileName.Length = ReparseFileName.MaximumLength =
|
||||
Response->Rsp.Create.Reparse.FileName.Size;
|
||||
|
||||
Result = STATUS_ACCESS_DENIED;
|
||||
if (IO_REPARSE == Response->IoStatus.Information)
|
||||
{
|
||||
if (0 == ReparseFileName.Length ||
|
||||
(PUINT8)ReparseFileName.Buffer + ReparseFileName.Length >
|
||||
(PUINT8)Response + Response->Size)
|
||||
FSP_RETURN();
|
||||
|
||||
if (ReparseFileName.Length > FileObject->FileName.MaximumLength)
|
||||
{
|
||||
PVOID Buffer = FspAllocExternal(ReparseFileName.Length);
|
||||
if (0 == Buffer)
|
||||
FSP_RETURN(Result = STATUS_INSUFFICIENT_RESOURCES);
|
||||
FspFreeExternal(FileObject->FileName.Buffer);
|
||||
FileObject->FileName.MaximumLength = ReparseFileName.Length;
|
||||
FileObject->FileName.Buffer = Buffer;
|
||||
}
|
||||
FileObject->FileName.Length = 0;
|
||||
RtlCopyUnicodeString(&FileObject->FileName, &ReparseFileName);
|
||||
}
|
||||
else
|
||||
if (IO_REMOUNT == Response->IoStatus.Information)
|
||||
{
|
||||
if (0 != ReparseFileName.Length)
|
||||
FSP_RETURN();
|
||||
}
|
||||
else
|
||||
FSP_RETURN();
|
||||
|
||||
Irp->IoStatus.Information = Response->IoStatus.Information;
|
||||
Result = Response->IoStatus.Status;
|
||||
FSP_RETURN();
|
||||
}
|
||||
|
||||
/* are we doing access checks? */
|
||||
if (!FsvrtDeviceExtension->VolumeParams.NoSystemAccessCheck)
|
||||
{
|
||||
/* read-only attribute check */
|
||||
if (!FileCreated && FlagOn(ResponseFileAttributes, FILE_ATTRIBUTE_READONLY))
|
||||
{
|
||||
/* from fastfat: allowed accesses when read-only */
|
||||
ACCESS_MASK Allowed =
|
||||
DELETE | READ_CONTROL | WRITE_OWNER | WRITE_DAC |
|
||||
SYNCHRONIZE | ACCESS_SYSTEM_SECURITY |
|
||||
FILE_READ_DATA | FILE_READ_EA | FILE_WRITE_EA |
|
||||
FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES |
|
||||
FILE_EXECUTE | FILE_TRAVERSE | FILE_LIST_DIRECTORY |
|
||||
FILE_ADD_SUBDIRECTORY | FILE_ADD_FILE | FILE_DELETE_CHILD;
|
||||
|
||||
if (FlagOn(DesiredAccess, ~Allowed))
|
||||
{
|
||||
FspFsvolCreateCleanupClose(Irp, Response);
|
||||
FSP_RETURN(Result = STATUS_ACCESS_DENIED);
|
||||
}
|
||||
else
|
||||
if (!FlagOn(ResponseFileAttributes, FILE_ATTRIBUTE_DIRECTORY) &&
|
||||
FlagOn(CreateOptions, FILE_DELETE_ON_CLOSE))
|
||||
{
|
||||
FspFsvolCreateCleanupClose(Irp, Response);
|
||||
FSP_RETURN(Result = STATUS_CANNOT_DELETE);
|
||||
}
|
||||
}
|
||||
|
||||
/* security descriptor check */
|
||||
SecurityDescriptor =
|
||||
(PVOID)(Response->Buffer + Response->Rsp.Create.Opened.SecurityDescriptor.Offset);
|
||||
SecurityDescriptorSize = Response->Rsp.Create.Opened.SecurityDescriptor.Size;
|
||||
if (0 != SecurityDescriptorSize)
|
||||
{
|
||||
if ((PUINT8)SecurityDescriptor + SecurityDescriptorSize >
|
||||
(PUINT8)Response + Response->Size ||
|
||||
!FspValidRelativeSecurityDescriptor(SecurityDescriptor, SecurityDescriptorSize, 0))
|
||||
{
|
||||
FspFsvolCreateCleanupClose(Irp, Response);
|
||||
FSP_RETURN(Result = STATUS_ACCESS_DENIED);
|
||||
}
|
||||
|
||||
/* access check */
|
||||
if (!SeAccessCheck(SecurityDescriptor,
|
||||
&AccessState->SubjectSecurityContext,
|
||||
FALSE,
|
||||
DesiredAccess,
|
||||
AccessState->PreviouslyGrantedAccess,
|
||||
&Privileges,
|
||||
IoGetFileObjectGenericMapping(),
|
||||
RequestorMode,
|
||||
&GrantedAccess,
|
||||
&Result))
|
||||
{
|
||||
FspFsvolCreateCleanupClose(Irp, Response);
|
||||
FSP_RETURN();
|
||||
}
|
||||
|
||||
if (0 != Privileges)
|
||||
{
|
||||
Result = SeAppendPrivileges(AccessState, Privileges);
|
||||
SeFreePrivileges(Privileges);
|
||||
if (!NT_SUCCESS(Result))
|
||||
{
|
||||
FspFsvolCreateCleanupClose(Irp, Response);
|
||||
FSP_RETURN();
|
||||
}
|
||||
}
|
||||
|
||||
SetFlag(AccessState->PreviouslyGrantedAccess, GrantedAccess);
|
||||
ClearFlag(AccessState->RemainingDesiredAccess, GrantedAccess);
|
||||
}
|
||||
}
|
||||
|
||||
/* were we asked to open a directory or non-directory? */
|
||||
if (FlagOn(CreateOptions, FILE_DIRECTORY_FILE) &&
|
||||
!FileCreated && !FlagOn(ResponseFileAttributes, FILE_ATTRIBUTE_DIRECTORY))
|
||||
{
|
||||
FspFsvolCreateCleanupClose(Irp, Response);
|
||||
FSP_RETURN(Result = STATUS_NOT_A_DIRECTORY);
|
||||
}
|
||||
if (FlagOn(CreateOptions, FILE_NON_DIRECTORY_FILE) &&
|
||||
!FileCreated && FlagOn(ResponseFileAttributes, FILE_ATTRIBUTE_DIRECTORY))
|
||||
{
|
||||
FspFsvolCreateCleanupClose(Irp, Response);
|
||||
FSP_RETURN(Result = STATUS_FILE_IS_A_DIRECTORY);
|
||||
}
|
||||
|
||||
/*
|
||||
* The following must be done under the file system volume device Resource,
|
||||
* because we are manipulating its GenericTable and accessing foreign FsContext's.
|
||||
*/
|
||||
ExAcquireResourceExclusiveLite(&FsvolDeviceExtension->Base.Resource, TRUE);
|
||||
try
|
||||
{
|
||||
/* insert the newly created FsContext into our generic table */
|
||||
FsContext = FspFsvolDeviceInsertContext(DeviceObject,
|
||||
FsContext->UserContext, FsContext, &FsContext->ElementStorage, &Inserted);
|
||||
ASSERT(0 != FsContext);
|
||||
|
||||
/* share access check */
|
||||
if (Inserted)
|
||||
{
|
||||
/*
|
||||
* This is a newly created FsContext. Set its share access and
|
||||
* increment its open count. There is no need to acquire the
|
||||
* FsContext's Resource (because it is newly created).
|
||||
*/
|
||||
IoSetShareAccess(AccessState->PreviouslyGrantedAccess,
|
||||
ShareAccess, FileObject, &FsContext->ShareAccess);
|
||||
FspFileContextOpen(FsContext);
|
||||
if (FlagOn(CreateOptions, FILE_DELETE_ON_CLOSE))
|
||||
FsContext->DeleteOnClose = TRUE;
|
||||
Result = STATUS_SUCCESS;
|
||||
}
|
||||
else
|
||||
{
|
||||
/*
|
||||
* This is an existing FsContext. We must acquire its Resource and
|
||||
* check if there is a delete pending and the share access. Only if
|
||||
* both tests succeed we increment the open count and report success.
|
||||
*/
|
||||
ExAcquireResourceExclusiveLite(FsContext->Header.Resource, TRUE);
|
||||
if (FsContext->DeletePending)
|
||||
Result = STATUS_DELETE_PENDING;
|
||||
else
|
||||
Result = IoCheckShareAccess(AccessState->PreviouslyGrantedAccess,
|
||||
ShareAccess, FileObject, &FsContext->ShareAccess, TRUE);
|
||||
if (NT_SUCCESS(Result))
|
||||
{
|
||||
FspFileContextRetain(FsContext);
|
||||
FspFileContextOpen(FsContext);
|
||||
if (FlagOn(CreateOptions, FILE_DELETE_ON_CLOSE))
|
||||
FsContext->DeleteOnClose = TRUE;
|
||||
}
|
||||
ExReleaseResourceLite(FsContext->Header.Resource);
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
ExReleaseResourceLite(&FsvolDeviceExtension->Base.Resource);
|
||||
}
|
||||
|
||||
/* did we fail our share access checks? */
|
||||
if (!NT_SUCCESS(Result))
|
||||
{
|
||||
ASSERT(!Inserted);
|
||||
FspFsvolCreateCleanupClose(Irp, Response);
|
||||
FSP_RETURN();
|
||||
}
|
||||
|
||||
/*
|
||||
* Looks like SUCCESS!
|
||||
*/
|
||||
|
||||
/* did an FsContext with the same UserContext already exist? */
|
||||
if (!Inserted)
|
||||
/* delete the newly created FsContext as it is not being used */
|
||||
FspFileContextRelease(FspIopRequestContext(Request, RequestFsContext));
|
||||
|
||||
/* disassociate our FsContext from the Request */
|
||||
FspIopRequestContext(Request, RequestFsContext) = 0;
|
||||
|
||||
/* record the user-mode file system contexts */
|
||||
FsContext->UserContext = Response->Rsp.Create.Opened.UserContext;
|
||||
FileObject->FsContext = FsContext;
|
||||
FileObject->FsContext2 = (PVOID)(UINT_PTR)Response->Rsp.Create.Opened.UserContext2;
|
||||
|
||||
/* finish seting up the FileObject */
|
||||
FileObject->Vpb = FsvrtDeviceObject->Vpb;
|
||||
|
||||
/* SUCCESS! */
|
||||
Irp->IoStatus.Information = Response->IoStatus.Information;
|
||||
Result = Response->IoStatus.Status;
|
||||
|
||||
FSP_LEAVE_IOC(
|
||||
"FileObject=%p[%p:\"%wZ\"]",
|
||||
IrpSp->FileObject, IrpSp->FileObject->RelatedFileObject, IrpSp->FileObject->FileName);
|
||||
}
|
||||
|
||||
static VOID FspFsvolCreateCleanupClose(
|
||||
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
/*
|
||||
* This routine handles the case where we must close an open file,
|
||||
* because of a failure during Create completion. We simply create
|
||||
* a CreateClose request and we post it as a work item.
|
||||
*
|
||||
* Ideally there would be no failure modes for this routine. Reality is
|
||||
* different.
|
||||
*
|
||||
* The more serious (but perhaps non-existent in practice) failure is a
|
||||
* memory allocation failure. In this case we will leak the user-mode
|
||||
* file system handle!
|
||||
*
|
||||
* This routine may also fail if we cannot post a work item, which means that
|
||||
* the virtual volume device and the file system volume device are being
|
||||
* deleted. Because it is assumed that only the user-mode file system would
|
||||
* initiate a device deletion, this case is more benign (presumably the file
|
||||
* system knows to close off all its handles when tearing down its devices).
|
||||
*/
|
||||
|
||||
NTSTATUS Result;
|
||||
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
|
||||
PDEVICE_OBJECT DeviceObject = IrpSp->DeviceObject;
|
||||
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
|
||||
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension =
|
||||
FspFsvrtDeviceExtension(FsvolDeviceExtension->FsvrtDeviceObject);
|
||||
FSP_FSCTL_TRANSACT_REQ *OriginalRequest = FspIrpRequest(Irp);
|
||||
FSP_FILE_CONTEXT *FsContext = FspIopRequestContext(OriginalRequest, RequestFsContext);
|
||||
UINT64 UserContext = Response->Rsp.Create.Opened.UserContext;
|
||||
UINT64 UserContext2 = Response->Rsp.Create.Opened.UserContext2;
|
||||
BOOLEAN FileNameRequired = 0 != FsvrtDeviceExtension->VolumeParams.FileNameRequired;
|
||||
FSP_FSCTL_TRANSACT_REQ *Request;
|
||||
|
||||
/* create the user-mode file system request */
|
||||
Result = FspIopCreateRequest(0, FileNameRequired ? &FsContext->FileName : 0, 0, &Request);
|
||||
if (!NT_SUCCESS(Result))
|
||||
goto leak_exit;
|
||||
|
||||
/* populate the CreateCleanupClose request */
|
||||
Request->Kind = FspFsctlTransactCreateCleanupCloseKind;
|
||||
Request->Req.Cleanup.UserContext = UserContext;
|
||||
Request->Req.Cleanup.UserContext2 = UserContext2;
|
||||
Request->Req.Cleanup.Delete = FILE_CREATED == Response->IoStatus.Information;
|
||||
|
||||
/* post as a work request */
|
||||
if (!FspIopPostWorkRequest(DeviceObject, Request))
|
||||
/* no need to delete the request here as FspIopPostWorkRequest() will do so in all cases */
|
||||
goto leak_exit;
|
||||
|
||||
goto exit;
|
||||
|
||||
leak_exit:;
|
||||
#if DBG
|
||||
DEBUGLOG("FileObject=%p[%p:\"%wZ\"], UserContext=%llx, UserContext2=%llx: "
|
||||
"error: the user-mode file system handle will be leaked!",
|
||||
IrpSp->FileObject, IrpSp->FileObject->RelatedFileObject, IrpSp->FileObject->FileName,
|
||||
UserContext, UserContext2);
|
||||
#endif
|
||||
|
||||
exit:;
|
||||
}
|
||||
|
||||
VOID FspFsvolCreateRequestFini(PVOID Context[3])
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
if (0 != Context[RequestFsContext])
|
||||
FspFileContextRelease(Context[RequestFsContext]);
|
||||
|
||||
if (0 != Context[RequestAccessToken])
|
||||
{
|
||||
#if DBG
|
||||
NTSTATUS Result0;
|
||||
Result0 = ObCloseHandle(Context[RequestAccessToken], KernelMode);
|
||||
if (!NT_SUCCESS(Result0))
|
||||
DEBUGLOG("ObCloseHandle() = %s", NtStatusSym(Result0));
|
||||
#else
|
||||
ObCloseHandle(Context[RequestAccessToken], KernelMode);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
NTSTATUS FspCreate(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp)
|
||||
{
|
||||
FSP_ENTER_MJ(PAGED_CODE());
|
||||
|
||||
ASSERT(IRP_MJ_CREATE == IrpSp->MajorFunction);
|
||||
|
||||
switch (FspDeviceExtension(DeviceObject)->Kind)
|
||||
{
|
||||
case FspFsvolDeviceExtensionKind:
|
||||
FSP_RETURN(Result = FspFsvolCreate(DeviceObject, Irp, IrpSp));
|
||||
case FspFsvrtDeviceExtensionKind:
|
||||
FSP_RETURN(Result = FspFsvrtCreate(DeviceObject, Irp, IrpSp));
|
||||
case FspFsctlDeviceExtensionKind:
|
||||
FSP_RETURN(Result = FspFsctlCreate(DeviceObject, Irp, IrpSp));
|
||||
default:
|
||||
FSP_RETURN(Result = STATUS_INVALID_DEVICE_REQUEST);
|
||||
}
|
||||
|
||||
FSP_LEAVE_MJ(
|
||||
"FileObject=%p[%p:\"%wZ\"], "
|
||||
"Flags=%x, "
|
||||
"DesiredAccess=%#lx, "
|
||||
"ShareAccess=%#x, "
|
||||
"Options=%#lx, "
|
||||
"FileAttributes=%#x, "
|
||||
"AllocationSize=%#lx:%#lx, "
|
||||
"Ea=%p, EaLength=%ld",
|
||||
IrpSp->FileObject, IrpSp->FileObject->RelatedFileObject, IrpSp->FileObject->FileName,
|
||||
IrpSp->Flags,
|
||||
IrpSp->Parameters.Create.SecurityContext->DesiredAccess,
|
||||
IrpSp->Parameters.Create.ShareAccess,
|
||||
IrpSp->Parameters.Create.Options,
|
||||
IrpSp->Parameters.Create.FileAttributes,
|
||||
Irp->Overlay.AllocationSize.HighPart, Irp->Overlay.AllocationSize.LowPart,
|
||||
Irp->AssociatedIrp.SystemBuffer, IrpSp->Parameters.Create.EaLength);
|
||||
}
|
72
src0/sys/fileobj.c
Normal file
72
src0/sys/fileobj.c
Normal file
@@ -0,0 +1,72 @@
|
||||
/**
|
||||
* @file sys/fileobj.c
|
||||
*
|
||||
* @copyright 2015 Bill Zissimopoulos
|
||||
*/
|
||||
|
||||
#include <sys/driver.h>
|
||||
|
||||
NTSTATUS FspFileContextCreate(PDEVICE_OBJECT DeviceObject,
|
||||
ULONG ExtraSize, FSP_FILE_CONTEXT **PFsContext);
|
||||
VOID FspFileContextDelete(FSP_FILE_CONTEXT *Context);
|
||||
|
||||
#ifdef ALLOC_PRAGMA
|
||||
#pragma alloc_text(PAGE, FspFileContextCreate)
|
||||
#pragma alloc_text(PAGE, FspFileContextDelete)
|
||||
#endif
|
||||
|
||||
NTSTATUS FspFileContextCreate(PDEVICE_OBJECT DeviceObject,
|
||||
ULONG ExtraSize, FSP_FILE_CONTEXT **PFsContext)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
*PFsContext = 0;
|
||||
|
||||
FSP_FILE_CONTEXT_NONPAGED *NonPaged = FspAllocNonPaged(sizeof *NonPaged);
|
||||
if (0 == NonPaged)
|
||||
return STATUS_INSUFFICIENT_RESOURCES;
|
||||
|
||||
FSP_FILE_CONTEXT *FsContext = FspAlloc(sizeof *FsContext + ExtraSize);
|
||||
if (0 == FsContext)
|
||||
{
|
||||
FspFree(NonPaged);
|
||||
return STATUS_INSUFFICIENT_RESOURCES;
|
||||
}
|
||||
|
||||
RtlZeroMemory(NonPaged, sizeof *NonPaged);
|
||||
ExInitializeResourceLite(&NonPaged->Resource);
|
||||
ExInitializeResourceLite(&NonPaged->PagingIoResource);
|
||||
ExInitializeFastMutex(&NonPaged->HeaderFastMutex);
|
||||
|
||||
RtlZeroMemory(FsContext, sizeof *FsContext + ExtraSize);
|
||||
FsContext->Header.NodeTypeCode = FspFileContextFileKind;
|
||||
FsContext->Header.NodeByteSize = sizeof *FsContext;
|
||||
FsContext->Header.IsFastIoPossible = FastIoIsQuestionable;
|
||||
FsContext->Header.Resource = &NonPaged->Resource;
|
||||
FsContext->Header.PagingIoResource = &NonPaged->PagingIoResource;
|
||||
FsRtlSetupAdvancedHeader(&FsContext->Header, &NonPaged->HeaderFastMutex);
|
||||
FsContext->NonPaged = NonPaged;
|
||||
FsContext->RefCount = 1;
|
||||
FsContext->FsvolDeviceObject = DeviceObject;
|
||||
FspDeviceRetain(FsContext->FsvolDeviceObject);
|
||||
RtlInitEmptyUnicodeString(&FsContext->FileName, FsContext->FileNameBuf, (USHORT)ExtraSize);
|
||||
|
||||
*PFsContext = FsContext;
|
||||
|
||||
return STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
VOID FspFileContextDelete(FSP_FILE_CONTEXT *FsContext)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
FsRtlTeardownPerStreamContexts(&FsContext->Header);
|
||||
|
||||
FspDeviceRelease(FsContext->FsvolDeviceObject);
|
||||
|
||||
ExDeleteResourceLite(&FsContext->NonPaged->PagingIoResource);
|
||||
ExDeleteResourceLite(&FsContext->NonPaged->Resource);
|
||||
FspFree(FsContext->NonPaged);
|
||||
|
||||
FspFree(FsContext);
|
||||
}
|
625
src0/sys/fsctl.c
Normal file
625
src0/sys/fsctl.c
Normal file
@@ -0,0 +1,625 @@
|
||||
/**
|
||||
* @file sys/fsctl.c
|
||||
*
|
||||
* @copyright 2015 Bill Zissimopoulos
|
||||
*/
|
||||
|
||||
#include <sys/driver.h>
|
||||
|
||||
/*
|
||||
* Overview
|
||||
*
|
||||
* The fsctl module provides the IOCTL interface to interact with the
|
||||
* user-mode file system. The user-mode file system can use the IOCTL's
|
||||
* to create new volumes, delete them (while they are live!) and transact
|
||||
* with them.
|
||||
*
|
||||
*
|
||||
* Volume Creation
|
||||
*
|
||||
* The creation of a new volume is performed using an FSP_FSCTL_CREATE
|
||||
* IOCTL code. Creation is simple: a new device \Device\Volume{GUID} is
|
||||
* created and its path is returned to the user-mode file system. The
|
||||
* user-mode file system also passes a security descriptor to associate
|
||||
* with the new virtual volume device so that only the creating user-mode
|
||||
* file system can control the new volume.
|
||||
*
|
||||
*
|
||||
* Volume Deletion
|
||||
*
|
||||
* Deletion of an existing volume is performed using FSP_FSCTL_DELETE and
|
||||
* is quite a bit more involved. We must protect against the following two
|
||||
* eventualities: (1) that the volume is currently in use and cannot simply
|
||||
* go away, and (2) that a simultaneous mount operation is taking place
|
||||
* while we are deleting the volume.
|
||||
*
|
||||
* To protect against the first eventuality we maintain a reference count
|
||||
* on all our device extensions. Every time an MJ function is entered,
|
||||
* the reference count is incremented (FspDeviceRetain). Every time
|
||||
* an IRP is completed, the reference count is decremented (FspDeviceRelease).
|
||||
* When the reference count reaches 0 the device is deleted using
|
||||
* IoDeleteDevice. This ensures that a device will not go away while an
|
||||
* IRP is being pending/processed.
|
||||
*
|
||||
* To protect against the second eventuality we use the lock (ERESOURCE)
|
||||
* on the root Fsctl device to wrap volume deletion and attempts from the
|
||||
* system to mount the same volume. We also mark the virtual volume device
|
||||
* as Deleted in case we attempt to delete it (FspDeviceRelease) but we
|
||||
* cannot because it is currently in use.
|
||||
*
|
||||
* A sticky point is our use of the Windows VPB. It is not well documented
|
||||
* how one should handle this structure during forcible dismount. The fastfat
|
||||
* and cdfs samples use a technique where they keep a spare VPB and they swap
|
||||
* it with the volume one during forcible dismount. We do something similar.
|
||||
* The issue is what to do with the old VPB, because we can delete a volume
|
||||
* that is not currently being used. We check the VPB's ReferenceCount and
|
||||
* we free the VPB in this case.
|
||||
*
|
||||
*
|
||||
* Volume Transact
|
||||
*
|
||||
* The user-mode file system's primary interaction with the kernel-mode driver
|
||||
* is by using the FSP_FSCTL_TRANSACT IOCTL code. Every virtual volume device
|
||||
* maintains an FSP_IOQ (refer to ioq.c for more). When an FSP_FSCTL_TRANSACT
|
||||
* arrives it first processes any responses (FSP_FSCTL_TRANSACT_RSP) that the
|
||||
* user-mode file system has sent to handle requests sent to it using a prior
|
||||
* FSP_FSCTL_TRANSACT. It then proceeds to handle any pending IRP requests by
|
||||
* sending the corresponding requests (FSP_FSCTL_TRANSACT_REQ) to the user-
|
||||
* mode file system.
|
||||
*/
|
||||
|
||||
static NTSTATUS FspFsctlCreateVolume(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
|
||||
static NTSTATUS FspFsctlMountVolume(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
|
||||
static NTSTATUS FspFsvrtDeleteVolume(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
|
||||
static WORKER_THREAD_ROUTINE FspFsvrtDeleteVolumeDelayed;
|
||||
static NTSTATUS FspFsvrtTransact(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
|
||||
static NTSTATUS FspFsctlFileSystemControl(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
|
||||
static NTSTATUS FspFsvrtFileSystemControl(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
|
||||
static NTSTATUS FspFsvolFileSystemControl(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
|
||||
FSP_DRIVER_DISPATCH FspFileSystemControl;
|
||||
FSP_IOCMPL_DISPATCH FspFileSystemControlComplete;
|
||||
|
||||
#ifdef ALLOC_PRAGMA
|
||||
#pragma alloc_text(PAGE, FspFsctlCreateVolume)
|
||||
#pragma alloc_text(PAGE, FspFsctlMountVolume)
|
||||
#pragma alloc_text(PAGE, FspFsvrtDeleteVolume)
|
||||
#pragma alloc_text(PAGE, FspFsvrtDeleteVolumeDelayed)
|
||||
#pragma alloc_text(PAGE, FspFsvrtTransact)
|
||||
#pragma alloc_text(PAGE, FspFsctlFileSystemControl)
|
||||
#pragma alloc_text(PAGE, FspFsvrtFileSystemControl)
|
||||
#pragma alloc_text(PAGE, FspFsvolFileSystemControl)
|
||||
#pragma alloc_text(PAGE, FspFileSystemControl)
|
||||
#pragma alloc_text(PAGE, FspFileSystemControlComplete)
|
||||
#endif
|
||||
|
||||
static NTSTATUS FspFsctlCreateVolume(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
/* check parameters */
|
||||
ULONG InputBufferLength = IrpSp->Parameters.FileSystemControl.InputBufferLength;
|
||||
ULONG OutputBufferLength = IrpSp->Parameters.FileSystemControl.OutputBufferLength;
|
||||
PVOID SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
|
||||
PSECURITY_DESCRIPTOR SecurityDescriptor =
|
||||
(PVOID)((PUINT8)SystemBuffer + FSP_FSCTL_VOLUME_PARAMS_SIZE);
|
||||
DWORD SecurityDescriptorSize = InputBufferLength - FSP_FSCTL_VOLUME_PARAMS_SIZE;
|
||||
if (FSP_FSCTL_VOLUME_PARAMS_SIZE >= InputBufferLength || 0 == SystemBuffer ||
|
||||
!FspValidRelativeSecurityDescriptor(SecurityDescriptor, SecurityDescriptorSize,
|
||||
DACL_SECURITY_INFORMATION))
|
||||
return STATUS_INVALID_PARAMETER;
|
||||
if (FSP_FSCTL_CREATE_BUFFER_SIZEMIN > OutputBufferLength)
|
||||
return STATUS_BUFFER_TOO_SMALL;
|
||||
|
||||
NTSTATUS Result;
|
||||
FSP_FSCTL_VOLUME_PARAMS VolumeParams = *(FSP_FSCTL_VOLUME_PARAMS *)SystemBuffer;
|
||||
PVOID SecurityDescriptorBuf = 0;
|
||||
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension;
|
||||
|
||||
/* check the passed in VolumeParams */
|
||||
if (FspFsctlIrpTimeoutMinimum > VolumeParams.IrpTimeout ||
|
||||
VolumeParams.IrpTimeout > FspFsctlIrpTimeoutMaximum)
|
||||
#if DBG
|
||||
/* allow the debug timeout value on debug builds */
|
||||
if (FspFsctlIrpTimeoutDebug != VolumeParams.IrpTimeout)
|
||||
#endif
|
||||
VolumeParams.IrpTimeout = FspFsctlIrpTimeoutDefault;
|
||||
if (FspFsctlTransactTimeoutMinimum > VolumeParams.TransactTimeout ||
|
||||
VolumeParams.TransactTimeout > FspFsctlTransactTimeoutMaximum)
|
||||
VolumeParams.TransactTimeout = FspFsctlTransactTimeoutDefault;
|
||||
|
||||
/* create volume guid */
|
||||
GUID Guid;
|
||||
Result = FspCreateGuid(&Guid);
|
||||
if (!NT_SUCCESS(Result))
|
||||
return Result;
|
||||
|
||||
/* copy the security descriptor from the system buffer to a temporary one */
|
||||
SecurityDescriptorBuf = FspAlloc(SecurityDescriptorSize);
|
||||
if (0 == SecurityDescriptorBuf)
|
||||
return STATUS_INSUFFICIENT_RESOURCES;
|
||||
RtlCopyMemory(SecurityDescriptorBuf, SecurityDescriptor, SecurityDescriptorSize);
|
||||
|
||||
/* prepare the device name and SDDL */
|
||||
PDEVICE_OBJECT FsvrtDeviceObject;
|
||||
UNICODE_STRING DeviceSddl;
|
||||
UNICODE_STRING DeviceName;
|
||||
RtlInitUnicodeString(&DeviceSddl, L"" FSP_FSVRT_DEVICE_SDDL);
|
||||
RtlInitEmptyUnicodeString(&DeviceName, SystemBuffer, FSP_FSCTL_CREATE_BUFFER_SIZEMIN);
|
||||
Result = RtlUnicodeStringPrintf(&DeviceName,
|
||||
L"\\Device\\Volume{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
|
||||
Guid.Data1, Guid.Data2, Guid.Data3,
|
||||
Guid.Data4[0], Guid.Data4[1], Guid.Data4[2], Guid.Data4[3],
|
||||
Guid.Data4[4], Guid.Data4[5], Guid.Data4[6], Guid.Data4[7]);
|
||||
ASSERT(NT_SUCCESS(Result));
|
||||
|
||||
/* create the virtual volume device */
|
||||
FSP_FSCTL_DEVICE_EXTENSION *FsctlDeviceExtension = FspFsctlDeviceExtension(DeviceObject);
|
||||
ExAcquireResourceExclusiveLite(&FsctlDeviceExtension->Base.Resource, TRUE);
|
||||
try
|
||||
{
|
||||
Result = FspDeviceCreateSecure(FspFsvrtDeviceExtensionKind, SecurityDescriptorSize,
|
||||
&DeviceName, FILE_DEVICE_VIRTUAL_DISK,
|
||||
&DeviceSddl, &FspFsvrtDeviceClassGuid,
|
||||
&FsvrtDeviceObject);
|
||||
if (NT_SUCCESS(Result))
|
||||
{
|
||||
#pragma prefast(suppress:28175, "We are a filesystem: ok to access SectorSize")
|
||||
FsvrtDeviceObject->SectorSize = VolumeParams.SectorSize;
|
||||
FsvrtDeviceExtension = FspFsvrtDeviceExtension(FsvrtDeviceObject);
|
||||
FsvrtDeviceExtension->FsctlDeviceObject = DeviceObject;
|
||||
FsvrtDeviceExtension->VolumeParams = VolumeParams;
|
||||
RtlCopyMemory(FsvrtDeviceExtension->SecurityDescriptorBuf,
|
||||
SecurityDescriptorBuf, SecurityDescriptorSize);
|
||||
FspDeviceInitComplete(FsvrtDeviceObject);
|
||||
Irp->IoStatus.Information = DeviceName.Length + sizeof(WCHAR);
|
||||
FspFsctlDeviceVolumeCreated(DeviceObject);
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
ExReleaseResourceLite(&FsctlDeviceExtension->Base.Resource);
|
||||
}
|
||||
|
||||
/* free the temporary security descriptor */
|
||||
if (0 != SecurityDescriptorBuf)
|
||||
FspFree(SecurityDescriptorBuf);
|
||||
|
||||
return Result;
|
||||
}
|
||||
|
||||
static NTSTATUS FspFsctlMountVolume(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
NTSTATUS Result;
|
||||
FSP_FSCTL_DEVICE_EXTENSION *FsctlDeviceExtension = FspFsctlDeviceExtension(DeviceObject);
|
||||
|
||||
ExAcquireResourceExclusiveLite(&FsctlDeviceExtension->Base.Resource, TRUE);
|
||||
try
|
||||
{
|
||||
PDEVICE_OBJECT *DeviceObjects = 0;
|
||||
ULONG DeviceObjectCount = 0;
|
||||
PVPB Vpb = IrpSp->Parameters.MountVolume.Vpb;
|
||||
PDEVICE_OBJECT FsvrtDeviceObject = IrpSp->Parameters.MountVolume.DeviceObject;
|
||||
PDEVICE_OBJECT FsvolDeviceObject;
|
||||
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension =
|
||||
FspFsvrtDeviceExtension(FsvrtDeviceObject);
|
||||
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension;
|
||||
|
||||
/* check the passed in volume object; it must be one of our own and not marked Deleted */
|
||||
Result = FspDeviceCopyList(&DeviceObjects, &DeviceObjectCount);
|
||||
if (NT_SUCCESS(Result))
|
||||
{
|
||||
Result = STATUS_UNRECOGNIZED_VOLUME;
|
||||
for (ULONG i = 0; DeviceObjectCount > i; i++)
|
||||
if (DeviceObjects[i] == FsvrtDeviceObject)
|
||||
{
|
||||
if (FspDeviceRetain(FsvrtDeviceObject))
|
||||
{
|
||||
if (!FsvrtDeviceExtension->Deleted &&
|
||||
FILE_DEVICE_VIRTUAL_DISK == FsvrtDeviceObject->DeviceType)
|
||||
Result = STATUS_SUCCESS;
|
||||
else
|
||||
FspDeviceRelease(FsvrtDeviceObject);
|
||||
}
|
||||
break;
|
||||
}
|
||||
FspDeviceDeleteList(DeviceObjects, DeviceObjectCount);
|
||||
}
|
||||
if (!NT_SUCCESS(Result))
|
||||
goto exit;
|
||||
|
||||
/* create the file system device object */
|
||||
Result = FspDeviceCreate(FspFsvolDeviceExtensionKind, 0,
|
||||
DeviceObject->DeviceType,
|
||||
&FsvolDeviceObject);
|
||||
if (NT_SUCCESS(Result))
|
||||
{
|
||||
/*
|
||||
* Reference the virtual volume device so that it will not go away while the
|
||||
* file system device object is alive!
|
||||
*/
|
||||
ObReferenceObject(FsvrtDeviceObject);
|
||||
|
||||
#pragma prefast(suppress:28175, "We are a filesystem: ok to access SectorSize")
|
||||
FsvolDeviceObject->SectorSize = FsvrtDeviceExtension->VolumeParams.SectorSize;
|
||||
FsvolDeviceExtension = FspFsvolDeviceExtension(FsvolDeviceObject);
|
||||
FsvolDeviceExtension->FsvrtDeviceObject = FsvrtDeviceObject;
|
||||
FsvrtDeviceExtension->FsvolDeviceObject = FsvolDeviceObject;
|
||||
FspDeviceInitComplete(FsvolDeviceObject);
|
||||
Vpb->DeviceObject = FsvolDeviceObject;
|
||||
Vpb->SerialNumber = FsvrtDeviceExtension->VolumeParams.SerialNumber;
|
||||
Irp->IoStatus.Information = 0;
|
||||
}
|
||||
|
||||
FspDeviceRelease(FsvrtDeviceObject);
|
||||
|
||||
exit:;
|
||||
}
|
||||
finally
|
||||
{
|
||||
ExReleaseResourceLite(&FsctlDeviceExtension->Base.Resource);
|
||||
}
|
||||
|
||||
return Result;
|
||||
}
|
||||
|
||||
typedef struct
|
||||
{
|
||||
PDEVICE_OBJECT FsvolDeviceObject;
|
||||
PVPB OldVpb;
|
||||
FSP_WORK_ITEM_WITH_DELAY WorkItemWithDelay;
|
||||
} FSP_FSVRT_DELETE_VOLUME_WORK_ITEM;
|
||||
|
||||
static NTSTATUS FspFsvrtDeleteVolume(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
NTSTATUS Result;
|
||||
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension = FspFsvrtDeviceExtension(DeviceObject);
|
||||
FSP_FSCTL_DEVICE_EXTENSION *FsctlDeviceExtension =
|
||||
FspFsctlDeviceExtension(FsvrtDeviceExtension->FsctlDeviceObject);
|
||||
|
||||
ExAcquireResourceExclusiveLite(&FsctlDeviceExtension->Base.Resource, TRUE);
|
||||
try
|
||||
{
|
||||
PDEVICE_OBJECT FsctlDeviceObject = FsvrtDeviceExtension->FsctlDeviceObject;
|
||||
PDEVICE_OBJECT FsvolDeviceObject = FsvrtDeviceExtension->FsvolDeviceObject;
|
||||
PVPB OldVpb;
|
||||
BOOLEAN DeleteVpb = FALSE;
|
||||
BOOLEAN DeleteDelayed = FALSE;
|
||||
LARGE_INTEGER DelayTimeout;
|
||||
FSP_FSVRT_DELETE_VOLUME_WORK_ITEM *WorkItem = 0;
|
||||
KIRQL Irql;
|
||||
|
||||
/* access check */
|
||||
Result = FspSecuritySubjectContextAccessCheck(
|
||||
FsvrtDeviceExtension->SecurityDescriptorBuf, FILE_WRITE_DATA, Irp->RequestorMode);
|
||||
if (!NT_SUCCESS(Result))
|
||||
goto exit;
|
||||
|
||||
/* pre-allocate a work item in case we need it for delayed delete */
|
||||
WorkItem = FspAllocNonPaged(sizeof *WorkItem);
|
||||
if (0 == WorkItem)
|
||||
{
|
||||
Result = STATUS_INSUFFICIENT_RESOURCES;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
/* mark the virtual volume device as deleted */
|
||||
FsvrtDeviceExtension->Deleted = TRUE;
|
||||
|
||||
/* stop the I/O queue */
|
||||
FspIoqStop(&FsvrtDeviceExtension->Ioq);
|
||||
|
||||
/* swap the preallocated VPB */
|
||||
#pragma prefast(push)
|
||||
#pragma prefast(disable:28175, "We are a filesystem: ok to access Vpb")
|
||||
IoAcquireVpbSpinLock(&Irql);
|
||||
OldVpb = DeviceObject->Vpb;
|
||||
if (0 != OldVpb && 0 != FsvrtDeviceExtension->SwapVpb)
|
||||
{
|
||||
DeviceObject->Vpb = FsvrtDeviceExtension->SwapVpb;
|
||||
DeviceObject->Vpb->Size = sizeof *DeviceObject->Vpb;
|
||||
DeviceObject->Vpb->Type = IO_TYPE_VPB;
|
||||
DeviceObject->Vpb->Flags = FlagOn(OldVpb->Flags, VPB_REMOVE_PENDING);
|
||||
DeviceObject->Vpb->RealDevice = OldVpb->RealDevice;
|
||||
DeviceObject->Vpb->RealDevice->Vpb = DeviceObject->Vpb;
|
||||
FsvrtDeviceExtension->SwapVpb = 0;
|
||||
DeleteVpb = 0 == OldVpb->ReferenceCount;
|
||||
DeleteDelayed = !DeleteVpb && 0 != FsvolDeviceObject;
|
||||
if (DeleteDelayed)
|
||||
/* keep VPB around for delayed delete */
|
||||
OldVpb->ReferenceCount++;
|
||||
}
|
||||
IoReleaseVpbSpinLock(Irql);
|
||||
if (DeleteDelayed)
|
||||
/* keep fsvol around for delayed delete */
|
||||
FspDeviceRetain(FsvolDeviceObject);
|
||||
else if (DeleteVpb)
|
||||
FspFreeExternal(OldVpb);
|
||||
#pragma prefast(pop)
|
||||
|
||||
/* release the file system device and virtual volume objects */
|
||||
FsvrtDeviceExtension->FsvolDeviceObject = 0;
|
||||
if (0 != FsvolDeviceObject)
|
||||
FspDeviceRelease(FsvolDeviceObject);
|
||||
FspDeviceRelease(DeviceObject);
|
||||
|
||||
FspFsctlDeviceVolumeDeleted(FsctlDeviceObject);
|
||||
|
||||
/* are we doing delayed delete of VPB and fsvol? */
|
||||
if (DeleteDelayed)
|
||||
{
|
||||
DelayTimeout.QuadPart = 300/*ms*/ * -10000;
|
||||
WorkItem->FsvolDeviceObject = FsvolDeviceObject;
|
||||
WorkItem->OldVpb = OldVpb;
|
||||
FspInitializeWorkItemWithDelay(&WorkItem->WorkItemWithDelay,
|
||||
FspFsvrtDeleteVolumeDelayed, WorkItem);
|
||||
FspQueueWorkItemWithDelay(&WorkItem->WorkItemWithDelay, DelayTimeout);
|
||||
WorkItem = 0;
|
||||
}
|
||||
|
||||
Result = STATUS_SUCCESS;
|
||||
|
||||
exit:
|
||||
if (0 != WorkItem)
|
||||
FspFree(WorkItem);
|
||||
}
|
||||
finally
|
||||
{
|
||||
ExReleaseResourceLite(&FsctlDeviceExtension->Base.Resource);
|
||||
}
|
||||
|
||||
return Result;
|
||||
}
|
||||
|
||||
static VOID FspFsvrtDeleteVolumeDelayed(PVOID Context)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
FSP_FSVRT_DELETE_VOLUME_WORK_ITEM *WorkItem = Context;
|
||||
BOOLEAN DeleteVpb = FALSE;
|
||||
LARGE_INTEGER DelayTimeout;
|
||||
KIRQL Irql;
|
||||
|
||||
IoAcquireVpbSpinLock(&Irql);
|
||||
ASSERT(0 != WorkItem->OldVpb->ReferenceCount);
|
||||
DeleteVpb = 1 == WorkItem->OldVpb->ReferenceCount;
|
||||
if (DeleteVpb)
|
||||
WorkItem->OldVpb->ReferenceCount = 0;
|
||||
IoReleaseVpbSpinLock(Irql);
|
||||
if (DeleteVpb)
|
||||
{
|
||||
FspFreeExternal(WorkItem->OldVpb);
|
||||
FspDeviceRelease(WorkItem->FsvolDeviceObject);
|
||||
FspFree(WorkItem);
|
||||
}
|
||||
else
|
||||
{
|
||||
DelayTimeout.QuadPart = 300/*ms*/ * -10000;
|
||||
FspQueueWorkItemWithDelay(&WorkItem->WorkItemWithDelay, DelayTimeout);
|
||||
}
|
||||
}
|
||||
|
||||
static NTSTATUS FspFsvrtTransact(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
/* check parameters */
|
||||
ULONG InputBufferLength = IrpSp->Parameters.FileSystemControl.InputBufferLength;
|
||||
ULONG OutputBufferLength = IrpSp->Parameters.FileSystemControl.OutputBufferLength;
|
||||
PVOID SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
|
||||
if (0 == SystemBuffer ||
|
||||
(0 != InputBufferLength &&
|
||||
FSP_FSCTL_DEFAULT_ALIGN_UP(sizeof(FSP_FSCTL_TRANSACT_RSP)) > InputBufferLength))
|
||||
return STATUS_INVALID_PARAMETER;
|
||||
if (FSP_FSCTL_TRANSACT_REQ_BUFFER_SIZEMIN > OutputBufferLength)
|
||||
return STATUS_BUFFER_TOO_SMALL;
|
||||
|
||||
NTSTATUS Result;
|
||||
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension = FspFsvrtDeviceExtension(DeviceObject);
|
||||
PUINT8 SystemBufferEnd;
|
||||
FSP_FSCTL_TRANSACT_RSP *Response, *NextResponse;
|
||||
FSP_FSCTL_TRANSACT_REQ *Request, *PendingIrpRequest;
|
||||
PIRP ProcessIrp, PendingIrp;
|
||||
LARGE_INTEGER Timeout;
|
||||
|
||||
/* access check */
|
||||
Result = FspSecuritySubjectContextAccessCheck(
|
||||
FsvrtDeviceExtension->SecurityDescriptorBuf, FILE_WRITE_DATA, Irp->RequestorMode);
|
||||
if (!NT_SUCCESS(Result))
|
||||
return Result;
|
||||
|
||||
/* process any user-mode file system responses */
|
||||
Response = SystemBuffer;
|
||||
SystemBufferEnd = (PUINT8)SystemBuffer + InputBufferLength;
|
||||
for (;;)
|
||||
{
|
||||
NextResponse = FspFsctlTransactConsumeResponse(Response, SystemBufferEnd);
|
||||
if (0 == NextResponse)
|
||||
break;
|
||||
|
||||
ProcessIrp = FspIoqEndProcessingIrp(&FsvrtDeviceExtension->Ioq, (UINT_PTR)Response->Hint);
|
||||
if (0 == ProcessIrp)
|
||||
/* either IRP was canceled or a bogus Hint was provided */
|
||||
continue;
|
||||
|
||||
FspIopDispatchComplete(ProcessIrp, Response);
|
||||
|
||||
Response = NextResponse;
|
||||
}
|
||||
|
||||
/* wait for an IRP to arrive */
|
||||
KeQuerySystemTime(&Timeout);
|
||||
Timeout.QuadPart += FsvrtDeviceExtension->VolumeParams.TransactTimeout * 10000;
|
||||
/* convert millis to nanos and add to absolute time */
|
||||
while (0 == (PendingIrp = FspIoqNextPendingIrp(&FsvrtDeviceExtension->Ioq, &Timeout)))
|
||||
{
|
||||
if (FspIoqStopped(&FsvrtDeviceExtension->Ioq))
|
||||
return STATUS_CANCELLED;
|
||||
}
|
||||
if (FspIoqTimeout == PendingIrp)
|
||||
{
|
||||
Irp->IoStatus.Information = 0;
|
||||
return STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
/* send any pending IRP's to the user-mode file system */
|
||||
Request = SystemBuffer;
|
||||
SystemBufferEnd = (PUINT8)SystemBuffer + OutputBufferLength;
|
||||
ASSERT(FspFsctlTransactCanProduceRequest(Request, SystemBufferEnd));
|
||||
for (;;)
|
||||
{
|
||||
PendingIrpRequest = FspIrpRequest(PendingIrp);
|
||||
|
||||
Result = FspIopDispatchPrepare(PendingIrp, PendingIrpRequest);
|
||||
if (!NT_SUCCESS(Result))
|
||||
FspIopCompleteIrp(PendingIrp, Result);
|
||||
else
|
||||
{
|
||||
RtlCopyMemory(Request, PendingIrpRequest, PendingIrpRequest->Size);
|
||||
Request = FspFsctlTransactProduceRequest(Request, PendingIrpRequest->Size);
|
||||
|
||||
if (!FspIoqStartProcessingIrp(&FsvrtDeviceExtension->Ioq, PendingIrp))
|
||||
{
|
||||
/*
|
||||
* This can only happen if the Ioq was stopped. Abandon everything
|
||||
* and return STATUS_CANCELLED. Any IRP's in the Pending and Process
|
||||
* queues of the Ioq will be cancelled during FspIoqStop(). We must
|
||||
* also cancel the PendingIrp we have in our hands.
|
||||
*/
|
||||
ASSERT(FspIoqStopped(&FsvrtDeviceExtension->Ioq));
|
||||
FspIopCompleteIrp(PendingIrp, STATUS_CANCELLED);
|
||||
return STATUS_CANCELLED;
|
||||
}
|
||||
|
||||
/* check that we have enough space before pulling the next pending IRP off the queue */
|
||||
if (!FspFsctlTransactCanProduceRequest(Request, SystemBufferEnd))
|
||||
break;
|
||||
}
|
||||
|
||||
PendingIrp = FspIoqNextPendingIrp(&FsvrtDeviceExtension->Ioq, 0);
|
||||
if (0 == PendingIrp)
|
||||
break;
|
||||
|
||||
}
|
||||
Irp->IoStatus.Information = (PUINT8)Request - (PUINT8)SystemBuffer;
|
||||
|
||||
return STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
static NTSTATUS FspFsctlFileSystemControl(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
NTSTATUS Result = STATUS_INVALID_DEVICE_REQUEST;
|
||||
switch (IrpSp->MinorFunction)
|
||||
{
|
||||
case IRP_MN_USER_FS_REQUEST:
|
||||
switch (IrpSp->Parameters.FileSystemControl.FsControlCode)
|
||||
{
|
||||
case FSP_FSCTL_CREATE:
|
||||
Result = FspFsctlCreateVolume(DeviceObject, Irp, IrpSp);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case IRP_MN_MOUNT_VOLUME:
|
||||
Result = FspFsctlMountVolume(DeviceObject, Irp, IrpSp);
|
||||
break;
|
||||
#if 0
|
||||
case IRP_MN_VERIFY_VOLUME:
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
return Result;
|
||||
}
|
||||
|
||||
static NTSTATUS FspFsvrtFileSystemControl(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
NTSTATUS Result = STATUS_INVALID_DEVICE_REQUEST;
|
||||
switch (IrpSp->MinorFunction)
|
||||
{
|
||||
case IRP_MN_USER_FS_REQUEST:
|
||||
switch (IrpSp->Parameters.FileSystemControl.FsControlCode)
|
||||
{
|
||||
case FSP_FSCTL_DELETE:
|
||||
Result = FspFsvrtDeleteVolume(DeviceObject, Irp, IrpSp);
|
||||
break;
|
||||
case FSP_FSCTL_TRANSACT:
|
||||
Result = FspFsvrtTransact(DeviceObject, Irp, IrpSp);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
return Result;
|
||||
}
|
||||
|
||||
static NTSTATUS FspFsvolFileSystemControl(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
NTSTATUS Result = STATUS_INVALID_DEVICE_REQUEST;
|
||||
switch (IrpSp->MinorFunction)
|
||||
{
|
||||
case IRP_MN_USER_FS_REQUEST:
|
||||
break;
|
||||
}
|
||||
return Result;
|
||||
}
|
||||
|
||||
NTSTATUS FspFileSystemControl(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp)
|
||||
{
|
||||
FSP_ENTER_MJ(PAGED_CODE());
|
||||
|
||||
ASSERT(IRP_MJ_FILE_SYSTEM_CONTROL == IrpSp->MajorFunction);
|
||||
|
||||
switch (FspDeviceExtension(DeviceObject)->Kind)
|
||||
{
|
||||
case FspFsvolDeviceExtensionKind:
|
||||
FSP_RETURN(Result = FspFsvolFileSystemControl(DeviceObject, Irp, IrpSp));
|
||||
case FspFsvrtDeviceExtensionKind:
|
||||
FSP_RETURN(Result = FspFsvrtFileSystemControl(DeviceObject, Irp, IrpSp));
|
||||
case FspFsctlDeviceExtensionKind:
|
||||
FSP_RETURN(Result = FspFsctlFileSystemControl(DeviceObject, Irp, IrpSp));
|
||||
default:
|
||||
FSP_RETURN(Result = STATUS_INVALID_DEVICE_REQUEST);
|
||||
}
|
||||
|
||||
FSP_LEAVE_MJ(
|
||||
"FileObject=%p%s%s",
|
||||
IrpSp->FileObject,
|
||||
IRP_MN_USER_FS_REQUEST == IrpSp->MinorFunction ? ", " : "",
|
||||
IRP_MN_USER_FS_REQUEST == IrpSp->MinorFunction ?
|
||||
IoctlCodeSym(IrpSp->Parameters.FileSystemControl.FsControlCode) : "");
|
||||
}
|
||||
|
||||
VOID FspFileSystemControlComplete(
|
||||
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
|
||||
{
|
||||
FSP_ENTER_IOC(PAGED_CODE());
|
||||
|
||||
FSP_LEAVE_IOC(
|
||||
"FileObject=%p%s%s",
|
||||
IrpSp->FileObject,
|
||||
IRP_MN_USER_FS_REQUEST == IrpSp->MinorFunction ? ", " : "",
|
||||
IRP_MN_USER_FS_REQUEST == IrpSp->MinorFunction ?
|
||||
IoctlCodeSym(IrpSp->Parameters.FileSystemControl.FsControlCode) : "");
|
||||
}
|
102
src0/sys/idevctl.c
Normal file
102
src0/sys/idevctl.c
Normal file
@@ -0,0 +1,102 @@
|
||||
/**
|
||||
* @file sys/idevctl.c
|
||||
*
|
||||
* @copyright 2015 Bill Zissimopoulos
|
||||
*/
|
||||
|
||||
#include <sys/driver.h>
|
||||
|
||||
static NTSTATUS FspFsvolInternalDeviceControl(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
|
||||
FSP_IOCMPL_DISPATCH FspFsvolInternalDeviceControlComplete;
|
||||
FSP_DRIVER_DISPATCH FspInternalDeviceControl;
|
||||
|
||||
#ifdef ALLOC_PRAGMA
|
||||
#pragma alloc_text(PAGE, FspFsvolInternalDeviceControl)
|
||||
#pragma alloc_text(PAGE, FspFsvolInternalDeviceControlComplete)
|
||||
#pragma alloc_text(PAGE, FspInternalDeviceControl)
|
||||
#endif
|
||||
|
||||
static NTSTATUS FspFsvolInternalDeviceControl(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
NTSTATUS Result = STATUS_INVALID_DEVICE_REQUEST;
|
||||
switch (IrpSp->Parameters.DeviceIoControl.IoControlCode)
|
||||
{
|
||||
case FSP_FSCTL_WORK:
|
||||
{
|
||||
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
|
||||
PDEVICE_OBJECT FsvrtDeviceObject = FsvolDeviceExtension->FsvrtDeviceObject;
|
||||
|
||||
if (!FspDeviceRetain(FsvrtDeviceObject))
|
||||
return STATUS_CANCELLED;
|
||||
try
|
||||
{
|
||||
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension =
|
||||
FspFsvrtDeviceExtension(FsvrtDeviceObject);
|
||||
FSP_FSCTL_TRANSACT_REQ *Request = IrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
|
||||
|
||||
ASSERT(0 == Request->Hint);
|
||||
|
||||
/* associate the passed Request with our Irp; acquire ownership of the Request */
|
||||
Request->Hint = (UINT_PTR)Irp;
|
||||
FspIrpRequest(Irp) = Request;
|
||||
|
||||
/*
|
||||
* Post the IRP to our Ioq; we do this here instead of at IRP_LEAVE_MJ time,
|
||||
* so that we can disassociate the Request on failure and release ownership
|
||||
* back to the caller.
|
||||
*/
|
||||
if (!FspIoqPostIrp(&FsvrtDeviceExtension->Ioq, Irp))
|
||||
{
|
||||
/* this can only happen if the Ioq was stopped */
|
||||
ASSERT(FspIoqStopped(&FsvrtDeviceExtension->Ioq));
|
||||
|
||||
Request->Hint = 0;
|
||||
FspIrpRequest(Irp) = 0;
|
||||
|
||||
Result = STATUS_CANCELLED;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
Result = STATUS_PENDING;
|
||||
|
||||
exit:;
|
||||
}
|
||||
finally
|
||||
{
|
||||
FspDeviceRelease(FsvrtDeviceObject);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
return Result;
|
||||
}
|
||||
|
||||
VOID FspFsvolInternalDeviceControlComplete(
|
||||
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
|
||||
{
|
||||
FSP_ENTER_IOC(PAGED_CODE());
|
||||
|
||||
FSP_LEAVE_IOC("%s", IoctlCodeSym(IrpSp->Parameters.DeviceIoControl.IoControlCode));
|
||||
}
|
||||
|
||||
NTSTATUS FspInternalDeviceControl(
|
||||
PDEVICE_OBJECT DeviceObject, PIRP Irp)
|
||||
{
|
||||
FSP_ENTER_MJ(PAGED_CODE());
|
||||
|
||||
ASSERT(IRP_MJ_INTERNAL_DEVICE_CONTROL == IrpSp->MajorFunction);
|
||||
|
||||
switch (FspDeviceExtension(DeviceObject)->Kind)
|
||||
{
|
||||
case FspFsvolDeviceExtensionKind:
|
||||
FSP_RETURN(Result = FspFsvolInternalDeviceControl(DeviceObject, Irp, IrpSp));
|
||||
default:
|
||||
FSP_RETURN(Result = STATUS_INVALID_DEVICE_REQUEST);
|
||||
}
|
||||
|
||||
FSP_LEAVE_MJ("%s", IoctlCodeSym(IrpSp->Parameters.DeviceIoControl.IoControlCode));
|
||||
}
|
109
src0/sys/misc.c
Normal file
109
src0/sys/misc.c
Normal file
@@ -0,0 +1,109 @@
|
||||
/**
|
||||
* @file sys/misc.c
|
||||
*
|
||||
* @copyright 2015 Bill Zissimopoulos
|
||||
*/
|
||||
|
||||
#include <sys/driver.h>
|
||||
|
||||
NTSTATUS FspCreateGuid(GUID *Guid);
|
||||
BOOLEAN FspValidRelativeSecurityDescriptor(
|
||||
PSECURITY_DESCRIPTOR SecurityDescriptor, ULONG SecurityDescriptorLength,
|
||||
SECURITY_INFORMATION RequiredInformation);
|
||||
NTSTATUS FspSecuritySubjectContextAccessCheck(
|
||||
PSECURITY_DESCRIPTOR SecurityDescriptor, ACCESS_MASK DesiredAccess, KPROCESSOR_MODE AccessMode);
|
||||
VOID FspInitializeWorkItemWithDelay(FSP_WORK_ITEM_WITH_DELAY *WorkItem,
|
||||
PWORKER_THREAD_ROUTINE Routine, PVOID Context);
|
||||
VOID FspQueueWorkItemWithDelay(FSP_WORK_ITEM_WITH_DELAY *WorkItem, LARGE_INTEGER Timeout);
|
||||
static KDEFERRED_ROUTINE FspQueueWorkItemWithDelayDPC;
|
||||
|
||||
#ifdef ALLOC_PRAGMA
|
||||
#pragma alloc_text(PAGE, FspCreateGuid)
|
||||
#pragma alloc_text(PAGE, FspValidRelativeSecurityDescriptor)
|
||||
#pragma alloc_text(PAGE, FspSecuritySubjectContextAccessCheck)
|
||||
#pragma alloc_text(PAGE, FspInitializeWorkItemWithDelay)
|
||||
#pragma alloc_text(PAGE, FspQueueWorkItemWithDelay)
|
||||
#endif
|
||||
|
||||
NTSTATUS FspCreateGuid(GUID *Guid)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
NTSTATUS Result;
|
||||
|
||||
int Retries = 3;
|
||||
do
|
||||
{
|
||||
Result = ExUuidCreate(Guid);
|
||||
} while (!NT_SUCCESS(Result) && 0 < --Retries);
|
||||
|
||||
return Result;
|
||||
}
|
||||
|
||||
BOOLEAN FspValidRelativeSecurityDescriptor(
|
||||
PSECURITY_DESCRIPTOR SecurityDescriptor, ULONG SecurityDescriptorLength,
|
||||
SECURITY_INFORMATION RequiredInformation)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
BOOLEAN Result;
|
||||
|
||||
try
|
||||
{
|
||||
Result = RtlValidRelativeSecurityDescriptor(SecurityDescriptor, SecurityDescriptorLength,
|
||||
RequiredInformation);
|
||||
}
|
||||
except (EXCEPTION_EXECUTE_HANDLER)
|
||||
{
|
||||
Result = FALSE;
|
||||
}
|
||||
|
||||
return Result;
|
||||
}
|
||||
|
||||
NTSTATUS FspSecuritySubjectContextAccessCheck(
|
||||
PSECURITY_DESCRIPTOR SecurityDescriptor, ACCESS_MASK DesiredAccess, KPROCESSOR_MODE AccessMode)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
NTSTATUS Result = STATUS_ACCESS_DENIED;
|
||||
SECURITY_SUBJECT_CONTEXT SecuritySubjectContext;
|
||||
ACCESS_MASK GrantedAccess;
|
||||
|
||||
SeCaptureSubjectContext(&SecuritySubjectContext);
|
||||
if (SeAccessCheck(SecurityDescriptor,
|
||||
&SecuritySubjectContext, FALSE,
|
||||
DesiredAccess, 0, 0, IoGetFileObjectGenericMapping(), AccessMode,
|
||||
&GrantedAccess, &Result))
|
||||
Result = STATUS_SUCCESS;
|
||||
SeReleaseSubjectContext(&SecuritySubjectContext);
|
||||
|
||||
return Result;
|
||||
}
|
||||
|
||||
VOID FspInitializeWorkItemWithDelay(FSP_WORK_ITEM_WITH_DELAY *WorkItem,
|
||||
PWORKER_THREAD_ROUTINE Routine, PVOID Context)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
KeInitializeTimer(&WorkItem->Timer);
|
||||
KeInitializeDpc(&WorkItem->Dpc, FspQueueWorkItemWithDelayDPC, WorkItem);
|
||||
ExInitializeWorkItem(&WorkItem->WorkQueueItem, Routine, Context);
|
||||
}
|
||||
|
||||
VOID FspQueueWorkItemWithDelay(FSP_WORK_ITEM_WITH_DELAY *WorkItem, LARGE_INTEGER Timeout)
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
KeSetTimer(&WorkItem->Timer, Timeout, &WorkItem->Dpc);
|
||||
}
|
||||
|
||||
static VOID FspQueueWorkItemWithDelayDPC(PKDPC Dpc,
|
||||
PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
|
||||
{
|
||||
// !PAGED_CODE();
|
||||
|
||||
FSP_WORK_ITEM_WITH_DELAY *WorkItem = DeferredContext;
|
||||
|
||||
ExQueueWorkItem(&WorkItem->WorkQueueItem, DelayedWorkQueue);
|
||||
}
|
Reference in New Issue
Block a user