Major refactoring: WIP

This commit is contained in:
Bill Zissimopoulos
2015-12-20 10:57:45 -08:00
parent f099fe4bff
commit 7197501c9a
47 changed files with 2622 additions and 1982 deletions

20
src0/dll/debug.c Normal file
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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);
}