--- /dev/null
+
+#ifndef _NTOS_CCFUNCS_H
+#define _NTOS_CCFUNCS_H
+/* $Id: ccfuncs.h,v 1.8 2002/09/08 10:47:43 chorns Exp $ */
+
+/* exported variables */
+/*
+CcFastMdlReadWait
+CcFastReadNotPossible
+CcFastReadWait
+*/
+
+BOOLEAN
+STDCALL
+CcCanIWrite (
+ IN PFILE_OBJECT FileObject,
+ IN ULONG BytesToWrite,
+ IN BOOLEAN Wait,
+ IN BOOLEAN Retrying
+ );
+
+BOOLEAN
+STDCALL
+CcCopyRead (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ OUT PVOID Buffer,
+ OUT PIO_STATUS_BLOCK IoStatus
+ );
+
+BOOLEAN
+STDCALL
+CcCopyWrite (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ IN PVOID Buffer
+ );
+
+VOID
+STDCALL
+CcDeferWrite (
+ IN PFILE_OBJECT FileObject,
+ IN PCC_POST_DEFERRED_WRITE PostRoutine,
+ IN PVOID Context1,
+ IN PVOID Context2,
+ IN ULONG BytesToWrite,
+ IN BOOLEAN Retrying
+ );
+
+BOOLEAN
+STDCALL
+CcFastCopyRead (
+ IN PFILE_OBJECT FileObject,
+ IN ULONG FileOffset,
+ IN ULONG Length,
+ IN ULONG PageCount,
+ OUT PVOID Buffer,
+ OUT PIO_STATUS_BLOCK IoStatus
+ );
+
+BOOLEAN
+STDCALL
+CcFastCopyWrite (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN PVOID Buffer
+ );
+
+VOID
+STDCALL
+CcFlushCache (
+ IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
+ IN PLARGE_INTEGER FileOffset OPTIONAL,
+ IN ULONG Length,
+ OUT PIO_STATUS_BLOCK IoStatus OPTIONAL
+ );
+
+LARGE_INTEGER
+STDCALL
+CcGetDirtyPages (
+ IN PVOID LogHandle,
+ IN PDIRTY_PAGE_ROUTINE DirtyPageRoutine,
+ IN PVOID Context1,
+ IN PVOID Context2
+ );
+
+PFILE_OBJECT
+STDCALL
+CcGetFileObjectFromBcb (
+ IN PVOID Bcb
+ );
+
+PFILE_OBJECT
+STDCALL
+CcGetFileObjectFromSectionPtrs (
+ IN PSECTION_OBJECT_POINTERS SectionObjectPointer
+ );
+
+LARGE_INTEGER
+STDCALL
+CcGetLsnForFileObject (
+ IN PFILE_OBJECT FileObject,
+ OUT PLARGE_INTEGER OldestLsn OPTIONAL
+ );
+
+VOID
+STDCALL
+CcInitializeCacheMap (
+ IN PFILE_OBJECT FileObject,
+ IN PCC_FILE_SIZES FileSizes,
+ IN BOOLEAN PinAccess,
+ IN PCACHE_MANAGER_CALLBACKS CallBacks,
+ IN PVOID LazyWriterContext
+ );
+
+BOOLEAN
+STDCALL
+CcIsThereDirtyData (
+ IN PVPB Vpb
+ );
+
+BOOLEAN
+STDCALL
+CcMapData (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ OUT PVOID * Bcb,
+ OUT PVOID * Buffer
+ );
+
+VOID
+STDCALL
+CcMdlRead (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ OUT PMDL * MdlChain,
+ OUT PIO_STATUS_BLOCK IoStatus
+ );
+
+VOID
+STDCALL
+CcMdlReadComplete (
+ IN PFILE_OBJECT FileObject,
+ IN PMDL MdlChain
+ );
+
+VOID
+STDCALL
+CcMdlWriteComplete (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN PMDL MdlChain
+ );
+
+BOOLEAN
+STDCALL
+CcPinMappedData (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ OUT PVOID * Bcb
+ );
+
+BOOLEAN
+STDCALL
+CcPinRead (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ OUT PVOID * Bcb,
+ OUT PVOID * Buffer
+ );
+
+VOID
+STDCALL
+CcPrepareMdlWrite (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ OUT PMDL * MdlChain,
+ OUT PIO_STATUS_BLOCK IoStatus
+ );
+
+BOOLEAN
+STDCALL
+CcPreparePinWrite (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Zero,
+ IN BOOLEAN Wait,
+ OUT PVOID * Bcb,
+ OUT PVOID * Buffer
+ );
+
+BOOLEAN
+STDCALL
+CcPurgeCacheSection (
+ IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
+ IN PLARGE_INTEGER FileOffset OPTIONAL,
+ IN ULONG Length,
+ IN BOOLEAN UninitializeCacheMaps
+ );
+
+#define CcReadAhead(FO,FOFF,LEN) \
+{ \
+ if ((LEN) >= 256) \
+ { \
+ CcScheduleReadAhead((FO),(FOFF),(LEN)); \
+ } \
+}
+
+VOID
+STDCALL
+CcRepinBcb (
+ IN PVOID Bcb
+ );
+
+VOID
+STDCALL
+CcScheduleReadAhead (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length
+ );
+
+VOID
+STDCALL
+CcSetAdditionalCacheAttributes (
+ IN PFILE_OBJECT FileObject,
+ IN BOOLEAN DisableReadAhead,
+ IN BOOLEAN DisableWriteBehind
+ );
+
+VOID
+STDCALL
+CcSetBcbOwnerPointer (
+ IN PVOID Bcb,
+ IN PVOID Owner
+ );
+
+VOID
+STDCALL
+CcSetDirtyPageThreshold (
+ IN PFILE_OBJECT FileObject,
+ IN ULONG DirtyPageThreshold
+ );
+
+VOID
+STDCALL
+CcSetDirtyPinnedData (
+ IN PVOID Bcb,
+ IN PLARGE_INTEGER Lsn OPTIONAL
+ );
+
+VOID
+STDCALL
+CcSetFileSizes (
+ IN PFILE_OBJECT FileObject,
+ IN PCC_FILE_SIZES FileSizes
+ );
+
+VOID
+STDCALL
+CcSetLogHandleForFile (
+ IN PFILE_OBJECT FileObject,
+ IN PVOID LogHandle,
+ IN PFLUSH_TO_LSN FlushToLsnRoutine
+ );
+
+VOID
+STDCALL
+CcSetReadAheadGranularity (
+ IN PFILE_OBJECT FileObject,
+ IN ULONG Granularity
+ );
+
+BOOLEAN
+STDCALL
+CcUninitializeCacheMap (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER TruncateSize OPTIONAL,
+ IN PCACHE_UNINITIALIZE_EVENT UninitializeCompleteEvent OPTIONAL
+ );
+
+VOID
+STDCALL
+CcUnpinData (
+ IN PVOID Bcb
+ );
+
+VOID
+STDCALL
+CcUnpinDataForThread (
+ IN PVOID Bcb,
+ IN ERESOURCE_THREAD ResourceThreadId
+ );
+
+VOID
+STDCALL
+CcUnpinRepinnedBcb (
+ IN PVOID Bcb,
+ IN BOOLEAN WriteThrough,
+ IN PIO_STATUS_BLOCK IoStatus
+ );
+
+BOOLEAN
+STDCALL
+CcZeroData (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER StartOffset,
+ IN PLARGE_INTEGER EndOffset,
+ IN BOOLEAN Wait
+ );
+
+#endif
+
+/* EOF */
--- /dev/null
+#ifndef __INCLUDE_DDK_CCTYPES_H
+#define __INCLUDE_DDK_CCTYPES_H
+
+typedef struct _CACHE_UNINITIALIZE_EVENT
+{
+ struct _CACHE_UNINITIALIZE_EVENT * Next;
+ KEVENT Event;
+} CACHE_UNINITIALIZE_EVENT, *PCACHE_UNINITIALIZE_EVENT;
+
+typedef struct _CC_FILE_SIZES
+{
+ LARGE_INTEGER AllocationSize;
+ LARGE_INTEGER FileSize;
+ LARGE_INTEGER ValidDataLength;
+} CC_FILE_SIZES, *PCC_FILE_SIZES;
+
+
+typedef VOID STDCALL
+(*PCC_POST_DEFERRED_WRITE)(IN PVOID Context1,
+ IN PVOID Context2);
+
+typedef struct _PUBLIC_BCB
+{
+ CSHORT NodeTypeCode;
+ CSHORT NodeByteSize;
+ ULONG MappedLength;
+ LARGE_INTEGER MappedFileOffset;
+} PUBLIC_BCB, *PPUBLIC_BCB;
+
+typedef VOID (*PDIRTY_PAGE_ROUTINE) (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN PLARGE_INTEGER OldestLsn,
+ IN PLARGE_INTEGER NewestLsn,
+ IN PVOID Context1,
+ IN PVOID Context2
+);
+
+typedef BOOLEAN STDCALL
+(*PACQUIRE_FOR_LAZY_WRITE)(IN PVOID Context,
+ IN BOOLEAN Wait);
+
+typedef VOID STDCALL
+(*PRELEASE_FROM_LAZY_WRITE)(IN PVOID Context);
+
+typedef BOOLEAN STDCALL
+(*PACQUIRE_FOR_READ_AHEAD)(IN PVOID Context,
+ IN BOOLEAN Wait);
+
+typedef VOID STDCALL
+(*PRELEASE_FROM_READ_AHEAD)(IN PVOID Context);
+
+typedef struct _CACHE_MANAGER_CALLBACKS
+{
+ PACQUIRE_FOR_LAZY_WRITE AcquireForLazyWrite;
+ PRELEASE_FROM_LAZY_WRITE ReleaseFromLazyWrite;
+ PACQUIRE_FOR_READ_AHEAD AcquireForReadAhead;
+ PRELEASE_FROM_READ_AHEAD ReleaseFromReadAhead;
+} CACHE_MANAGER_CALLBACKS, *PCACHE_MANAGER_CALLBACKS;
+
+/* this is already defined in iotypes.h */
+/*
+typedef struct _SECTION_OBJECT_POINTERS
+{
+ PVOID DataSectionObject;
+ PVOID SharedCacheMap;
+ PVOID ImageSectionObject;
+} SECTION_OBJECT_POINTERS, *PSECTION_OBJECT_POINTERS;
+*/
+
+typedef VOID STDCALL
+(*PFLUSH_TO_LSN)(IN PVOID LogHandle,
+ IN LARGE_INTEGER Lsn);
+
+typedef struct _REACTOS_COMMON_FCB_HEADER
+{
+ CSHORT NodeTypeCode;
+ CSHORT NodeByteSize;
+ struct _BCB* Bcb;
+ LARGE_INTEGER AllocationSize;
+ LARGE_INTEGER FileSize;
+ LARGE_INTEGER ValidDataLength;
+} REACTOS_COMMON_FCB_HEADER, *PREACTOS_COMMON_FCB_HEADER;
+
+#endif /* __INCLUDE_DDK_CCTYPES_H */
--- /dev/null
+/*
+ * FUNCTION: Creates a registry key
+ * ARGUMENTS:
+ * KeyHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Specifies the allowed or desired access to the key
+ * It can have a combination of the following values:
+ * KEY_READ | KEY_WRITE | KEY_EXECUTE | KEY_ALL_ACCESS
+ * or
+ * KEY_QUERY_VALUE The values of the key can be queried.
+ * KEY_SET_VALUE The values of the key can be modified.
+ * KEY_CREATE_SUB_KEYS The key may contain subkeys.
+ * KEY_ENUMERATE_SUB_KEYS Subkeys can be queried.
+ * KEY_NOTIFY
+ * KEY_CREATE_LINK A symbolic link to the key can be created.
+ * ObjectAttributes = The name of the key may be specified directly in the name field
+ * of object attributes or relative to a key in rootdirectory.
+ * TitleIndex = Might specify the position in the sequential order of subkeys.
+ * Class = Specifies the kind of data, for example REG_SZ for string data. [ ??? ]
+ * CreateOptions = Specifies additional options with which the key is created
+ * REG_OPTION_VOLATILE The key is not preserved across boots.
+ * REG_OPTION_NON_VOLATILE The key is preserved accross boots.
+ * REG_OPTION_CREATE_LINK The key is a symbolic link to another key.
+ * REG_OPTION_BACKUP_RESTORE Key is being opened or created for backup/restore operations.
+ * Disposition = Indicates if the call to NtCreateKey resulted in the creation of a key it
+ * can have the following values: REG_CREATED_NEW_KEY | REG_OPENED_EXISTING_KEY
+ * RETURNS:
+ * Status
+ */
+
+NTSTATUS STDCALL
+NtCreateKey(OUT PHANDLE KeyHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN ULONG TitleIndex,
+ IN PUNICODE_STRING Class OPTIONAL,
+ IN ULONG CreateOptions,
+ IN PULONG Disposition OPTIONAL);
+
+NTSTATUS STDCALL
+ZwCreateKey(OUT PHANDLE KeyHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN ULONG TitleIndex,
+ IN PUNICODE_STRING Class OPTIONAL,
+ IN ULONG CreateOptions,
+ IN PULONG Disposition OPTIONAL);
+
--- /dev/null
+
+/*
+ * Object Manager structures and typedefs
+ */
+
+/*
+ * key query information class
+ */
+
+typedef enum _KEY_INFORMATION_CLASS
+{
+ KeyBasicInformation,
+ KeyNodeInformation,
+ KeyFullInformation
+} KEY_INFORMATION_CLASS;
+
+typedef struct _KEY_BASIC_INFORMATION
+{
+ LARGE_INTEGER LastWriteTime;
+ ULONG TitleIndex;
+ ULONG NameLength;
+ WCHAR Name[1];
+} KEY_BASIC_INFORMATION, *PKEY_BASIC_INFORMATION;
+
+typedef struct _KEY_FULL_INFORMATION
+{
+ LARGE_INTEGER LastWriteTime;
+ ULONG TitleIndex;
+ ULONG ClassOffset;
+ ULONG ClassLength;
+ ULONG SubKeys;
+ ULONG MaxNameLen;
+ ULONG MaxClassLen;
+ ULONG Values;
+ ULONG MaxValueNameLen;
+ ULONG MaxValueDataLen;
+ WCHAR Class[1];
+} KEY_FULL_INFORMATION, *PKEY_FULL_INFORMATION;
+
+typedef struct _KEY_NODE_INFORMATION
+{
+ LARGE_INTEGER LastWriteTime;
+ ULONG TitleIndex;
+ ULONG ClassOffset;
+ ULONG ClassLength;
+ ULONG NameLength;
+ WCHAR Name[1];
+} KEY_NODE_INFORMATION, *PKEY_NODE_INFORMATION;
+
+/* key set information class */
+/*
+ * KeyWriteTimeInformation
+ */
+
+/* key value information class */
+
+typedef enum _KEY_VALUE_INFORMATION_CLASS
+{
+ KeyValueBasicInformation,
+ KeyValueFullInformation,
+ KeyValuePartialInformation
+} KEY_VALUE_INFORMATION_CLASS;
+
+typedef struct _KEY_VALUE_BASIC_INFORMATION
+{
+ ULONG TitleIndex;
+ ULONG Type;
+ ULONG NameLength;
+ WCHAR Name[1];
+} KEY_VALUE_BASIC_INFORMATION, *PKEY_VALUE_BASIC_INFORMATION;
+
+typedef struct _KEY_VALUE_FULL_INFORMATION
+{
+ ULONG TitleIndex;
+ ULONG Type;
+ ULONG DataOffset;
+ ULONG DataLength;
+ ULONG NameLength;
+ WCHAR Name[1];
+} KEY_VALUE_FULL_INFORMATION, *PKEY_VALUE_FULL_INFORMATION;
+
+typedef struct _KEY_VALUE_PARTIAL_INFORMATION
+{
+ ULONG TitleIndex;
+ ULONG Type;
+ ULONG DataLength;
+ UCHAR Data[1];
+} KEY_VALUE_PARTIAL_INFORMATION, *PKEY_VALUE_PARTIAL_INFORMATION;
+
+
+/* used by [Nt/Zw]QueryMultipleValueKey */
+
+typedef struct _KEY_VALUE_ENTRY
+{
+ PUNICODE_STRING ValueName;
+ ULONG DataLength;
+ ULONG DataOffset;
+ ULONG Type;
+} KEY_VALUE_ENTRY, *PKEY_VALUE_ENTRY;
+
--- /dev/null
+#ifndef __INCLUDE_DDK_DBGFUNCS_H
+#define __INCLUDE_DDK_DBGFUNCS_H
+/* $Id: dbgfuncs.h,v 1.7 2002/09/08 10:47:43 chorns Exp $ */
+
+#define DBG_STATUS_CONTROL_C 1
+#define DBG_STATUS_SYSRQ 2
+#define DBG_STATUS_BUGCHECK_FIRST 3
+#define DBG_STATUS_BUGCHECK_SECOND 4
+#define DBG_STATUS_FATAL 5
+VOID STDCALL DbgBreakPointWithStatus (ULONG Status);
+VOID STDCALL DbgBreakPoint(VOID);
+ULONG DbgPrint(PCH Format,...);
+VOID STDCALL DbgPrompt (PCH OutputString, PCH InputString, USHORT InputSize);
+
+
+#define DBG_GET_SHOW_FACILITY 0x0001
+#define DBG_GET_SHOW_SEVERITY 0x0002
+#define DBG_GET_SHOW_ERRCODE 0x0004
+#define DBG_GET_SHOW_ERRTEXT 0x0008
+VOID DbgGetErrorText(NTSTATUS ErrorCode, PUNICODE_STRING ErrorText, ULONG Flags);
+VOID DbgPrintErrorMessage(NTSTATUS ErrorCode);
+
+#endif /* __INCLUDE_DDK_DBGFUNCS_H */
--- /dev/null
+#ifndef _DDK_DEFINES_H
+#define _DDK_DEFINES_H
+
+/* GENERAL DEFINITIONS ****************************************************/
+
+#ifndef __ASM__
+
+#define _WIN32_WINNT 0x0400
+
+#include <ddk/kedef.h>
+#include <ddk/iodef.h>
+
+#define EXPORTED __declspec(dllexport)
+#define IMPORTED __declspec(dllimport)
+
+/*
+ * PURPOSE: Number of a thread priority levels
+ */
+#define NR_PRIORITY_LEVELS (32)
+
+/*
+ * PURPOSE: Type of queue to insert a work item in
+ */
+enum
+{
+ CriticalWorkQueue,
+ DelayedWorkQueue,
+ HyperCriticalWorkQueue,
+};
+
+/*
+ * Types of memory to allocate
+ */
+enum
+{
+ NonPagedPool,
+ NonPagedPoolMustSucceed,
+ NonPagedPoolCacheAligned,
+ NonPagedPoolCacheAlignedMustS,
+ PagedPool,
+ PagedPoolCacheAligned,
+};
+
+/*
+ * This is a list of bug check types (not MS's)
+ */
+enum
+{
+ APC_INDEX_MISMATCH = 1,
+ DEVICE_QUEUE_NOT_BUSY,
+ INVALID_AFFINITY_SET,
+ INVALID_DATA_ACCESS_TRAP,
+ INVALID_PROCESS_ATTACH_ATTEMPT,
+ INVALID_PROCESS_DEATTACH_ATTEMPT,
+ INVALID_SOFTWARE_INTERRUPT,
+ IRQL_NOT_DISPATCH_LEVEL,
+ IRQL_NOT_GREATER_OR_EQUAL,
+ NO_EXCEPTION_HANDLING_SUPPORT,
+ MAXIMUM_WAIT_OBJECTS_EXCEEDED,
+ MUTEX_LEVEL_NUMBER_VIOLATION,
+ NO_USER_MODE_CONTEXT,
+ SPIN_LOCK_ALREADY_OWNED,
+ SPIN_LOCK_NOT_OWNED,
+ THREAD_NOT_MUTEX_OWNER,
+ TRAP_CAUSE_UNKNOWN,
+ EMPTY_THREAD_REAPER_LIST,
+ CREATE_DELETE_LOCK_NOT_LOCKED,
+ LAST_CHANCE_CALLED_FROM_KMODE,
+ CID_HANDLE_CREATION,
+ CID_HANDLE_DELETION,
+ REFERENCE_BY_POINTER,
+ BAD_POOL_HEADER,
+ MEMORY_MANAGMENT,
+ PFN_SHARE_COUNT,
+ PFN_REFERENCE_COUNT,
+ NO_SPIN_LOCK_AVAILABLE,
+ KMODE_EXCEPTION_NOT_HANDLED,
+ SHARED_RESOURCE_CONV_ERROR,
+ KERNEL_APC_PENDING_DURING_EXIT,
+ QUOTA_UNDERFLOW,
+ FILE_SYSTEM,
+ FAT_FILE_SYSTEM,
+ NTFS_FILE_SYSTEM,
+ NPFS_FILE_SYSTEM,
+ CDFS_FILE_SYSTEM,
+ RDR_FILE_SYSTEM,
+ CORRUPT_ACCESS_TOKEN,
+ SECURITY_SYSTEM,
+ INCONSISTENT_IRP,
+ PANIC_STACK_SWITCH,
+ PORT_DRIVER_INTERNAL,
+ SCSI_DISK_DRIVER_INTERNAL,
+ INSTRUCTION_BUS_ERROR,
+ SET_OF_INVALID_CONTEXT,
+ PHASE0_INITIALIZATION_FAILED,
+ PHASE1_INITIALIZATION_FAILED,
+ UNEXPECTED_INITIALIZATION_CALL,
+ CACHE_MANAGER,
+ NO_MORE_IRP_STACK_LOCATIONS,
+ DEVICE_REFERENCE_COUNT_NOT_ZERO,
+ FLOPPY_INTERNAL_ERROR,
+ SERIAL_DRIVER_INTERNAL,
+ SYSTEM_EXIT_OWNED_MUTEX,
+ SYSTEM_UNWIND_PREVIOUS_USER,
+ SYSTEN_SERVICE_EXCEPTION,
+ INTERRUPT_UNWIND_ATTEMPTED,
+ INTERRUPT_EXCEPTION_NOT_HANDLED,
+ MULTIPROCESSOR_CONFIGURATION_NOT_SUPPORTED,
+ NO_MORE_SYSTEM_PTES,
+ TARGET_MDL_TOO_SMALL,
+ MUST_SUCCEED_POOL_EMPTY,
+ ATDISK_DRIVER_INTERNAL,
+ NO_SUCH_PARTITION,
+ MULTIPLE_IRP_COMPLETE_REQUESTS,
+ INSUFFICENT_SYSTEM_MAP_PAGES,
+ DEREF_UNKNOWN_LOGON_SERVICE,
+ REF_UNKNOWN_LOGON_SERVICE,
+ CANCEL_STATE_IN_COMPLETED_IRP,
+ PAGE_FAULT_WITH_INTERRUPTS_OFF,
+ IRQL_GT_ZERO_AT_SYSTEM_SERVICE,
+ STREAMS_INTERNAL_ERROR,
+ FATAL_UNHANDLED_HARD_ERROR,
+ NO_PAGES_AVAILABLE,
+ PFN_LIST_CORRUPT,
+ NDIS_INTERNAL_ERROR,
+ PAGE_FAULT_IN_NONPAGED_AREA,
+ REGISTRY_ERROR,
+ MAILSLOT_FILE_SYSTEM,
+ NO_BOOT_DEVICE,
+ LM_SERVER_INTERNAL_ERROR,
+ DATA_COHERENCY_EXCEPTION,
+ INSTRUCTION_COHERENCY_EXCEPTION,
+ XNS_INTERNAL_ERROR,
+ FTDISK_INTERNAL_ERROR,
+ PINBALL_FILE_SYSTEM,
+ CRITICAL_SERVICE_FAILED,
+ SET_ENV_VAR_FAILED,
+ HAL_INITIALIZED_FAILED,
+ UNSUPPORTED_PROCESSOR,
+ OBJECT_INITIALIZATION_FAILED,
+ SECURITY_INITIALIZATION_FAILED,
+ PROCESS_INITIALIZATION_FAILED,
+ HAL1_INITIALIZATION_FAILED,
+};
+enum
+{
+ KBUG_NONE,
+ KBUG_ORPHANED_IRP,
+ KBUG_IO_STACK_OVERFLOW,
+ KBUG_OUT_OF_MEMORY,
+ KBUG_POOL_FREE_LIST_CORRUPT,
+
+ /*
+ * These are well known but the actual value is unknown
+ */
+// NO_PAGES_AVAILABLE,
+
+ /*
+ * These are well known (MS) bug types
+ * (Reference: NT Insider 1997 - http://www.osr.com)
+ */
+ IRQL_NOT_LESS_OR_EQUAL = 0xa,
+// KMODE_EXCEPTION_NOT_HANDLED = 0x1e,
+ UNEXPECTED_KERNEL_MODE_TRAP = 0x7f,
+ PAGE_FAULT_IN_NON_PAGED_AREA = 0x50,
+};
+
+/*
+ * PURPOSE: Object attributes
+ */
+enum
+{
+ OBJ_INHERIT = 0x2,
+ OBJ_PERMANENT = 0x10,
+ OBJ_EXCLUSIVE = 0x20,
+ OBJ_CASE_INSENSITIVE = 0x40,
+ OBJ_OPENIF = 0x80,
+ OBJ_OPENLINK = 0x100,\r
+ OBJ_VALID_ATTRIBUTES = 0x1F2,\r
+};
+
+/*
+ * PURPOSE: Timer types
+ */
+enum
+ {
+ NotificationTimer,
+ SynchronizationTimer,
+ };
+
+/*
+ * PURPOSE: Some drivers use these
+ */
+#ifndef IN
+#define IN
+#define OUT
+#define OPTIONAL
+#endif
+
+/*
+ * PURPOSE: Arguments to MmProbeAndLockPages
+ */
+enum
+{
+ IoReadAccess,
+ IoWriteAccess,
+ IoModifyAccess,
+};
+
+#define MAXIMUM_VOLUME_LABEL_LENGTH (32)
+
+#include <ddk/i386/irql.h>
+
+#define PASSIVE_LEVEL 0 // Passive release level
+#define LOW_LEVEL 0 // Lowest interrupt level
+#define APC_LEVEL 1 // APC interrupt level
+#define DISPATCH_LEVEL 2 // Dispatcher level
+/* timer used for profiling */
+#define PROFILE_LEVEL 27
+/* Interval clock 1 level - Not used on x86 */
+#define CLOCK1_LEVEL 28
+#define CLOCK2_LEVEL 28 // Interval clock 2 level
+#define IPI_LEVEL 29 // Interprocessor interrupt level
+#define POWER_LEVEL 30 // Power failure level
+#define HIGH_LEVEL 31 // Highest interrupt level
+#define SYNCH_LEVEL (IPI_LEVEL-1) // synchronization level
+
+#endif /* __ASM__ */
+
+/* Values returned by KeGetPreviousMode() */
+#define KernelMode (0)
+#define UserMode (1)
+
+#endif /* ndef _DDK_DEFINES_H */
--- /dev/null
+#ifndef _NTOS_EXFUNCS_H
+#define _NTOS_EXFUNCS_H
+
+/* EXECUTIVE ROUTINES ******************************************************/
+
+#define TAG(A, B, C, D) (ULONG)(((A)<<0) + ((B)<<8) + ((C)<<16) + ((D)<<24))
+
+VOID
+FASTCALL
+ExAcquireFastMutex (
+ PFAST_MUTEX FastMutex
+ );
+VOID
+FASTCALL
+ExAcquireFastMutexUnsafe (
+ PFAST_MUTEX FastMutex
+ );
+BOOLEAN
+STDCALL
+ExAcquireResourceExclusive (
+ PERESOURCE Resource,
+ BOOLEAN Wait
+ );
+BOOLEAN
+STDCALL
+ExAcquireResourceExclusiveLite (
+ PERESOURCE Resource,
+ BOOLEAN Wait
+ );
+BOOLEAN
+STDCALL
+ExAcquireResourceSharedLite (
+ PERESOURCE Resource,
+ BOOLEAN Wait
+ );
+BOOLEAN
+STDCALL
+ExAcquireSharedStarveExclusive (
+ PERESOURCE Resource,
+ BOOLEAN Wait
+ );
+BOOLEAN
+STDCALL
+ExAcquireSharedWaitForExclusive (
+ PERESOURCE Resource,
+ BOOLEAN Wait
+ );
+
+PVOID
+STDCALL
+ExAllocateFromZone (
+ PZONE_HEADER Zone
+ );
+
+/*
+ * PVOID
+ * ExAllocateFromZone (
+ * PZONE_HEADER Zone
+ * );
+ *
+ * FUNCTION:
+ * Allocate a block from a zone
+ *
+ * ARGUMENTS:
+ * Zone = Zone to allocate from
+ *
+ * RETURNS:
+ * The base address of the block allocated
+ */
+#define ExAllocateFromZone(Zone) \
+ (PVOID)((Zone)->FreeList.Next); \
+ if ((Zone)->FreeList.Next) \
+ (Zone)->FreeList.Next = (Zone)->FreeList.Next->Next
+
+/*
+ * FUNCTION: Allocates memory from the nonpaged pool
+ * ARGUMENTS:
+ * NumberOfBytes = minimum size of the block to be allocated
+ * PoolType = the type of memory to use for the block (ignored)
+ * RETURNS:
+ * the address of the block if it succeeds
+ */
+PVOID
+STDCALL
+ExAllocatePool (
+ IN POOL_TYPE PoolType,
+ IN ULONG NumberOfBytes
+ );
+
+PVOID
+STDCALL
+ExAllocatePoolWithQuota (
+ IN POOL_TYPE PoolType,
+ IN ULONG NumberOfBytes
+ );
+PVOID
+STDCALL
+ExAllocatePoolWithQuotaTag (
+ IN POOL_TYPE PoolType,
+ IN ULONG NumberOfBytes,
+ IN ULONG Tag
+ );
+PVOID
+STDCALL
+ExAllocatePoolWithTag (
+ IN POOL_TYPE PoolType,
+ IN ULONG NumberOfBytes,
+ IN ULONG Tag
+ );
+
+VOID
+STDCALL
+ExConvertExclusiveToSharedLite (
+ PERESOURCE Resource
+ );
+
+NTSTATUS
+STDCALL
+ExCreateCallback (
+ OUT PCALLBACK_OBJECT * CallbackObject,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN BOOLEAN Create,
+ IN BOOLEAN AllowMultipleCallbacks
+ );
+
+NTSTATUS
+STDCALL
+ExDeleteResource (
+ PERESOURCE Resource
+ );
+NTSTATUS
+STDCALL
+ExDeleteResourceLite (
+ PERESOURCE Resource
+ );
+
+VOID
+STDCALL
+ExDisableResourceBoostLite (
+ PERESOURCE Resource
+ );
+
+NTSTATUS
+STDCALL
+ExExtendZone (
+ PZONE_HEADER Zone,
+ PVOID Segment,
+ ULONG SegmentSize
+ );
+
+/*
+ * FUNCTION: Releases previously allocated memory
+ * ARGUMENTS:
+ * block = block to free
+ */
+VOID
+STDCALL
+ExFreePool (
+ PVOID block
+ );
+
+/*
+ * PVOID
+ * ExFreeToZone (
+ * PZONE_HEADER Zone,
+ * PVOID Block
+ * );
+ *
+ * FUNCTION:
+ * Frees a block from a zone
+ *
+ * ARGUMENTS:
+ * Zone = Zone the block was allocated from
+ * Block = Block to free
+ */
+#define ExFreeToZone(Zone,Block) \
+ (((PSINGLE_LIST_ENTRY)(Block))->Next = (Zone)->FreeList.Next, \
+ (Zone)->FreeList.Next = ((PSINGLE_LIST_ENTRY)(Block)), \
+ ((PSINGLE_LIST_ENTRY)(Block))->Next)
+
+/*
+ * ERESOURCE_THREAD
+ * ExGetCurrentResourceThread (
+ * VOID
+ * );
+ */
+#define ExGetCurrentResourceThread() \
+ ((ERESOURCE_THREAD)PsGetCurrentThread())
+
+ULONG
+STDCALL
+ExGetExclusiveWaiterCount (
+ PERESOURCE Resource
+ );
+
+ULONG
+STDCALL
+ExGetPreviousMode (
+ VOID
+ );
+
+ULONG
+STDCALL
+ExGetSharedWaiterCount (
+ PERESOURCE Resource
+ );
+
+/*
+ * VOID
+ * ExInitializeFastMutex (
+ * PFAST_MUTEX FastMutex
+ * );
+ */
+#define ExInitializeFastMutex(_FastMutex) \
+ ((PFAST_MUTEX)_FastMutex)->Count = 1; \
+ ((PFAST_MUTEX)_FastMutex)->Owner = NULL; \
+ ((PFAST_MUTEX)_FastMutex)->Contention = 0; \
+ KeInitializeEvent(&((PFAST_MUTEX)_FastMutex)->Event, \
+ SynchronizationEvent, \
+ FALSE);
+
+NTSTATUS
+STDCALL
+ExInitializeResource (
+ PERESOURCE Resource
+ );
+NTSTATUS
+STDCALL
+ExInitializeResourceLite (
+ PERESOURCE Resource
+ );
+
+/*
+ * VOID
+ * ExInitializeSListHead (
+ * PSLIST_HEADER SListHead
+ * );
+ */
+#define ExInitializeSListHead(ListHead) \
+ (ListHead)->Alignment = 0
+
+/*
+ * VOID
+ * ExInitializeWorkItem (
+ * PWORK_QUEUE_ITEM Item,
+ * PWORKER_THREAD_ROUTINE Routine,
+ * PVOID Context
+ * );
+ *
+ * FUNCTION:
+ * Initializes a work item to be processed by one of the system
+ * worker threads
+ *
+ * ARGUMENTS:
+ * Item = Pointer to the item to be initialized
+ * Routine = Routine to be called by the worker thread
+ * Context = Parameter to be passed to the callback
+ */
+#define ExInitializeWorkItem(Item, WorkerRoutine, RoutineContext) \
+ ASSERT_IRQL(DISPATCH_LEVEL); \
+ (Item)->Routine = (WorkerRoutine); \
+ (Item)->Context = (RoutineContext); \
+ (Item)->Entry.Flink = NULL; \
+ (Item)->Entry.Blink = NULL;
+
+NTSTATUS
+STDCALL
+ExInitializeZone (
+ PZONE_HEADER Zone,
+ ULONG BlockSize,
+ PVOID InitialSegment,
+ ULONG InitialSegmentSize
+ );
+
+LARGE_INTEGER
+STDCALL
+ExInterlockedAddLargeInteger (
+ PLARGE_INTEGER Addend,
+ LARGE_INTEGER Increment,
+ PKSPIN_LOCK Lock
+ );
+
+VOID
+FASTCALL
+ExInterlockedAddLargeStatistic (
+ IN PLARGE_INTEGER Addend,
+ IN ULONG Increment
+ );
+
+ULONG
+STDCALL
+ExInterlockedAddUlong (
+ PULONG Addend,
+ ULONG Increment,
+ PKSPIN_LOCK Lock
+ );
+
+/*
+ * PVOID
+ * STDCALL
+ * ExInterlockedAllocateFromZone (
+ * PZONE_HEADER Zone,
+ * PKSPIN_LOCK Lock
+ * );
+ */
+#define ExInterlockedAllocateFromZone(Zone,Lock) \
+ (PVOID)ExInterlockedPopEntryList(&(Zone)->FreeList,Lock)
+
+LONGLONG
+FASTCALL
+ExInterlockedCompareExchange64 (
+ IN OUT PLONGLONG Destination,
+ IN PLONGLONG Exchange,
+ IN PLONGLONG Comparand,
+ IN PKSPIN_LOCK Lock
+ );
+
+INTERLOCKED_RESULT
+STDCALL
+ExInterlockedDecrementLong (
+ PLONG Addend,
+ PKSPIN_LOCK Lock
+ );
+ULONG
+STDCALL
+ExInterlockedExchangeUlong (
+ PULONG Target,
+ ULONG Value,
+ PKSPIN_LOCK Lock
+ );
+NTSTATUS
+STDCALL
+ExInterlockedExtendZone (
+ PZONE_HEADER Zone,
+ PVOID Segment,
+ ULONG SegmentSize,
+ PKSPIN_LOCK Lock
+ );
+
+/*
+ * PVOID
+ * ExInterlockedFreeToZone (
+ * PZONE_HEADER Zone,
+ * PVOID Block,
+ * PKSPIN_LOCK Lock
+ * );
+ */
+#define ExInterlockedFreeToZone(Zone,Block,Lock) \
+ ExInterlockedPushEntryList(&(Zone)->FreeList,((PSINGLE_LIST_ENTRY)(Block)),(Lock))
+
+INTERLOCKED_RESULT
+STDCALL
+ExInterlockedIncrementLong (
+ PLONG Addend,
+ PKSPIN_LOCK Lock
+ );
+PLIST_ENTRY
+STDCALL
+ExInterlockedInsertHeadList (
+ PLIST_ENTRY ListHead,
+ PLIST_ENTRY ListEntry,
+ PKSPIN_LOCK Lock
+ );
+PLIST_ENTRY
+STDCALL
+ExInterlockedInsertTailList (
+ PLIST_ENTRY ListHead,
+ PLIST_ENTRY ListEntry,
+ PKSPIN_LOCK Lock
+ );
+PSINGLE_LIST_ENTRY
+STDCALL
+ExInterlockedPopEntryList (
+ PSINGLE_LIST_ENTRY ListHead,
+ PKSPIN_LOCK Lock
+ );
+PSINGLE_LIST_ENTRY
+FASTCALL
+ExInterlockedPopEntrySList (
+ PSLIST_HEADER ListHead,
+ PKSPIN_LOCK Lock
+ );
+PSINGLE_LIST_ENTRY
+STDCALL
+ExInterlockedPushEntryList (
+ PSINGLE_LIST_ENTRY ListHead,
+ PSINGLE_LIST_ENTRY ListEntry,
+ PKSPIN_LOCK Lock
+ );
+PSINGLE_LIST_ENTRY
+FASTCALL
+ExInterlockedPushEntrySList (
+ PSLIST_HEADER ListHead,
+ PSINGLE_LIST_ENTRY ListEntry,
+ PKSPIN_LOCK Lock
+ );
+
+VOID
+ExInterlockedRemoveEntryList (
+ PLIST_ENTRY ListHead,
+ PLIST_ENTRY Entry,
+ PKSPIN_LOCK Lock
+ );
+
+PLIST_ENTRY
+STDCALL
+ExInterlockedRemoveHeadList (
+ PLIST_ENTRY Head,
+ PKSPIN_LOCK Lock
+ );
+
+/*
+ * BOOLEAN
+ * ExIsFullZone (
+ * PZONE_HEADER Zone
+ * );
+ */
+#define ExIsFullZone(Zone) \
+ ((Zone)->FreeList.Next==(PSINGLE_LIST_ENTRY)NULL)
+
+/*
+ * BOOLEAN
+ * ExIsObjectInFirstZoneSegment (
+ * PZONE_HEADER Zone,
+ * PVOID Object
+ * );
+ */
+#define ExIsObjectInFirstZoneSegment(Zone,Object) \
+ (((PUCHAR)(Object)>=(PUCHAR)(Zone)->SegmentList.Next) && \
+ ((PUCHAR)(Object)<(PUCHAR)(Zone)->SegmentList.Next+(Zone)->TotalSegmentSize))
+
+BOOLEAN
+STDCALL
+ExIsProcessorFeaturePresent (
+ IN ULONG ProcessorFeature
+ );
+
+BOOLEAN
+STDCALL
+ExIsResourceAcquiredExclusiveLite (
+ PERESOURCE Resource
+ );
+
+ULONG
+STDCALL
+ExIsResourceAcquiredSharedLite (
+ PERESOURCE Resource
+ );
+
+VOID
+STDCALL
+ExLocalTimeToSystemTime (
+ PLARGE_INTEGER LocalTime,
+ PLARGE_INTEGER SystemTime
+ );
+
+VOID
+STDCALL
+ExNotifyCallback (
+ IN PVOID CallbackObject,
+ IN PVOID Argument1,
+ IN PVOID Argument2
+ );
+
+VOID
+STDCALL
+ExPostSystemEvent (
+ ULONG Unknown1,
+ ULONG Unknown2,
+ ULONG Unknown3
+ );
+
+/*
+ * USHORT
+ * ExQueryDepthSList (
+ * PSLIST_HEADER SListHead
+ * );
+ */
+#define ExQueryDepthSList(ListHead) \
+ (USHORT)(ListHead)->s.Depth
+
+VOID
+STDCALL
+ExQueueWorkItem (
+ PWORK_QUEUE_ITEM WorkItem,
+ WORK_QUEUE_TYPE QueueType
+ );
+VOID
+STDCALL
+ExRaiseAccessViolation (
+ VOID
+ );
+VOID
+STDCALL
+ExRaiseDatatypeMisalignment (
+ VOID
+ );
+VOID
+STDCALL
+ExRaiseStatus (
+ NTSTATUS Status
+ );
+
+PVOID
+STDCALL
+ExRegisterCallback (
+ IN PCALLBACK_OBJECT CallbackObject,
+ IN PCALLBACK_FUNCTION CallbackFunction,
+ IN PVOID CallbackContext
+ );
+
+VOID
+STDCALL
+ExReinitializeResourceLite (
+ PERESOURCE Resource
+ );
+/* ReactOS Specific: begin */
+VOID
+FASTCALL
+ExReleaseFastMutex (
+ PFAST_MUTEX Mutex
+ );
+/* ReactOS Specific: end */
+VOID
+FASTCALL
+ExReleaseFastMutexUnsafe (
+ PFAST_MUTEX Mutex
+ );
+/*
+VOID
+STDCALL
+ExReleaseResource (
+ PERESOURCE Resource
+ );
+*/
+#define ExReleaseResource(Resource) \
+ (ExReleaseResourceLite (Resource))
+
+VOID
+FASTCALL
+ExReleaseResourceLite (
+ PERESOURCE Resource
+ );
+VOID
+STDCALL
+ExReleaseResourceForThread (
+ PERESOURCE Resource,
+ ERESOURCE_THREAD ResourceThreadId
+ );
+VOID
+STDCALL
+ExReleaseResourceForThreadLite (
+ PERESOURCE Resource,
+ ERESOURCE_THREAD ResourceThreadId
+ );
+
+VOID
+STDCALL
+ExSetResourceOwnerPointer (
+ IN PERESOURCE Resource,
+ IN PVOID OwnerPointer
+ );
+
+VOID
+STDCALL
+ExSystemTimeToLocalTime (
+ PLARGE_INTEGER SystemTime,
+ PLARGE_INTEGER LocalTime
+ );
+
+BOOLEAN
+FASTCALL
+ExTryToAcquireFastMutex (
+ PFAST_MUTEX FastMutex
+ );
+
+BOOLEAN
+STDCALL
+ExTryToAcquireResourceExclusiveLite (
+ PERESOURCE Resource
+ );
+
+VOID
+STDCALL
+ExUnregisterCallback (
+ IN PVOID CallbackRegistration
+ );
+
+
+/*
+ * PVOID
+ * ExAllocateFromNPagedLookasideList (
+ * PNPAGED_LOOKASIDE_LIST LookSide
+ * );
+ *
+ * FUNCTION:
+ * Removes (pops) the first entry from the specified nonpaged
+ * lookaside list.
+ *
+ * ARGUMENTS:
+ * Lookaside = Pointer to a nonpaged lookaside list
+ *
+ * RETURNS:
+ * Address of the allocated list entry
+ */
+static
+inline
+PVOID
+ExAllocateFromNPagedLookasideList (
+ IN PNPAGED_LOOKASIDE_LIST Lookaside
+ )
+{
+ PVOID Entry;
+
+ Lookaside->TotalAllocates++;
+ Entry = ExInterlockedPopEntrySList (&Lookaside->ListHead,
+ &Lookaside->Lock);
+ if (Entry == NULL)
+ {
+ Lookaside->AllocateMisses++;
+ Entry = (Lookaside->Allocate)(Lookaside->Type,
+ Lookaside->Size,
+ Lookaside->Tag);
+ }
+
+ return Entry;
+}
+
+PVOID
+STDCALL
+ExAllocateFromPagedLookasideList (
+ PPAGED_LOOKASIDE_LIST LookSide
+ );
+
+VOID
+STDCALL
+ExDeleteNPagedLookasideList (
+ PNPAGED_LOOKASIDE_LIST Lookaside
+ );
+
+VOID
+STDCALL
+ExDeletePagedLookasideList (
+ PPAGED_LOOKASIDE_LIST Lookaside
+ );
+
+
+/*
+ * VOID
+ * ExFreeToNPagedLookasideList (
+ * PNPAGED_LOOKASIDE_LIST Lookaside,
+ * PVOID Entry
+ * );
+ *
+ * FUNCTION:
+ * Inserts (pushes) the specified entry into the specified
+ * nonpaged lookaside list.
+ *
+ * ARGUMENTS:
+ * Lookaside = Pointer to the nonpaged lookaside list
+ * Entry = Pointer to the entry that is inserted in the lookaside list
+ */
+static
+inline
+VOID
+ExFreeToNPagedLookasideList (
+ IN PNPAGED_LOOKASIDE_LIST Lookaside,
+ IN PVOID Entry
+ )
+{
+ Lookaside->TotalFrees++;
+ if (ExQueryDepthSList (&Lookaside->ListHead) >= Lookaside->MinimumDepth)
+ {
+ Lookaside->FreeMisses++;
+ (Lookaside->Free)(Entry);
+ }
+ else
+ {
+ ExInterlockedPushEntrySList (&Lookaside->ListHead,
+ (PSINGLE_LIST_ENTRY)Entry,
+ &Lookaside->Lock);
+ }
+}
+
+VOID
+STDCALL
+ExFreeToPagedLookasideList (
+ PPAGED_LOOKASIDE_LIST Lookaside,
+ PVOID Entry
+ );
+
+VOID
+STDCALL
+ExInitializeNPagedLookasideList (
+ PNPAGED_LOOKASIDE_LIST Lookaside,
+ PALLOCATE_FUNCTION Allocate,
+ PFREE_FUNCTION Free,
+ ULONG Flags,
+ ULONG Size,
+ ULONG Tag,
+ USHORT Depth
+ );
+
+VOID
+STDCALL
+ExInitializePagedLookasideList (
+ PPAGED_LOOKASIDE_LIST Lookaside,
+ PALLOCATE_FUNCTION Allocate,
+ PFREE_FUNCTION Free,
+ ULONG Flags,
+ ULONG Size,
+ ULONG Tag,
+ USHORT Depth
+ );
+
+ULONG FASTCALL
+ExfInterlockedAddUlong(IN PULONG Addend,
+ IN ULONG Increment,
+ IN PKSPIN_LOCK Lock);
+
+PLIST_ENTRY FASTCALL
+ExfInterlockedInsertHeadList(IN PLIST_ENTRY ListHead,
+ IN PLIST_ENTRY ListEntry,
+ IN PKSPIN_LOCK Lock);
+
+PLIST_ENTRY FASTCALL
+ExfInterlockedInsertTailList(IN PLIST_ENTRY ListHead,
+ IN PLIST_ENTRY ListEntry,
+ IN PKSPIN_LOCK Lock);
+
+PSINGLE_LIST_ENTRY FASTCALL
+ExfInterlockedPopEntryList(IN PSINGLE_LIST_ENTRY ListHead,
+ IN PKSPIN_LOCK Lock);
+
+PSINGLE_LIST_ENTRY FASTCALL
+ExfInterlockedPushEntryList(IN PSINGLE_LIST_ENTRY ListHead,
+ IN PSINGLE_LIST_ENTRY ListEntry,
+ IN PKSPIN_LOCK Lock);
+
+PLIST_ENTRY FASTCALL
+ExfInterlockedRemoveHeadList(IN PLIST_ENTRY Head,
+ IN PKSPIN_LOCK Lock);
+
+INTERLOCKED_RESULT FASTCALL
+Exfi386InterlockedIncrementLong(IN PLONG Addend);
+
+INTERLOCKED_RESULT FASTCALL
+Exfi386InterlockedDecrementLong(IN PLONG Addend);
+
+ULONG FASTCALL
+Exfi386InterlockedExchangeUlong(IN PULONG Target,
+ IN ULONG Value);
+
+INTERLOCKED_RESULT STDCALL
+Exi386InterlockedIncrementLong(IN PLONG Addend);
+
+INTERLOCKED_RESULT STDCALL
+Exi386InterlockedDecrementLong(IN PLONG Addend);
+
+ULONG STDCALL
+Exi386InterlockedExchangeUlong(IN PULONG Target,
+ IN ULONG Value);
+
+
+LONG
+FASTCALL
+InterlockedCompareExchange (
+ PLONG Destination,
+ LONG Exchange,
+ LONG Comperand
+ );
+
+#ifdef _GNU_H_WINDOWS_H
+#ifdef InterlockedDecrement
+#undef InterlockedDecrement
+#undef InterlockedExchange
+#undef InterlockedExchangeAdd
+#undef InterlockedIncrement
+#endif /* def InterlockedDecrement */
+#endif /* def _GNU_H_WINDOWS_H */
+LONG
+FASTCALL
+InterlockedDecrement (
+ PLONG Addend
+ );
+LONG
+FASTCALL
+InterlockedExchange (
+ PLONG Target,
+ LONG Value
+ );
+LONG
+FASTCALL
+InterlockedExchangeAdd (
+ PLONG Addend,
+ LONG Value
+ );
+LONG
+FASTCALL
+InterlockedIncrement (
+ PLONG Addend
+ );
+
+/*---*/
+
+typedef
+unsigned int
+(exception_hook) (
+ CONTEXT * c,
+ unsigned int exp
+ );
+unsigned int
+ExHookException (
+ exception_hook fn,
+ unsigned int exp
+ );
+
+/* BEGIN REACTOS ONLY */
+
+BOOLEAN STDCALL
+ExInitializeBinaryTree(IN PBINARY_TREE Tree,
+ IN PKEY_COMPARATOR Compare,
+ IN BOOLEAN UseNonPagedPool);
+
+VOID STDCALL
+ExDeleteBinaryTree(IN PBINARY_TREE Tree);
+
+VOID STDCALL
+ExInsertBinaryTree(IN PBINARY_TREE Tree,
+ IN PVOID Key,
+ IN PVOID Value);
+
+BOOLEAN STDCALL
+ExSearchBinaryTree(IN PBINARY_TREE Tree,
+ IN PVOID Key,
+ OUT PVOID * Value);
+
+BOOLEAN STDCALL
+ExRemoveBinaryTree(IN PBINARY_TREE Tree,
+ IN PVOID Key,
+ IN PVOID * Value);
+
+BOOLEAN STDCALL
+ExTraverseBinaryTree(IN PBINARY_TREE Tree,
+ IN TRAVERSE_METHOD Method,
+ IN PTRAVERSE_ROUTINE Routine,
+ IN PVOID Context);
+
+BOOLEAN STDCALL
+ExInitializeSplayTree(IN PSPLAY_TREE Tree,
+ IN PKEY_COMPARATOR Compare,
+ IN BOOLEAN Weighted,
+ IN BOOLEAN UseNonPagedPool);
+
+VOID STDCALL
+ExDeleteSplayTree(IN PSPLAY_TREE Tree);
+
+VOID STDCALL
+ExInsertSplayTree(IN PSPLAY_TREE Tree,
+ IN PVOID Key,
+ IN PVOID Value);
+
+BOOLEAN STDCALL
+ExSearchSplayTree(IN PSPLAY_TREE Tree,
+ IN PVOID Key,
+ OUT PVOID * Value);
+
+BOOLEAN STDCALL
+ExRemoveSplayTree(IN PSPLAY_TREE Tree,
+ IN PVOID Key,
+ IN PVOID * Value);
+
+BOOLEAN STDCALL
+ExWeightOfSplayTree(IN PSPLAY_TREE Tree,
+ OUT PULONG Weight);
+
+BOOLEAN STDCALL
+ExTraverseSplayTree(IN PSPLAY_TREE Tree,
+ IN TRAVERSE_METHOD Method,
+ IN PTRAVERSE_ROUTINE Routine,
+ IN PVOID Context);
+
+BOOLEAN STDCALL
+ExInitializeHashTable(IN PHASH_TABLE HashTable,
+ IN ULONG HashTableSize,
+ IN PKEY_COMPARATOR Compare OPTIONAL,
+ IN BOOLEAN UseNonPagedPool);
+
+VOID STDCALL
+ExDeleteHashTable(IN PHASH_TABLE HashTable);
+
+VOID STDCALL
+ExInsertHashTable(IN PHASH_TABLE HashTable,
+ IN PVOID Key,
+ IN ULONG KeyLength,
+ IN PVOID Value);
+
+BOOLEAN STDCALL
+ExSearchHashTable(IN PHASH_TABLE HashTable,
+ IN PVOID Key,
+ IN ULONG KeyLength,
+ OUT PVOID * Value);
+
+BOOLEAN STDCALL
+ExRemoveHashTable(IN PHASH_TABLE HashTable,
+ IN PVOID Key,
+ IN ULONG KeyLength,
+ IN PVOID * Value);
+
+/* END REACTOS ONLY */
+
+#endif /* ndef _NTOS_EXFUNCS_H */
--- /dev/null
+/* $Id: extypes.h,v 1.11 2002/09/08 10:47:43 chorns Exp $ */
+
+#ifndef __INCLUDE_DDK_EXTYPES_H
+#define __INCLUDE_DDK_EXTYPES_H
+
+#ifdef __NTOSKRNL__
+extern POBJECT_TYPE EXPORTED ExDesktopObjectType;
+extern POBJECT_TYPE EXPORTED ExEventObjectType;
+extern POBJECT_TYPE EXPORTED ExWindowStationObjectType;
+#else
+extern POBJECT_TYPE IMPORTED ExDesktopObjectType;
+extern POBJECT_TYPE IMPORTED ExEventObjectType;
+extern POBJECT_TYPE IMPORTED ExWindowStationObjectType;
+#endif
+
+typedef ULONG INTERLOCKED_RESULT;
+typedef ULONG WORK_QUEUE_TYPE;
+
+typedef ULONG ERESOURCE_THREAD, *PERESOURCE_THREAD;
+
+typedef struct _OWNER_ENTRY
+{
+ ERESOURCE_THREAD OwnerThread;
+ union
+ {
+ LONG OwnerCount;
+ ULONG TableSize;
+ } a;
+} OWNER_ENTRY, *POWNER_ENTRY;
+
+typedef struct _ERESOURCE
+{
+ LIST_ENTRY SystemResourcesList;
+ POWNER_ENTRY OwnerTable;
+ SHORT ActiveCount;
+ USHORT Flag;
+ PKSEMAPHORE SharedWaiters;
+ PKEVENT ExclusiveWaiters;
+ OWNER_ENTRY OwnerThreads[2];
+ ULONG ContentionCount;
+ USHORT NumberOfSharedWaiters;
+ USHORT NumberOfExclusiveWaiters;
+ union
+ {
+ PVOID Address;
+ ULONG CreatorBackTraceIndex;
+ } a;
+ KSPIN_LOCK SpinLock;
+} ERESOURCE, *PERESOURCE;
+
+
+typedef struct
+{
+ LONG Count;
+ struct _KTHREAD* Owner;
+ ULONG Contention;
+ KEVENT Event;
+ ULONG OldIrql;
+} FAST_MUTEX, *PFAST_MUTEX;
+
+typedef struct _ZONE_HEADER
+{
+ SINGLE_LIST_ENTRY FreeList;
+ SINGLE_LIST_ENTRY SegmentList;
+ ULONG BlockSize;
+ ULONG TotalSegmentSize;
+} ZONE_HEADER, *PZONE_HEADER;
+
+typedef struct _ZONE_SEGMENT
+{
+ SINGLE_LIST_ENTRY Entry;
+ ULONG size;
+} ZONE_SEGMENT, *PZONE_SEGMENT;
+
+typedef struct _ZONE_ENTRY
+{
+ SINGLE_LIST_ENTRY Entry;
+} ZONE_ENTRY, *PZONE_ENTRY;
+
+
+typedef VOID STDCALL
+(*PWORKER_THREAD_ROUTINE)(PVOID Parameter);
+
+typedef struct _WORK_QUEUE_ITEM
+{
+ LIST_ENTRY Entry;
+ PWORKER_THREAD_ROUTINE Routine;
+ PVOID Context;
+} WORK_QUEUE_ITEM, *PWORK_QUEUE_ITEM;
+
+typedef PVOID STDCALL
+(*PALLOCATE_FUNCTION)(POOL_TYPE PoolType,
+ ULONG NumberOfBytes,
+ ULONG Tag);
+
+typedef VOID STDCALL
+(*PFREE_FUNCTION)(PVOID Buffer);
+
+typedef union _SLIST_HEADER
+{
+ ULONGLONG Alignment;
+ struct
+ {
+ SINGLE_LIST_ENTRY Next;
+ USHORT Depth;
+ USHORT Sequence;
+ } s;
+} SLIST_HEADER, *PSLIST_HEADER;
+
+typedef struct _NPAGED_LOOKASIDE_LIST
+{
+ SLIST_HEADER ListHead;
+ USHORT MinimumDepth;
+ USHORT MaximumDepth;
+ ULONG TotalAllocates;
+ ULONG AllocateMisses;
+ ULONG TotalFrees;
+ ULONG FreeMisses;
+ POOL_TYPE Type;
+ ULONG Tag;
+ ULONG Size;
+ PALLOCATE_FUNCTION Allocate;
+ PFREE_FUNCTION Free;
+ LIST_ENTRY ListEntry;
+ ULONG LastTotalAllocates;
+ ULONG LastAllocateMisses;
+ ULONG Pad[2];
+ KSPIN_LOCK Lock;
+} NPAGED_LOOKASIDE_LIST, *PNPAGED_LOOKASIDE_LIST;
+
+typedef struct _PAGED_LOOKASIDE_LIST
+{
+ SLIST_HEADER ListHead;
+ USHORT MinimumDepth;
+ USHORT MaximumDepth;
+ ULONG TotalAllocates;
+ ULONG AllocateMisses;
+ ULONG TotalFrees;
+ ULONG FreeMisses;
+ POOL_TYPE Type;
+ ULONG Tag;
+ ULONG Size;
+ PALLOCATE_FUNCTION Allocate;
+ PFREE_FUNCTION Free;
+ LIST_ENTRY ListEntry;
+ ULONG LastTotalAllocates;
+ ULONG LastAllocateMisses;
+ FAST_MUTEX Lock;
+} PAGED_LOOKASIDE_LIST, *PPAGED_LOOKASIDE_LIST;
+
+
+/* callback object (not functional in NT4)*/
+
+typedef struct _CALLBACK_OBJECT *PCALLBACK_OBJECT;
+
+typedef VOID STDCALL
+(*PCALLBACK_FUNCTION)(PVOID CallbackContext,
+ PVOID Argument1,
+ PVOID Argument2);
+
+/* BEGIN REACTOS ONLY */
+
+typedef enum _TRAVERSE_METHOD {
+ TraverseMethodPreorder,
+ TraverseMethodInorder,
+ TraverseMethodPostorder
+} TRAVERSE_METHOD;
+
+typedef LONG STDCALL
+(*PKEY_COMPARATOR)(IN PVOID Key1,
+ IN PVOID Key2);
+
+typedef BOOLEAN STDCALL
+(*PTRAVERSE_ROUTINE)(IN PVOID Context,
+ IN PVOID Key,
+ IN PVOID Value);
+
+struct _BINARY_TREE_NODE;
+
+typedef struct _BINARY_TREE
+{
+ struct _BINARY_TREE_NODE * RootNode;
+ PKEY_COMPARATOR Compare;
+ BOOLEAN UseNonPagedPool;
+ union {
+ NPAGED_LOOKASIDE_LIST NonPaged;
+ PAGED_LOOKASIDE_LIST Paged;
+ } List;
+ union {
+ KSPIN_LOCK NonPaged;
+ FAST_MUTEX Paged;
+ } Lock;
+} BINARY_TREE, *PBINARY_TREE;
+
+
+struct _SPLAY_TREE_NODE;
+
+typedef struct _SPLAY_TREE
+{
+ struct _SPLAY_TREE_NODE * RootNode;
+ PKEY_COMPARATOR Compare;
+ BOOLEAN Weighted;
+ BOOLEAN UseNonPagedPool;
+ union {
+ NPAGED_LOOKASIDE_LIST NonPaged;
+ PAGED_LOOKASIDE_LIST Paged;
+ } List;
+ union {
+ KSPIN_LOCK NonPaged;
+ FAST_MUTEX Paged;
+ } Lock;
+ PVOID Reserved[4];
+} SPLAY_TREE, *PSPLAY_TREE;
+
+
+typedef struct _HASH_TABLE
+{
+ // Size of hash table in number of bits
+ ULONG HashTableSize;
+
+ // Use non-paged pool memory?
+ BOOLEAN UseNonPagedPool;
+
+ // Lock for this structure
+ union {
+ KSPIN_LOCK NonPaged;
+ FAST_MUTEX Paged;
+ } Lock;
+
+ // Pointer to array of hash buckets with splay trees
+ PSPLAY_TREE HashTrees;
+} HASH_TABLE, *PHASH_TABLE;
+
+/* END REACTOS ONLY */
+
+#endif /* __INCLUDE_DDK_EXTYPES_H */
+
+/* EOF */
--- /dev/null
+#ifndef __INCLUDE_DDK_FSFUNCS_H
+#define __INCLUDE_DDK_FSFUNCS_H
+/* $Id: fsfuncs.h,v 1.16 2002/09/08 10:47:44 chorns Exp $ */
+#define FlagOn(x,f) ((x) & (f))
+
+BOOLEAN STDCALL
+FsRtlAddLargeMcbEntry(IN PLARGE_MCB Mcb,
+ IN LONGLONG Vbn,
+ IN LONGLONG Lbn,
+ IN LONGLONG SectorCount);
+
+VOID STDCALL
+FsRtlAddMcbEntry(
+ DWORD Unknown0,
+ DWORD Unknown1,
+ DWORD Unknown2,
+ DWORD Unknown3
+ );
+
+VOID STDCALL
+FsRtlAddToTunnelCache (
+ IN PTUNNEL Cache,
+ IN ULONGLONG DirectoryKey,
+ IN PUNICODE_STRING ShortName,
+ IN PUNICODE_STRING LongName,
+ IN BOOLEAN KeyByShortName,
+ IN ULONG DataLength,
+ IN PVOID Data
+ );
+
+PVOID STDCALL
+FsRtlAllocatePool (
+ IN POOL_TYPE PoolType,
+ IN ULONG NumberOfBytes
+ );
+
+PVOID STDCALL
+FsRtlAllocatePoolWithQuota (
+ IN POOL_TYPE PoolType,
+ IN ULONG NumberOfBytes
+ );
+
+PVOID STDCALL
+FsRtlAllocatePoolWithQuotaTag (
+ IN POOL_TYPE PoolType,
+ IN ULONG NumberOfBytes,
+ IN ULONG Tag
+ );
+PVOID
+STDCALL
+FsRtlAllocatePoolWithTag (
+ IN POOL_TYPE PoolType,
+ IN ULONG NumberOfBytes,
+ IN ULONG Tag
+ );
+DWORD
+STDCALL
+FsRtlAllocateResource (
+ VOID
+ );
+BOOLEAN
+STDCALL
+FsRtlAreNamesEqual (
+ IN PUNICODE_STRING Name1,
+ IN PUNICODE_STRING Name2,
+ IN BOOLEAN IgnoreCase,
+ IN PWCHAR UpcaseTable OPTIONAL
+ );
+DWORD
+STDCALL
+FsRtlBalanceReads (
+ DWORD Unknown0
+ );
+BOOLEAN
+STDCALL
+FsRtlCheckLockForReadAccess (
+ IN PFILE_LOCK FileLock,
+ IN PIRP Irp
+ );
+BOOLEAN
+STDCALL
+FsRtlCheckLockForWriteAccess (
+ IN PFILE_LOCK FileLock,
+ IN PIRP Irp
+ );
+
+NTSTATUS STDCALL
+FsRtlCheckOplock(IN POPLOCK Oplock,
+ IN PIRP Irp,
+ IN PVOID Context,
+ IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine OPTIONAL,
+ IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine OPTIONAL);
+
+BOOLEAN
+STDCALL
+FsRtlCopyRead (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ IN ULONG LockKey,
+ OUT PVOID Buffer,
+ OUT PIO_STATUS_BLOCK IoStatus,
+ IN PDEVICE_OBJECT DeviceObject
+ );
+BOOLEAN
+STDCALL
+FsRtlCopyWrite (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ IN ULONG LockKey,
+ IN PVOID Buffer,
+ OUT PIO_STATUS_BLOCK IoStatus,
+ IN PDEVICE_OBJECT DeviceObject
+ );
+
+BOOLEAN STDCALL
+FsRtlCurrentBatchOplock(IN POPLOCK Oplock);
+
+VOID STDCALL
+FsRtlDeleteKeyFromTunnelCache(IN PTUNNEL Cache,
+ IN ULONGLONG DirectoryKey);
+
+VOID STDCALL
+FsRtlDeleteTunnelCache(IN PTUNNEL Cache);
+
+VOID STDCALL
+FsRtlDeregisterUncProvider(IN HANDLE Handle);
+
+VOID
+STDCALL
+FsRtlDissectDbcs (
+ DWORD Unknown0,
+ DWORD Unknown1,
+ DWORD Unknown2,
+ DWORD Unknown3
+ );
+VOID
+STDCALL
+FsRtlDissectName (
+ DWORD Unknown0,
+ DWORD Unknown1,
+ DWORD Unknown2,
+ DWORD Unknown3
+ );
+BOOLEAN
+STDCALL
+FsRtlDoesDbcsContainWildCards (
+ IN DWORD Unknown0
+ );
+BOOLEAN
+STDCALL
+FsRtlDoesNameContainWildCards (
+ IN PUNICODE_STRING Name
+ );
+BOOLEAN
+STDCALL
+FsRtlFastCheckLockForRead (
+ IN PFILE_LOCK FileLock,
+ IN PLARGE_INTEGER FileOffset,
+ IN PLARGE_INTEGER Length,
+ IN ULONG Key,
+ IN PFILE_OBJECT FileObject,
+ IN PEPROCESS Process
+ );
+BOOLEAN
+STDCALL
+FsRtlFastCheckLockForWrite (
+ IN PFILE_LOCK FileLock,
+ IN PLARGE_INTEGER FileOffset,
+ IN PLARGE_INTEGER Length,
+ IN ULONG Key,
+ IN PFILE_OBJECT FileObject,
+ IN PEPROCESS Process
+ );
+NTSTATUS
+STDCALL
+FsRtlFastUnlockAll (
+ IN PFILE_LOCK FileLock,
+ IN PFILE_OBJECT FileObject,
+ IN PEPROCESS Process,
+ IN PVOID Context OPTIONAL
+ );
+NTSTATUS
+STDCALL
+FsRtlFastUnlockAllByKey (
+ IN PFILE_LOCK FileLock,
+ IN PFILE_OBJECT FileObject,
+ IN PEPROCESS Process,
+ IN DWORD Key,
+ IN PVOID Context OPTIONAL
+ );
+NTSTATUS
+STDCALL
+FsRtlFastUnlockSingle (
+ IN PFILE_LOCK FileLock,
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN PLARGE_INTEGER Length,
+ IN PEPROCESS Process,
+ IN ULONG Key,
+ IN PVOID Context OPTIONAL,
+ IN BOOLEAN AlreadySynchronized
+ );
+VOID
+STDCALL
+FsRtlFindInTunnelCache (
+ IN PTUNNEL Cache,
+ IN ULONGLONG DirectoryKey,
+ IN PUNICODE_STRING Name,
+ OUT PUNICODE_STRING ShortName,
+ OUT PUNICODE_STRING LongName,
+ IN OUT PULONG DataLength,
+ OUT PVOID Data
+ );
+NTSTATUS
+STDCALL
+FsRtlGetFileSize (
+ IN PFILE_OBJECT FileObject,
+ IN OUT PLARGE_INTEGER FileSize
+ );
+PFILE_LOCK_INFO
+STDCALL
+FsRtlGetNextFileLock (
+ IN PFILE_LOCK FileLock,
+ IN BOOLEAN Restart
+ );
+
+BOOLEAN STDCALL
+FsRtlGetNextLargeMcbEntry(IN PLARGE_MCB Mcb,
+ IN ULONG RunIndex,
+ OUT PLONGLONG Vbn,
+ OUT PLONGLONG Lbn,
+ OUT PLONGLONG SectorCount);
+
+VOID
+STDCALL
+FsRtlGetNextMcbEntry (
+ DWORD Unknown0,
+ DWORD Unknown1,
+ DWORD Unknown2,
+ DWORD Unknown3,
+ DWORD Unknown4
+ );
+#define FsRtlEnterFileSystem KeEnterCriticalRegion
+#define FsRtlExitFileSystem KeLeaveCriticalRegion
+VOID
+STDCALL
+FsRtlInitializeFileLock (
+ IN PFILE_LOCK FileLock,
+ IN PCOMPLETE_LOCK_IRP_ROUTINE CompleteLockIrpRoutine OPTIONAL,
+ IN PUNLOCK_ROUTINE UnlockRoutine OPTIONAL
+ );
+
+VOID STDCALL
+FsRtlInitializeLargeMcb(IN PLARGE_MCB Mcb,
+ IN POOL_TYPE PoolType);
+
+VOID
+STDCALL
+FsRtlInitializeMcb (
+ DWORD Unknown0,
+ DWORD Unknown1
+ );
+
+VOID STDCALL
+FsRtlInitializeOplock(IN OUT POPLOCK Oplock);
+
+VOID
+STDCALL
+FsRtlInitializeTunnelCache (
+ IN PTUNNEL Cache
+ );
+BOOLEAN
+STDCALL
+FsRtlIsDbcsInExpression (
+ DWORD Unknown0,
+ DWORD Unknown1
+ );
+BOOLEAN
+STDCALL
+FsRtlIsFatDbcsLegal (
+ DWORD Unknown0,
+ DWORD Unknown1,
+ DWORD Unknown2,
+ DWORD Unknown3,
+ DWORD Unknown4
+ );
+BOOLEAN
+STDCALL
+FsRtlIsHpfsDbcsLegal (
+ DWORD Unknown0,
+ DWORD Unknown1,
+ DWORD Unknown2,
+ DWORD Unknown3,
+ DWORD Unknown4
+ );
+BOOLEAN
+STDCALL
+FsRtlIsNameInExpression (
+ IN PUNICODE_STRING Expression,
+ IN PUNICODE_STRING Name,
+ IN BOOLEAN IgnoreCase,
+ IN PWCHAR UpcaseTable OPTIONAL
+ );
+
+BOOLEAN STDCALL
+FsRtlIsNtstatusExpected(IN NTSTATUS NtStatus);
+
+BOOLEAN STDCALL
+FsRtlIsTotalDeviceFailure(IN NTSTATUS NtStatus);
+
+#define FsRtlIsUnicodeCharacterWild(C) ( \
+ (((C) >= 0x40) ? \
+ FALSE : \
+ FlagOn((*FsRtlLegalAnsiCharacterArray)[(C)], FSRTL_WILD_CHARACTER )) \
+ )
+
+BOOLEAN STDCALL
+FsRtlLookupLargeMcbEntry(IN PLARGE_MCB Mcb,
+ IN LONGLONG Vbn,
+ OUT PLONGLONG Lbn OPTIONAL,
+ OUT PLONGLONG SectorCountFromLbn OPTIONAL,
+ OUT PLONGLONG StartingLbn OPTIONAL,
+ OUT PLONGLONG SectorCountFromStartingLbn OPTIONAL,
+ OUT PULONG Index OPTIONAL);
+
+BOOLEAN STDCALL
+FsRtlLookupLastLargeMcbEntry(IN PLARGE_MCB Mcb,
+ OUT PLONGLONG Vbn,
+ OUT PLONGLONG Lbn);
+
+VOID
+STDCALL
+FsRtlLookupLastMcbEntry (
+ DWORD Unknown0,
+ DWORD Unknown1,
+ DWORD Unknown2
+ );
+VOID
+STDCALL
+FsRtlLookupMcbEntry (
+ DWORD Unknown0,
+ DWORD Unknown1,
+ DWORD Unknown2,
+ DWORD Unknown3,
+ DWORD Unknown4
+ );
+BOOLEAN
+STDCALL
+FsRtlMdlRead (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN ULONG LockKey,
+ OUT PMDL *MdlChain,
+ OUT PIO_STATUS_BLOCK IoStatus
+ );
+BOOLEAN
+STDCALL
+FsRtlMdlReadComplete (
+ IN PFILE_OBJECT FileObject,
+ IN OUT PMDL MdlChain
+ );
+BOOLEAN
+STDCALL
+FsRtlMdlReadCompleteDev (
+ IN PFILE_OBJECT FileObject,
+ IN PMDL MdlChain,
+ IN PDEVICE_OBJECT DeviceObject
+ );
+BOOLEAN
+STDCALL
+FsRtlMdlReadDev (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN ULONG LockKey,
+ OUT PMDL *MdlChain,
+ OUT PIO_STATUS_BLOCK IoStatus,
+ IN PDEVICE_OBJECT DeviceObject
+ );
+BOOLEAN
+STDCALL
+FsRtlMdlWriteComplete (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN PMDL MdlChain
+ );
+BOOLEAN
+STDCALL
+FsRtlMdlWriteCompleteDev (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN PMDL MdlChain,
+ IN PDEVICE_OBJECT DeviceObject
+ );
+VOID
+STDCALL
+FsRtlNotifyChangeDirectory (
+ IN PNOTIFY_SYNC NotifySync,
+ IN PVOID FsContext,
+ IN PSTRING FullDirectoryName,
+ IN PLIST_ENTRY NotifyList,
+ IN BOOLEAN WatchTree,
+ IN ULONG CompletionFilter,
+ IN PIRP NotifyIrp
+ );
+VOID
+STDCALL
+FsRtlNotifyCleanup (
+ IN PNOTIFY_SYNC NotifySync,
+ IN PLIST_ENTRY NotifyList,
+ IN PVOID FsContext
+ );
+typedef
+BOOLEAN (*PCHECK_FOR_TRAVERSE_ACCESS) (
+ IN PVOID NotifyContext,
+ IN PVOID TargetContext,
+ IN PSECURITY_SUBJECT_CONTEXT SubjectContext
+ );
+VOID
+STDCALL
+FsRtlNotifyFullChangeDirectory (
+ IN PNOTIFY_SYNC NotifySync,
+ IN PLIST_ENTRY NotifyList,
+ IN PVOID FsContext,
+ IN PSTRING FullDirectoryName,
+ IN BOOLEAN WatchTree,
+ IN BOOLEAN IgnoreBuffer,
+ IN ULONG CompletionFilter,
+ IN PIRP NotifyIrp,
+ IN PCHECK_FOR_TRAVERSE_ACCESS TraverseCallback OPTIONAL,
+ IN PSECURITY_SUBJECT_CONTEXT SubjectContext OPTIONAL
+ );
+VOID
+STDCALL
+FsRtlNotifyFullReportChange (
+ IN PNOTIFY_SYNC NotifySync,
+ IN PLIST_ENTRY NotifyList,
+ IN PSTRING FullTargetName,
+ IN USHORT TargetNameOffset,
+ IN PSTRING StreamName OPTIONAL,
+ IN PSTRING NormalizedParentName OPTIONAL,
+ IN ULONG FilterMatch,
+ IN ULONG Action,
+ IN PVOID TargetContext
+ );
+VOID
+STDCALL
+FsRtlNotifyUninitializeSync (
+ IN OUT PNOTIFY_SYNC * NotifySync
+ );
+VOID
+STDCALL
+FsRtlNotifyReportChange (
+ IN PNOTIFY_SYNC NotifySync,
+ IN PLIST_ENTRY NotifyList,
+ IN PSTRING FullTargetName,
+ IN PUSHORT FileNamePartLength,
+ IN ULONG FilterMatch
+ );
+
+VOID STDCALL
+FsRtlNotifyInitializeSync(IN OUT PNOTIFY_SYNC *NotifySync);
+
+NTSTATUS STDCALL
+FsRtlNotifyVolumeEvent(IN PFILE_OBJECT FileObject,
+ IN ULONG EventCode);
+
+NTSTATUS STDCALL
+FsRtlOplockFsctrl(IN POPLOCK Oplock,
+ IN PIRP Irp,
+ IN ULONG OpenCount);
+
+BOOLEAN STDCALL
+FsRtlOplockIsFastIoPossible(IN POPLOCK Oplock);
+
+BOOLEAN
+STDCALL
+FsRtlPrepareMdlWrite (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN ULONG LockKey,
+ OUT PMDL *MdlChain,
+ OUT PIO_STATUS_BLOCK IoStatus
+ );
+BOOLEAN
+STDCALL
+FsRtlPrepareMdlWriteDev (
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN ULONG LockKey,
+ OUT PMDL *MdlChain,
+ OUT PIO_STATUS_BLOCK IoStatus,
+ IN PDEVICE_OBJECT DeviceObject
+ );
+
+NTSTATUS STDCALL
+FsRtlNormalizeNtstatus(IN NTSTATUS NtStatusToNormalize,
+ IN NTSTATUS NormalizedNtStatus);
+
+ULONG STDCALL
+FsRtlNumberOfRunsInLargeMcb(IN PLARGE_MCB Mcb);
+
+VOID
+STDCALL
+FsRtlNumberOfRunsInMcb (
+ DWORD Unknown0
+ );
+VOID
+STDCALL
+FsRtlPostPagingFileStackOverflow (
+ DWORD Unknown0,
+ DWORD Unknown1,
+ DWORD Unknown2
+ );
+VOID
+STDCALL
+FsRtlPostStackOverflow (
+ DWORD Unknown0,
+ DWORD Unknown1,
+ DWORD Unknown2
+ );
+BOOLEAN
+STDCALL
+FsRtlPrivateLock (
+ IN PFILE_LOCK FileLock,
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN PLARGE_INTEGER Length,
+ IN PEPROCESS Process,
+ IN ULONG Key,
+ IN BOOLEAN FailImmediately,
+ IN BOOLEAN ExclusiveLock,
+ OUT PIO_STATUS_BLOCK IoStatus,
+ IN PIRP Irp OPTIONAL,
+ IN PVOID Context,
+ IN BOOLEAN AlreadySynchronized
+ );
+NTSTATUS
+STDCALL
+FsRtlProcessFileLock (
+ IN PFILE_LOCK FileLock,
+ IN PIRP Irp,
+ IN PVOID Context OPTIONAL
+ );
+
+NTSTATUS STDCALL
+FsRtlRegisterUncProvider(IN OUT PHANDLE Handle,
+ IN PUNICODE_STRING RedirectorDeviceName,
+ IN BOOLEAN MailslotsSupported);
+
+VOID STDCALL
+FsRtlRemoveLargeMcbEntry(IN PLARGE_MCB Mcb,
+ IN LONGLONG Vbn,
+ IN LONGLONG SectorCount);
+
+VOID
+STDCALL
+FsRtlRemoveMcbEntry (
+ DWORD Unknown0,
+ DWORD Unknown1,
+ DWORD Unknown2
+ );
+
+BOOLEAN STDCALL
+FsRtlSplitLargeMcb(IN PLARGE_MCB Mcb,
+ IN LONGLONG Vbn,
+ IN LONGLONG Amount);
+
+NTSTATUS
+STDCALL
+FsRtlSyncVolumes (
+ DWORD Unknown0,
+ DWORD Unknown1,
+ DWORD Unknown2
+ );
+
+VOID STDCALL
+FsRtlTruncateLargeMcb(IN PLARGE_MCB Mcb,
+ IN LONGLONG Vbn);
+
+VOID
+STDCALL
+FsRtlTruncateMcb (
+ DWORD Unknown0,
+ DWORD Unknown1
+ );
+VOID
+STDCALL
+FsRtlUninitializeFileLock (
+ IN PFILE_LOCK FileLock
+ );
+
+VOID STDCALL
+FsRtlUninitializeLargeMcb(IN PLARGE_MCB Mcb);
+
+VOID
+STDCALL
+FsRtlUninitializeMcb (
+ DWORD Unknown0
+ );
+
+VOID STDCALL
+FsRtlUninitializeOplock(IN POPLOCK Oplock);
+
+#endif /* __INCLUDE_DDK_FSFUNCS_H */
--- /dev/null
+#ifndef __INCLUDE_DDK_FSTYPES_H
+#define __INCLUDE_DDK_FSTYPES_H
+/* $Id: fstypes.h,v 1.7 2002/09/08 10:47:44 chorns Exp $ */
+
+#define FSRTL_TAG TAG('F','S','r','t')
+
+typedef struct _FILE_LOCK_INFO {
+ LARGE_INTEGER StartingByte;
+ LARGE_INTEGER Length;
+ BOOLEAN ExclusiveLock;
+ ULONG Key;
+ PFILE_OBJECT FileObject;
+ PEPROCESS Process;
+ LARGE_INTEGER EndingByte;
+} FILE_LOCK_INFO, *PFILE_LOCK_INFO;
+
+// raw internal file lock struct returned from FsRtlGetNextFileLock
+typedef struct _FILE_SHARED_LOCK_ENTRY {
+ PVOID Unknown1;
+ PVOID Unknown2;
+ FILE_LOCK_INFO FileLock;
+} FILE_SHARED_LOCK_ENTRY, *PFILE_SHARED_LOCK_ENTRY;
+
+// raw internal file lock struct returned from FsRtlGetNextFileLock
+typedef struct _FILE_EXCLUSIVE_LOCK_ENTRY {
+ LIST_ENTRY ListEntry;
+ PVOID Unknown1;
+ PVOID Unknown2;
+ FILE_LOCK_INFO FileLock;
+} FILE_EXCLUSIVE_LOCK_ENTRY, *PFILE_EXCLUSIVE_LOCK_ENTRY;
+
+typedef NTSTATUS (*PCOMPLETE_LOCK_IRP_ROUTINE) (
+ IN PVOID Context,
+ IN PIRP Irp
+);
+
+typedef VOID (*PUNLOCK_ROUTINE) (
+ IN PVOID Context,
+ IN PFILE_LOCK_INFO FileLockInfo
+);
+
+typedef struct _FILE_LOCK {
+ PCOMPLETE_LOCK_IRP_ROUTINE CompleteLockIrpRoutine;
+ PUNLOCK_ROUTINE UnlockRoutine;
+ BOOLEAN FastIoIsQuestionable;
+ BOOLEAN Pad[3];
+ PVOID LockInformation;
+ FILE_LOCK_INFO LastReturnedLockInfo;
+ PVOID LastReturnedLock;
+} FILE_LOCK, *PFILE_LOCK;
+
+typedef struct _TUNNEL {
+ FAST_MUTEX Mutex;
+ PRTL_SPLAY_LINKS Cache;
+ LIST_ENTRY TimerQueue;
+ USHORT NumEntries;
+} TUNNEL, *PTUNNEL;
+
+typedef struct _NOTIFY_SYNC
+{
+ DWORD Unknown0; /* 0x00 */
+ DWORD Unknown1; /* 0x04 */
+ DWORD Unknown2; /* 0x08 */
+ WORD Unknown3; /* 0x0c */
+ WORD Unknown4; /* 0x0e */
+ DWORD Unknown5; /* 0x10 */
+ DWORD Unknown6; /* 0x14 */
+ DWORD Unknown7; /* 0x18 */
+ DWORD Unknown8; /* 0x1c */
+ DWORD Unknown9; /* 0x20 */
+ DWORD Unknown10; /* 0x24 */
+
+} NOTIFY_SYNC, * PNOTIFY_SYNC;
+
+
+typedef struct _LARGE_MCB
+{
+ PFAST_MUTEX FastMutex;
+ ULONG MaximumPairCount;
+ ULONG PairCount;
+ POOL_TYPE PoolType;
+ PVOID Mapping;
+} LARGE_MCB, *PLARGE_MCB;
+
+
+typedef VOID
+(*POPLOCK_WAIT_COMPLETE_ROUTINE)(PVOID Context,
+ PIRP Irp);
+
+typedef VOID
+(*POPLOCK_FS_PREPOST_IRP)(PVOID Context,
+ PIRP Irp);
+
+typedef PVOID OPLOCK, *POPLOCK;
+
+#endif /* __INCLUDE_DDK_FSFUNCS_H */
--- /dev/null
+#ifndef __INCLUDE_DDK_HALFUNCS_H
+#define __INCLUDE_DDK_HALFUNCS_H
+/* $Id: halfuncs.h,v 1.3 2002/09/08 10:47:44 chorns Exp $ */
+
+VOID STDCALL
+HalAcquireDisplayOwnership(IN PHAL_RESET_DISPLAY_PARAMETERS ResetDisplayParameters);
+
+NTSTATUS STDCALL
+HalAdjustResourceList(PCM_RESOURCE_LIST Resources);
+
+NTSTATUS STDCALL
+HalAllocateAdapterChannel(IN PADAPTER_OBJECT AdapterObject,
+ IN PDEVICE_OBJECT DeviceObject,
+ IN ULONG NumberOfMapRegisters,
+ IN PDRIVER_CONTROL ExecutionRoutine,
+ IN PVOID Context);
+
+PVOID STDCALL
+HalAllocateCommonBuffer(PADAPTER_OBJECT AdapterObject,
+ ULONG Length,
+ PPHYSICAL_ADDRESS LogicalAddress,
+ BOOLEAN CacheEnabled);
+
+PVOID STDCALL
+HalAllocateCrashDumpRegisters(IN PADAPTER_OBJECT AdapterObject,
+ IN OUT PULONG NumberOfMapRegisters);
+
+BOOLEAN STDCALL
+HalAllProcessorsStarted(VOID);
+
+NTSTATUS STDCALL
+HalAssignSlotResources(
+ PUNICODE_STRING RegistryPath,
+ PUNICODE_STRING DriverClassName,
+ PDRIVER_OBJECT DriverObject,
+ PDEVICE_OBJECT DeviceObject,
+ INTERFACE_TYPE BusType,
+ ULONG BusNumber,
+ ULONG SlotNumber,
+ PCM_RESOURCE_LIST *AllocatedResources
+ );
+
+BOOLEAN STDCALL
+HalBeginSystemInterrupt(ULONG Vector,
+ KIRQL Irql,
+ PKIRQL OldIrql);
+
+VOID STDCALL
+HalCalibratePerformanceCounter(ULONG Count);
+
+/*
+FASTCALL
+HalClearSoftwareInterrupt
+*/
+
+BOOLEAN STDCALL
+HalDisableSystemInterrupt(ULONG Vector,
+ ULONG Unknown2);
+
+VOID STDCALL
+HalDisplayString(IN PCH String);
+
+BOOLEAN STDCALL
+HalEnableSystemInterrupt(ULONG Vector,
+ ULONG Unknown2,
+ ULONG Unknown3);
+
+VOID STDCALL
+HalEndSystemInterrupt(KIRQL Irql,
+ ULONG Unknown2);
+
+
+/* Is this function really exported ?? */
+VOID
+HalExamineMBR(PDEVICE_OBJECT DeviceObject,
+ ULONG SectorSize,
+ ULONG MBRTypeIdentifier,
+ PVOID Buffer);
+
+BOOLEAN STDCALL
+HalFlushCommonBuffer(ULONG Unknown1,
+ ULONG Unknown2,
+ ULONG Unknown3,
+ ULONG Unknown4,
+ ULONG Unknown5,
+ ULONG Unknown6,
+ ULONG Unknown7,
+ ULONG Unknown8);
+
+VOID STDCALL
+HalFreeCommonBuffer(PADAPTER_OBJECT AdapterObject,
+ ULONG Length,
+ PHYSICAL_ADDRESS LogicalAddress,
+ PVOID VirtualAddress,
+ BOOLEAN CacheEnabled);
+
+PADAPTER_OBJECT STDCALL
+HalGetAdapter(PDEVICE_DESCRIPTION DeviceDescription,
+ PULONG NumberOfMapRegisters);
+
+ULONG STDCALL
+HalGetBusData(BUS_DATA_TYPE BusDataType,
+ ULONG BusNumber,
+ ULONG SlotNumber,
+ PVOID Buffer,
+ ULONG Length);
+
+ULONG STDCALL
+HalGetBusDataByOffset(BUS_DATA_TYPE BusDataType,
+ ULONG BusNumber,
+ ULONG SlotNumber,
+ PVOID Buffer,
+ ULONG Offset,
+ ULONG Length);
+
+/* Is this function really exported ?? */
+ULONG
+HalGetDmaAlignmentRequirement(VOID);
+
+BOOLEAN STDCALL
+HalGetEnvironmentVariable(IN PCH Name,
+ OUT PCH Value,
+ IN USHORT ValueLength);
+
+ULONG STDCALL
+HalGetInterruptVector(INTERFACE_TYPE InterfaceType,
+ ULONG BusNumber,
+ ULONG BusInterruptLevel,
+ ULONG BusInterruptVector,
+ PKIRQL Irql,
+ PKAFFINITY Affinity);
+
+VOID STDCALL
+HalInitializeProcessor(ULONG ProcessorNumber,
+ PVOID ProcessorStack);
+
+BOOLEAN STDCALL
+HalInitSystem(ULONG BootPhase,
+ PLOADER_PARAMETER_BLOCK LoaderBlock);
+
+BOOLEAN STDCALL
+HalMakeBeep(ULONG Frequency);
+
+VOID STDCALL
+HalQueryDisplayParameters(PULONG DispSizeX,
+ PULONG DispSizeY,
+ PULONG CursorPosX,
+ PULONG CursorPosY);
+
+VOID STDCALL
+HalQueryRealTimeClock(PTIME_FIELDS Time);
+
+/* Is this function really exported ?? */
+VOID
+HalQuerySystemInformation(VOID);
+
+ULONG STDCALL
+HalReadDmaCounter(PADAPTER_OBJECT AdapterObject);
+
+VOID STDCALL
+HalReportResourceUsage(VOID);
+
+VOID STDCALL
+HalRequestIpi(ULONG Unknown);
+
+/*
+FASTCALL
+HalRequestSoftwareInterrupt
+*/
+
+VOID STDCALL
+HalReturnToFirmware(ULONG Action);
+
+ULONG STDCALL
+HalSetBusData(BUS_DATA_TYPE BusDataType,
+ ULONG BusNumber,
+ ULONG SlotNumber,
+ PVOID Buffer,
+ ULONG Length);
+
+ULONG STDCALL
+HalSetBusDataByOffset(BUS_DATA_TYPE BusDataType,
+ ULONG BusNumber,
+ ULONG SlotNumber,
+ PVOID Buffer,
+ ULONG Offset,
+ ULONG Length);
+
+VOID STDCALL
+HalSetDisplayParameters(ULONG CursorPosX,
+ ULONG CursorPosY);
+
+BOOLEAN STDCALL
+HalSetEnvironmentVariable(IN PCH Name,
+ IN PCH Value);
+
+/*
+HalSetProfileInterval
+*/
+
+VOID STDCALL
+HalSetRealTimeClock(PTIME_FIELDS Time);
+
+/*
+HalSetTimeIncrement
+*/
+
+BOOLEAN STDCALL
+HalStartNextProcessor(ULONG Unknown1,
+ ULONG Unknown2);
+
+/*
+HalStartProfileInterrupt
+*/
+
+/*
+HalStopProfileInterrupt
+*/
+
+ULONG FASTCALL
+HalSystemVectorDispatchEntry(ULONG Unknown1,
+ ULONG Unknown2,
+ ULONG Unknown3);
+
+BOOLEAN STDCALL
+HalTranslateBusAddress(INTERFACE_TYPE InterfaceType,
+ ULONG BusNumber,
+ PHYSICAL_ADDRESS BusAddress,
+ PULONG AddressSpace,
+ PPHYSICAL_ADDRESS TranslatedAddress);
+
+
+/*
+ * Kernel debugger support functions
+ */
+
+BOOLEAN STDCALL
+KdPortInitialize(PKD_PORT_INFORMATION PortInformation,
+ DWORD Unknown1,
+ DWORD Unknown2);
+
+BOOLEAN STDCALL
+KdPortGetByte(PUCHAR ByteRecieved);
+
+BOOLEAN STDCALL
+KdPortPollByte(PUCHAR ByteRecieved);
+
+VOID STDCALL
+KdPortPutByte(UCHAR ByteToSend);
+
+
+/*
+ * Port I/O functions
+ */
+
+VOID STDCALL
+READ_PORT_BUFFER_UCHAR(PUCHAR Port,
+ PUCHAR Value,
+ ULONG Count);
+
+VOID STDCALL
+READ_PORT_BUFFER_ULONG(PULONG Port,
+ PULONG Value,
+ ULONG Count);
+
+VOID STDCALL
+READ_PORT_BUFFER_USHORT(PUSHORT Port,
+ PUSHORT Value,
+ ULONG Count);
+
+UCHAR STDCALL
+READ_PORT_UCHAR(PUCHAR Port);
+
+ULONG STDCALL
+READ_PORT_ULONG(PULONG Port);
+
+USHORT STDCALL
+READ_PORT_USHORT(PUSHORT Port);
+
+VOID STDCALL
+WRITE_PORT_BUFFER_UCHAR(PUCHAR Port,
+ PUCHAR Value,
+ ULONG Count);
+
+VOID STDCALL
+WRITE_PORT_BUFFER_ULONG(PULONG Port,
+ PULONG Value,
+ ULONG Count);
+
+VOID STDCALL
+WRITE_PORT_BUFFER_USHORT(PUSHORT Port,
+ PUSHORT Value,
+ ULONG Count);
+
+VOID STDCALL
+WRITE_PORT_UCHAR(PUCHAR Port,
+ UCHAR Value);
+
+VOID STDCALL
+WRITE_PORT_ULONG(PULONG Port,
+ ULONG Value);
+
+VOID STDCALL
+WRITE_PORT_USHORT(PUSHORT Port,
+ USHORT Value);
+
+#endif /* __INCLUDE_DDK_HALDDK_H */
+
+/* EOF */
--- /dev/null
+/* $Id: haltypes.h,v 1.5 2002/09/08 10:47:44 chorns Exp $
+ *
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS kernel
+ * FILE: include/ddk/haltypes.h
+ * PURPOSE: HAL provided defintions for device drivers
+ * PROGRAMMER: David Welch (welch@mcmail.com)
+ * REVISION HISTORY:
+ * 23/06/98: Taken from linux system.h
+ */
+
+
+#ifndef __INCLUDE_DDK_HALTYPES_H
+#define __INCLUDE_DDK_HALTYPES_H
+
+
+/* HalReturnToFirmware */
+#define FIRMWARE_HALT 1
+#define FIRMWARE_REBOOT 3
+
+enum
+{
+ DEVICE_DESCRIPTION_VERSION,
+ DEVICE_DESCRIPTION_VERSION1,
+};
+
+typedef ULONG DMA_WIDTH;
+typedef ULONG DMA_SPEED;
+
+/*
+ * PURPOSE: Types for HalGetBusData
+ */
+typedef enum _BUS_DATA_TYPE
+{
+ ConfigurationSpaceUndefined = -1,
+ Cmos,
+ EisaConfiguration,
+ Pos,
+ CbusConfiguration,
+ PCIConfiguration,
+ VMEConfiguration,
+ NuBusConfiguration,
+ PCMCIAConfiguration,
+ MPIConfiguration,
+ MPSAConfiguration,
+ PNPISAConfiguration,
+ MaximumBusDataType,
+} BUS_DATA_TYPE, *PBUS_DATA_TYPE;
+
+typedef struct _DEVICE_DESCRIPTION
+{
+ ULONG Version;
+ BOOLEAN Master;
+ BOOLEAN ScatterGather;
+ BOOLEAN DemandMode;
+ BOOLEAN AutoInitialize;
+ BOOLEAN Dma32BitAddress;
+ BOOLEAN IgnoreCount;
+ BOOLEAN Reserved1;
+ BOOLEAN Reserved2;
+ ULONG BusNumber;
+ ULONG DmaChannel;
+ INTERFACE_TYPE InterfaceType;
+ DMA_WIDTH DmaWidth;
+ DMA_SPEED DmaSpeed;
+ ULONG MaximumLength;
+ ULONG DmaPort;
+} DEVICE_DESCRIPTION, *PDEVICE_DESCRIPTION;
+
+
+/* PCI bus definitions */
+
+#define PCI_TYPE0_ADDRESSES 6
+#define PCI_TYPE1_ADDRESSES 2
+#define PCI_TYPE2_ADDRESSES 5
+
+typedef struct _PCI_COMMON_CONFIG
+{
+ USHORT VendorID; /* read-only */
+ USHORT DeviceID; /* read-only */
+ USHORT Command;
+ USHORT Status;
+ UCHAR RevisionID; /* read-only */
+ UCHAR ProgIf; /* read-only */
+ UCHAR SubClass; /* read-only */
+ UCHAR BaseClass; /* read-only */
+ UCHAR CacheLineSize; /* read-only */
+ UCHAR LatencyTimer; /* read-only */
+ UCHAR HeaderType; /* read-only */
+ UCHAR BIST;
+ union
+ {
+ struct _PCI_HEADER_TYPE_0
+ {
+ ULONG BaseAddresses[PCI_TYPE0_ADDRESSES];
+ ULONG CIS;
+ USHORT SubVendorID;
+ USHORT SubSystemID;
+ ULONG ROMBaseAddress;
+ ULONG Reserved2[2];
+
+ UCHAR InterruptLine;
+ UCHAR InterruptPin; /* read-only */
+ UCHAR MinimumGrant; /* read-only */
+ UCHAR MaximumLatency; /* read-only */
+ } type0;
+
+ /* PCI to PCI Bridge */
+ struct _PCI_HEADER_TYPE_1
+ {
+ ULONG BaseAddresses[PCI_TYPE1_ADDRESSES];
+ UCHAR PrimaryBus;
+ UCHAR SecondaryBus;
+ UCHAR SubordinateBus;
+ UCHAR SecondaryLatency;
+ UCHAR IOBase;
+ UCHAR IOLimit;
+ USHORT SecondaryStatus;
+ USHORT MemoryBase;
+ USHORT MemoryLimit;
+ USHORT PrefetchBase;
+ USHORT PrefetchLimit;
+ ULONG PrefetchBaseUpper32;
+ ULONG PrefetchLimitUpper32;
+ USHORT IOBaseUpper16;
+ USHORT IOLimitUpper16;
+ UCHAR CapabilitiesPtr;
+ UCHAR Reserved1[3];
+ ULONG ROMBaseAddress;
+ UCHAR InterruptLine;
+ UCHAR InterruptPin;
+ USHORT BridgeControl;
+ } type1;
+
+ /* PCI to CARDBUS Bridge */
+ struct _PCI_HEADER_TYPE_2
+ {
+ ULONG SocketRegistersBaseAddress;
+ UCHAR CapabilitiesPtr;
+ UCHAR Reserved;
+ USHORT SecondaryStatus;
+ UCHAR PrimaryBus;
+ UCHAR SecondaryBus;
+ UCHAR SubordinateBus;
+ UCHAR SecondaryLatency;
+ struct
+ {
+ ULONG Base;
+ ULONG Limit;
+ } Range[PCI_TYPE2_ADDRESSES-1];
+ UCHAR InterruptLine;
+ UCHAR InterruptPin;
+ USHORT BridgeControl;
+ } type2;
+ } u;
+ UCHAR DeviceSpecific[192];
+} PCI_COMMON_CONFIG, *PPCI_COMMON_CONFIG;
+
+#define PCI_COMMON_HDR_LENGTH (FIELD_OFFSET (PCI_COMMON_CONFIG, DeviceSpecific))
+
+#define PCI_MAX_DEVICES 32
+#define PCI_MAX_FUNCTION 8
+
+#define PCI_INVALID_VENDORID 0xFFFF
+
+
+/* Bit encodings for PCI_COMMON_CONFIG.HeaderType */
+
+#define PCI_MULTIFUNCTION 0x80
+#define PCI_DEVICE_TYPE 0x00
+#define PCI_BRIDGE_TYPE 0x01
+
+
+/* Bit encodings for PCI_COMMON_CONFIG.Command */
+
+#define PCI_ENABLE_IO_SPACE 0x0001
+#define PCI_ENABLE_MEMORY_SPACE 0x0002
+#define PCI_ENABLE_BUS_MASTER 0x0004
+#define PCI_ENABLE_SPECIAL_CYCLES 0x0008
+#define PCI_ENABLE_WRITE_AND_INVALIDATE 0x0010
+#define PCI_ENABLE_VGA_COMPATIBLE_PALETTE 0x0020
+#define PCI_ENABLE_PARITY 0x0040
+#define PCI_ENABLE_WAIT_CYCLE 0x0080
+#define PCI_ENABLE_SERR 0x0100
+#define PCI_ENABLE_FAST_BACK_TO_BACK 0x0200
+
+
+/* Bit encodings for PCI_COMMON_CONFIG.Status */
+
+#define PCI_STATUS_FAST_BACK_TO_BACK 0x0080
+#define PCI_STATUS_DATA_PARITY_DETECTED 0x0100
+#define PCI_STATUS_DEVSEL 0x0600 /* 2 bits wide */
+#define PCI_STATUS_SIGNALED_TARGET_ABORT 0x0800
+#define PCI_STATUS_RECEIVED_TARGET_ABORT 0x1000
+#define PCI_STATUS_RECEIVED_MASTER_ABORT 0x2000
+#define PCI_STATUS_SIGNALED_SYSTEM_ERROR 0x4000
+#define PCI_STATUS_DETECTED_PARITY_ERROR 0x8000
+
+
+/* Bit encodes for PCI_COMMON_CONFIG.u.type0.BaseAddresses */
+
+#define PCI_ADDRESS_IO_SPACE 0x00000001
+#define PCI_ADDRESS_MEMORY_TYPE_MASK 0x00000006
+#define PCI_ADDRESS_MEMORY_PREFETCHABLE 0x00000008
+
+#define PCI_TYPE_32BIT 0
+#define PCI_TYPE_20BIT 2
+#define PCI_TYPE_64BIT 4
+
+
+/* Bit encodes for PCI_COMMON_CONFIG.u.type0.ROMBaseAddresses */
+
+#define PCI_ROMADDRESS_ENABLED 0x00000001
+
+
+typedef struct _PCI_SLOT_NUMBER
+{
+ union
+ {
+ struct
+ {
+ ULONG DeviceNumber:5;
+ ULONG FunctionNumber:3;
+ ULONG Reserved:24;
+ } bits;
+ ULONG AsULONG;
+ } u;
+} PCI_SLOT_NUMBER, *PPCI_SLOT_NUMBER;
+
+
+/* Hal dispatch table */
+
+typedef enum _HAL_QUERY_INFORMATION_CLASS
+{
+ HalInstalledBusInformation,
+ HalProfileSourceInformation,
+ HalSystemDockInformation,
+ HalPowerInformation,
+ HalProcessorSpeedInformation,
+ HalCallbackInformation,
+ HalMapRegisterInformation,
+ HalMcaLogInformation,
+ HalFrameBufferCachingInformation,
+ HalDisplayBiosInformation
+ /* information levels >= 0x8000000 reserved for OEM use */
+} HAL_QUERY_INFORMATION_CLASS, *PHAL_QUERY_INFORMATION_CLASS;
+
+
+typedef enum _HAL_SET_INFORMATION_CLASS
+{
+ HalProfileSourceInterval,
+ HalProfileSourceInterruptHandler,
+ HalMcaRegisterDriver
+} HAL_SET_INFORMATION_CLASS, *PHAL_SET_INFORMATION_CLASS;
+
+
+typedef struct _BUS_HANDLER *PBUS_HANDLER;
+typedef struct _DEVICE_HANDLER_OBJECT *PDEVICE_HANDLER_OBJECT;
+
+
+typedef BOOLEAN STDCALL
+(*PHAL_RESET_DISPLAY_PARAMETERS)(ULONG Columns, ULONG Rows);
+
+typedef NTSTATUS STDCALL
+(*pHalQuerySystemInformation)(IN HAL_QUERY_INFORMATION_CLASS InformationClass,
+ IN ULONG BufferSize,
+ IN OUT PVOID Buffer,
+ OUT PULONG ReturnedLength);
+
+
+typedef NTSTATUS STDCALL
+(*pHalSetSystemInformation)(IN HAL_SET_INFORMATION_CLASS InformationClass,
+ IN ULONG BufferSize,
+ IN PVOID Buffer);
+
+
+typedef NTSTATUS STDCALL
+(*pHalQueryBusSlots)(IN PBUS_HANDLER BusHandler,
+ IN ULONG BufferSize,
+ OUT PULONG SlotNumbers,
+ OUT PULONG ReturnedLength);
+
+
+/* Control codes of HalDeviceControl function */
+#define BCTL_EJECT 0x0001
+#define BCTL_QUERY_DEVICE_ID 0x0002
+#define BCTL_QUERY_DEVICE_UNIQUE_ID 0x0003
+#define BCTL_QUERY_DEVICE_CAPABILITIES 0x0004
+#define BCTL_QUERY_DEVICE_RESOURCES 0x0005
+#define BCTL_QUERY_DEVICE_RESOURCE_REQUIREMENTS 0x0006
+#define BCTL_QUERY_EJECT 0x0007
+#define BCTL_SET_LOCK 0x0008
+#define BCTL_SET_POWER 0x0009
+#define BCTL_SET_RESUME 0x000A
+#define BCTL_SET_DEVICE_RESOURCES 0x000B
+
+/* Defines for BCTL structures */
+typedef struct
+{
+ BOOLEAN PowerSupported;
+ BOOLEAN ResumeSupported;
+ BOOLEAN LockSupported;
+ BOOLEAN EjectSupported;
+ BOOLEAN Removable;
+} BCTL_DEVICE_CAPABILITIES, *PBCTL_DEVICE_CAPABILITIES;
+
+
+typedef struct _DEVICE_CONTROL_CONTEXT
+{
+ NTSTATUS Status;
+ PDEVICE_HANDLER_OBJECT DeviceHandler;
+ PDEVICE_OBJECT DeviceObject;
+ ULONG ControlCode;
+ PVOID Buffer;
+ PULONG BufferLength;
+ PVOID Context;
+} DEVICE_CONTROL_CONTEXT, *PDEVICE_CONTROL_CONTEXT;
+
+
+typedef VOID STDCALL
+(*PDEVICE_CONTROL_COMPLETION)(IN PDEVICE_CONTROL_CONTEXT ControlContext);
+
+
+typedef NTSTATUS STDCALL
+(*pHalDeviceControl)(IN PDEVICE_HANDLER_OBJECT DeviceHandler,
+ IN PDEVICE_OBJECT DeviceObject,
+ IN ULONG ControlCode,
+ IN OUT PVOID Buffer OPTIONAL,
+ IN OUT PULONG BufferLength OPTIONAL,
+ IN PVOID Context,
+ IN PDEVICE_CONTROL_COMPLETION CompletionRoutine);
+
+typedef VOID FASTCALL
+(*pHalExamineMBR)(IN PDEVICE_OBJECT DeviceObject,
+ IN ULONG SectorSize,
+ IN ULONG MBRTypeIdentifier,
+ OUT PVOID *Buffer);
+
+typedef VOID FASTCALL
+(*pHalIoAssignDriveLetters)(IN PLOADER_PARAMETER_BLOCK LoaderBlock,
+ IN PSTRING NtDeviceName,
+ OUT PUCHAR NtSystemPath,
+ OUT PSTRING NtSystemPathString);
+
+typedef NTSTATUS FASTCALL
+(*pHalIoReadPartitionTable)(IN PDEVICE_OBJECT DeviceObject,
+ IN ULONG SectorSize,
+ IN BOOLEAN ReturnRecognizedPartitions,
+ OUT PDRIVE_LAYOUT_INFORMATION *PartitionBuffer);
+
+typedef NTSTATUS FASTCALL
+(*pHalIoSetPartitionInformation)(IN PDEVICE_OBJECT DeviceObject,
+ IN ULONG SectorSize,
+ IN ULONG PartitionNumber,
+ IN ULONG PartitionType);
+
+typedef NTSTATUS FASTCALL
+(*pHalIoWritePartitionTable)(IN PDEVICE_OBJECT DeviceObject,
+ IN ULONG SectorSize,
+ IN ULONG SectorsPerTrack,
+ IN ULONG NumberOfHeads,
+ IN PDRIVE_LAYOUT_INFORMATION PartitionBuffer);
+
+typedef PBUS_HANDLER FASTCALL
+(*pHalHandlerForBus)(IN INTERFACE_TYPE InterfaceType,
+ IN ULONG BusNumber);
+
+typedef VOID FASTCALL
+(*pHalReferenceBusHandler)(IN PBUS_HANDLER BusHandler);
+
+
+typedef struct _HAL_DISPATCH
+{
+ ULONG Version;
+ pHalQuerySystemInformation HalQuerySystemInformation;
+ pHalSetSystemInformation HalSetSystemInformation;
+ pHalQueryBusSlots HalQueryBusSlots;
+ pHalDeviceControl HalDeviceControl;
+ pHalExamineMBR HalExamineMBR;
+ pHalIoAssignDriveLetters HalIoAssignDriveLetters;
+ pHalIoReadPartitionTable HalIoReadPartitionTable;
+ pHalIoSetPartitionInformation HalIoSetPartitionInformation;
+ pHalIoWritePartitionTable HalIoWritePartitionTable;
+ pHalHandlerForBus HalReferenceHandlerForBus;
+ pHalReferenceBusHandler HalReferenceBusHandler;
+ pHalReferenceBusHandler HalDereferenceBusHandler;
+} HAL_DISPATCH, *PHAL_DISPATCH;
+
+#define HAL_DISPATCH_VERSION 1
+
+#ifdef __NTOSKRNL__
+extern HAL_DISPATCH EXPORTED HalDispatchTable;
+#else
+extern HAL_DISPATCH IMPORTED HalDispatchTable;
+#endif
+
+
+/* Hal private dispatch table */
+
+typedef struct _HAL_PRIVATE_DISPATCH
+{
+ ULONG Version;
+} HAL_PRIVATE_DISPATCH, *PHAL_PRIVATE_DISPATCH;
+
+#define HAL_PRIVATE_DISPATCH_VERSION 1
+
+
+#ifdef __NTOSKRNL__
+extern HAL_PRIVATE_DISPATCH EXPORTED HalPrivateDispatchTable;
+#else
+extern HAL_PRIVATE_DISPATCH IMPORTED HalPrivateDispatchTable;
+#endif
+
+
+
+/*
+ * Kernel debugger section
+ */
+
+typedef struct _KD_PORT_INFORMATION
+{
+ ULONG ComPort;
+ ULONG BaudRate;
+ ULONG BaseAddress;
+} KD_PORT_INFORMATION, *PKD_PORT_INFORMATION;
+
+
+#ifdef __NTHAL__
+extern ULONG EXPORTED KdComPortInUse;
+#else
+extern ULONG IMPORTED KdComPortInUse;
+#endif
+
+#endif /* __INCLUDE_DDK_HALTYPES_H */
+
+/* EOF */
--- /dev/null
+/*
+ * PURPOSE: The number of device specific level levels
+ */
+#define NR_DEVICE_SPECIFIC_LEVELS (16)
+
+
+
--- /dev/null
+#ifndef __INCLUDE_DDK_I386_PAGESIZE_H
+#define __INCLUDE_DDK_I386_PAGESIZE_H
+
+#define PAGESIZE (4096)
+
+#endif /* __INCLUDE_DDK_I386_PAGESIZE_H */
--- /dev/null
+/*
+ *
+ */
+
+#ifndef __INCLUDE_DDK_I386_TSS_H
+#define __INCLUDE_DDK_I386_TSS_H
+
+#define KTSS_ESP0 (0x4)
+
+#ifndef __ASM__
+
+typedef struct _KTSS
+{
+ USHORT PreviousTask;
+ USHORT Reserved1;
+ ULONG Esp0;
+ USHORT Ss0;
+ USHORT Reserved2;
+ ULONG Esp1;
+ USHORT Ss1;
+ USHORT Reserved3;
+ ULONG Esp2;
+ USHORT Ss2;
+ USHORT Reserved4;
+ ULONG Cr3;
+ ULONG Eip;
+ ULONG Eflags;
+ ULONG Eax;
+ ULONG Ecx;
+ ULONG Edx;
+ ULONG Ebx;
+ ULONG Esp;
+ ULONG Ebp;
+ ULONG Esi;
+ ULONG Edi;
+ USHORT Es;
+ USHORT Reserved5;
+ USHORT Cs;
+ USHORT Reserved6;
+ USHORT Ss;
+ USHORT Reserved7;
+ USHORT Ds;
+ USHORT Reserved8;
+ USHORT Fs;
+ USHORT Reserved9;
+ USHORT Gs;
+ USHORT Reserved10;
+ USHORT Ldt;
+ USHORT Reserved11;
+ USHORT Trap;
+ USHORT IoMapBase;
+ UCHAR IoBitmap[1];
+} KTSS __attribute__((packed));
+
+#endif /* not __ASM__ */
+
+#endif /* __INCLUDE_DDK_I386_TSS_H */
--- /dev/null
+#ifndef __INCLUDE_DDK_IOCTRL_H
+#define __INCLUDE_DDK_IOCTRL_H
+
+
+#define CTL_CODE(Dev, Func, Meth, Acc) ( ((Dev)<<16) | ((Acc)<<14) | ((Func)<<2) | (Meth))
+
+
+#define DEVICE_TYPE_FROM_CTL_CODE(ctlCode) (((ULONG)(ctlCode&0xffff0000))>>16)
+#define IO_METHOD_FROM_CTL_CODE(ctlCode) (ctlCode&0x00000003)
+
+
+// IOCTL Parameter buffering methods
+#define METHOD_BUFFERED 0
+#define METHOD_IN_DIRECT 1
+#define METHOD_OUT_DIRECT 2
+#define METHOD_NEITHER 3
+
+// IOCTL File access type
+#define FILE_ANY_ACCESS 0
+#define FILE_READ_ACCESS 1
+#define FILE_WRITE_ACCESS 2
+
+#endif /* __INCLUDE_DDK_IOCTRL_H */
--- /dev/null
+#ifndef __INCLUDE_DDK_IODEF_H
+#define __INCLUDE_DDK_IODEF_H
+
+typedef enum _IO_QUERY_DEVICE_DESCRIPTION
+{
+ IoQueryDeviceIdentifier = 0,
+ IoQueryDeviceConfigurationData,
+ IoQueryDeviceComponentInformation,
+ IoQueryDeviceDataFormatMaximum,
+} IO_QUERY_DEVICE_DESCRIPTION, *PIO_QUERY_DEVICE_DESCRIPTION;
+
+typedef enum _CONFIGURATION_TYPE
+{
+ DiskController,
+ ParallelController,
+ MaximumType,
+} CONFIGURATION_TYPE, *PCONFIGURATION_TYPE;
+
+typedef enum _CM_RESOURCE_TYPE
+{
+ CmResourceTypePort = 1,
+ CmResourceTypeInterrupt,
+ CmResourceTypeMemory,
+ CmResourceTypeDma,
+ CmResourceTypeDeviceSpecific,
+ CmResourceTypeMaximum,
+} CM_RESOURCE_TYPE;
+
+typedef enum _CM_SHARE_DISPOSITION
+{
+ CmResourceShareDeviceExclusive = 1,
+ CmResourceShareDriverExclusive,
+ CmResourceShareShared,
+ CmResourceShareMaximum,
+} CM_SHARE_DISPOSITION;
+
+enum
+{
+ CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE,
+ CM_RESOURCE_INTERRUPT_LATCHED,
+};
+
+enum
+{
+ CM_RESOURCE_PORT_MEMORY,
+ CM_RESOURCE_PORT_IO,
+};
+
+/*
+ * PURPOSE: Irp flags
+ */
+enum
+{
+ IRP_NOCACHE = 0x1,
+ IRP_PAGING_IO = 0x2,
+ IRP_MOUNT_COMPLETION = 0x2,
+ IRP_SYNCHRONOUS_API = 0x4,
+ IRP_ASSOCIATED_IRP = 0x8,
+ IRP_BUFFERED_IO = 0x10,
+ IRP_DEALLOCATE_BUFFER = 0x20,
+ IRP_INPUT_OPERATION = 0x40,
+ IRP_SYNCHRONOUS_PAGING_IO = 0x40,
+ IRP_CREATE_OPERATION = 0x80,
+ IRP_READ_OPERATION = 0x100,
+ IRP_WRITE_OPERATION = 0x200,
+ IRP_CLOSE_OPERATION = 0x400,
+ IRP_DEFER_IO_COMPLETION = 0x800,
+ IRP_OB_QUERY_NAME = 0x1000,
+ IRP_HOLD_DEVICE_QUEUE = 0x2000,
+ IRP_RETRY_IO_COMPLETION = 0x4000
+};
+
+#define SL_FORCE_ACCESS_CHECK (0x1)
+#define SL_OPEN_PAGING_FILE (0x2)
+#define SL_OPEN_TARGET_DIRECTORY (0x4)
+#define SL_CASE_SENSITIVE (0x80)
+
+#define SL_KEY_SPECIFIED (0x1)
+#define SL_OVERRIDE_VERIFY_VOLUME (0x2)
+#define SL_WRITE_THROUGHT (0x4)
+#define SL_FT_SEQUENTIAL_WRITE (0x8)
+
+#define SL_FAIL_IMMEDIATELY (0x1)
+#define SL_EXCLUSIVE_LOCK (0x2)
+
+#define SL_WATCH_TREE (0x1)
+
+#define SL_RESTART_SCAN (0x1)
+#define SL_RETURN_SINGLE_ENTRY (0x2)
+#define SL_INDEX_SPECIFIED (0x4)
+
+#define SL_ALLOW_RAW_MOUNT (0x1)
+
+#define SL_PENDING_RETURNED 0x01
+#define SL_INVOKE_ON_CANCEL 0x20
+#define SL_INVOKE_ON_SUCCESS 0x40
+#define SL_INVOKE_ON_ERROR 0x80
+
+/*
+ * Possible flags for the device object flags
+ */
+#define DO_UNLOAD_PENDING 0x00000001
+#define DO_VERIFY_VOLUME 0x00000002
+#define DO_BUFFERED_IO 0x00000004
+#define DO_EXCLUSIVE 0x00000008
+#define DO_DIRECT_IO 0x00000010
+#define DO_MAP_IO_BUFFER 0x00000020
+#define DO_DEVICE_HAS_NAME 0x00000040
+#define DO_DEVICE_INITIALIZING 0x00000080
+#define DO_SYSTEM_BOOT_PARTITION 0x00000100
+#define DO_LONG_TERM_REQUESTS 0x00000200
+#define DO_NEVER_LAST_DEVICE 0x00000400
+#define DO_SHUTDOWN_REGISTERED 0x00000800
+#define DO_BUS_ENUMERATED_DEVICE 0x00001000
+#define DO_POWER_PAGABLE 0x00002000
+#define DO_POWER_INRUSH 0x00004000
+#define DO_LOW_PRIORITY_FILESYSTEM 0x00010000
+
+/*
+ * Possible device types
+ */
+#define FILE_DEVICE_BEEP 0x00000001
+#define FILE_DEVICE_CD_ROM 0x00000002
+#define FILE_DEVICE_CD_ROM_FILE_SYSTEM 0x00000003
+#define FILE_DEVICE_CONTROLLER 0x00000004
+#define FILE_DEVICE_DATALINK 0x00000005
+#define FILE_DEVICE_DFS 0x00000006
+#define FILE_DEVICE_DISK 0x00000007
+#define FILE_DEVICE_DISK_FILE_SYSTEM 0x00000008
+#define FILE_DEVICE_FILE_SYSTEM 0x00000009
+#define FILE_DEVICE_INPORT_PORT 0x0000000a
+#define FILE_DEVICE_KEYBOARD 0x0000000b
+#define FILE_DEVICE_MAILSLOT 0x0000000c
+#define FILE_DEVICE_MIDI_IN 0x0000000d
+#define FILE_DEVICE_MIDI_OUT 0x0000000e
+#define FILE_DEVICE_MOUSE 0x0000000f
+#define FILE_DEVICE_MULTI_UNC_PROVIDER 0x00000010
+#define FILE_DEVICE_NAMED_PIPE 0x00000011
+#define FILE_DEVICE_NETWORK 0x00000012
+#define FILE_DEVICE_NETWORK_BROWSER 0x00000013
+#define FILE_DEVICE_NETWORK_FILE_SYSTEM 0x00000014
+#define FILE_DEVICE_NULL 0x00000015
+#define FILE_DEVICE_PARALLEL_PORT 0x00000016
+#define FILE_DEVICE_PHYSICAL_NETCARD 0x00000017
+#define FILE_DEVICE_PRINTER 0x00000018
+#define FILE_DEVICE_SCANNER 0x00000019
+#define FILE_DEVICE_SERIAL_MOUSE_PORT 0x0000001a
+#define FILE_DEVICE_SERIAL_PORT 0x0000001b
+#define FILE_DEVICE_SCREEN 0x0000001c
+#define FILE_DEVICE_SOUND 0x0000001d
+#define FILE_DEVICE_STREAMS 0x0000001e
+#define FILE_DEVICE_TAPE 0x0000001f
+#define FILE_DEVICE_TAPE_FILE_SYSTEM 0x00000020
+#define FILE_DEVICE_TRANSPORT 0x00000021
+#define FILE_DEVICE_UNKNOWN 0x00000022
+#define FILE_DEVICE_VIDEO 0x00000023
+#define FILE_DEVICE_VIRTUAL_DISK 0x00000024
+#define FILE_DEVICE_WAVE_IN 0x00000025
+#define FILE_DEVICE_WAVE_OUT 0x00000026
+#define FILE_DEVICE_8042_PORT 0x00000027
+#define FILE_DEVICE_NETWORK_REDIRECTOR 0x00000028
+#define FILE_DEVICE_BATTERY 0x00000029
+#define FILE_DEVICE_BUS_EXTENDER 0x0000002a
+#define FILE_DEVICE_MODEM 0x0000002b
+#define FILE_DEVICE_VDM 0x0000002c
+#define FILE_DEVICE_MASS_STORAGE 0x0000002d
+#define FILE_DEVICE_SMB 0x0000002e
+#define FILE_DEVICE_KS 0x0000002f
+#define FILE_DEVICE_CHANGER 0x00000030
+#define FILE_DEVICE_SMARTCARD 0x00000031
+#define FILE_DEVICE_ACPI 0x00000032
+#define FILE_DEVICE_DVD 0x00000033
+#define FILE_DEVICE_FULLSCREEN_VIDEO 0x00000034
+#define FILE_DEVICE_DFS_FILE_SYSTEM 0x00000035
+#define FILE_DEVICE_DFS_VOLUME 0x00000036
+#define FILE_DEVICE_SERENUM 0x00000037
+#define FILE_DEVICE_TERMSRV 0x00000038
+#define FILE_DEVICE_KSEC 0x00000039
+
+#define FILE_REMOVABLE_MEDIA 0x00000001
+#define FILE_READ_ONLY_DEVICE 0x00000002
+#define FILE_FLOPPY_DISKETTE 0x00000004
+#define FILE_WRITE_ONCE_MEDIA 0x00000008
+#define FILE_REMOTE_DEVICE 0x00000010
+#define FILE_DEVICE_IS_MOUNTED 0x00000020
+#define FILE_VIRTUAL_VOLUME 0x00000040
+#define FILE_AUTOGENERATED_DEVICE_NAME 0x00000080
+#define FILE_DEVICE_SECURE_OPEN 0x00000100
+
+
+/*
+ * PURPOSE: Bus types
+ */
+typedef enum _INTERFACE_TYPE
+{
+ InterfaceTypeUndefined = -1,
+ Internal,
+ Isa,
+ Eisa,
+ MicroChannel,
+ TurboChannel,
+ PCIBus,
+ VMEBus,
+ NuBus,
+ PCMCIABus,
+ CBus,
+ MPIBus,
+ MPSABus,
+ ProcessorInternal,
+ InternalPowerBus,
+ PNPISABus,
+ MaximumInterfaceType
+} INTERFACE_TYPE, *PINTERFACE_TYPE;
+
+
+enum
+{
+ IRP_MJ_CREATE,
+ IRP_MJ_CREATE_NAMED_PIPE,
+ IRP_MJ_CLOSE,
+ IRP_MJ_READ,
+ IRP_MJ_WRITE,
+ IRP_MJ_QUERY_INFORMATION,
+ IRP_MJ_SET_INFORMATION,
+ IRP_MJ_QUERY_EA,
+ IRP_MJ_SET_EA,
+ IRP_MJ_FLUSH_BUFFERS,
+ IRP_MJ_QUERY_VOLUME_INFORMATION,
+ IRP_MJ_SET_VOLUME_INFORMATION,
+ IRP_MJ_DIRECTORY_CONTROL,
+ IRP_MJ_FILE_SYSTEM_CONTROL,
+ IRP_MJ_DEVICE_CONTROL,
+ IRP_MJ_INTERNAL_DEVICE_CONTROL,
+ IRP_MJ_SHUTDOWN,
+ IRP_MJ_LOCK_CONTROL,
+ IRP_MJ_CLEANUP,
+ IRP_MJ_CREATE_MAILSLOT,
+ IRP_MJ_QUERY_SECURITY,
+ IRP_MJ_SET_SECURITY,
+ IRP_MJ_POWER,
+ IRP_MJ_SYSTEM_CONTROL,
+ IRP_MJ_DEVICE_CHANGE,
+ IRP_MJ_QUERY_QUOTA,
+ IRP_MJ_SET_QUOTA,
+ IRP_MJ_PNP,
+ IRP_MJ_MAXIMUM_FUNCTION,
+};
+
+#define IRP_MJ_SCSI IRP_MJ_INTERNAL_DEVICE_CONTROL
+
+/*
+ * Minor function numbers for IRP_MJ_FILE_SYSTEM_CONTROL
+ */
+#define IRP_MN_USER_FS_REQUEST 0x00
+#define IRP_MN_MOUNT_VOLUME 0x01
+#define IRP_MN_VERIFY_VOLUME 0x02
+#define IRP_MN_LOAD_FILE_SYSTEM 0x03
+
+/*
+ * Minor function numbers for IRP_MJ_SCSI
+ */
+#define IRP_MN_SCSI_CLASS 0x01
+
+/*
+ * Minor function codes for IRP_MJ_POWER
+ */
+#define IRP_MN_WAIT_WAKE 0x00
+#define IRP_MN_POWER_SEQUENCE 0x01
+#define IRP_MN_SET_POWER 0x02
+#define IRP_MN_QUERY_POWER 0x03
+
+/*
+ * Minor function codes for IRP_MJ_PNP
+ */
+#define IRP_MN_START_DEVICE 0x00
+#define IRP_MN_QUERY_REMOVE_DEVICE 0x01
+#define IRP_MN_REMOVE_DEVICE 0x02
+#define IRP_MN_CANCEL_REMOVE_DEVICE 0x03
+#define IRP_MN_STOP_DEVICE 0x04
+#define IRP_MN_QUERY_STOP_DEVICE 0x05
+#define IRP_MN_CANCEL_STOP_DEVICE 0x06
+#define IRP_MN_QUERY_DEVICE_RELATIONS 0x07
+#define IRP_MN_QUERY_INTERFACE 0x08
+#define IRP_MN_QUERY_CAPABILITIES 0x09
+#define IRP_MN_QUERY_RESOURCES 0x0A
+#define IRP_MN_QUERY_RESOURCE_REQUIREMENTS 0x0B
+#define IRP_MN_QUERY_DEVICE_TEXT 0x0C
+#define IRP_MN_FILTER_RESOURCE_REQUIREMENTS 0x0D
+#define IRP_MN_READ_CONFIG 0x0F
+#define IRP_MN_WRITE_CONFIG 0x10
+#define IRP_MN_EJECT 0x11
+#define IRP_MN_SET_LOCK 0x12
+#define IRP_MN_QUERY_ID 0x13
+#define IRP_MN_QUERY_PNP_DEVICE_STATE 0x14
+#define IRP_MN_QUERY_BUS_INFORMATION 0x15
+#define IRP_MN_DEVICE_USAGE_NOTIFICATION 0x16
+#define IRP_MN_SURPRISE_REMOVAL 0x17
+#define IRP_MN_QUERY_LEGACY_BUS_INFORMATION 0x18
+
+
+/*
+ * Priority increments
+ */
+#define EVENT_INCREMENT 1
+#define IO_NO_INCREMENT 0
+#define IO_CD_ROM_INCREMENT 1
+#define IO_DISK_INCREMENT 4
+#define IO_KEYBOARD_INCREMENT 6
+#define IO_MAILSLOT_INCREMENT 2
+#define IO_MOUSE_INCREMENT 6
+#define IO_NAMED_PIPE_INCREMENT 2
+#define IO_NETWORK_INCREMENT 2
+#define IO_PARALLEL_INCREMENT 1
+#define IO_SERIAL_INCREMENT 2
+#define IO_SOUND_INCREMENT 8
+#define IO_VIDEO_INCREMENT 1
+#define MUTANT_INCREMENT 1
+#define SEMAPHORE_INCREMENT 1
+
+#define FILE_BYTE_ALIGNMENT 0x00000000
+#define FILE_WORD_ALIGNMENT 0x00000001
+#define FILE_LONG_ALIGNMENT 0x00000003
+#define FILE_QUAD_ALIGNMENT 0x00000007
+#define FILE_OCTA_ALIGNMENT 0x0000000f
+#define FILE_32_BYTE_ALIGNMENT 0x0000001f
+#define FILE_64_BYTE_ALIGNMENT 0x0000003f
+#define FILE_128_BYTE_ALIGNMENT 0x0000007f
+#define FILE_256_BYTE_ALIGNMENT 0x000000ff
+#define FILE_512_BYTE_ALIGNMENT 0x000001ff
+
+/*
+ * File disposition values
+ */
+#define FILE_SUPERSEDED 0x0000
+#define FILE_OPENED 0x0001
+#define FILE_CREATED 0x0002
+#define FILE_OVERWRITTEN 0x0003
+#define FILE_EXISTS 0x0004
+#define FILE_DOES_NOT_EXIST 0x0005
+
+
+/*
+ * file creation flags
+ */
+#define FILE_DIRECTORY_FILE 0x00000001
+#define FILE_WRITE_THROUGH 0x00000002
+#define FILE_SEQUENTIAL_ONLY 0x00000004
+#define FILE_NO_INTERMEDIATE_BUFFERING 0x00000008
+
+#define FILE_SYNCHRONOUS_IO_ALERT 0x00000010
+#define FILE_SYNCHRONOUS_IO_NONALERT 0x00000020
+#define FILE_NON_DIRECTORY_FILE 0x00000040
+#define FILE_CREATE_TREE_CONNECTION 0x00000080
+
+#define FILE_COMPLETE_IF_OPLOCKED 0x00000100
+#define FILE_NO_EA_KNOWLEDGE 0x00000200
+#define FILE_OPEN_FOR_RECOVERY 0x00000400
+#define FILE_RANDOM_ACCESS 0x00000800
+
+#define FILE_DELETE_ON_CLOSE 0x00001000
+#define FILE_OPEN_BY_FILE_ID 0x00002000
+#define FILE_OPEN_FOR_BACKUP_INTENT 0x00004000
+#define FILE_NO_COMPRESSION 0x00008000
+
+#define FILE_RESERVE_OPFILTER 0x00100000
+#define FILE_TRANSACTED_MODE 0x00200000
+#define FILE_OPEN_OFFLINE_FILE 0x00400000
+
+#define FILE_VALID_OPTION_FLAGS 0x007fffff
+#define FILE_VALID_PIPE_OPTION_FLAGS 0x00000032
+#define FILE_VALID_MAILSLOT_OPTION_FLAGS 0x00000032
+#define FILE_VALID_SET_FLAGS 0x00001036
+
+
+typedef ULONG FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS;
+
+/*
+ * file system information class values
+ */
+#define FileFsVolumeInformation 1
+#define FileFsLabelInformation 2
+#define FileFsSizeInformation 3
+#define FileFsDeviceInformation 4
+#define FileFsAttributeInformation 5
+#define FileFsControlInformation 6
+#define FileFsQuotaQueryInformation 7
+#define FileFsQuotaSetInformation 8
+#define FileFsMaximumInformation 9
+
+#define IRP_MN_QUERY_DIRECTORY 0x01
+#define IRP_MN_NOTIFY_CHANGE_DIRECTORY 0x02
+
+#endif
--- /dev/null
+#ifndef _INCLUDE_DDK_IOFUNCS_H
+#define _INCLUDE_DDK_IOFUNCS_H
+/* $Id: iofuncs.h,v 1.33 2002/09/08 10:47:44 chorns Exp $ */
+
+/* --- EXPORTED BY NTOSKRNL --- */
+
+/**********************************************************************
+ * NAME EXPORTED
+ * IoAcquireCancelSpinLock@4
+ *
+ * DESCRIPTION
+ * Synchronizes cancelable-state transistions for IRPs in a
+ * multiprocessor-safe way.
+ *
+ * ARGUMENTS
+ * Irpl
+ * Variable to store the current IRQ level.
+ *
+ * RETURN VALUE
+ * None.
+ *
+ * REVISIONS
+ *
+ */
+VOID
+STDCALL
+IoAcquireCancelSpinLock (
+ PKIRQL Irpl
+ );
+VOID
+STDCALL
+IoAcquireVpbSpinLock (
+ PKIRQL Irpl
+ );
+/**********************************************************************
+ * NAME EXPORTED
+ * IoAllocateAdapterChannel@
+ *
+ * DESCRIPTION
+ * Allocates an adaptor object for a DMA operation on the target
+ * device.
+ *
+ * ARGUMENTS
+ * Adaptor
+ * Adapter channel or busmaster adapter to be allocated;
+ *
+ * DeviceObject
+ * Target device for DMA;
+ *
+ * NumberOfMapRegisters
+ * Number of map registers;
+ *
+ * ExecutionRoutine
+ * Routine to be called when the adaptor is available;
+ *
+ * Context
+ * Driver defined contex that will be passed to the
+ * execution routine.
+ *
+ * RETURN VALUE
+ * Success or failure code.
+ *
+ * REVISIONS
+ *
+ */
+NTSTATUS
+STDCALL
+IoAllocateAdapterChannel (
+ PADAPTER_OBJECT AdaperObject,
+ PDEVICE_OBJECT DeviceObject,
+ ULONG NumberOfMapRegisters,
+ PDRIVER_CONTROL ExecutionRoutine,
+ PVOID Context
+ );
+/**********************************************************************
+ * NAME EXPORTED
+ * IoAllocateController@16
+ *
+ * DESCRIPTION
+ * Sets up a call to a driver supplied controller object as
+ * soon as it is available.
+ *
+ * ARGUMENTS
+ * ControllerObject
+ * Driver created controller object;
+ *
+ * DeviceObject
+ * Target device;
+ *
+ * ExecutionObject
+ * Routine to be called;
+ *
+ * Context
+ * Driver determined context to be based to the
+ * routine.
+ *
+ * RETURN VALUE
+ * None.
+ *
+ * REVISIONS
+ *
+ */
+VOID
+STDCALL
+IoAllocateController (
+ PCONTROLLER_OBJECT ControllerObject,
+ PDEVICE_OBJECT DeviceObject,
+ PDRIVER_CONTROL ExecutionRoutine,
+ PVOID Context
+ );
+/**********************************************************************
+ * NAME EXPORTED
+ * IoAllocateErrorLogEntry@8
+ *
+ * DESCRIPTION
+ * Allocates an error log packet.
+ *
+ * ARGUMENTS
+ * IoObject
+ * Object which found the error;
+ *
+ * EntrySize
+ * Size in bytes of the packet to be allocated.
+ *
+ * RETURN VALUE
+ * On success, a pointer to the allocated packet.
+ * On failure, it returns NULL.
+ */
+PVOID
+STDCALL
+IoAllocateErrorLogEntry (
+ PVOID IoObject,
+ UCHAR EntrySize
+ );
+/**********************************************************************
+ * NAME EXPORTED
+ * IoAllocateIrp@8
+ *
+ * DESCRIPTION
+ * Allocates an IRP.
+ *
+ * ARGUMENTS
+ * StackSize
+ * Number of stack locations to allocate;
+ *
+ * ChargeQuota
+ * Who knows.
+ *
+ * RETURN VALUE
+ * On success, the allocated IRP. On failure, NULL.
+ */
+PIRP
+STDCALL
+IoAllocateIrp (
+ CCHAR StackSize,
+ BOOLEAN ChargeQuota
+ );
+/**********************************************************************
+ * NAME EXPORTED
+ * IoAllocateMdl@20
+ *
+ * DESCRIPTION
+ * Allocates an MDL large enough to map the supplied buffer.
+ *
+ * ARGUMENTS
+ * VirtualAddress
+ * Base virtual address of the buffer to be mapped;
+ *
+ * Length
+ * Length of the buffer to be mapped;
+ *
+ * SecondaryBuffer
+ * Whether the buffer is primary or secondary;
+ *
+ * ChargeQuota
+ * Charge non-paged pool quota to current thread;
+ *
+ * Irp
+ * Optional irp to be associated with the MDL.
+ *
+ * RETURN VALUE
+ * On success, the allocated MDL; on failure, NULL.
+ */
+PMDL
+STDCALL
+IoAllocateMdl (
+ PVOID VirtualAddress,
+ ULONG Length,
+ BOOLEAN SecondaryBuffer,
+ BOOLEAN ChargeQuota,
+ PIRP Irp
+ );
+
+/**********************************************************************
+ * NAME MACRO
+ * IoAssignArcName
+ *
+ * DESCRIPTION
+ * Creates a symbolic link between the ARC name of a physical
+ * device and the name of the corresponding device object
+ *
+ * ARGUMENTS
+ * ArcName
+ * ARC name of the device
+ *
+ * DeviceName
+ * Name of the device object
+ *
+ * NOTES
+ * VOID
+ * IoAssignArcName (
+ * PUNICODE_STRING ArcName,
+ * PUNICODE_STRING DeviceName
+ * );
+ */
+#define IoAssignArcName(ArcName,DeviceName) \
+ (IoCreateSymbolicLink((ArcName),(DeviceName)))
+
+/**********************************************************************
+ * NAME EXPORTED
+ * IoAssignResources@24
+ *
+ * DESCRIPTION
+ * Takes a list of requested hardware resources and allocates
+ * them.
+ *
+ * ARGUMENTS
+ * RegisterPath
+ * ?
+ *
+ * DriverClassName
+ * ?
+ *
+ * DriverObject
+ * Driver object passed to the DriverEntry routine;
+ *
+ * DeviceObject
+ * ?
+ *
+ * RequestedResources
+ * List of resources.
+ *
+ * RETURN VALUE
+ */
+NTSTATUS
+STDCALL
+IoAssignResources (
+ PUNICODE_STRING RegistryPath,
+ PUNICODE_STRING DriverClassName,
+ PDRIVER_OBJECT DriverObject,
+ PDEVICE_OBJECT DeviceObject,
+ PIO_RESOURCE_REQUIREMENTS_LIST RequestedResources,
+ PCM_RESOURCE_LIST * AllocatedResources
+ );
+/*
+ * FUNCTION: Attaches the callers device object to a named target device
+ * ARGUMENTS:
+ * SourceDevice = caller's device
+ * TargetDevice = Name of the target device
+ * AttachedDevice = Caller allocated storage. On return contains
+ * a pointer to the target device
+ * RETURNS: Success or failure code
+ */
+NTSTATUS
+STDCALL
+IoAttachDevice (
+ PDEVICE_OBJECT SourceDevice,
+ PUNICODE_STRING TargetDevice,
+ PDEVICE_OBJECT * AttachedDevice
+ );
+/*
+ * FUNCTION: Obsolete
+ * ARGUMENTS:
+ * SourceDevice = device to attach
+ * TargetDevice = device to be attached to
+ * RETURNS: Success or failure code
+ */
+NTSTATUS
+STDCALL
+IoAttachDeviceByPointer (
+ PDEVICE_OBJECT SourceDevice,
+ PDEVICE_OBJECT TargetDevice
+ );
+/*
+ * FUNCTION: Attaches the callers device to the highest device in the chain
+ * ARGUMENTS:
+ * SourceDevice = caller's device
+ * TargetDevice = Device to attach
+ * RETURNS: On success the previously highest device
+ * On failure NULL
+ */
+PDEVICE_OBJECT
+STDCALL
+IoAttachDeviceToDeviceStack (
+ PDEVICE_OBJECT SourceDevice,
+ PDEVICE_OBJECT TargetDevice
+ );
+/*
+ * FUNCTION: Builds a irp to be sent to lower level drivers
+ * ARGUMENTS:
+ * MajorFunction = Major function code to be set in the IRP
+ * DeviceObject = Next lower device object
+ * Buffer = Buffer (only required for some major function codes)
+ * Length = Length in bytes of the buffer
+ * StartingOffset = Starting offset on the target device
+ * IoStatusBlock = Storage for status about the operation (optional)
+ * RETURNS: On success the IRP allocated
+ * On failure NULL
+ */
+PIRP
+STDCALL
+IoBuildAsynchronousFsdRequest (
+ ULONG MajorFunction,
+ PDEVICE_OBJECT DeviceObject,
+ PVOID Buffer,
+ ULONG Length,
+ PLARGE_INTEGER StartingOffset,
+ PIO_STATUS_BLOCK IoStatusBlock
+ );
+/*
+ * FUNCTION: Allocates and sets up an IRP for a device control request
+ * ARGUMENTS:
+ * IoControlCode = Type of request
+ * DeviceObject = Target device
+ * InputBuffer = Optional input buffer to the driver
+ * InputBufferLength = Length of the input buffer
+ * OutputBuffer = Optional output buffer
+ * OutputBufferLength = Length of the output buffer
+ * InternalDeviceIoControl = TRUE if the request is internal
+ * Event = Initialized event for the caller to wait for the request
+ * to be completed
+ * IoStatusBlock = I/O status block to be set when the request is
+ * completed
+ * RETURNS: Returns the IRP created
+ */
+PIRP
+STDCALL
+IoBuildDeviceIoControlRequest (
+ ULONG IoControlCode,
+ PDEVICE_OBJECT DeviceObject,
+ PVOID InputBuffer,
+ ULONG InputBufferLength,
+ PVOID OutputBuffer,
+ ULONG OutputBufferLength,
+ BOOLEAN InternalDeviceIoControl,
+ PKEVENT Event,
+ PIO_STATUS_BLOCK IoStatusBlock
+ );
+VOID
+STDCALL
+IoBuildPartialMdl (
+ PMDL SourceMdl,
+ PMDL TargetMdl,
+ PVOID VirtualAddress,
+ ULONG Length
+ );
+PIRP
+STDCALL
+IoBuildSynchronousFsdRequest (
+ ULONG MajorFunction,
+ PDEVICE_OBJECT DeviceObject,
+ PVOID Buffer,
+ ULONG Length,
+ PLARGE_INTEGER StartingOffset,
+ PKEVENT Event,
+ PIO_STATUS_BLOCK IoStatusBlock
+ );
+NTSTATUS
+STDCALL
+IoCallDriver (
+ PDEVICE_OBJECT DeviceObject,
+ PIRP Irp
+ );
+BOOLEAN
+STDCALL
+IoCancelIrp (
+ PIRP Irp
+ );
+
+NTSTATUS STDCALL
+IoCheckDesiredAccess(IN OUT PACCESS_MASK DesiredAccess,
+ IN ACCESS_MASK GrantedAccess);
+
+NTSTATUS STDCALL
+IoCheckEaBufferValidity(IN PFILE_FULL_EA_INFORMATION EaBuffer,
+ IN ULONG EaLength,
+ OUT PULONG ErrorOffset);
+
+NTSTATUS STDCALL
+IoCheckFunctionAccess(IN ACCESS_MASK GrantedAccess,
+ IN UCHAR MajorFunction,
+ IN UCHAR MinorFunction,
+ IN ULONG IoControlCode,
+ IN PFILE_INFORMATION_CLASS FileInformationClass OPTIONAL,
+ IN PFS_INFORMATION_CLASS FsInformationClass OPTIONAL);
+
+NTSTATUS
+STDCALL
+IoCheckShareAccess (
+ ACCESS_MASK DesiredAccess,
+ ULONG DesiredShareAccess,
+ PFILE_OBJECT FileObject,
+ PSHARE_ACCESS ShareAccess,
+ BOOLEAN Update
+ );
+VOID
+STDCALL
+IoCompleteRequest (
+ PIRP Irp,
+ CCHAR PriorityBoost
+ );
+NTSTATUS
+STDCALL
+IoConnectInterrupt (
+ PKINTERRUPT * InterruptObject,
+ PKSERVICE_ROUTINE ServiceRoutine,
+ PVOID ServiceContext,
+ PKSPIN_LOCK SpinLock,
+ ULONG Vector,
+ KIRQL Irql,
+ KIRQL SynchronizeIrql,
+ KINTERRUPT_MODE InterruptMode,
+ BOOLEAN ShareVector,
+ KAFFINITY ProcessorEnableMask,
+ BOOLEAN FloatingSave
+ );
+
+PCONTROLLER_OBJECT
+STDCALL
+IoCreateController (
+ ULONG Size
+ );
+/*
+ * FUNCTION: Allocates memory for and intializes a device object for use for
+ * a driver
+ * ARGUMENTS:
+ * DriverObject : Driver object passed by iomgr when the driver was
+ * loaded
+ * DeviceExtensionSize : Number of bytes for the device extension
+ * DeviceName : Unicode name of device
+ * DeviceType : Device type
+ * DeviceCharacteristics : Bit mask of device characteristics
+ * Exclusive : True if only one thread can access the device at a
+ * time
+ * RETURNS:
+ * Success or failure
+ * DeviceObject : Contains a pointer to allocated device object
+ * if the call succeeded
+ * NOTES: See the DDK documentation for more information
+ */
+NTSTATUS
+STDCALL
+IoCreateDevice (
+ PDRIVER_OBJECT DriverObject,
+ ULONG DeviceExtensionSize,
+ PUNICODE_STRING DeviceName,
+ DEVICE_TYPE DeviceType,
+ ULONG DeviceCharacteristics,
+ BOOLEAN Exclusive,
+ PDEVICE_OBJECT * DeviceObject
+ );
+NTSTATUS
+STDCALL
+IoCreateFile (
+ OUT PHANDLE FileHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN PLARGE_INTEGER AllocationSize OPTIONAL,
+ IN ULONG FileAttributes,
+ IN ULONG ShareAccess,
+ IN ULONG CreateDisposition,
+ IN ULONG CreateOptions,
+ IN PVOID EaBuffer OPTIONAL,
+ IN ULONG EaLength,
+ IN CREATE_FILE_TYPE CreateFileType,
+ IN PVOID ExtraCreateParameters OPTIONAL,
+ IN ULONG Options
+ );
+PKEVENT
+STDCALL
+IoCreateNotificationEvent (
+ PUNICODE_STRING EventName,
+ PHANDLE EventHandle
+ );
+PFILE_OBJECT
+STDCALL
+IoCreateStreamFileObject (
+ PFILE_OBJECT FileObject,
+ PDEVICE_OBJECT DeviceObject
+ );
+NTSTATUS
+STDCALL
+IoCreateSymbolicLink (
+ PUNICODE_STRING SymbolicLinkName,
+ PUNICODE_STRING DeviceName
+ );
+PKEVENT
+STDCALL
+IoCreateSynchronizationEvent (
+ PUNICODE_STRING EventName,
+ PHANDLE EventHandle
+ );
+NTSTATUS
+STDCALL
+IoCreateUnprotectedSymbolicLink (
+ PUNICODE_STRING SymbolicLinkName,
+ PUNICODE_STRING DeviceName
+ );
+
+/*
+ * FUNCTION:
+ * Deletes a symbolic link between the ARC name of a physical
+ * device and the name of the corresponding device object
+ *
+ * ARGUMENTS:
+ * ArcName = ARC name of the device
+ *
+ * NOTES:
+ * VOID
+ * IoDeassignArcName (
+ * PUNICODE_STRING ArcName
+ * );
+ */
+#define IoDeassignArcName(ArcName) \
+ (IoDeleteSymbolicLink((ArcName)))
+
+VOID
+STDCALL
+IoDeleteController (
+ PCONTROLLER_OBJECT ControllerObject
+ );
+VOID
+STDCALL
+IoDeleteDevice (
+ PDEVICE_OBJECT DeviceObject
+ );
+NTSTATUS
+STDCALL
+IoDeleteSymbolicLink (
+ PUNICODE_STRING SymbolicLinkName
+ );
+VOID
+STDCALL
+IoDetachDevice (
+ PDEVICE_OBJECT TargetDevice
+ );
+VOID
+STDCALL
+IoDisconnectInterrupt (
+ PKINTERRUPT InterruptObject
+ );
+VOID
+STDCALL
+IoEnqueueIrp (
+ PIRP Irp
+ );
+
+BOOLEAN STDCALL
+IoFastQueryNetworkAttributes(IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN ACCESS_MASK DesiredAccess,
+ IN ULONG OpenOptions,
+ OUT PIO_STATUS_BLOCK IoStatus,
+ OUT PFILE_NETWORK_OPEN_INFORMATION Buffer);
+
+VOID
+STDCALL
+IoFreeController (
+ PCONTROLLER_OBJECT ControllerObject
+ );
+VOID
+STDCALL
+IoFreeIrp (
+ PIRP Irp
+ );
+VOID
+STDCALL
+IoFreeMdl (
+ PMDL Mdl
+ );
+PDEVICE_OBJECT
+STDCALL
+IoGetAttachedDevice (
+ PDEVICE_OBJECT DeviceObject
+ );
+PDEVICE_OBJECT
+STDCALL
+IoGetAttachedDeviceReference (
+ PDEVICE_OBJECT DeviceObject
+ );
+PDEVICE_OBJECT
+STDCALL
+IoGetBaseFileSystemDeviceObject (
+ IN PFILE_OBJECT FileObject
+ );
+PCONFIGURATION_INFORMATION
+STDCALL
+IoGetConfigurationInformation (
+ VOID
+ );
+
+/*
+ * FUNCTION: Gets a pointer to the callers location in the I/O stack in
+ * the given IRP
+ * ARGUMENTS:
+ * Irp = Points to the IRP
+ * RETURNS: A pointer to the stack location
+ *
+ * NOTES:
+ * PIO_STACK_LOCATION
+ * IoGetCurrentIrpStackLocation (PIRP Irp)
+ */
+#define IoGetCurrentIrpStackLocation(Irp) \
+ ((Irp)->Tail.Overlay.CurrentStackLocation)
+
+#define IoSetNextIrpStackLocation(Irp) { \
+ (Irp)->CurrentLocation--; \
+ (Irp)->Tail.Overlay.CurrentStackLocation--; }
+
+#define IoCopyCurrentIrpStackLocationToNext(Irp) { \
+ PIO_STACK_LOCATION IrpSp; \
+ PIO_STACK_LOCATION NextIrpSp; \
+ IrpSp = IoGetCurrentIrpStackLocation((Irp)); \
+ NextIrpSp = IoGetNextIrpStackLocation((Irp)); \
+ RtlCopyMemory(NextIrpSp, IrpSp, \
+ FIELD_OFFSET(IO_STACK_LOCATION, CompletionRoutine)); \
+ NextIrpSp->Control = 0; }
+
+#define IoSkipCurrentIrpStackLocation(Irp) \
+ (Irp)->CurrentLocation++; \
+ (Irp)->Tail.Overlay.CurrentStackLocation++;
+
+struct _EPROCESS*
+STDCALL
+IoGetCurrentProcess (
+ VOID
+ );
+NTSTATUS
+STDCALL
+IoGetDeviceObjectPointer (
+ PUNICODE_STRING ObjectName,
+ ACCESS_MASK DesiredAccess,
+ PFILE_OBJECT * FileObject,
+ PDEVICE_OBJECT * DeviceObject
+ );
+PDEVICE_OBJECT
+STDCALL
+IoGetDeviceToVerify (
+ struct _ETHREAD* Thread
+ );
+PGENERIC_MAPPING
+STDCALL
+IoGetFileObjectGenericMapping (
+ VOID
+ );
+
+#define IoGetFunctionCodeFromCtlCode(ControlCode) \
+ ((ControlCode >> 2) & 0x00000FFF)
+
+PVOID
+STDCALL
+IoGetInitialStack (
+ VOID
+ );
+
+/*
+ * FUNCTION: Gives a higher level driver access to the next lower driver's
+ * I/O stack location
+ * ARGUMENTS:
+ * Irp = points to the irp
+ * RETURNS: A pointer to the stack location
+ *
+ * NOTES:
+ * PIO_STACK_LOCATION
+ * IoGetNextIrpStackLocation (PIRP Irp)
+ */
+#define IoGetNextIrpStackLocation(Irp) \
+ ((Irp)->Tail.Overlay.CurrentStackLocation-1)
+
+
+PDEVICE_OBJECT
+STDCALL
+IoGetRelatedDeviceObject (
+ PFILE_OBJECT FileObject
+ );
+struct _EPROCESS*
+STDCALL
+IoGetRequestorProcess (
+ IN PIRP Irp
+ );
+
+VOID
+STDCALL
+IoGetStackLimits (
+ PULONG LowLimit,
+ PULONG HighLimit
+ );
+
+PIRP
+STDCALL
+IoGetTopLevelIrp (
+ VOID
+ );
+
+#define IoInitializeDpcRequest(DeviceObject,DpcRoutine) \
+ (KeInitializeDpc(&(DeviceObject)->Dpc, \
+ (PKDEFERRED_ROUTINE)(DpcRoutine), \
+ (DeviceObject)))
+
+/*
+ * FUNCTION: Initalizes an irp allocated by the caller
+ * ARGUMENTS:
+ * Irp = IRP to initalize
+ * PacketSize = Size in bytes of the IRP
+ * StackSize = Number of stack locations in the IRP
+ */
+VOID
+STDCALL
+IoInitializeIrp (
+ PIRP Irp,
+ USHORT PacketSize,
+ CCHAR StackSize
+ );
+NTSTATUS
+STDCALL
+IoInitializeTimer (
+ PDEVICE_OBJECT DeviceObject,
+ PIO_TIMER_ROUTINE TimerRoutine,
+ PVOID Context
+ );
+
+/*
+ * NOTES:
+ * BOOLEAN
+ * IsErrorUserInduced (NTSTATUS Status)
+ */
+#define IoIsErrorUserInduced(Status) \
+ ((BOOLEAN)(((Status) == STATUS_DEVICE_NOT_READY) || \
+ ((Status) == STATUS_IO_TIMEOUT) || \
+ ((Status) == STATUS_MEDIA_WRITE_PROTECTED) || \
+ ((Status) == STATUS_NO_MEDIA_IN_DRIVE) || \
+ ((Status) == STATUS_VERIFY_REQUIRED) || \
+ ((Status) == STATUS_UNRECOGNIZED_MEDIA) || \
+ ((Status) == STATUS_WRONG_VOLUME)))
+
+BOOLEAN
+STDCALL
+IoIsOperationSynchronous (
+ IN PIRP Irp
+ );
+BOOLEAN
+STDCALL
+IoIsSystemThread (
+ PVOID Unknown0
+ );
+PIRP
+STDCALL
+IoMakeAssociatedIrp (
+ PIRP Irp,
+ CCHAR StackSize
+ );
+
+/*
+ * FUNCTION: Marks the specified irp, indicating further processing will
+ * be required by other driver routines
+ * ARGUMENTS:
+ * Irp = Irp to mark
+ * NOTES:
+ * VOID
+ * IoMarkIrpPending (PIRP Irp)
+ */
+#define IoMarkIrpPending(Irp) \
+ (IoGetCurrentIrpStackLocation(Irp)->Control |= SL_PENDING_RETURNED)
+
+
+NTSTATUS
+STDCALL
+IoOpenDeviceInstanceKey (
+ DWORD Unknown0,
+ DWORD Unknown1,
+ DWORD Unknown2,
+ DWORD Unknown3,
+ DWORD Unknown4
+ );
+NTSTATUS
+STDCALL
+IoQueryDeviceDescription (
+ PINTERFACE_TYPE BusType,
+ PULONG BusNumber,
+ PCONFIGURATION_TYPE ControllerType,
+ PULONG ControllerNumber,
+ PCONFIGURATION_TYPE PeripheralType,
+ PULONG PeripheralNumber,
+ PIO_QUERY_DEVICE_ROUTINE CalloutRoutine,
+ PVOID Context
+ );
+DWORD
+STDCALL
+IoQueryDeviceEnumInfo (
+ DWORD Unknown0,
+ DWORD Unknown1
+ );
+// IoQueryFileInformation: confirmed - Undocumented because it does not require a valid file handle
+NTSTATUS
+STDCALL
+IoQueryFileInformation (
+ IN PFILE_OBJECT FileObject,
+ IN FILE_INFORMATION_CLASS FileInformationClass,
+ IN ULONG Length,
+ OUT PVOID FileInformation,
+ OUT PULONG ReturnedLength
+ );
+NTSTATUS
+STDCALL
+IoQueryVolumeInformation (
+ IN PFILE_OBJECT FileObject,
+ IN FS_INFORMATION_CLASS FsInformationClass,
+ IN ULONG Length,
+ OUT PVOID FsInformation,
+ OUT PULONG ReturnedLength
+ );
+VOID
+STDCALL
+IoQueueThreadIrp (
+ IN PIRP Irp
+ );
+VOID
+STDCALL
+IoRaiseHardError (
+ PIRP Irp,
+ PVPB Vpb,
+ PDEVICE_OBJECT RealDeviceObject
+ );
+BOOLEAN
+STDCALL
+IoRaiseInformationalHardError (
+ NTSTATUS ErrorStatus,
+ PUNICODE_STRING String,
+ struct _KTHREAD* Thread
+ );
+VOID
+STDCALL
+IoRegisterDriverReinitialization (
+ PDRIVER_OBJECT DriverObject,
+ PDRIVER_REINITIALIZE ReinitRoutine,
+ PVOID Context
+ );
+VOID
+STDCALL
+IoRegisterFileSystem (
+ PDEVICE_OBJECT DeviceObject
+ );
+#if (_WIN32_WINNT >= 0x0400)
+NTSTATUS
+STDCALL
+IoRegisterFsRegistrationChange (
+ IN PDRIVER_OBJECT DriverObject,
+ IN PFSDNOTIFICATIONPROC FSDNotificationProc
+ );
+#endif // (_WIN32_WINNT >= 0x0400)
+NTSTATUS
+STDCALL
+IoRegisterShutdownNotification (
+ PDEVICE_OBJECT DeviceObject
+ );
+VOID
+STDCALL
+IoReleaseCancelSpinLock (
+ IN KIRQL Irql
+ );
+VOID
+STDCALL
+IoReleaseVpbSpinLock (
+ IN KIRQL Irql
+ );
+VOID
+STDCALL
+IoRemoveShareAccess (
+ PFILE_OBJECT FileObject,
+ PSHARE_ACCESS ShareAccess
+ );
+NTSTATUS
+STDCALL
+IoReportHalResourceUsage (
+ IN PUNICODE_STRING HalDescription,
+ IN PCM_RESOURCE_LIST RawList,
+ IN PCM_RESOURCE_LIST TranslatedList,
+ IN ULONG ListSize
+ );
+NTSTATUS
+STDCALL
+IoReportResourceUsage (
+ PUNICODE_STRING DriverClassName,
+ PDRIVER_OBJECT DriverObject,
+ PCM_RESOURCE_LIST DriverList,
+ ULONG DriverListSize,
+ PDEVICE_OBJECT DeviceObject,
+ PCM_RESOURCE_LIST DeviceList,
+ ULONG DeviceListSize,
+ BOOLEAN OverrideConflict,
+ PBOOLEAN ConflictDetected
+ );
+
+#define IoRequestDpc(DeviceObject,Irp,Context) \
+ (KeInsertQueueDpc(&(DeviceObject)->Dpc,(Irp),(Context)))
+
+#define IoSetCancelRoutine(Irp,NewCancelRoutine) \
+ ((PDRIVER_CANCEL)InterlockedExchange((PULONG)&(Irp)->CancelRoutine, \
+ (ULONG)(NewCancelRoutine)));
+
+#define IoSetCompletionRoutine(Irp,Routine,Context,Success,Error,Cancel) \
+ { \
+ PIO_STACK_LOCATION param; \
+ assert((Success)||(Error)||(Cancel)?(Routine)!=NULL:TRUE); \
+ param = IoGetNextIrpStackLocation((Irp)); \
+ param->CompletionRoutine=(Routine); \
+ param->CompletionContext=(Context); \
+ param->Control = 0; \
+ if ((Success)) \
+ param->Control = SL_INVOKE_ON_SUCCESS; \
+ if ((Error)) \
+ param->Control |= SL_INVOKE_ON_ERROR; \
+ if ((Cancel)) \
+ param->Control |= SL_INVOKE_ON_CANCEL; \
+ }
+
+VOID STDCALL
+IoSetDeviceToVerify (IN struct _ETHREAD* Thread,
+ IN PDEVICE_OBJECT DeviceObject);
+VOID
+STDCALL
+IoSetHardErrorOrVerifyDevice (
+ IN PIRP Irp,
+ IN PDEVICE_OBJECT DeviceObject
+ );
+NTSTATUS
+STDCALL
+IoSetInformation (
+ IN PFILE_OBJECT FileObject,
+ IN FILE_INFORMATION_CLASS FileInformationClass,
+ IN ULONG Length,
+ OUT PVOID FileInformation
+ );
+
+#define IoSetNextIrpStackLocation(Irp) \
+{ \
+ (Irp)->CurrentLocation--; \
+ (Irp)->Tail.Overlay.CurrentStackLocation--; \
+}
+
+VOID
+STDCALL
+IoSetShareAccess (
+ ACCESS_MASK DesiredAccess,
+ ULONG DesiredShareAccess,
+ PFILE_OBJECT FileObject,
+ PSHARE_ACCESS ShareAccess
+ );
+BOOLEAN
+STDCALL
+IoSetThreadHardErrorMode (
+ IN BOOLEAN HardErrorEnabled
+ );
+VOID
+STDCALL
+IoSetTopLevelIrp (
+ IN PIRP Irp
+ );
+
+/*
+ * FUNCTION: Determines the size of an IRP
+ * ARGUMENTS:
+ * StackSize = number of stack locations in the IRP
+ * RETURNS: The size of the IRP in bytes
+USHORT
+IoSizeOfIrp (CCHAR StackSize)
+ */
+#define IoSizeOfIrp(StackSize) \
+ ((USHORT)(sizeof(IRP)+(((StackSize)-1)*sizeof(IO_STACK_LOCATION))))
+
+/* original macro */
+/*
+#define IoSizeOfIrp(StackSize) \
+ ((USHORT)(sizeof(IRP)+((StackSize)*sizeof(IO_STACK_LOCATION))))
+*/
+
+/*
+ * FUNCTION: Dequeues the next IRP from the device's associated queue and
+ * calls its StartIo routine
+ * ARGUMENTS:
+ * DeviceObject = Device object
+ * Cancelable = True if IRPs in the queue can be cancelled
+ */
+VOID
+STDCALL
+IoStartNextPacket (
+ PDEVICE_OBJECT DeviceObject,
+ BOOLEAN Cancelable
+ );
+VOID
+STDCALL
+IoStartNextPacketByKey (
+ PDEVICE_OBJECT DeviceObject,
+ BOOLEAN Cancelable,
+ ULONG Key
+ );
+/*
+ * FUNCTION: Calls the drivers StartIO routine with the IRP or queues it if
+ * the device is busy
+ * ARGUMENTS:
+ * DeviceObject = Device to pass the IRP to
+ * Irp = Irp to be processed
+ * Key = Optional value for where to insert the IRP
+ * CancelFunction = Entry point for a driver supplied cancel function
+ */
+VOID
+STDCALL
+IoStartPacket (
+ PDEVICE_OBJECT DeviceObject,
+ PIRP Irp,
+ PULONG Key,
+ PDRIVER_CANCEL CancelFunction
+ );
+VOID
+STDCALL
+IoStartTimer (
+ PDEVICE_OBJECT DeviceObject
+ );
+VOID
+STDCALL
+IoStopTimer (
+ PDEVICE_OBJECT DeviceObject
+ );
+
+NTSTATUS STDCALL
+IoPageRead(PFILE_OBJECT FileObject,
+ PMDL Mdl,
+ PLARGE_INTEGER Offset,
+ PKEVENT Event,
+ PIO_STATUS_BLOCK StatusBlock);
+
+NTSTATUS STDCALL
+IoSynchronousPageWrite (PFILE_OBJECT FileObject,
+ PMDL Mdl,
+ PLARGE_INTEGER Offset,
+ PKEVENT Event,
+ PIO_STATUS_BLOCK StatusBlock);
+
+struct _EPROCESS* STDCALL IoThreadToProcess (struct _ETHREAD* Thread);
+VOID
+STDCALL
+IoUnregisterFileSystem (
+ IN PDEVICE_OBJECT DeviceObject
+ );
+#if (_WIN32_WINNT >= 0x0400)
+VOID
+STDCALL
+IoUnregisterFsRegistrationChange (
+ IN PDRIVER_OBJECT DriverObject,
+ IN PFSDNOTIFICATIONPROC FSDNotificationProc
+ );
+#endif // (_WIN32_WINNT >= 0x0400)
+VOID
+STDCALL
+IoUnregisterShutdownNotification (
+ IN PDEVICE_OBJECT DeviceObject
+ );
+VOID
+STDCALL
+IoUpdateShareAccess (
+ IN PFILE_OBJECT FileObject,
+ IN PSHARE_ACCESS ShareAccess
+ );
+NTSTATUS
+STDCALL
+IoVerifyVolume (
+ IN PDEVICE_OBJECT DeviceObject,
+ IN BOOLEAN AllowRawMount
+ );
+VOID
+STDCALL
+IoWriteErrorLogEntry (
+ PVOID ElEntry
+ );
+/*
+ * FUNCTION: Sends an irp to the next lower driver
+ */
+NTSTATUS
+FASTCALL
+IofCallDriver (
+ PDEVICE_OBJECT DeviceObject,
+ PIRP Irp
+ );
+/*
+ * FUNCTION: Indicates the caller has finished all processing for a given
+ * I/O request and is returning the given IRP to the I/O manager
+ * ARGUMENTS:
+ * Irp = Irp to be cancelled
+ * PriorityBoost = Increment by which to boost the priority of the
+ * thread making the request
+ */
+VOID
+FASTCALL
+IofCompleteRequest (
+ PIRP Irp,
+ CCHAR PriorityBoost
+ );
+
+/* --- EXPORTED BY HAL --- */
+
+VOID
+STDCALL
+IoAssignDriveLetters (
+ IN PLOADER_PARAMETER_BLOCK LoaderBlock,
+ IN PSTRING NtDeviceName,
+ OUT PUCHAR NtSystemPath,
+ OUT PSTRING NtSystemPathString
+ );
+
+BOOLEAN
+STDCALL
+IoFlushAdapterBuffers (
+ PADAPTER_OBJECT AdapterObject,
+ PMDL Mdl,
+ PVOID MapRegisterBase,
+ PVOID CurrentVa,
+ ULONG Length,
+ BOOLEAN WriteToDevice
+ );
+
+VOID
+STDCALL
+IoFreeAdapterChannel (
+ PADAPTER_OBJECT AdapterObject
+ );
+
+VOID
+STDCALL
+IoFreeMapRegisters (
+ PADAPTER_OBJECT AdapterObject,
+ PVOID MapRegisterBase,
+ ULONG NumberOfMapRegisters
+ );
+
+PHYSICAL_ADDRESS
+STDCALL
+IoMapTransfer (
+ PADAPTER_OBJECT AdapterObject,
+ PMDL Mdl,
+ PVOID MapRegisterBase,
+ PVOID CurrentVa,
+ PULONG Length,
+ BOOLEAN WriteToDevice
+ );
+
+NTSTATUS
+STDCALL
+IoReadPartitionTable (
+ PDEVICE_OBJECT DeviceObject,
+ ULONG SectorSize,
+ BOOLEAN ReturnedRecognizedPartitions,
+ PDRIVE_LAYOUT_INFORMATION * PartitionBuffer
+ );
+
+NTSTATUS
+STDCALL
+IoSetPartitionInformation (
+ PDEVICE_OBJECT DeviceObject,
+ ULONG SectorSize,
+ ULONG PartitionNumber,
+ ULONG PartitionType
+ );
+
+NTSTATUS
+STDCALL
+IoWritePartitionTable (
+ PDEVICE_OBJECT DeviceObject,
+ ULONG SectorSize,
+ ULONG SectorsPerTrack,
+ ULONG NumberOfHeads,
+ PDRIVE_LAYOUT_INFORMATION PartitionBuffer
+ );
+
+
+/* --- --- --- INTERNAL or REACTOS ONLY --- --- --- */
+
+/*
+ * FUNCTION: Registers the driver with WMI
+ * ARGUMENTS:
+ * DeviceObject = Device to register
+ * Action = Action to take
+ * RETURNS: Status (?)
+ */
+/*
+NTSTATUS
+IoWMIRegistrationControl (
+ PDEVICE_OBJECT DeviceObject,
+ WMIREGACTION Action);
+*/
+
+BOOLEAN
+IoIsTotalDeviceFailure (
+ NTSTATUS Status
+ );
+
+
+#endif /* ndef _INCLUDE_DDK_IOFUNCS_H */
--- /dev/null
+/* $Id: iotypes.h,v 1.41 2002/09/08 10:47:44 chorns Exp $
+ *
+ */
+
+#ifndef __INCLUDE_DDK_IOTYPES_H
+#define __INCLUDE_DDK_IOTYPES_H
+
+#include <ntos/disk.h>
+#include <ntos/file.h>
+
+#ifdef __NTOSKRNL__
+extern POBJECT_TYPE EXPORTED IoAdapterObjectType;
+extern POBJECT_TYPE EXPORTED IoDeviceHandlerObjectType;
+extern POBJECT_TYPE EXPORTED IoDeviceObjectType;
+extern POBJECT_TYPE EXPORTED IoDriverObjectType;
+extern POBJECT_TYPE EXPORTED IoFileObjectType;
+#else
+extern POBJECT_TYPE IMPORTED IoAdapterObjectType;
+extern POBJECT_TYPE IMPORTED IoDeviceHandlerObjectType;
+extern POBJECT_TYPE IMPORTED IoDeviceObjectType;
+extern POBJECT_TYPE IMPORTED IoDriverObjectType;
+extern POBJECT_TYPE IMPORTED IoFileObjectType;
+#endif
+
+/*
+ * These are referenced before they can be fully defined
+ */
+struct _DRIVER_OBJECT;
+struct _FILE_OBJECT;
+struct _DEVICE_OBJECT;
+struct _IRP;
+struct _IO_STATUS_BLOCK;
+struct _SCSI_REQUEST_BLOCK;
+
+/* SIMPLE TYPES *************************************************************/
+
+enum
+{
+ DeallocateObject,
+ KeepObject,
+};
+
+
+typedef enum _CREATE_FILE_TYPE
+{
+ CreateFileTypeNone,
+ CreateFileTypeNamedPipe,
+ CreateFileTypeMailslot
+} CREATE_FILE_TYPE;
+
+
+typedef struct _SHARE_ACCESS
+{
+ ULONG OpenCount;
+ ULONG Readers;
+ ULONG Writers;
+ ULONG Deleters;
+ ULONG SharedRead;
+ ULONG SharedWrite;
+ ULONG SharedDelete;
+} SHARE_ACCESS, *PSHARE_ACCESS;
+
+/* FUNCTION TYPES ************************************************************/
+
+typedef VOID STDCALL
+(*PDRIVER_REINITIALIZE)(struct _DRIVER_OBJECT* DriverObject,
+ PVOID Context,
+ ULONG Count);
+
+typedef NTSTATUS STDCALL
+(*PIO_QUERY_DEVICE_ROUTINE)(PVOID Context,
+ PUNICODE_STRING Pathname,
+ INTERFACE_TYPE BusType,
+ ULONG BusNumber,
+ PKEY_VALUE_FULL_INFORMATION* BI,
+ CONFIGURATION_TYPE ControllerType,
+ ULONG ControllerNumber,
+ PKEY_VALUE_FULL_INFORMATION* CI,
+ CONFIGURATION_TYPE PeripheralType,
+ ULONG PeripheralNumber,
+ PKEY_VALUE_FULL_INFORMATION* PI);
+
+typedef NTSTATUS STDCALL
+(*PIO_COMPLETION_ROUTINE)(struct _DEVICE_OBJECT* DeviceObject,
+ struct _IRP* Irp,
+ PVOID Context);
+
+typedef VOID STDCALL
+(*PIO_APC_ROUTINE)(PVOID ApcContext,
+ struct _IO_STATUS_BLOCK* IoStatusBlock,
+ ULONG Reserved);
+
+
+/* STRUCTURE TYPES ***********************************************************/
+
+typedef struct _ADAPTER_OBJECT ADAPTER_OBJECT, *PADAPTER_OBJECT;
+
+/*
+ * PURPOSE: Special timer associated with each device
+ * NOTES: This is a guess
+ */
+typedef struct _IO_TIMER
+{
+ KTIMER timer;
+ KDPC dpc;
+} IO_TIMER, *PIO_TIMER;
+
+typedef struct _IO_SECURITY_CONTEXT
+{
+ PSECURITY_QUALITY_OF_SERVICE SecurityQos;
+ PACCESS_STATE AccessState;
+ ACCESS_MASK DesiredAccess;
+ ULONG FullCreateOptions;
+} IO_SECURITY_CONTEXT, *PIO_SECURITY_CONTEXT;
+
+
+typedef struct _IO_RESOURCE_DESCRIPTOR
+{
+ UCHAR Option;
+ UCHAR Type;
+ UCHAR ShareDisposition;
+
+ /*
+ * Reserved for system use
+ */
+ UCHAR Spare1;
+
+ USHORT Flags;
+
+ /*
+ * Reserved for system use
+ */
+ UCHAR Spare2;
+
+ union
+ {
+ struct
+ {
+ ULONG Length;
+ ULONG Alignment;
+ PHYSICAL_ADDRESS MinimumAddress;
+ PHYSICAL_ADDRESS MaximumAddress;
+ } Port;
+ struct
+ {
+ ULONG Length;
+ ULONG Alignment;
+ PHYSICAL_ADDRESS MinimumAddress;
+ PHYSICAL_ADDRESS MaximumAddress;
+ } Memory;
+ struct
+ {
+ ULONG MinimumVector;
+ ULONG MaximumVector;
+ } Interrupt;
+ struct
+ {
+ ULONG MinimumChannel;
+ ULONG MaximumChannel;
+ } Dma;
+ } u;
+} IO_RESOURCE_DESCRIPTOR, *PIO_RESOURCE_DESCRIPTOR;
+
+// IO_RESOURCE_DESCRIPTOR Options
+#define IO_RESOURCE_REQUIRED 0x00
+#define IO_RESOURCE_PREFERRED 0x01
+#define IO_RESOURCE_DEFAULT 0x02
+#define IO_RESOURCE_ALTERNATIVE 0x08
+
+typedef struct _IO_RESOURCE_LIST
+{
+ USHORT Version;
+ USHORT Revision;
+ ULONG Count;
+ IO_RESOURCE_DESCRIPTOR Descriptors[1];
+} IO_RESOURCE_LIST, *PIO_RESOURCE_LIST;
+
+typedef struct _IO_RESOURCE_REQUIREMENTS_LIST
+{
+ /*
+ * List size in bytes
+ */
+ ULONG ListSize;
+
+ /*
+ * System defined enum for the bus
+ */
+ INTERFACE_TYPE InterfaceType;
+
+ ULONG BusNumber;
+ ULONG SlotNumber;
+ ULONG Reserved[3];
+ ULONG AlternativeLists;
+ IO_RESOURCE_LIST List[1];
+} IO_RESOURCE_REQUIREMENTS_LIST, *PIO_RESOURCE_REQUIREMENTS_LIST;
+
+typedef struct
+{
+ UCHAR Type;
+ UCHAR ShareDisposition;
+ USHORT Flags;
+ union
+ {
+ struct
+ {
+ PHYSICAL_ADDRESS Start;
+ ULONG Length;
+ } __attribute__((packed)) Port;
+ struct
+ {
+ ULONG Level;
+ ULONG Vector;
+ ULONG Affinity;
+ } __attribute__((packed))Interrupt;
+ struct
+ {
+ PHYSICAL_ADDRESS Start;
+ ULONG Length;
+ } __attribute__((packed))Memory;
+ struct
+ {
+ ULONG Channel;
+ ULONG Port;
+ ULONG Reserved1;
+ } __attribute__((packed))Dma;
+ struct
+ {
+ ULONG DataSize;
+ ULONG Reserved1;
+ ULONG Reserved2;
+ } __attribute__((packed))DeviceSpecificData;
+ } __attribute__((packed)) u;
+} __attribute__((packed)) CM_PARTIAL_RESOURCE_DESCRIPTOR, *PCM_PARTIAL_RESOURCE_DESCRIPTOR;
+
+typedef struct
+{
+ USHORT Version;
+ USHORT Revision;
+ ULONG Count;
+ CM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptors[1];
+} __attribute__((packed))CM_PARTIAL_RESOURCE_LIST, *PCM_PARTIAL_RESOURCE_LIST;
+
+typedef struct
+{
+ INTERFACE_TYPE InterfaceType;
+ ULONG BusNumber;
+ CM_PARTIAL_RESOURCE_LIST PartialResourceList;
+} __attribute__((packed)) CM_FULL_RESOURCE_DESCRIPTOR;
+
+typedef struct
+{
+ ULONG Count;
+ CM_FULL_RESOURCE_DESCRIPTOR List[1];
+} CM_RESOURCE_LIST, *PCM_RESOURCE_LIST;
+
+
+/*
+ * PURPOSE: IRP stack location
+ */
+typedef struct __attribute__((packed)) _IO_STACK_LOCATION
+{
+ UCHAR MajorFunction;
+ UCHAR MinorFunction;
+ UCHAR Flags;
+ UCHAR Control;
+
+ union
+ {
+ struct
+ {
+ PIO_SECURITY_CONTEXT SecurityContext;
+ ULONG Options;
+ USHORT FileAttributes;
+ USHORT ShareAccess;
+ ULONG EaLength;
+ } Create;
+ struct
+ {
+ ULONG Length;
+ ULONG Key;
+ LARGE_INTEGER ByteOffset;
+ } Read;
+ struct
+ {
+ ULONG Length;
+ ULONG Key;
+ LARGE_INTEGER ByteOffset;
+ } Write;
+ struct
+ {
+ ULONG OutputBufferLength;
+ ULONG InputBufferLength;
+ ULONG IoControlCode;
+ PVOID Type3InputBuffer;
+ } DeviceIoControl;
+ struct
+ {
+ ULONG OutputBufferLength;
+ ULONG InputBufferLength;
+ ULONG IoControlCode;
+ PVOID Type3InputBuffer;
+ } FileSystemControl;
+ struct
+ {
+ struct _VPB* Vpb;
+ struct _DEVICE_OBJECT* DeviceObject;
+ } MountVolume;
+ struct
+ {
+ struct _VPB* Vpb;
+ struct _DEVICE_OBJECT* DeviceObject;
+ } VerifyVolume;
+ struct
+ {
+ ULONG Length;
+ FILE_INFORMATION_CLASS FileInformationClass;
+ } QueryFile;
+ struct
+ {
+ ULONG Length;
+ FS_INFORMATION_CLASS FsInformationClass;
+ } QueryVolume;
+ struct
+ {
+ ULONG Length;
+ FS_INFORMATION_CLASS FsInformationClass;
+ } SetVolume;
+ struct
+ {
+ ULONG Length;
+ FILE_INFORMATION_CLASS FileInformationClass;
+ struct _FILE_OBJECT* FileObject;
+ union
+ {
+ struct
+ {
+ BOOLEAN ReplaceIfExists;
+ BOOLEAN AdvanceOnly;
+ } d;
+ ULONG ClusterCount;
+ HANDLE DeleteHandle;
+ } u;
+ } SetFile;
+ struct
+ {
+ ULONG Length;
+ PUNICODE_STRING FileName;
+ FILE_INFORMATION_CLASS FileInformationClass;
+ ULONG FileIndex;
+ } QueryDirectory;
+
+ // Parameters for IRP_MN_QUERY_DEVICE_RELATIONS
+ struct
+ {
+ DEVICE_RELATION_TYPE Type;
+ } QueryDeviceRelations;
+
+ // Parameters for IRP_MN_QUERY_INTERFACE
+ struct
+ {
+ CONST GUID *InterfaceType;
+ USHORT Size;
+ USHORT Version;
+ PINTERFACE Interface;
+ PVOID InterfaceSpecificData;
+ } QueryInterface;
+
+ // Parameters for IRP_MN_QUERY_CAPABILITIES
+ struct
+ {
+ PDEVICE_CAPABILITIES Capabilities;
+ } DeviceCapabilities;
+
+ // Parameters for IRP_MN_QUERY_ID
+ struct
+ {
+ BUS_QUERY_ID_TYPE IdType;
+ } QueryId;
+
+ // Parameters for IRP_MN_QUERY_DEVICE_TEXT
+ struct
+ {
+ DEVICE_TEXT_TYPE DeviceTextType;
+ LCID LocaleId;
+ } QueryDeviceText;
+
+ // Parameters for IRP_MN_DEVICE_USAGE_NOTIFICATION
+ struct
+ {
+ BOOLEAN InPath;
+ BOOLEAN Reserved[3];
+ DEVICE_USAGE_NOTIFICATION_TYPE Type;
+ } UsageNotification;
+
+ // Parameters for IRP_MN_WAIT_WAKE
+ struct
+ {
+ SYSTEM_POWER_STATE PowerState;
+ } WaitWake;
+
+ // Parameter for IRP_MN_POWER_SEQUENCE
+ struct
+ {
+ PPOWER_SEQUENCE PowerSequence;
+ } PowerSequence;
+
+ // Parameters for IRP_MN_SET_POWER and IRP_MN_QUERY_POWER
+ struct
+ {
+ ULONG SystemContext;
+ POWER_STATE_TYPE Type;
+ POWER_STATE State;
+ POWER_ACTION ShutdownType;
+ } Power;
+
+ // Parameters for IRP_MN_START_DEVICE
+ struct
+ {
+ PCM_RESOURCE_LIST AllocatedResources;
+ PCM_RESOURCE_LIST AllocatedResourcesTranslated;
+ } StartDevice;
+
+ /* Parameters for IRP_MN_SCSI_CLASS */
+ struct
+ {
+ struct _SCSI_REQUEST_BLOCK *Srb;
+ } Scsi;
+
+ /* Paramters for other calls */
+ struct
+ {
+ PVOID Argument1;
+ PVOID Argument2;
+ PVOID Argument3;
+ PVOID Argument4;
+ } Others;
+ } Parameters;
+
+ struct _DEVICE_OBJECT* DeviceObject;
+ struct _FILE_OBJECT* FileObject;
+
+ PIO_COMPLETION_ROUTINE CompletionRoutine;
+ PVOID CompletionContext;
+
+} __attribute__((packed)) IO_STACK_LOCATION, *PIO_STACK_LOCATION;
+
+
+typedef struct _IO_STATUS_BLOCK
+{
+ NTSTATUS Status;
+ ULONG Information;
+} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
+
+
+typedef struct _IO_PIPE_CREATE_BUFFER
+{
+ BOOLEAN WriteModeMessage;
+ BOOLEAN ReadModeMessage;
+ BOOLEAN NonBlocking;
+ ULONG MaxInstances;
+ ULONG InBufferSize;
+ ULONG OutBufferSize;
+ LARGE_INTEGER TimeOut;
+} IO_PIPE_CREATE_BUFFER, *PIO_PIPE_CREATE_BUFFER;
+
+
+typedef struct _IO_MAILSLOT_CREATE_BUFFER
+{
+ ULONG Param; /* ?? */
+ ULONG MaxMessageSize;
+ LARGE_INTEGER TimeOut;
+} IO_MAILSLOT_CREATE_BUFFER, *PIO_MAILSLOT_CREATE_BUFFER;
+
+
+/*
+ * Driver entry point declaration
+ */
+typedef NTSTATUS STDCALL
+(*PDRIVER_INITIALIZE)(struct _DRIVER_OBJECT* DriverObject,
+ PUNICODE_STRING RegistryPath);
+
+/*
+ * Driver cancel declaration
+ */
+typedef NTSTATUS STDCALL
+(*PDRIVER_CANCEL)(struct _DEVICE_OBJECT* DeviceObject,
+ struct _IRP* RegistryPath);
+
+
+typedef struct _SECTION_OBJECT_POINTERS
+{
+ PVOID DataSectionObject;
+ PVOID SharedCacheMap;
+ PVOID ImageSectionObject;
+} SECTION_OBJECT_POINTERS, *PSECTION_OBJECT_POINTERS;
+
+typedef struct _IO_COMPLETION_CONTEXT
+{
+ PVOID Port;
+ ULONG Key;
+} IO_COMPLETION_CONTEXT, *PIO_COMPLETION_CONTEXT;
+
+#define FO_FILE_OPEN 0x00000001
+#define FO_SYNCHRONOUS_IO 0x00000002
+#define FO_ALERTABLE_IO 0x00000004
+#define FO_NO_INTERMEDIATE_BUFFERING 0x00000008
+#define FO_WRITE_THROUGH 0x00000010
+#define FO_SEQUENTIAL_ONLY 0x00000020
+#define FO_CACHE_SUPPORTED 0x00000040
+#define FO_NAMED_PIPE 0x00000080
+#define FO_STREAM_FILE 0x00000100
+#define FO_MAILSLOT 0x00000200
+#define FO_GENERATE_AUDIT_ON_CLOSE 0x00000400
+#define FO_DIRECT_DEVICE_OPEN 0x00000800
+#define FO_FILE_MODIFIED 0x00001000
+#define FO_FILE_SIZE_CHANGED 0x00002000
+#define FO_CLEANUP_COMPLETE 0x00004000
+#define FO_TEMPORARY_FILE 0x00008000
+#define FO_DELETE_ON_CLOSE 0x00010000
+#define FO_OPENED_CASE_SENSITIVE 0x00020000
+#define FO_HANDLE_CREATED 0x00040000
+#define FO_FILE_FAST_IO_READ 0x00080000
+
+/*
+ * ReactOS specific flags
+ */
+#define FO_DIRECT_CACHE_READ 0x72000001
+#define FO_DIRECT_CACHE_WRITE 0x72000002
+#define FO_DIRECT_CACHE_PAGING_READ 0x72000004
+#define FO_DIRECT_CACHE_PAGING_WRITE 0x72000008
+#define FO_FCB_IS_VALID 0x72000010
+
+typedef struct _FILE_OBJECT
+{
+ CSHORT Type;
+ CSHORT Size;
+ struct _DEVICE_OBJECT* DeviceObject;
+ struct _VPB* Vpb;
+ PVOID FsContext;
+ PVOID FsContext2;
+ PSECTION_OBJECT_POINTERS SectionObjectPointers;
+ PVOID PrivateCacheMap;
+ NTSTATUS FinalStatus;
+ struct _FILE_OBJECT* RelatedFileObject;
+ BOOLEAN LockOperation;
+ BOOLEAN DeletePending;
+ BOOLEAN ReadAccess;
+ BOOLEAN WriteAccess;
+ BOOLEAN DeleteAccess;
+ BOOLEAN SharedRead;
+ BOOLEAN SharedWrite;
+ BOOLEAN SharedDelete;
+ ULONG Flags;
+ UNICODE_STRING FileName;
+ LARGE_INTEGER CurrentByteOffset;
+ ULONG Waiters;
+ ULONG Busy;
+ PVOID LastLock;
+ KEVENT Lock;
+ KEVENT Event;
+ PIO_COMPLETION_CONTEXT CompletionContext;
+} FILE_OBJECT, *PFILE_OBJECT;
+
+
+typedef struct _IRP
+{
+ CSHORT Type;
+ USHORT Size;
+ PMDL MdlAddress;
+ ULONG Flags;
+ union
+ {
+ struct _IRP* MasterIrp;
+ LONG IrpCount;
+ PVOID SystemBuffer;
+ } AssociatedIrp;
+ LIST_ENTRY ThreadListEntry;
+ IO_STATUS_BLOCK IoStatus;
+ KPROCESSOR_MODE RequestorMode;
+ BOOLEAN PendingReturned;
+ CHAR StackCount;
+ CHAR CurrentLocation;
+ BOOLEAN Cancel;
+ KIRQL CancelIrql;
+ CCHAR ApcEnvironment;// CCHAR or PVOID?
+ UCHAR AllocationFlags;//UCHAR or ULONG?
+ PIO_STATUS_BLOCK UserIosb;
+ PKEVENT UserEvent;
+ union
+ {
+ struct
+ {
+ PIO_APC_ROUTINE UserApcRoutine;
+ PVOID UserApcContext;
+ } AsynchronousParameters;
+ LARGE_INTEGER AllocationSize;
+ } Overlay;
+ PDRIVER_CANCEL CancelRoutine;
+ PVOID UserBuffer;
+ union
+ {
+ struct
+ {
+ union {
+ KDEVICE_QUEUE_ENTRY DeviceQueueEntry;
+ PVOID DriverContext[4];
+ };
+ struct _ETHREAD* Thread;
+ PCHAR AuxiliaryBuffer;
+ LIST_ENTRY ListEntry;
+ struct _IO_STACK_LOCATION* CurrentStackLocation;
+ PFILE_OBJECT OriginalFileObject;
+ } Overlay;
+ KAPC Apc;
+ ULONG CompletionKey;
+ } Tail;
+ IO_STACK_LOCATION Stack[1];
+} IRP, *PIRP;
+
+#define VPB_MOUNTED 0x00000001
+#define VPB_LOCKED 0x00000002
+#define VPB_PERSISTENT 0x00000004
+#define VPB_REMOVE_PENDING 0x00000008
+
+typedef struct _VPB
+{
+ CSHORT Type;
+ CSHORT Size;
+ USHORT Flags;
+ USHORT VolumeLabelLength;
+ struct _DEVICE_OBJECT* DeviceObject;
+ struct _DEVICE_OBJECT* RealDevice;
+ ULONG SerialNumber;
+ ULONG ReferenceCount;
+ WCHAR VolumeLabel[MAXIMUM_VOLUME_LABEL_LENGTH];
+} VPB, *PVPB;
+
+
+typedef struct _DEVICE_OBJECT
+{
+ CSHORT Type;
+ CSHORT Size;
+ LONG ReferenceCount;
+ struct _DRIVER_OBJECT* DriverObject;
+ struct _DEVICE_OBJECT* NextDevice;
+ struct _DEVICE_OBJECT* AttachedDevice;
+ struct _IRP* CurrentIrp;
+ PIO_TIMER Timer;
+ ULONG Flags;
+ ULONG Characteristics;
+ PVPB Vpb;
+ PVOID DeviceExtension;
+ DEVICE_TYPE DeviceType;
+ CCHAR StackSize;
+ union
+ {
+ LIST_ENTRY ListHead;
+ WAIT_CONTEXT_BLOCK Wcb;
+ } Queue;
+ ULONG AlignmentRequirement;
+ KDEVICE_QUEUE DeviceQueue;
+ KDPC Dpc;
+ ULONG ActiveThreadCount;
+ PSECURITY_DESCRIPTOR SecurityDescriptor;
+ KEVENT DeviceLock;
+ USHORT SectorSize;
+ USHORT Spare1;
+ struct _DEVOBJ_EXTENSION* DeviceObjectExtension;
+ PVOID Reserved;
+} DEVICE_OBJECT, *PDEVICE_OBJECT;
+
+
+/*
+ * Fast i/o routine type declaration
+ */
+//typedef NTSTATUS (*PFAST_IO_DISPATCH)(struct _DEVICE_OBJECT*, IRP*);
+//FIXME : this type is ok for read and write, but not for all routines
+typedef BOOLEAN STDCALL
+(*PFAST_IO_ROUTINE)(IN struct _FILE_OBJECT *FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ IN ULONG LockKey,
+ OUT PVOID Buffer,
+ OUT PIO_STATUS_BLOCK IoStatus,
+ IN struct _DEVICE_OBJECT *DeviceObject);
+
+typedef struct _FAST_IO_DISPATCH {
+ ULONG SizeOfFastIoDispatch;
+ PFAST_IO_ROUTINE FastIoCheckIfPossible;
+ PFAST_IO_ROUTINE FastIoRead;
+ PFAST_IO_ROUTINE FastIoWrite;
+ PFAST_IO_ROUTINE FastIoQueryBasicInfo;
+ PFAST_IO_ROUTINE FastIoQueryStandardInfo;
+ PFAST_IO_ROUTINE FastIoLock;
+ PFAST_IO_ROUTINE FastIoUnlockSingle;
+ PFAST_IO_ROUTINE FastIoUnlockAll;
+ PFAST_IO_ROUTINE FastIoUnlockAllByKey;
+ PFAST_IO_ROUTINE FastIoDeviceControl;
+ PFAST_IO_ROUTINE AcquireFileForNtCreateSection;
+ PFAST_IO_ROUTINE ReleaseFileForNtCreateSection;
+ PFAST_IO_ROUTINE FastIoDetachDevice;
+ PFAST_IO_ROUTINE FastIoQueryNetworkOpenInfo;
+ PFAST_IO_ROUTINE AcquireForModWrite;
+ PFAST_IO_ROUTINE MdlRead;
+ PFAST_IO_ROUTINE MdlReadComplete;
+ PFAST_IO_ROUTINE PrepareMdlWrite;
+ PFAST_IO_ROUTINE MdlWriteComplete;
+ PFAST_IO_ROUTINE FastIoReadCompressed;
+ PFAST_IO_ROUTINE FastIoWriteCompressed;
+ PFAST_IO_ROUTINE MdlReadCompleteCompressed;
+ PFAST_IO_ROUTINE MdlWriteCompleteCompressed;
+ PFAST_IO_ROUTINE FastIoQueryOpen;
+ PFAST_IO_ROUTINE ReleaseForModWrite;
+ PFAST_IO_ROUTINE AcquireForCcFlush;
+ PFAST_IO_ROUTINE ReleaseForCcFlush;
+} FAST_IO_DISPATCH, *PFAST_IO_DISPATCH;
+
+/*
+ * Dispatch routine type declaration
+ */
+typedef NTSTATUS STDCALL
+(*PDRIVER_DISPATCH)(IN struct _DEVICE_OBJECT *DeviceObject,
+ IN struct _IRP *Irp);
+
+/*
+ * StartIo routine type declaration
+ */
+typedef VOID STDCALL
+(*PDRIVER_STARTIO)(IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp);
+
+/*
+ * Unload routine type declaration
+ */
+typedef VOID STDCALL
+(*PDRIVER_UNLOAD)(IN struct _DRIVER_OBJECT *DriverObject);
+
+/*
+ * AddDevice routine type declaration
+ */
+typedef NTSTATUS STDCALL
+(*PDRIVER_ADD_DEVICE)(IN struct _DRIVER_OBJECT *DriverObject,
+ IN struct _DEVICE_OBJECT *PhysicalDeviceObject);
+
+
+typedef struct _DRIVER_EXTENSION
+{
+ struct _DRIVER_OBJECT* DriverObject;
+ PDRIVER_ADD_DEVICE AddDevice;
+ ULONG Count;
+ UNICODE_STRING ServiceKeyName;
+} DRIVER_EXTENSION, *PDRIVER_EXTENSION;
+
+#if 0
+typedef
+struct _FAST_IO_DISPATCH_TABLE
+{
+ ULONG Count;
+ PFAST_IO_DISPATCH Dispatch;
+
+} FAST_IO_DISPATCH_TABLE, * PFAST_IO_DISPATCH_TABLE;
+#endif
+
+typedef struct _DRIVER_OBJECT
+{
+ CSHORT Type;
+ CSHORT Size;
+ PDEVICE_OBJECT DeviceObject;
+ ULONG Flags;
+ PVOID DriverStart;
+ ULONG DriverSize;
+ PVOID DriverSection;
+ PDRIVER_EXTENSION DriverExtension;
+ UNICODE_STRING DriverName;
+ PUNICODE_STRING HardwareDatabase;
+#if 0
+ PFAST_IO_DISPATCH_TABLE FastIoDispatch;
+#else
+ PFAST_IO_DISPATCH FastIoDispatch;
+#endif
+ PDRIVER_INITIALIZE DriverInit;
+ PDRIVER_STARTIO DriverStartIo;
+ PDRIVER_UNLOAD DriverUnload;
+ PDRIVER_DISPATCH MajorFunction[IRP_MJ_MAXIMUM_FUNCTION + 1];
+} DRIVER_OBJECT, *PDRIVER_OBJECT;
+
+
+typedef struct _CONFIGURATION_INFORMATION
+{
+ ULONG DiskCount;
+ ULONG FloppyCount;
+ ULONG CDRomCount;
+ ULONG TapeCount;
+ ULONG ScsiPortCount;
+ ULONG SerialCount;
+ ULONG ParallelCount;
+ BOOLEAN AtDiskPrimaryAddressClaimed;
+ BOOLEAN AtDiskSecondaryAddressClaimed;
+} CONFIGURATION_INFORMATION, *PCONFIGURATION_INFORMATION;
+
+typedef VOID STDCALL
+(*PIO_DPC_ROUTINE)(PKDPC Dpc,
+ PDEVICE_OBJECT DeviceObject,
+ PIRP Irp,
+ PVOID Context);
+
+typedef VOID STDCALL
+(*PIO_TIMER_ROUTINE)(PDEVICE_OBJECT DeviceObject,
+ PVOID Context);
+
+#if WINDOWS_STRUCTS_DOESNT_ALREADY_DEFINE_THIS
+typedef struct _PARTITION_INFORMATION
+{
+ LARGE_INTEGER StartingOffset;
+ LARGE_INTEGER PartitionLength;
+ ULONG HiddenSectors;
+ ULONG PartitionNumber;
+ UCHAR PartitionType;
+ BOOLEAN BootIndicator;
+ BOOLEAN RecognizedPartition;
+ BOOLEAN RewritePartition;
+} PARTITION_INFORMATION, *PPARTITION_INFORMATION;
+#endif
+
+typedef struct _DRIVER_LAYOUT_INFORMATION
+{
+ ULONG PartitionCount;
+ ULONG Signature;
+ PARTITION_INFORMATION PartitionEntry[1];
+} DRIVER_LAYOUT_INFORMATION, *PDRIVER_LAYOUT_INFORMATION;
+
+
+typedef IO_ALLOCATION_ACTION STDCALL
+(*PDRIVER_CONTROL)(PDEVICE_OBJECT DeviceObject,
+ PIRP Irp,
+ PVOID MapRegisterBase,
+ PVOID Context);
+#if (_WIN32_WINNT >= 0x0400)
+typedef VOID STDCALL
+(*PFSDNOTIFICATIONPROC)(IN PDEVICE_OBJECT PtrTargetFileSystemDeviceObject,
+ IN BOOLEAN DriverActive);
+#endif // (_WIN32_WINNT >= 0x0400)
+
+#endif /* __INCLUDE_DDK_IOTYPES_H */
--- /dev/null
+#ifndef __INCLUDE_DDK_KDFUNCS_H
+#define __INCLUDE_DDK_KDFUNCS_H
+/* $Id: kdfuncs.h,v 1.8 2002/09/08 10:47:44 chorns Exp $ */
+
+/* --- NTOSKRNL.EXE --- */
+#if defined(__NTOSKRNL__)
+extern BOOLEAN KdDebuggerEnabled __declspec(dllexport);
+extern BOOLEAN KdDebuggerNotPresent __declspec(dllexport);
+#else
+extern BOOLEAN KdDebuggerEnabled __declspec(dllimport);
+extern BOOLEAN KdDebuggerNotPresent __declspec(dllimport);
+#endif
+
+BYTE
+STDCALL
+KdPollBreakIn (
+ VOID
+ );
+
+BOOLEAN
+STDCALL
+KdPortInitialize (
+ PKD_PORT_INFORMATION PortInformation,
+ DWORD Unknown1,
+ DWORD Unknown2
+ );
+
+BOOLEAN
+STDCALL
+KdPortInitializeEx (
+ PKD_PORT_INFORMATION PortInformation,
+ DWORD Unknown1,
+ DWORD Unknown2
+ );
+
+BOOLEAN
+STDCALL
+KdPortGetByte (
+ PUCHAR ByteRecieved
+ );
+
+BOOLEAN
+STDCALL
+KdPortGetByteEx (
+ PKD_PORT_INFORMATION PortInformation,
+ PUCHAR ByteRecieved
+ );
+
+BOOLEAN
+STDCALL
+KdPortPollByte (
+ PUCHAR ByteRecieved
+ );
+
+BOOLEAN
+STDCALL
+KdPortPollByteEx (
+ PKD_PORT_INFORMATION PortInformation,
+ PUCHAR ByteRecieved
+ );
+
+VOID
+STDCALL
+KdPortPutByte (
+ UCHAR ByteToSend
+ );
+
+VOID
+STDCALL
+KdPortPutByteEx (
+ PKD_PORT_INFORMATION PortInformation,
+ UCHAR ByteToSend
+ );
+
+VOID
+STDCALL
+KdPortRestore (
+ VOID
+ );
+
+VOID
+STDCALL
+KdPortSave (
+ VOID
+ );
+
+BOOLEAN
+STDCALL
+KdPortDisableInterrupts(
+ VOID
+ );
+
+BOOLEAN
+STDCALL
+KdPortEnableInterrupts(
+ VOID
+ );
+
+#endif /* __INCLUDE_DDK_KDFUNCS_H */
--- /dev/null
+#ifndef __INCLUDE_DDK_KEDEF_H
+#define __INCLUDE_DDK_KEDEF_H
+
+typedef enum _KBUGCHECK_BUFFER_DUMP_STATE
+{
+ BufferEmpty,
+ BufferInserted,
+ BufferStarted,
+ BufferFinished,
+ BufferIncomplete
+}KBUGCHECK_BUFFER_DUMP_STATE;
+
+typedef enum _KINTERRUPT_MODE
+{
+ LevelSensitive,
+ Latched,
+} KINTERRUPT_MODE;
+
+/*
+ * PURPOSE: DPC importance
+ */
+typedef enum _KDPC_IMPORTANCE
+{
+ LowImportance,
+ MediumImportance,
+ HighImportance
+} KDPC_IMPORTANCE;
+
+typedef enum _EVENT_TYPE
+{
+ NotificationEvent,
+ SynchronizationEvent,
+} EVENT_TYPE;
+
+typedef enum _KWAIT_REASON
+{
+ Executive,
+ FreePage,
+ PageIn,
+ PoolAllocation,
+ DelayExecution,
+ Suspended,
+ UserRequest,
+ WrExecutive,
+ WrFreePage,
+ WrPageIn,
+ WrDelayExecution,
+ WrSuspended,
+ WrUserRequest,
+ WrEventPair,
+ WrQueue,
+ WrLpcReceive,
+ WrLpcReply,
+ WrVirtualMemory,
+ WrPageOut,
+ WrRendezvous,
+ Spare2,
+ Spare3,
+ Spare4,
+ Spare5,
+ Spare6,
+ WrKernel,
+ MaximumWaitReason,
+} KWAIT_REASON;
+
+#endif
--- /dev/null
+#ifndef __INCLUDE_DDK_KEFUNCS_H
+#define __INCLUDE_DDK_KEFUNCS_H
+
+
+/* KERNEL FUNCTIONS ********************************************************/
+
+#define KeFlushIoBuffers(Mdl, ReadOperation, DmaOperation)
+
+VOID STDCALL KeAttachProcess (struct _EPROCESS* Process);
+
+VOID KeDrainApcQueue(VOID);
+struct _KPROCESS* KeGetCurrentProcess(VOID);
+
+/*
+ * FUNCTION: Acquires a spinlock so the caller can synchronize access to
+ * data
+ * ARGUMENTS:
+ * SpinLock = Initialized spinlock
+ * OldIrql (OUT) = Set the previous irql on return
+ */
+VOID STDCALL KeAcquireSpinLock (PKSPIN_LOCK SpinLock,
+ PKIRQL OldIrql);
+
+VOID STDCALL KeAcquireSpinLockAtDpcLevel (PKSPIN_LOCK SpinLock);
+
+/*
+ * FUNCTION: Brings the system down in a controlled manner when an
+ * inconsistency that might otherwise cause corruption has been detected
+ * ARGUMENTS:
+ * BugCheckCode = Specifies the reason for the bug check
+ * RETURNS: Doesn't
+ */
+VOID STDCALL KeBugCheck (ULONG BugCheckCode);
+
+
+/*
+ * FUNCTION: Brings the system down in a controlled manner when an
+ * inconsistency that might otherwise cause corruption has been detected
+ * ARGUMENTS:
+ * BugCheckCode = Specifies the reason for the bug check
+ * BugCheckParameter[1-4] = Additional information about bug
+ * RETURNS: Doesn't
+ */
+VOID STDCALL KeBugCheckEx (ULONG BugCheckCode,
+ ULONG BugCheckParameter1,
+ ULONG BugCheckParameter2,
+ ULONG BugCheckParameter3,
+ ULONG BugCheckParameter4);
+
+BOOLEAN STDCALL KeCancelTimer (PKTIMER Timer);
+
+VOID STDCALL KeClearEvent (PKEVENT Event);
+
+NTSTATUS STDCALL KeConnectInterrupt(PKINTERRUPT InterruptObject);
+
+NTSTATUS STDCALL KeDelayExecutionThread (KPROCESSOR_MODE WaitMode,
+ BOOLEAN Alertable,
+ PLARGE_INTEGER Internal);
+
+BOOLEAN STDCALL KeDeregisterBugCheckCallback (
+ PKBUGCHECK_CALLBACK_RECORD CallbackRecord);
+
+VOID STDCALL KeDetachProcess (VOID);
+
+VOID STDCALL KeDisconnectInterrupt(PKINTERRUPT InterruptObject);
+
+VOID STDCALL KeEnterCriticalRegion (VOID);
+
+/*
+ * FUNCTION: Enters the kernel debugger
+ * ARGUMENTS:
+ * None
+ */
+VOID STDCALL KeEnterKernelDebugger (VOID);
+
+VOID STDCALL KeFlushWriteBuffer (VOID);
+
+KIRQL STDCALL KeGetCurrentIrql (VOID);
+
+ULONG KeGetCurrentProcessorNumber(VOID);
+
+struct _KTHREAD* STDCALL KeGetCurrentThread (VOID);
+
+ULONG KeGetDcacheFillSize(VOID);
+
+ULONG STDCALL KeGetPreviousMode (VOID);
+
+VOID STDCALL KeInitializeApc (PKAPC Apc,
+ struct _KTHREAD* Thread,
+ UCHAR StateIndex,
+ PKKERNEL_ROUTINE KernelRoutine,
+ PKRUNDOWN_ROUTINE RundownRoutine,
+ PKNORMAL_ROUTINE NormalRoutine,
+ UCHAR Mode,
+ PVOID Context);
+
+/*
+ * VOID
+ * KeInitializeCallbackRecord (
+ * PKBUGCHECK_CALLBACK_RECORD CallbackRecord
+ * );
+ */
+#define KeInitializeCallbackRecord(CallbackRecord) \
+ (CallbackRecord)->State = BufferEmpty
+
+VOID STDCALL KeInitializeDeviceQueue (PKDEVICE_QUEUE DeviceQueue);
+
+VOID STDCALL KeInitializeDpc (PKDPC Dpc,
+ PKDEFERRED_ROUTINE DeferredRoutine,
+ PVOID DeferredContext);
+
+VOID STDCALL KeInitializeEvent (PKEVENT Event,
+ EVENT_TYPE Type,
+ BOOLEAN State);
+
+NTSTATUS STDCALL KeInitializeInterrupt(PKINTERRUPT InterruptObject,
+ PKSERVICE_ROUTINE ServiceRoutine,
+ PVOID ServiceContext,
+ PKSPIN_LOCK SpinLock,
+ ULONG Vector,
+ KIRQL Irql,
+ KIRQL SynchronizeIrql,
+ KINTERRUPT_MODE InterruptMode,
+ BOOLEAN ShareVector,
+ KAFFINITY ProcessorEnableMask,
+ BOOLEAN FloatingSave);
+
+VOID STDCALL KeInitializeMutant(IN PKMUTANT Mutant,
+ IN BOOLEAN InitialOwner);
+
+VOID STDCALL KeInitializeMutex (PKMUTEX Mutex,
+ ULONG Level);
+
+VOID STDCALL
+KeInitializeQueue(IN PKQUEUE Queue,
+ IN ULONG Count);
+
+VOID STDCALL KeInitializeSemaphore (PKSEMAPHORE Semaphore,
+ LONG Count,
+ LONG Limit);
+
+/*
+ * FUNCTION: Initializes a spinlock
+ * ARGUMENTS:
+ * SpinLock = Spinlock to initialize
+ */
+VOID STDCALL KeInitializeSpinLock (PKSPIN_LOCK SpinLock);
+
+VOID STDCALL KeInitializeTimer (PKTIMER Timer);
+
+VOID STDCALL KeInitializeTimerEx (PKTIMER Timer,
+ TIMER_TYPE Type);
+
+BOOLEAN STDCALL KeInsertByKeyDeviceQueue (PKDEVICE_QUEUE DeviceQueue,
+ PKDEVICE_QUEUE_ENTRY QueueEntry,
+ ULONG SortKey);
+
+BOOLEAN STDCALL KeInsertDeviceQueue (PKDEVICE_QUEUE DeviceQueue,
+ PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);
+
+LONG STDCALL
+KeInsertHeadQueue(IN PKQUEUE Queue,
+ IN PLIST_ENTRY Entry);
+
+LONG STDCALL
+KeInsertQueue(IN PKQUEUE Queue,
+ IN PLIST_ENTRY Entry);
+
+VOID STDCALL KeInsertQueueApc (PKAPC Apc,
+ PVOID SystemArgument1,
+ PVOID SystemArgument2,
+ UCHAR Mode);
+
+BOOLEAN STDCALL KeInsertQueueDpc (PKDPC Dpc,
+ PVOID SystemArgument1,
+ PVOID SystemArgument2);
+
+VOID STDCALL KeLeaveCriticalRegion (VOID);
+
+VOID STDCALL KeLowerIrql (KIRQL NewIrql);
+
+NTSTATUS STDCALL KePulseEvent (PKEVENT Event,
+ KPRIORITY Increment,
+ BOOLEAN Wait);
+
+LARGE_INTEGER
+STDCALL
+KeQueryPerformanceCounter (
+ PLARGE_INTEGER PerformanceFrequency
+ );
+
+VOID
+STDCALL
+KeQuerySystemTime (
+ PLARGE_INTEGER CurrentTime
+ );
+
+VOID
+STDCALL
+KeQueryTickCount (
+ PLARGE_INTEGER TickCount
+ );
+
+ULONG
+STDCALL
+KeQueryTimeIncrement (
+ VOID
+ );
+
+VOID
+STDCALL
+KeRaiseIrql (
+ KIRQL NewIrql,
+ PKIRQL OldIrql
+ );
+
+KIRQL
+STDCALL
+KeRaiseIrqlToDpcLevel (
+ VOID
+ );
+
+KIRQL
+STDCALL
+KeRaiseIrqlToSynchLevel (
+ VOID
+ );
+
+/*
+ * FUNCTION: Raises a user mode exception
+ * ARGUMENTS:
+ * ExceptionCode = Status code of the exception
+ */
+VOID
+STDCALL
+KeRaiseUserException (
+ IN NTSTATUS ExceptionCode
+ );
+
+LONG
+STDCALL
+KeReadStateEvent (
+ PKEVENT Event
+ );
+
+LONG STDCALL
+KeReadStateMutant(IN PKMUTANT Mutant);
+
+LONG STDCALL
+KeReadStateMutex(IN PKMUTEX Mutex);
+
+LONG STDCALL
+KeReadStateQueue(IN PKQUEUE Queue);
+
+LONG STDCALL
+KeReadStateSemaphore(IN PKSEMAPHORE Semaphore);
+
+BOOLEAN STDCALL
+KeReadStateTimer(IN PKTIMER Timer);
+
+BOOLEAN
+STDCALL
+KeRegisterBugCheckCallback (
+ PKBUGCHECK_CALLBACK_RECORD CallbackRecord,
+ PKBUGCHECK_CALLBACK_ROUTINE CallbackRoutine,
+ PVOID Buffer,
+ ULONG Length,
+ PUCHAR Component
+ );
+
+LONG
+STDCALL
+KeReleaseMutant(
+ IN PKMUTANT Mutant,
+ IN KPRIORITY Increment,
+ IN BOOLEAN Abandon,
+ IN BOOLEAN Wait
+ );
+
+LONG
+STDCALL
+KeReleaseMutex (
+ PKMUTEX Mutex,
+ BOOLEAN Wait
+ );
+
+LONG
+STDCALL
+KeReleaseSemaphore (
+ PKSEMAPHORE Semaphore,
+ KPRIORITY Increment,
+ LONG Adjustment,
+ BOOLEAN Wait
+ );
+
+VOID
+STDCALL
+KeReleaseSpinLock (
+ PKSPIN_LOCK Spinlock,
+ KIRQL NewIrql
+ );
+
+VOID
+STDCALL
+KeReleaseSpinLockFromDpcLevel (
+ PKSPIN_LOCK Spinlock
+ );
+
+PKDEVICE_QUEUE_ENTRY
+STDCALL
+KeRemoveByKeyDeviceQueue (
+ PKDEVICE_QUEUE DeviceQueue,
+ ULONG SortKey
+ );
+
+PKDEVICE_QUEUE_ENTRY
+STDCALL
+KeRemoveDeviceQueue (
+ PKDEVICE_QUEUE DeviceQueue
+ );
+
+BOOLEAN STDCALL
+KeRemoveEntryDeviceQueue(PKDEVICE_QUEUE DeviceQueue,
+ PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);
+
+PLIST_ENTRY STDCALL
+KeRemoveQueue(IN PKQUEUE Queue,
+ IN KPROCESSOR_MODE WaitMode,
+ IN PLARGE_INTEGER Timeout OPTIONAL);
+
+BOOLEAN STDCALL
+KeRemoveQueueDpc(IN PKDPC Dpc);
+
+LONG STDCALL
+KeResetEvent(IN PKEVENT Event);
+
+LONG STDCALL
+KeSetBasePriorityThread(struct _KTHREAD* Thread,
+ LONG Increment);
+
+LONG
+STDCALL
+KeSetEvent (
+ PKEVENT Event,
+ KPRIORITY Increment,
+ BOOLEAN Wait
+ );
+
+KPRIORITY STDCALL KeSetPriorityThread (struct _KTHREAD* Thread,
+ KPRIORITY Priority);
+
+BOOLEAN STDCALL KeSetTimer (PKTIMER Timer,
+ LARGE_INTEGER DueTime,
+ PKDPC Dpc);
+
+BOOLEAN STDCALL KeSetTimerEx (PKTIMER Timer,
+ LARGE_INTEGER DueTime,
+ LONG Period,
+ PKDPC Dpc);
+
+VOID STDCALL KeStallExecutionProcessor (ULONG MicroSeconds);
+
+BOOLEAN STDCALL KeSynchronizeExecution (PKINTERRUPT Interrupt,
+ PKSYNCHRONIZE_ROUTINE SynchronizeRoutine,
+ PVOID SynchronizeContext);
+
+NTSTATUS STDCALL KeWaitForMultipleObjects (ULONG Count,
+ PVOID Object[],
+ WAIT_TYPE WaitType,
+ KWAIT_REASON WaitReason,
+ KPROCESSOR_MODE WaitMode,
+ BOOLEAN Alertable,
+ PLARGE_INTEGER Timeout,
+ PKWAIT_BLOCK WaitBlockArray);
+
+NTSTATUS
+STDCALL
+KeWaitForMutexObject (
+ PKMUTEX Mutex,
+ KWAIT_REASON WaitReason,
+ KPROCESSOR_MODE WaitMode,
+ BOOLEAN Alertable,
+ PLARGE_INTEGER Timeout
+ );
+
+NTSTATUS
+STDCALL
+KeWaitForSingleObject (
+ PVOID Object,
+ KWAIT_REASON WaitReason,
+ KPROCESSOR_MODE WaitMode,
+ BOOLEAN Alertable,
+ PLARGE_INTEGER Timeout
+ );
+
+
+
+// io permission map has a 8k size
+// Each bit in the IOPM corresponds to an io port byte address. The bitmap
+// is initialized to allow IO at any port. [ all bits set ].
+
+typedef struct _IOPM
+{
+ UCHAR Bitmap[8192];
+} IOPM, *PIOPM;
+
+/*
+ * FUNCTION: Provides the kernel with a new access map for a driver
+ * ARGUMENTS:
+ * NewMap: = If FALSE the kernel's map is set to all disabled. If TRUE
+ * the kernel disables access to a particular port.
+ * IoPortMap = Caller supplies storage for the io permission map.
+ * REMARKS
+ * Each bit in the IOPM corresponds to an io port byte address. The bitmap
+ * is initialized to allow IO at any port. [ all bits set ]. The IOPL determines
+ * the minium privilege level required to perform IO prior to checking the permission map.
+ */
+VOID Ke386SetIoAccessMap(ULONG NewMap, PIOPM *IoPermissionMap);
+
+/*
+ * FUNCTION: Queries the io permission map.
+ * ARGUMENTS:
+ * NewMap: = If FALSE the kernel's map is set to all disabled. If TRUE
+ * the kernel disables access to a particular port.
+ * IoPortMap = Caller supplies storage for the io permission map.
+ * REMARKS
+ * Each bit in the IOPM corresponds to an io port byte address. The bitmap
+ * is initialized to allow IO at any port. [ all bits set ]. The IOPL determines
+ * the minium privilege level required to perform IO prior to checking the permission map.
+ */
+VOID Ke386QueryIoAccessMap(BOOLEAN NewMap, PIOPM *IoPermissionMap);
+
+/*
+ * FUNCTION: Set the process IOPL
+ * ARGUMENTS:
+ * Eprocess = Pointer to a executive process object
+ * EnableIo = Specify TRUE to enable IO and FALSE to disable
+ */
+NTSTATUS Ke386IoSetAccessProcess(struct _EPROCESS* Eprocess, BOOLEAN EnableIo);
+
+/*
+ * FUNCTION: Releases a set of Global Descriptor Table Selectors
+ * ARGUMENTS:
+ * SelArray =
+ * NumOfSelectors =
+ */
+NTSTATUS KeI386ReleaseGdtSelectors(OUT PULONG SelArray,
+ IN ULONG NumOfSelectors);
+
+/*
+ * FUNCTION: Allocates a set of Global Descriptor Table Selectors
+ * ARGUMENTS:
+ * SelArray =
+ * NumOfSelectors =
+ */
+NTSTATUS KeI386AllocateGdtSelectors(OUT PULONG SelArray,
+ IN ULONG NumOfSelectors);
+
+
+KIRQL
+FASTCALL
+KfAcquireSpinLock (
+ IN PKSPIN_LOCK SpinLock
+ );
+
+VOID
+FASTCALL
+KfLowerIrql (
+ IN KIRQL NewIrql
+ );
+
+
+KIRQL
+FASTCALL
+KfRaiseIrql (
+ IN KIRQL NewIrql
+ );
+
+VOID
+FASTCALL
+KfReleaseSpinLock (
+ IN PKSPIN_LOCK SpinLock,
+ IN KIRQL NewIrql
+ );
+
+
+VOID STDCALL KiDeliverApc(ULONG Unknown1,
+ ULONG Unknown2,
+ ULONG Unknown3);
+
+VOID STDCALL KiDispatchInterrupt(VOID);
+
+#endif /* __INCLUDE_DDK_KEFUNCS_H */
--- /dev/null
+/* KERNEL TYPES **************************************************************/
+
+#ifndef __INCLUDE_DDK_KETYPES_H
+#define __INCLUDE_DDK_KETYPES_H
+
+#define MB_FLAGS_MEM_INFO (0x1)
+#define MB_FLAGS_BOOT_DEVICE (0x2)
+#define MB_FLAGS_COMMAND_LINE (0x4)
+#define MB_FLAGS_MODULE_INFO (0x8)
+#define MB_FLAGS_AOUT_SYMS (0x10)
+#define MB_FLAGS_ELF_SYMS (0x20)
+#define MB_FLAGS_MMAP_INFO (0x40)
+#define MB_FLAGS_DRIVES_INFO (0x80)
+#define MB_FLAGS_CONFIG_TABLE (0x100)
+#define MB_FLAGS_BOOT_LOADER_NAME (0x200)
+#define MB_FLAGS_APM_TABLE (0x400)
+#define MB_FLAGS_GRAPHICS_TABLE (0x800)
+
+typedef struct _LOADER_MODULE
+{
+ ULONG ModStart;
+ ULONG ModEnd;
+ ULONG String;
+ ULONG Reserved;
+} LOADER_MODULE, *PLOADER_MODULE;
+
+typedef struct _ADDRESS_RANGE
+{
+ ULONG BaseAddrLow;
+ ULONG BaseAddrHigh;
+ ULONG LengthLow;
+ ULONG LengthHigh;
+ ULONG Type;
+} ADDRESS_RANGE, *PADDRESS_RANGE;
+
+typedef struct _LOADER_PARAMETER_BLOCK
+{
+ ULONG Flags;
+ ULONG MemLower;
+ ULONG MemHigher;
+ ULONG BootDevice;
+ ULONG CommandLine;
+ ULONG ModsCount;
+ ULONG ModsAddr;
+ UCHAR Syms[12];
+ ULONG MmapLength;
+ ULONG MmapAddr;
+ ULONG DrivesCount;
+ ULONG DrivesAddr;
+ ULONG ConfigTable;
+ ULONG BootLoaderName;
+} LOADER_PARAMETER_BLOCK, *PLOADER_PARAMETER_BLOCK;
+
+#ifdef __NTOSKRNL__
+extern CHAR EXPORTED KeNumberProcessors;
+extern LOADER_PARAMETER_BLOCK EXPORTED KeLoaderBlock;
+extern ULONG EXPORTED KeDcacheFlushCount;
+extern ULONG EXPORTED KeIcacheFlushCount;
+#else
+extern CHAR IMPORTED KeNumberProcessors;
+extern LOADER_PARAMETER_BLOCK IMPORTED KeLoaderBlock;
+extern ULONG EXPORTED KeDcacheFlushCount;
+extern ULONG EXPORTED KeIcacheFlushCount;
+#endif
+
+
+
+struct _KMUTANT;
+
+typedef LONG KPRIORITY;
+
+typedef VOID STDCALL
+(*PKBUGCHECK_CALLBACK_ROUTINE)(PVOID Buffer,
+ ULONG Length);
+
+typedef BOOLEAN STDCALL
+(*PKSYNCHRONIZE_ROUTINE)(PVOID SynchronizeContext);
+
+struct _KAPC;
+
+typedef VOID STDCALL
+(*PKNORMAL_ROUTINE)(PVOID NormalContext,
+ PVOID SystemArgument1,
+ PVOID SystemArgument2);
+
+typedef VOID STDCALL
+(*PKKERNEL_ROUTINE)(struct _KAPC* Apc,
+ PKNORMAL_ROUTINE* NormalRoutine,
+ PVOID* NormalContext,
+ PVOID* SystemArgument1,
+ PVOID* SystemArgument2);
+
+typedef VOID STDCALL
+(*PKRUNDOWN_ROUTINE)(struct _KAPC* Apc);
+
+struct _DISPATCHER_HEADER;
+
+typedef struct _KWAIT_BLOCK
+/*
+ * PURPOSE: Object describing the wait a thread is currently performing
+ */
+{
+ LIST_ENTRY WaitListEntry;
+ struct _KTHREAD* Thread;
+ struct _DISPATCHER_HEADER *Object;
+ struct _KWAIT_BLOCK* NextWaitBlock;
+ USHORT WaitKey;
+ USHORT WaitType;
+} KWAIT_BLOCK, *PKWAIT_BLOCK;
+
+typedef struct _DISPATCHER_HEADER
+{
+ UCHAR Type;
+ UCHAR Absolute;
+ UCHAR Size;
+ UCHAR Inserted;
+ LONG SignalState;
+ LIST_ENTRY WaitListHead;
+} __attribute__((packed)) DISPATCHER_HEADER, *PDISPATCHER_HEADER;
+
+
+typedef struct _KQUEUE
+{
+ DISPATCHER_HEADER Header;
+ LIST_ENTRY EntryListHead;
+ ULONG CurrentCount;
+ ULONG MaximumCount;
+ LIST_ENTRY ThreadListEntry;
+} KQUEUE, *PKQUEUE;
+
+struct _KDPC;
+
+typedef struct _KTIMER
+ {
+ DISPATCHER_HEADER Header;
+ ULARGE_INTEGER DueTime;
+ LIST_ENTRY TimerListEntry;
+ struct _KDPC* Dpc;
+ LONG Period;
+} KTIMER, *PKTIMER;
+
+struct _KSPIN_LOCK;
+
+typedef struct _KSPIN_LOCK
+{
+ ULONG Lock;
+} KSPIN_LOCK, *PKSPIN_LOCK;
+
+typedef struct _KDEVICE_QUEUE
+{
+ LIST_ENTRY ListHead;
+ BOOLEAN Busy;
+ KSPIN_LOCK Lock;
+} KDEVICE_QUEUE, *PKDEVICE_QUEUE;
+
+
+typedef struct _KAPC
+{
+ CSHORT Type;
+ CSHORT Size;
+ ULONG Spare0;
+ struct _KTHREAD* Thread;
+ LIST_ENTRY ApcListEntry;
+ PKKERNEL_ROUTINE KernelRoutine;
+ PKRUNDOWN_ROUTINE RundownRoutine;
+ PKNORMAL_ROUTINE NormalRoutine;
+ PVOID NormalContext;
+ PVOID SystemArgument1;
+ PVOID SystemArgument2;
+ CCHAR ApcStateIndex;
+ KPROCESSOR_MODE ApcMode;
+ USHORT Inserted;
+} __attribute__((packed)) KAPC, *PKAPC;
+
+typedef struct _KBUGCHECK_CALLBACK_RECORD
+{
+ LIST_ENTRY Entry;
+ PKBUGCHECK_CALLBACK_ROUTINE CallbackRoutine;
+ PVOID Buffer;
+ ULONG Length;
+ PUCHAR Component;
+ ULONG Checksum;
+ UCHAR State;
+} KBUGCHECK_CALLBACK_RECORD, *PKBUGCHECK_CALLBACK_RECORD;
+
+typedef struct _KMUTEX
+{
+ DISPATCHER_HEADER Header;
+ LIST_ENTRY MutantListEntry;
+ struct _KTHREAD* OwnerThread;
+ BOOLEAN Abandoned;
+ UCHAR ApcDisable;
+} KMUTEX, *PKMUTEX, KMUTANT, *PKMUTANT;
+
+typedef struct _KSEMAPHORE
+{
+ DISPATCHER_HEADER Header;
+ LONG Limit;
+} __attribute__((packed)) KSEMAPHORE, *PKSEMAPHORE;
+
+typedef struct _KEVENT
+{
+ DISPATCHER_HEADER Header;
+} KEVENT, *PKEVENT;
+
+typedef struct _KEVENT_PAIR
+{
+ CSHORT Type;
+ CSHORT Size;
+ KEVENT LowEvent;
+ KEVENT HighEvent;
+} KEVENT_PAIR, *PKEVENT_PAIR;
+
+
+struct _KDPC;
+
+/*
+ * PURPOSE: Defines a delayed procedure call routine
+ * NOTE:
+ * Dpc = The associated DPC object
+ * DeferredContext = Driver defined context for the DPC
+ * SystemArgument[1-2] = Undocumented.
+ *
+ */
+typedef VOID STDCALL
+(*PKDEFERRED_ROUTINE)(struct _KDPC* Dpc,
+ PVOID DeferredContext,
+ PVOID SystemArgument1,
+ PVOID SystemArgument2);
+
+/*
+ * PURPOSE: Defines a delayed procedure call object
+ */
+typedef struct _KDPC
+{
+ SHORT Type;
+ UCHAR Number;
+ UCHAR Importance;
+ LIST_ENTRY DpcListEntry;
+ PKDEFERRED_ROUTINE DeferredRoutine;
+ PVOID DeferredContext;
+ PVOID SystemArgument1;
+ PVOID SystemArgument2;
+ PULONG Lock;
+} __attribute__((packed)) KDPC, *PKDPC;
+
+
+
+typedef struct _KDEVICE_QUEUE_ENTRY
+{
+ LIST_ENTRY Entry;
+ ULONG Key;
+ BOOLEAN Inserted;
+} KDEVICE_QUEUE_ENTRY, *PKDEVICE_QUEUE_ENTRY;
+
+typedef struct _WAIT_CONTEXT_BLOCK
+{
+} WAIT_CONTEXT_BLOCK, *PWAIT_CONTEXT_BLOCK;
+
+struct _KINTERRUPT;
+
+typedef BOOLEAN STDCALL
+(*PKSERVICE_ROUTINE)(struct _KINTERRUPT* Interrupt,
+ PVOID ServiceContext);
+
+typedef struct _KINTERRUPT
+{
+ ULONG Vector;
+ KAFFINITY ProcessorEnableMask;
+ PKSPIN_LOCK IrqLock;
+ BOOLEAN Shareable;
+ BOOLEAN FloatingSave;
+ PKSERVICE_ROUTINE ServiceRoutine;
+ PVOID ServiceContext;
+ LIST_ENTRY Entry;
+ KIRQL SynchLevel;
+} KINTERRUPT, *PKINTERRUPT;
+
+typedef struct _KSYSTEM_TIME
+{
+ ULONG LowPart;
+ LONG High1Part;
+ LONG High2Part;
+} KSYSTEM_TIME, *PKSYSTEM_TIME;
+
+typedef struct _EPROCESS EPROCESS, *PEPROCESS;
+
+#endif /* __INCLUDE_DDK_KETYPES_H */
--- /dev/null
+#ifndef __INCLUDE_DDK_LDRFUNCS_H
+#define __INCLUDE_DDK_LDRFUNCS_H
+/* $Id: ldrfuncs.h,v 1.5 2002/09/08 10:47:44 chorns Exp $ */
+
+NTSTATUS STDCALL
+LdrAccessResource(IN PVOID BaseAddress,
+ IN PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry,
+ OUT PVOID *Resource OPTIONAL,
+ OUT PULONG Size OPTIONAL);
+
+NTSTATUS STDCALL
+LdrFindResource_U(IN PVOID BaseAddress,
+ IN PLDR_RESOURCE_INFO ResourceInfo,
+ IN ULONG Level,
+ OUT PIMAGE_RESOURCE_DATA_ENTRY *ResourceDataEntry);
+
+#endif /* __INCLUDE_DDK_LDRFUNCS_H */
--- /dev/null
+#ifndef __INCLUDE_DDK_LDRTYPES_H
+#define __INCLUDE_DDK_LDRTYPES_H
+/* $Id: ldrtypes.h,v 1.3 2002/09/08 10:47:44 chorns Exp $ */
+
+typedef struct _LDR_RESOURCE_INFO
+{
+ ULONG Type;
+ ULONG Name;
+ ULONG Language;
+} LDR_RESOURCE_INFO, *PLDR_RESOURCE_INFO;
+
+#define RESOURCE_TYPE_LEVEL 0
+#define RESOURCE_NAME_LEVEL 1
+#define RESOURCE_LANGUAGE_LEVEL 2
+#define RESOURCE_DATA_LEVEL 3
+
+#endif /* __INCLUDE_DDK_LDRTYPES_H */
--- /dev/null
+/*
+ * MINIPORT.H - miniport driver interface header
+ */
+
+#define EMULATOR_READ_ACCESS 0x00000001
+#define EMULATOR_WRITE_ACCESS 0x00000002
+
+typedef enum _EMULATOR_PORT_ACCESS_TYPE
+{
+ Uchar,
+ Ushort,
+ Ulong
+} EMULATOR_PORT_ACCESS_TYPE, *PEMULATOR_PORT_ACCESS_TYPE;
+
+typedef struct _EMULATOR_ACCESS_ENTRY
+{
+ ULONG BasePort;
+ ULONG NumConsecutivePorts;
+ EMULATOR_PORT_ACCESS_TYPE AccessType;
+ UCHAR AccessMode;
+ UCHAR StringSupport;
+ PVOID Routine;
+} EMULATOR_ACCESS_ENTRY, *PEMULATOR_ACCESS_ENTRY;
+
+
--- /dev/null
+#ifndef _INCLUDE_DDK_MMFUNCS_H
+#define _INCLUDE_DDK_MMFUNCS_H
+/* $Id: mmfuncs.h,v 1.13 2002/09/08 10:47:44 chorns Exp $ */
+/* MEMORY MANAGMENT ******************************************************/
+
+
+#ifdef __NTOSKRNL__
+extern PVOID EXPORTED MmUserProbeAddress;
+extern PVOID EXPORTED MmHighestUserAddress;
+#else
+extern PVOID IMPORTED MmUserProbeAddress;
+extern PVOID IMPORTED MmHighestUserAddress;
+#endif
+
+#ifdef __NTOSKRNL__
+extern POBJECT_TYPE EXPORTED MmSectionObjectType;
+#else
+extern POBJECT_TYPE IMPORTED MmSectionObjectType;
+#endif
+
+
+/*
+ * FUNCTION: Returns the number of pages spanned by an address range
+ * ARGUMENTS:
+ * Va = start of range
+ * Size = Size of range
+ * RETURNS: The number of pages
+ */
+#if 0
+extern inline unsigned int ADDRESS_AND_SIZE_TO_SPAN_PAGES(PVOID Va,
+ ULONG Size)
+{
+ ULONG HighestAddr;
+ ULONG LowestAddr;
+
+ HighestAddr = PAGE_ROUND_UP(Size + ((ULONG)Va));
+ LowestAddr = PAGE_ROUND_DOWN((ULONG)Va);
+ return((HighestAddr - LowestAddr) / PAGESIZE);
+}
+#endif
+#define ADDRESS_AND_SIZE_TO_SPAN_PAGES(Va, Size) \
+ (ULONG)((PAGE_ROUND_UP((Size) + ((ULONG)(Va))) - \
+ PAGE_ROUND_DOWN((ULONG)(Va))) / PAGESIZE)
+
+/*
+ * FUNCTION: Returns FALSE is the pointer is NULL, TRUE otherwise
+ */
+#define ARGUMENT_PRESENT(arg) ((arg)!=NULL)
+
+/*
+ * FUNCTION: Returns the byte offset of the address within its page
+ */
+#define BYTE_OFFSET(va) (((ULONG)va)%PAGESIZE)
+
+/*
+ * FUNCTION: Takes a count in bytes and returns the number of pages
+ * required to hold it
+ */
+#define BYTES_TO_PAGES(size) (?)
+
+DWORD
+STDCALL
+MmAdjustWorkingSetSize (
+ DWORD Unknown0,
+ DWORD Unknown1,
+ DWORD Unknown2
+ );
+PVOID
+STDCALL
+MmAllocateContiguousMemory (
+ IN ULONG NumberOfBytes,
+ IN PHYSICAL_ADDRESS HighestAcceptableAddress
+ );
+
+PVOID STDCALL
+MmAllocateContiguousAlignedMemory(IN ULONG NumberOfBytes,
+ IN PHYSICAL_ADDRESS HighestAcceptableAddress,
+ IN ULONG Alignment);
+
+PVOID
+STDCALL
+MmAllocateNonCachedMemory (
+ IN ULONG NumberOfBytes
+ );
+/*
+ * FUNCTION: Fills in the corresponding physical page array for a given MDL
+ * for a buffer in nonpaged system space
+ * ARGUMENTS:
+ * MemoryDescriptorList = MDL to fill
+ */
+VOID
+STDCALL
+MmBuildMdlForNonPagedPool (
+ PMDL MemoryDescriptorList
+ );
+BOOLEAN
+STDCALL
+MmCanFileBeTruncated (
+ IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
+ IN PLARGE_INTEGER NewFileSize
+ );
+/*
+ * FUNCTION: Allocates and initializes an MDL
+ * ARGUMENTS:
+ * MemoryDescriptorList = Optional caller allocated MDL to initalize
+ * Base = Base virtual address for buffer
+ * Length = Length in bytes of the buffer
+ * RETURNS: A pointer to the initalized MDL
+ */
+PMDL
+STDCALL
+MmCreateMdl (
+ PMDL MemoryDescriptorList,
+ PVOID Base,
+ ULONG Length
+ );
+#if 0
+NTSTATUS
+STDCALL
+MmCreateSection (
+ OUT PSECTION_OBJECT * SectionObject,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
+ IN PLARGE_INTEGER MaximumSize,
+ IN ULONG SectionPageProtection,
+ IN ULONG AllocationAttributes,
+ IN HANDLE FileHandle OPTIONAL,
+ IN PFILE_OBJECT File OPTIONAL
+ );
+#endif
+DWORD
+STDCALL
+MmDbgTranslatePhysicalAddress (
+ DWORD Unknown0,
+ DWORD Unknown1
+ );
+BOOLEAN
+STDCALL
+MmDisableModifiedWriteOfSection (
+ DWORD Unknown0
+ );
+BOOLEAN
+STDCALL
+MmFlushImageSection (
+ IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
+ IN MMFLUSH_TYPE FlushType
+ );
+BOOLEAN
+STDCALL
+MmForceSectionClosed (
+ DWORD Unknown0,
+ DWORD Unknown1
+ );
+VOID
+STDCALL
+MmFreeContiguousMemory (
+ IN OUT PVOID BaseAddress
+ );
+VOID
+STDCALL
+MmFreeNonCachedMemory (
+ IN PVOID BaseAddress,
+ IN ULONG NumberOfBytes
+ );
+/*
+ * FUNCTION: Returns the length in bytes of a buffer described by an MDL
+ * ARGUMENTS:
+ * Mdl = the mdl
+ * RETURNS: Size of the buffer
+ */
+#define MmGetMdlByteCount(Mdl) ((Mdl)->ByteCount)
+
+/*
+ * FUNCTION: Returns the byte offset within a page of the buffer described
+ * by an MDL
+ * ARGUMENTS:
+ * Mdl = the mdl
+ * RETURNS: The offset in bytes
+ */
+#define MmGetMdlByteOffset(Mdl) \
+ ((Mdl)->ByteOffset)
+
+/*
+ * FUNCTION: Returns the initial virtual address for a buffer described
+ * by an MDL
+ * ARGUMENTS:
+ * Mdl = the mdl
+ * RETURNS: The initial virtual address
+ */
+#define MmGetMdlVirtualAddress(Mdl) \
+ ((PVOID) ((PCHAR) (Mdl)->StartVa + (Mdl)->ByteOffset))
+
+/*
+ * FUNCTION: Returns the physical address corresponding to a given valid
+ * virtual address
+ * ARGUMENTS:
+ * BaseAddress = the virtual address
+ * RETURNS: The physical address
+ */
+PHYSICAL_ADDRESS
+STDCALL
+MmGetPhysicalAddress (
+ IN PVOID BaseAddress
+ );
+
+#define MmGetProcedureAddress(Address) (Address)
+
+/*
+ * PVOID
+ * MmGetSystemAddressForMdl (
+ * PMDL Mdl
+ * );
+ *
+ * FUNCTION:
+ * Maps the physical pages described by an MDL into system space
+ *
+ * ARGUMENTS:
+ * Mdl = mdl
+ *
+ * RETURNS:
+ * The base system address for the mapped buffer
+ */
+#define MmGetSystemAddressForMdl(Mdl) \
+ (((Mdl)->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA | MDL_SOURCE_IS_NONPAGED_POOL)) ? \
+ ((Mdl)->MappedSystemVa):(MmMapLockedPages((Mdl),KernelMode)))
+
+NTSTATUS
+STDCALL
+MmGrowKernelStack (
+ DWORD Unknown0
+ );
+
+
+/*
+ * VOID
+ * MmInitializeMdl (
+ * PMDL MemoryDescriptorList,
+ * PVOID BaseVa,
+ * ULONG Length
+ * );
+ *
+ * FUNCTION:
+ * Initalizes an MDL
+ *
+ * ARGUMENTS:
+ * MemoryDescriptorList = MDL to be initalized
+ * BaseVa = Base virtual address of the buffer
+ * Length = Length in bytes of the buffer
+ */
+#define MmInitializeMdl(MemoryDescriptorList,BaseVa,Length) \
+{ \
+ (MemoryDescriptorList)->Next = (PMDL)NULL; \
+ (MemoryDescriptorList)->Size = (CSHORT)(sizeof(MDL) + \
+ (ADDRESS_AND_SIZE_TO_SPAN_PAGES((BaseVa),(Length)) * sizeof(ULONG))); \
+ (MemoryDescriptorList)->MdlFlags = 0; \
+ (MemoryDescriptorList)->StartVa = (PVOID)PAGE_ROUND_DOWN((BaseVa)); \
+ (MemoryDescriptorList)->ByteOffset = (ULONG)((BaseVa) - PAGE_ROUND_DOWN((BaseVa))); \
+ (MemoryDescriptorList)->ByteCount = (Length); \
+ (MemoryDescriptorList)->Process = PsGetCurrentProcess(); \
+}
+
+/*
+ * FUNCTION: Checks whether an address is valid for read/write
+ * ARGUMENTS:
+ * VirtualAddress = address to be check
+ * RETURNS: TRUE if an access would be valid
+ */
+BOOLEAN
+STDCALL
+MmIsAddressValid (
+ IN PVOID VirtualAddress
+ );
+BOOLEAN
+STDCALL
+MmIsNonPagedSystemAddressValid (
+ IN PVOID VirtualAddress
+ );
+BOOLEAN
+STDCALL
+MmIsRecursiveIoFault (
+ VOID
+ );
+/*
+ * FUNCTION: Checks if the current platform is a workstation or a server
+ * RETURNS: If the system is a server returns true
+ * NOTE: Drivers can use this as an estimate of the likely resources
+ * available
+ */
+BOOLEAN
+STDCALL
+MmIsThisAnNtAsSystem (
+ VOID
+ );
+/*
+ * FUNCTION: Locks a section of the driver's code into memory
+ * ARGUMENTS:
+ * AddressWithinSection = Any address in the region
+ * RETURNS: A handle to the region
+ */
+#define MmLockPagableCodeSection(Address) \
+ MmLockPagableDataSection(Address)
+
+/*
+ * FUNCTION: Locks a section of the driver's data into memory
+ * ARGUMENTS:
+ * AddressWithinSection = Any address in the region
+ * RETURNS: A handle to the region
+ */
+PVOID
+STDCALL
+MmLockPagableDataSection (
+ PVOID AddressWithinSection
+ );
+PVOID
+STDCALL
+MmLockPagableImageSection (
+ PVOID AddressWithinSection
+ );
+/*
+ * FUNCTION: Locks a section of memory
+ * ARGUMENTS:
+ * ImageSectionHandle = handle returned from MmLockPagableCodeSection
+ * or MmLockPagableDataSection
+ */
+VOID
+STDCALL
+MmLockPagableSectionByHandle (
+ PVOID ImageSectionHandle
+ );
+PVOID
+STDCALL
+MmMapIoSpace (
+ PHYSICAL_ADDRESS PhysicalAddress,
+ ULONG NumberOfBytes,
+ BOOLEAN CacheEnable
+ );
+/*
+ * FUNCTION: Maps the pages described by a given MDL
+ * ARGUMENTS:
+ * MemoryDescriptorList = MDL updated by MmProbeAndLockPages
+ * AccessMode = Access mode in which to map the MDL
+ * RETURNS: The base virtual address which maps the buffer
+ */
+PVOID
+STDCALL
+MmMapLockedPages (
+ PMDL MemoryDescriptorList,
+ KPROCESSOR_MODE AccessMode
+ );
+VOID
+STDCALL
+MmMapMemoryDumpMdl (
+ PVOID Unknown0
+ );
+PVOID
+STDCALL
+MmMapVideoDisplay (
+ IN PHYSICAL_ADDRESS PhysicalAddress,
+ IN ULONG NumberOfBytes,
+ IN MEMORY_CACHING_TYPE CacheType
+ );
+NTSTATUS
+STDCALL
+MmMapViewInSystemSpace (
+ IN PVOID Section,
+ OUT PVOID * MappedBase,
+ IN PULONG ViewSize
+ );
+NTSTATUS
+STDCALL
+MmMapViewOfSection (
+ IN PVOID SectionObject,
+ IN PEPROCESS Process,
+ IN OUT PVOID * BaseAddress,
+ IN ULONG ZeroBits,
+ IN ULONG CommitSize,
+ IN OUT PLARGE_INTEGER SectionOffset OPTIONAL,
+ IN OUT PULONG ViewSize,
+ IN SECTION_INHERIT InheritDisposition,
+ IN ULONG AllocationType,
+ IN ULONG Protect
+ );
+
+/*
+ * FUNCTION: Makes the whole driver pageable
+ * ARGUMENTS:
+ * AddressWithinSection = Any address within the driver
+ */
+VOID
+STDCALL
+MmPageEntireDriver (
+ PVOID AddressWithinSection
+ );
+
+/*
+ * VOID
+ * MmPrepareMdlForReuse (
+ * PMDL Mdl
+ * );
+ *
+ * FUNCTION:
+ * Reinitializes a caller-allocated MDL
+ *
+ * ARGUMENTS:
+ * Mdl = Points to the MDL that will be reused
+ */
+#define MmPrepareMdlForReuse(Mdl) \
+ if (((Mdl)->MdlFlags & MDL_PARTIAL_HAS_BEEN_MAPPED) != 0) \
+ { \
+ assert(((Mdl)->MdlFlags & MDL_PARTIAL) != 0); \
+ MmUnmapLockedPages ((Mdl)->MappedSystemVa, (Mdl)); \
+ } \
+ else if (((Mdl)->MdlFlags & MDL_PARTIAL) == 0) \
+ { \
+ assert(((Mdl)->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA) == 0); \
+ }
+
+/*
+ * FUNCTION: Probes the specified pages, makes them resident and locks
+ * the physical pages mapped by the virtual address range
+ * ARGUMENTS:
+ * MemoryDescriptorList = MDL which supplies the virtual address,
+ * byte offset and length
+ * AccessMode = Access mode with which to probe the arguments
+ * Operation = Types of operation for which the pages should be
+ * probed
+ */
+VOID
+STDCALL
+MmProbeAndLockPages (
+ PMDL MemoryDescriptorList,
+ KPROCESSOR_MODE AccessMode,
+ LOCK_OPERATION Operation
+ );
+
+/*
+ * FUNCTION: Returns an estimate of the amount of memory in the system
+ * RETURNS: Either MmSmallSystem, MmMediumSystem or MmLargeSystem
+ */
+MM_SYSTEM_SIZE
+STDCALL
+MmQuerySystemSize (
+ VOID
+ );
+
+/*
+ * FUNCTION: Resets the pageable status of a driver's sections to their
+ * compile time settings
+ * ARGUMENTS:
+ * AddressWithinSection = Any address within the driver
+ */
+VOID
+STDCALL
+MmResetDriverPaging (
+ PVOID AddressWithinSection
+ );
+
+DWORD
+STDCALL
+MmSecureVirtualMemory (
+ DWORD Unknown0,
+ DWORD Unknown1,
+ DWORD Unknown2
+ );
+BOOLEAN
+STDCALL
+MmSetAddressRangeModified (
+ DWORD Unknown0,
+ DWORD Unknown1
+ );
+NTSTATUS
+STDCALL
+MmSetBankedSection (
+ DWORD Unknown0,
+ DWORD Unknown1,
+ DWORD Unknown2,
+ DWORD Unknown3,
+ DWORD Unknown4,
+ DWORD Unknown5
+ );
+
+/*
+ * FUNCTION: Returns the number of bytes to allocate for an MDL
+ * describing a given address range
+ * ARGUMENTS:
+ * Base = Base virtual address for the region
+ * Length = size in bytes of the region
+ * RETURNS: The number of bytes required for the MDL
+ */
+ULONG
+STDCALL
+MmSizeOfMdl (
+ PVOID Base,
+ ULONG Length
+ );
+/*
+ * FUNCTION: Unlocks the physical pages described by a given MDL
+ * ARGUMENTS:
+ * Mdl = Mdl to unlock
+ */
+VOID
+STDCALL
+MmUnlockPages (
+ PMDL Mdl
+ );
+/*
+ * FUNCTION: Releases a section of driver code or data previously locked into
+ * memory
+ * ARGUMENTS:
+ * ImageSectionHandle = Handle for the locked section
+ */
+VOID
+STDCALL
+MmUnlockPagableImageSection (
+ PVOID ImageSectionHandle
+ );
+VOID
+STDCALL
+MmUnmapIoSpace (
+ PVOID BaseAddress,
+ ULONG NumberOfBytes
+ );
+VOID
+STDCALL
+MmUnmapLockedPages (
+ PVOID BaseAddress,
+ PMDL MemoryDescriptorList
+ );
+VOID
+STDCALL
+MmUnmapVideoDisplay (
+ IN PVOID BaseAddress,
+ IN ULONG NumberOfBytes
+ );
+NTSTATUS
+STDCALL
+MmUnmapViewInSystemSpace (
+ DWORD Unknown0
+ );
+#if 0
+NTSTATUS
+STDCALL
+MmUnmapViewOfSection (
+ PEPROCESS Process,
+ PMEMORY_AREA MemoryArea
+ )
+#endif
+VOID
+STDCALL
+MmUnsecureVirtualMemory (
+ DWORD Unknown0
+ );
+#endif
--- /dev/null
+/* $Id: mmtypes.h,v 1.13 2002/09/08 10:47:44 chorns Exp $ */
+
+#ifndef _INCLUDE_DDK_MMTYPES_H
+#define _INCLUDE_DDK_MMTYPES_H
+
+#include <ddk/i386/pagesize.h>
+#include <ntos/mm.h>
+
+
+#define PAGE_ROUND_UP(x) ( (((ULONG)x)%PAGESIZE) ? ((((ULONG)x)&(~0xfff))+0x1000) : ((ULONG)x) )
+#define PAGE_ROUND_DOWN(x) (((ULONG)x)&(~0xfff))
+
+
+/*
+ * FUNCTION: Determines if the given virtual address is page aligned
+ */
+#define IS_PAGE_ALIGNED(Va) (((ULONG)Va)&0xfff)
+
+/*
+ * PURPOSE: Returns the byte offset of a field within a structure
+ */
+#define FIELD_OFFSET(Type,Field) (LONG)(&(((Type *)(0))->Field))
+
+/*
+ * PURPOSE: Returns the base address structure if the caller knows the
+ * address of a field within the structure
+ * ARGUMENTS:
+ * Address = address of the field
+ * Type = Type of the whole structure
+ * Field = Name of the field whose address is none
+ */
+#define CONTAINING_RECORD(Address,Type,Field) (Type *)(((LONG)Address) - FIELD_OFFSET(Type,Field))
+
+
+#define MDL_MAPPED_TO_SYSTEM_VA (0x1)
+#define MDL_PAGES_LOCKED (0x2)
+#define MDL_SOURCE_IS_NONPAGED_POOL (0x4)
+#define MDL_ALLOCATED_FIXED_SIZE (0x8)
+#define MDL_PARTIAL (0x10)
+#define MDL_PARTIAL_HAS_BEEN_MAPPED (0x20)
+#define MDL_IO_PAGE_READ (0x40)
+#define MDL_WRITE_OPERATION (0x80)
+#define MDL_PARENT_MAPPED_SYSTEM_VA (0x100)
+#define MDL_LOCK_HELD (0x200)
+#define MDL_SCATTER_GATHER_VA (0x400)
+#define MDL_IO_SPACE (0x800)
+#define MDL_NETWORK_HEADER (0x1000)
+#define MDL_MAPPING_CAN_FAIL (0x2000)
+#define MDL_ALLOCATED_MUST_SUCCEED (0x4000)
+#define MDL_64_BIT_VA (0x8000)
+
+
+typedef struct _MDL
+/*
+ * PURPOSE: Describes a user buffer passed to a system API
+ */
+{
+ struct _MDL* Next;
+ CSHORT Size;
+ CSHORT MdlFlags;
+ struct _EPROCESS* Process;
+ PVOID MappedSystemVa;
+ PVOID StartVa;
+ ULONG ByteCount;
+ ULONG ByteOffset;
+} MDL, *PMDL;
+
+#define MmSmallSystem (0)
+#define MmMediumSystem (1)
+#define MmLargeSystem (2)
+
+/* Used in MmFlushImageSection */
+typedef enum _MMFLUSH_TYPE
+{
+ MmFlushForDelete,
+ MmFlushForWrite
+} MMFLUSH_TYPE;
+
+typedef enum _MEMORY_CACHING_TYPE
+{
+ MmNonCached = FALSE,
+ MmCached = TRUE,
+ MmFrameBufferCached,
+ MmHardwareCoherentCached,
+ MmMaximumCacheType
+} MEMORY_CACHING_TYPE;
+
+#endif
--- /dev/null
+#ifndef _NTDD8042_
+#define _NTDD8042_
+
+#define IOCTL_INTERNAL_I8042_HOOK_KEYBOARD CTL_CODE(FILE_DEVICE_KEYBOARD, 0x0FF0, METHOD_NEITHER, FILE_ANY_ACCESS)
+#define IOCTL_INTERNAL_I8042_HOOK_MOUSE CTL_CODE(FILE_DEVICE_MOUSE, 0x0FF0, METHOD_NEITHER, FILE_ANY_ACCESS)
+
+typedef enum _KEYBOARD_SCAN_STATE {
+ Normal,
+ GotE0,
+ GotE1
+} KEYBOARD_SCAN_STATE, *PKEYBOARD_SCAN_STATE;
+
+typedef
+NTSTATUS
+(*PI8042_SYNCH_READ_PORT) (
+ IN PVOID Context,
+ PUCHAR Value,
+ BOOLEAN WaitForACK
+ );
+
+typedef
+NTSTATUS
+(*PI8042_SYNCH_WRITE_PORT) (
+ IN PVOID Context,
+ UCHAR Value,
+ BOOLEAN WaitForACK
+ );
+
+typedef enum _TRANSMIT_STATE {
+ Idle = 0,
+ SendingBytes
+} TRANSMIT_STATE;
+
+typedef struct _OUTPUT_PACKET {
+ PUCHAR Bytes;
+ ULONG CurrentByte;
+ ULONG ByteCount;
+ TRANSMIT_STATE State;
+} OUTPUT_PACKET, *POUTPUT_PACKET;
+
+typedef
+NTSTATUS
+(*PI8042_KEYBOARD_INITIALIZATION_ROUTINE) (
+ IN PVOID InitializationContext,
+ IN PVOID SynchFuncContext,
+ IN PI8042_SYNCH_READ_PORT ReadPort,
+ IN PI8042_SYNCH_WRITE_PORT WritePort,
+ OUT PBOOLEAN TurnTranslationOn
+ );
+
+typedef
+BOOLEAN
+(*PI8042_KEYBOARD_ISR) (
+ PVOID IsrContext,
+ PKEYBOARD_INPUT_DATA CurrentInput,
+ POUTPUT_PACKET CurrentOutput,
+ UCHAR StatusByte,
+ PUCHAR Byte,
+ PBOOLEAN ContinueProcessing,
+ PKEYBOARD_SCAN_STATE ScanState
+ );
+
+typedef struct _INTERNAL_I8042_HOOK_KEYBOARD {
+
+ //
+ // Context variable for all callback routines
+ //
+ PVOID Context;
+
+ //
+ // Routine to call after the mouse is reset
+ //
+ PI8042_KEYBOARD_INITIALIZATION_ROUTINE InitializationRoutine;
+
+ //
+ // Routine to call when a byte is received via the interrupt
+ //
+ PI8042_KEYBOARD_ISR IsrRoutine;
+
+ //
+ // Write function
+ //
+ //UNIMPLEMENTED PI8042_ISR_WRITE_PORT IsrWritePort;
+
+ //
+ // Queue the current packet (ie the one passed into the isr callback hook)
+ // to be reported to the class driver
+ //
+ //UNIMPLEMENTED PI8042_QUEUE_PACKET QueueKeyboardPacket;
+
+ //
+ // Context for IsrWritePort, QueueKeyboardPacket
+ //
+ //UNIMPLEMENTED PVOID CallContext;
+
+} INTERNAL_I8042_HOOK_KEYBOARD, *PINTERNAL_I8042_HOOK_KEYBOARD;
+
+#endif //_NTDD8042_
--- /dev/null
+#ifndef _BEEP_H_INCLUDED_
+#define _BEEP_H_INCLUDED_
+
+#define IOCTL_BEEP_SET CTL_CODE(FILE_DEVICE_BEEP,0,METHOD_BUFFERED,FILE_ANY_ACCESS)
+
+typedef struct tagBEEP_SET_PARAMETERS
+{
+ ULONG Frequency;
+ ULONG Duration;
+} BEEP_SET_PARAMETERS, *PBEEP_SET_PARAMETERS;
+
+#define BEEP_FREQUENCY_MINIMUM 0x25
+#define BEEP_FREQUENCY_MAXIMUM 0x7FFF
+
+#endif /* _BEEP_H_INCLUDED_ */
--- /dev/null
+#ifndef _NTDDBLUE_H_INCLUDED_
+#define _NTDDBLUE_H_INCLUDED_
+
+#include <ntos/console.h>
+
+#define IOCTL_CONSOLE_GET_SCREEN_BUFFER_INFO CTL_CODE(FILE_DEVICE_SCREEN, 0x801, METHOD_BUFFERED, FILE_READ_ACCESS)
+#define IOCTL_CONSOLE_SET_SCREEN_BUFFER_INFO CTL_CODE(FILE_DEVICE_SCREEN, 0x802, METHOD_BUFFERED, FILE_WRITE_ACCESS)
+#define IOCTL_CONSOLE_GET_CURSOR_INFO CTL_CODE(FILE_DEVICE_SCREEN, 0x803, METHOD_BUFFERED, FILE_READ_ACCESS)
+#define IOCTL_CONSOLE_SET_CURSOR_INFO CTL_CODE(FILE_DEVICE_SCREEN, 0x804, METHOD_BUFFERED, FILE_WRITE_ACCESS)
+#define IOCTL_CONSOLE_GET_MODE CTL_CODE(FILE_DEVICE_SCREEN, 0x805, METHOD_BUFFERED, FILE_READ_ACCESS)
+#define IOCTL_CONSOLE_SET_MODE CTL_CODE(FILE_DEVICE_SCREEN, 0x806, METHOD_BUFFERED, FILE_WRITE_ACCESS)
+
+
+#define IOCTL_CONSOLE_FILL_OUTPUT_ATTRIBUTE CTL_CODE(FILE_DEVICE_SCREEN, 0x810, METHOD_BUFFERED, FILE_WRITE_ACCESS)
+#define IOCTL_CONSOLE_READ_OUTPUT_ATTRIBUTE CTL_CODE(FILE_DEVICE_SCREEN, 0x811, METHOD_IN_DIRECT, FILE_ANY_ACCESS)
+#define IOCTL_CONSOLE_WRITE_OUTPUT_ATTRIBUTE CTL_CODE(FILE_DEVICE_SCREEN, 0x812, METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
+#define IOCTL_CONSOLE_SET_TEXT_ATTRIBUTE CTL_CODE(FILE_DEVICE_SCREEN, 0x813, METHOD_BUFFERED, FILE_WRITE_ACCESS)
+
+
+#define IOCTL_CONSOLE_FILL_OUTPUT_CHARACTER CTL_CODE(FILE_DEVICE_SCREEN, 0x820, METHOD_BUFFERED, FILE_WRITE_ACCESS)
+#define IOCTL_CONSOLE_READ_OUTPUT_CHARACTER CTL_CODE(FILE_DEVICE_SCREEN, 0x821, METHOD_IN_DIRECT, FILE_ANY_ACCESS)
+#define IOCTL_CONSOLE_WRITE_OUTPUT_CHARACTER CTL_CODE(FILE_DEVICE_SCREEN, 0x822, METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
+
+
+#define IOCTL_CONSOLE_DRAW CTL_CODE(FILE_DEVICE_SCREEN, 0x830, METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
+
+
+/* TYPEDEFS **************************************************************/
+
+
+typedef struct _CONSOLE_MODE
+{
+ DWORD dwMode;
+} CONSOLE_MODE, *PCONSOLE_MODE;
+
+
+typedef struct _OUTPUT_ATTRIBUTE
+{
+ WORD wAttribute;
+ DWORD nLength;
+ COORD dwCoord;
+ DWORD dwTransfered;
+} OUTPUT_ATTRIBUTE, *POUTPUT_ATTRIBUTE;
+
+
+typedef struct _OUTPUT_CHARACTER
+{
+ CHAR cCharacter;
+ DWORD nLength;
+ COORD dwCoord;
+ DWORD dwTransfered;
+} OUTPUT_CHARACTER, *POUTPUT_CHARACTER;
+
+
+typedef struct _CONSOLE_DRAW
+{
+ SHORT X; // Origin
+ SHORT Y;
+ SHORT SizeX; // Size of the screen buffer
+ SHORT SizeY;
+} CONSOLE_DRAW, *PCONSOLE_DRAW;
+
+
+#endif /* _NTDDBLUE_H_INCLUDED_ */
--- /dev/null
+/* $Id: ntddk.h,v 1.31 2002/09/08 10:47:44 chorns Exp $
+ *
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS kernel
+ * FILE: include/ddk/ntddk.h
+ * PURPOSE: Interface definitions for drivers
+ * PROGRAMMER: David Welch (welch@mcmail.com)
+ * UPDATE HISTORY:
+ * 15/05/98: Created
+ */
+
+#ifndef __NTDDK_H
+#define __NTDDK_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* INCLUDES ***************************************************************/
+
+#define FASTCALL __attribute__((fastcall))
+
+#define STATIC static
+
+#ifndef _GNU_H_WINDOWS_H
+/* NASTY HACK! Our msvcrt are messed up, causing msvcrt.dll to crash when
+ * the headers are mixed with MinGW msvcrt headers. Not including stdlib.h
+ * seems to correct this.
+ */
+#include <stdlib.h>
+#include <string.h>
+#endif
+#include <ntos/types.h>
+#include <ntos/time.h>
+#include <ntos/cdrom.h>
+#include <ntos/disk.h>
+#include <ntos/registry.h>
+#include <ntos/port.h>
+#include <napi/types.h>
+
+#include <pe.h>
+
+#include <ddk/status.h>
+#include <ddk/ntdef.h>
+#include <ddk/defines.h>
+#include <ddk/types.h>
+#include <ddk/cmtypes.h>
+#include <ddk/ketypes.h>
+#include <ntos/security.h>
+#include <ddk/obtypes.h>
+#include <ddk/setypes.h>
+#include <ddk/mmtypes.h>
+#include <ddk/potypes.h>
+#include <ddk/pnptypes.h>
+#include <ddk/iotypes.h>
+#include <ddk/extypes.h>
+#include <ddk/pstypes.h>
+#include <ddk/ldrtypes.h>
+#include <ddk/zwtypes.h>
+#include <ddk/ioctrl.h>
+#include <ddk/rtltypes.h>
+#include <ddk/haltypes.h>
+#include <napi/shared_data.h>
+
+#include <ddk/zw.h>
+#include <ddk/rtl.h>
+#include <ddk/dbgfuncs.h>
+#include <ddk/ldrfuncs.h>
+#include <ddk/cmfuncs.h>
+#if defined(__NTOSKRNL__) || defined(__NTDRIVER__) || defined(__NTHAL__)
+#include <ddk/exfuncs.h>
+#include <ddk/halfuncs.h>
+#include <ddk/mmfuncs.h>
+#include <ddk/kdfuncs.h>
+#include <ddk/kefuncs.h>
+#include <ddk/pofuncs.h>
+#include <ddk/pnpfuncs.h>
+#include <ddk/iofuncs.h>
+#include <ddk/psfuncs.h>
+#include <ddk/obfuncs.h>
+#include <ddk/sefuncs.h>
+#endif /*__NTOSKRNL__ || __NTDRIVER__ || __NTHAL__ */
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif /* __NTDDK_H */
+
--- /dev/null
+#ifndef _NTDDKBD_
+#define _NTDDKBD_
+
+typedef struct _KEYBOARD_INPUT_DATA {
+
+ //
+ // Unit number. E.g., for \Device\KeyboardPort0 the unit is '0',
+ // for \Device\KeyboardPort1 the unit is '1', and so on.
+ //
+
+ USHORT UnitId;
+ USHORT MakeCode;
+ USHORT Flags;
+ USHORT Reserved;
+ ULONG ExtraInformation;
+
+} KEYBOARD_INPUT_DATA, *PKEYBOARD_INPUT_DATA;
+
+#endif // _NTDDKBD_
--- /dev/null
+/*
+ * NTDDVID.H - Video Port and MiniPort driver interface
+ */
+
+#include <ddk/miniport.h>
+
+/*
+ * the rough idea:
+ * init:
+ * miniport driver defines entrypoint thusly:
+ * ULONG DriverEntry(PVOID Context1, PVOID Context2);
+ * miniport allocates and initializes a VIDEO_HW_INIT_DATA struct
+ * miniport calls VideoPortInitialize
+ * video port driver handles init of DriverObject (Context1)
+ * video port driver calls back into HwVidFindAdapter entry point
+ * video port driver finishes up and returns the status code that
+ * the miniport driver should return.
+ * io requests:
+ * video port driver reformats IRP into VRP
+ * video port driver calls back into HwVidStartIO entry point
+ * minimum IoControlCodes that must be handles by the miniport:
+ * IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES
+ * IOCTL_VIDEO_QUERY_AVAIL_MODES
+ * IOCTL_VIDEO_SET_CURRENT_MODE
+ * IOCTL_VIDEO_MAP_MEMORY
+ * IOCTL_VIDEO_RESET_DEVICE
+ * interrupts are handled the same as KM drivers.
+ */
+
+typedef LONG VP_STATUS, *PVP_STATUS;
+
+// Bit definitions for Attribute Flags
+#define VIDEO_MODE_COLOR 0x0001
+#define VIDEO_MODE_GRAPHICS 0x0002
+#define VIDEO_MODE_PALETTE_DRIVEN 0x0004
+
+#define VIDEO_MEMORY_SPACE_MEMORY 0x00
+#define VIDEO_MEMORY_SPACE_IO 0x01
+#define VIDEO_MEMORY_SPACE_USER_MODE 0x02
+#define VIDEO_MEMORY_SPACE_DENSE 0x04
+#define VIDEO_MEMORY_SPACE_P6CACHE 0x08
+
+typedef struct _VIDEO_POINTER_CAPABILITIES
+{
+ ULONG Flags;
+ ULONG MaxWidth;
+ ULONG MaxHeight;
+ ULONG HWPtrBitmapStart;
+ ULONG HWPtrBitmapEnd;
+} VIDEO_POINTER_CAPABILITIES, *PVIDEO_POINTER_CAPABILITIES;
+
+typedef struct _VIDEO_POINTER_ATTRIBUTES
+{
+ ULONG Flags;
+ ULONG Width;
+ ULONG Height;
+ ULONG WidthInBytes;
+ ULONG Enable;
+ SHORT Column;
+ SHORT Row;
+ UCHAR Pixels[1];
+} VIDEO_POINTER_ATTRIBUTES, *PVIDEO_POINTER_ATTRIBUTES;
+
+typedef enum _VIDEO_BANK_TYPE
+{
+ VideoNotBanked = 0,
+ VideoBanked1RW,
+ VideoBanked1R1W,
+ VideoBanked2RW,
+ NumVideoBankTypes
+} VIDEO_BANK_TYPE, *PVIDEO_BANK_TYPE;
+
+typedef struct _VIDEO_BANK_SELECT
+{
+ ULONG Length;
+ ULONG Size;
+ ULONG BankingFlags;
+ ULONG BankingType;
+ ULONG PlanarHCBankingType;
+ ULONG BitmapWidthInBytes;
+ ULONG BitmapSize;
+ ULONG Granularity;
+ ULONG PlanarHCGranularity;
+ ULONG CodeOffset;
+ ULONG PlanarHCBankCodeOffset;
+ ULONG PlanarHCEnableCodeOffset;
+ ULONG PlanarHCDisableCodeOffset;
+} VIDEO_BANK_SELECT, *PVIDEO_BANK_SELECT;
+
+typedef struct _VIDEO_CLUTDATA
+{
+ UCHAR Red;
+ UCHAR Green;
+ UCHAR Blue;
+ UCHAR Unused;
+} VIDEO_CLUTDATA, *PVIDEO_CLUTDATA;
+
+typedef struct _VIDEO_NUM_MODES
+{
+ ULONG NumModes;
+ ULONG ModeInformationLength;
+} VIDEO_NUM_MODES, *PVIDEO_NUM_MODES;
+
+typedef struct _VIDEO_MODE_INFORMATION
+{
+ ULONG Length;
+ ULONG ModeIndex;
+ ULONG VisScreenWidth;
+ ULONG VisScreenHeight;
+ ULONG ScreenStride;
+ ULONG NumberOfPlanes;
+ ULONG BitsPerPlane;
+ ULONG Frequency;
+ ULONG XMillimeter;
+ ULONG YMillimeter;
+ ULONG NumberRedBits;
+ ULONG NumberGreenBits;
+ ULONG NumberBlueBits;
+ ULONG RedMask;
+ ULONG GreenMask;
+ ULONG BlueMask;
+ ULONG AttributeFlags;
+ ULONG VideoMemoryBitmapWidth;
+ ULONG VideoMemoryBitmapHeight;
+ ULONG DriverSpecificAttributeFlags;
+} VIDEO_MODE_INFORMATION, *PVIDEO_MODE_INFORMATION;
+
+typedef enum _VIDEO_DEVICE_DATA_TYPE
+{
+ VpMachineData,
+ VpCmosData,
+ VpBusData,
+ VpControllerData,
+ VpMonitorData
+} VIDEO_DEVICE_DATA_TYPE, *PVIDEO_DEVICE_DATA_TYPE;
+
+typedef enum _VIDEO_SYNCHRONIZE_PRIORITY
+{
+ VpLowPriority,
+ VpMediumPriority,
+ VpHighPriority
+} VIDEO_SYNCHRONIZE_PRIORITY, *PVIDEO_SYNCHRONIZE_PRIORITY;
+
+typedef struct _STATUS_BLOCK
+{
+ VP_STATUS Status;
+ ULONG Information;
+} STATUS_BLOCK, *PSTATUS_BLOCK;
+
+typedef struct _VIDEO_REQUEST_PACKET
+{
+ ULONG IoControlCode;
+ PSTATUS_BLOCK StatusBlock;
+ PVOID InputBuffer;
+ ULONG InputBufferLength;
+ PVOID OutputBuffer;
+ ULONG OutputBufferLength;
+} VIDEO_REQUEST_PACKET, *PVIDEO_REQUEST_PACKET;
+
+#define IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES CTL_CODE(FILE_DEVICE_VIDEO, 0, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_QUERY_AVAIL_MODES CTL_CODE(FILE_DEVICE_VIDEO, 1, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_QUERY_CURRENT_MODE CTL_CODE(FILE_DEVICE_VIDEO, 2, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_SET_CURRENT_MODE CTL_CODE(FILE_DEVICE_VIDEO, 3, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_RESET_DEVICE CTL_CODE(FILE_DEVICE_VIDEO, 4, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_MAP_VIDEO_MEMORY CTL_CODE(FILE_DEVICE_VIDEO, 5, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_UNMAP_VIDEO_MEMORY CTL_CODE(FILE_DEVICE_VIDEO, 6, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_SHARE_VIDEO_MEMORY CTL_CODE(FILE_DEVICE_VIDEO, 7, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_UNSHARE_VIDEO_MEMORY CTL_CODE(FILE_DEVICE_VIDEO, 8, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_GET_PUBLIC_ACCESS_RANGES CTL_CODE(FILE_DEVICE_VIDEO, 9, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_FREE_PUBLIC_ACCESS_RANGES CTL_CODE(FILE_DEVICE_VIDEO, 10, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_GET_POWER_MANAGEMENT CTL_CODE(FILE_DEVICE_VIDEO, 11, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_SET_POWER_MANAGEMENT CTL_CODE(FILE_DEVICE_VIDEO, 12, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_COLOR_CAPABILITIES CTL_CODE(FILE_DEVICE_VIDEO, 13, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_SET_COLOR_REGISTERS CTL_CODE(FILE_DEVICE_VIDEO, 14, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_DISABLE_POINTER CTL_CODE(FILE_DEVICE_VIDEO, 15, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_ENABLE_POINTER CTL_CODE(FILE_DEVICE_VIDEO, 16, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_QUERY_POINTER_CAPABILITIES CTL_CODE(FILE_DEVICE_VIDEO, 17, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_QUERY_POINTER_ATTR CTL_CODE(FILE_DEVICE_VIDEO, 18, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_SET_POINTER_ATTR CTL_CODE(FILE_DEVICE_VIDEO, 19, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_QUERY_POINTER_POSITION CTL_CODE(FILE_DEVICE_VIDEO, 20, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_SET_POINTER_POSITION CTL_CODE(FILE_DEVICE_VIDEO, 21, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_SAVE_HARDWARE_STATE CTL_CODE(FILE_DEVICE_VIDEO, 22, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_RESTORE_HARDWARE_STATE CTL_CODE(FILE_DEVICE_VIDEO, 23, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_DISABLE_CURSOR CTL_CODE(FILE_DEVICE_VIDEO, 24, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_ENABLE_CURSOR CTL_CODE(FILE_DEVICE_VIDEO, 25, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_QUERY_CURSOR_ATTR CTL_CODE(FILE_DEVICE_VIDEO, 26, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_SET_CURSOR_ATTR CTL_CODE(FILE_DEVICE_VIDEO, 27, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_QUERY_CURSOR_POSITION CTL_CODE(FILE_DEVICE_VIDEO, 28, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_SET_CURSOR_POSITION CTL_CODE(FILE_DEVICE_VIDEO, 29, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_GET_BANK_SELECT_CODE CTL_CODE(FILE_DEVICE_VIDEO, 30, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_SET_PALETTE_REGISTERS CTL_CODE(FILE_DEVICE_VIDEO, 31, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_VIDEO_LOAD_AND_SET_FONT CTL_CODE(FILE_DEVICE_VIDEO, 32, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+typedef struct _VIDEO_PORT_CONFIG_INFO
+{
+ ULONG Length;
+ ULONG SystemIoBusNumber;
+ INTERFACE_TYPE AdapterInterfaceType;
+ ULONG BusInterruptLevel;
+ ULONG BusInterruptVector;
+ KINTERRUPT_MODE InterruptMode;
+ ULONG NumEmulatorAccessEntries;
+ PEMULATOR_ACCESS_ENTRY EmulatorAccessEntries;
+ ULONG EmulatorAccessEntriesContext;
+ PHYSICAL_ADDRESS VdmPhysicalVideoMemoryAddress;
+ ULONG VdmPhysicalVideoMemoryLength;
+ ULONG HardwareStateSize;
+ ULONG DmaChannel;
+ ULONG DmaPort;
+ UCHAR DmaShareable;
+ UCHAR InterruptShareable;
+} VIDEO_PORT_CONFIG_INFO, *PVIDEO_PORT_CONFIG_INFO;
+
+typedef VP_STATUS STDCALL
+(*PVIDEO_HW_FIND_ADAPTER)(PVOID HwDeviceExtension,
+ PVOID HwContext,
+ PWSTR ArgumentString,
+ PVIDEO_PORT_CONFIG_INFO ConfigInfo,
+ PUCHAR Again);
+
+typedef BOOLEAN STDCALL
+(*PVIDEO_HW_INITIALIZE)(PVOID HwDeviceExtension);
+
+typedef BOOLEAN STDCALL
+(*PVIDEO_HW_INTERRUPT)(PVOID HwDeviceExtension);
+
+typedef BOOLEAN STDCALL
+(*PVIDEO_HW_START_IO)(PVOID HwDeviceExtension,
+ PVIDEO_REQUEST_PACKET RequestPacket);
+
+typedef BOOLEAN STDCALL
+(*PVIDEO_HW_RESET_HW)(PVOID HwDeviceExtension,
+ ULONG Columns,
+ ULONG Rows);
+
+typedef VOID STDCALL
+(*PVIDEO_HW_TIMER)(PVOID HwDeviceExtension);
+
+typedef struct _VIDEO_HW_INITIALIZATION_DATA
+{
+ ULONG HwInitDataSize;
+ INTERFACE_TYPE AdapterInterfaceType;
+ PVIDEO_HW_FIND_ADAPTER HwFindAdapter;
+ PVIDEO_HW_INITIALIZE HwInitialize;
+ PVIDEO_HW_INTERRUPT HwInterrupt;
+ PVIDEO_HW_START_IO HwStartIO;
+ ULONG HwDeviceExtensionSize;
+ ULONG StartingDeviceNumber;
+ PVIDEO_HW_RESET_HW HwResetHw;
+ PVIDEO_HW_TIMER HwTimer;
+} VIDEO_HW_INITIALIZATION_DATA, *PVIDEO_HW_INITIALIZATION_DATA;
+
+typedef VP_STATUS STDCALL
+(*PMINIPORT_GET_REGISTRY_ROUTINE)(PVOID HwDeviceExtension,
+ PVOID Context,
+ PWSTR ValueName,
+ PVOID ValueData,
+ ULONG ValueLength);
+
+typedef VP_STATUS STDCALL
+(*PMINIPORT_QUERY_DEVICE_ROUTINE)(PVOID HwDeviceExtension,
+ PVOID Context,
+ VIDEO_DEVICE_DATA_TYPE DeviceDataType,
+ PVOID Identifier,
+ ULONG IdentiferLength,
+ PVOID ConfigurationData,
+ ULONG ConfigurationDataLength,
+ PVOID ComponentInformation,
+ ULONG ComponentInformationLength);
+
+typedef BOOLEAN STDCALL
+(*PMINIPORT_SYNCHRONIZE_ROUTINE)(PVOID Context);
+
+typedef struct _VIDEO_ACCESS_RANGE
+{
+ PHYSICAL_ADDRESS RangeStart;
+ ULONG RangeLength;
+ UCHAR RangeInIoSpace;
+ UCHAR RangeVisible;
+ UCHAR RangeShareable;
+} VIDEO_ACCESS_RANGE, *PVIDEO_ACCESS_RANGE;
+
+typedef struct _VIDEO_X86_BIOS_ARGUMENTS
+{
+ ULONG Eax;
+ ULONG Ebx;
+ ULONG Ecx;
+ ULONG Edx;
+ ULONG Esi;
+ ULONG Edi;
+ ULONG Ebp;
+} VIDEO_X86_BIOS_ARGUMENTS, *PVIDEO_X86_BIOS_ARGUMENTS;
+
+typedef VOID STDCALL
+(*PBANKED_SECTION_ROUTINE)(IN ULONG ReadBank,
+ IN ULONG WriteBank,
+ IN PVOID Context);
+
+typedef struct
+{
+ USHORT NumEntries;
+ USHORT FirstEntry;
+ union
+ {
+ VIDEO_CLUTDATA RgbArray;
+ ULONG RgbLong;
+ } LookupTable[1];
+} VIDEO_CLUT, *PVIDEO_CLUT;
+
+typedef struct _VIDEO_MEMORY
+{
+ PVOID RequestedVirtualAddress;
+} VIDEO_MEMORY, *PVIDEO_MEMORY;
+
+typedef struct _VIDEO_MEMORY_INFORMATION
+{
+ PVOID VideoRamBase;
+ ULONG VideoRamLength;
+ PVOID FrameBufferBase;
+ ULONG FrameBufferLength;
+} VIDEO_MEMORY_INFORMATION, *PVIDEO_MEMORY_INFORMATION;
+
+typedef struct _VIDEO_MODE
+{
+ ULONG RequestedMode;
+} VIDEO_MODE, *PVIDEO_MODE;
+
+typedef struct _VIDEO_SHARE_MEMORY
+{
+ HANDLE ProcessHandle;
+ ULONG ViewOffset;
+ ULONG ViewSize;
+ PVOID RequestedVirtualAddress;
+} VIDEO_SHARE_MEMORY, *PVIDEO_SHARE_MEMORY;
+
+ULONG STDCALL VideoPortCompareMemory(IN PVOID Source1, IN PVOID Source2, IN ULONG Length);
+VOID VideoPortDebugPrint(IN ULONG DebugPrintLevel, IN PCHAR DebugMessage, ...);
+VP_STATUS STDCALL VideoPortDisableInterrupt(IN PVOID HwDeviceExtension);
+VP_STATUS STDCALL VideoPortEnableInterrupt(IN PVOID HwDeviceExtension);
+VOID STDCALL VideoPortFreeDeviceBase(IN PVOID HwDeviceExtension, IN PVOID MappedAddress);
+ULONG STDCALL VideoPortGetBusData(IN PVOID HwDeviceExtension,
+ IN BUS_DATA_TYPE BusDataType,
+ IN ULONG SlotNumber,
+ OUT PVOID Buffer,
+ IN ULONG Offset,
+ IN ULONG Length);
+UCHAR STDCALL VideoPortGetCurrentIrql(VOID);
+PVOID STDCALL VideoPortGetDeviceBase(IN PVOID HwDeviceExtension,
+ IN PHYSICAL_ADDRESS IoAddress,
+ IN ULONG NumberOfUchars,
+ IN UCHAR InIoSpace);
+VP_STATUS STDCALL VideoPortGetDeviceData(IN PVOID HwDeviceExtension,
+ IN VIDEO_DEVICE_DATA_TYPE DeviceDataType,
+ IN PMINIPORT_QUERY_DEVICE_ROUTINE CallbackRoutine,
+ IN PVOID Context);
+VP_STATUS STDCALL VideoPortGetAccessRanges(IN PVOID HwDeviceExtension,
+ IN ULONG NumRequestedResources,
+ IN PIO_RESOURCE_DESCRIPTOR RequestedResources OPTIONAL,
+ IN ULONG NumAccessRanges,
+ IN PVIDEO_ACCESS_RANGE AccessRanges,
+ IN PVOID VendorId,
+ IN PVOID DeviceId,
+ IN PULONG Slot);
+VP_STATUS STDCALL VideoPortGetRegistryParameters(IN PVOID HwDeviceExtension,
+ IN PWSTR ParameterName,
+ IN UCHAR IsParameterFileName,
+ IN PMINIPORT_GET_REGISTRY_ROUTINE GetRegistryRoutine,
+ IN PVOID Context);
+ULONG STDCALL VideoPortInitialize(IN PVOID Context1,
+ IN PVOID Context2,
+ IN PVIDEO_HW_INITIALIZATION_DATA HwInitializationData,
+ IN PVOID HwContext);
+VP_STATUS STDCALL VideoPortInt10(IN PVOID HwDeviceExtension,
+ IN PVIDEO_X86_BIOS_ARGUMENTS BiosArguments);
+VOID STDCALL VideoPortLogError(IN PVOID HwDeviceExtension,
+ IN PVIDEO_REQUEST_PACKET Vrp OPTIONAL,
+ IN VP_STATUS ErrorCode,
+ IN ULONG UniqueId);
+VP_STATUS STDCALL VideoPortMapBankedMemory(IN PVOID HwDeviceExtension,
+ IN PHYSICAL_ADDRESS PhysicalAddress,
+ IN PULONG Length,
+ IN PULONG InIoSpace,
+ OUT PVOID *VirtualAddress,
+ IN ULONG BankLength,
+ IN UCHAR ReadWriteBank,
+ IN PBANKED_SECTION_ROUTINE BankRoutine,
+ IN PVOID Context);
+VP_STATUS STDCALL VideoPortMapMemory(IN PVOID HwDeviceExtension,
+ IN PHYSICAL_ADDRESS PhysicalAddress,
+ IN PULONG Length,
+ IN PULONG InIoSpace,
+ OUT PVOID *VirtualAddress);
+VOID STDCALL VideoPortMoveMemory(OUT PVOID Destination,
+ IN PVOID Source,
+ IN ULONG Length);
+UCHAR STDCALL VideoPortReadPortUchar(IN PUCHAR Port);
+USHORT STDCALL VideoPortReadPortUshort(IN PUSHORT Port);
+ULONG STDCALL VideoPortReadPortUlong(IN PULONG Port);
+VOID STDCALL VideoPortReadPortBufferUchar(IN PUCHAR Port, OUT PUCHAR Buffer, IN ULONG Count);
+VOID STDCALL VideoPortReadPortBufferUshort(IN PUSHORT Port, OUT PUSHORT Buffer, IN ULONG Count);
+VOID STDCALL VideoPortReadPortBufferUlong(IN PULONG Port, OUT PULONG Buffer, IN ULONG Count);
+UCHAR STDCALL VideoPortReadRegisterUchar(IN PUCHAR Register);
+USHORT STDCALL VideoPortReadRegisterUshort(IN PUSHORT Register);
+ULONG STDCALL VideoPortReadRegisterUlong(IN PULONG Register);
+VOID STDCALL VideoPortReadRegisterBufferUchar(IN PUCHAR Register, OUT PUCHAR Buffer, IN ULONG Count);
+VOID STDCALL VideoPortReadRegisterBufferUshort(IN PUSHORT Register, OUT PUSHORT Buffer, IN ULONG Count);
+VOID STDCALL VideoPortReadRegisterBufferUlong(IN PULONG Register, OUT PULONG Buffer, IN ULONG Count);
+BOOLEAN STDCALL VideoPortScanRom(IN PVOID HwDeviceExtension,
+ IN PUCHAR RomBase,
+ IN ULONG RomLength,
+ IN PUCHAR String);
+ULONG STDCALL VideoPortSetBusData(IN PVOID HwDeviceExtension,
+ IN BUS_DATA_TYPE BusDataType,
+ IN ULONG SlotNumber,
+ IN PVOID Buffer,
+ IN ULONG Offset,
+ IN ULONG Length);
+VP_STATUS STDCALL VideoPortSetRegistryParameters(IN PVOID HwDeviceExtension,
+ IN PWSTR ValueName,
+ IN PVOID ValueData,
+ IN ULONG ValueLength);
+VP_STATUS STDCALL VideoPortSetTrappedEmulatorPorts(IN PVOID HwDeviceExtension,
+ IN ULONG NumAccessRanges,
+ IN PVIDEO_ACCESS_RANGE AccessRange);
+VOID STDCALL VideoPortStallExecution(IN ULONG Microseconds);
+VOID STDCALL VideoPortStartTimer(IN PVOID HwDeviceExtension);
+VOID STDCALL VideoPortStopTimer(IN PVOID HwDeviceExtension);
+BOOLEAN STDCALL VideoPortSynchronizeExecution(IN PVOID HwDeviceExtension,
+ IN VIDEO_SYNCHRONIZE_PRIORITY Priority,
+ IN PMINIPORT_SYNCHRONIZE_ROUTINE SynchronizeRoutine,
+ OUT PVOID Context);
+VP_STATUS STDCALL VideoPortUnmapMemory(IN PVOID HwDeviceExtension,
+ IN PVOID VirtualAddress,
+ IN HANDLE ProcessHandle);
+VP_STATUS STDCALL VideoPortVerifyAccessRanges(IN PVOID HwDeviceExtension,
+ IN ULONG NumAccessRanges,
+ IN PVIDEO_ACCESS_RANGE AccessRanges);
+VOID STDCALL VideoPortWritePortUchar(IN PUCHAR Port, IN UCHAR Value);
+VOID STDCALL VideoPortWritePortUshort(IN PUSHORT Port, IN USHORT Value);
+VOID STDCALL VideoPortWritePortUlong(IN PULONG Port, IN ULONG Value);
+VOID STDCALL VideoPortWritePortBufferUchar(IN PUCHAR Port, IN PUCHAR Buffer, IN ULONG Count);
+VOID STDCALL VideoPortWritePortBufferUshort(IN PUSHORT Port, IN PUSHORT Buffer, IN ULONG Count);
+VOID STDCALL VideoPortWritePortBufferUlong(IN PULONG Port, IN PULONG Buffer, IN ULONG Count);
+VOID STDCALL VideoPortWriteRegisterUchar(IN PUCHAR Register, IN UCHAR Value);
+VOID STDCALL VideoPortWriteRegisterUshort(IN PUSHORT Register, IN USHORT Value);
+VOID STDCALL VideoPortWriteRegisterUlong(IN PULONG Register, IN ULONG Value);
+VOID STDCALL VideoPortWriteRegisterBufferUchar(IN PUCHAR Register, IN PUCHAR Buffer, IN ULONG Count);
+VOID STDCALL VideoPortWriteRegisterBufferUshort(IN PUSHORT Register, IN PUSHORT Buffer, IN ULONG Count);
+VOID STDCALL VideoPortWriteRegisterBufferUlong(IN PULONG Register, IN PULONG Buffer, IN ULONG Count);
+VOID STDCALL VideoPortZeroMemory(OUT PVOID Destination, IN ULONG Length);
+VOID STDCALL VideoPortZeroDeviceMemory(OUT PVOID Destination, IN ULONG Length);
+
+
--- /dev/null
+#ifndef __INCLUDE_DDK_NTDEF_H
+#define __INCLUDE_DDK_NTDEF_H
+
+struct _KTHREAD;
+struct _ETHREAD;
+struct _EPROCESS;
+
+#define NTKERNELAPI
+#define NTSYSAPI
+#define NTAPI
+
+
+#endif
--- /dev/null
+#ifndef __INCLUDE_DDK_NTIFS_H
+#define __INCLUDE_DDK_NTIFS_H
+
+struct _BCB;
+
+typedef struct _BCB* PBCB;
+
+struct _MEMORY_AREA;
+
+struct _CACHE_SEGMENT;
+
+typedef struct _CACHE_SEGMENT* PCACHE_SEGMENT;
+
+NTSTATUS STDCALL
+CcRosReleaseCacheSegment (struct _BCB* Bcb,
+ struct _CACHE_SEGMENT* CacheSeg,
+ BOOLEAN Valid,
+ BOOLEAN Dirty,
+ BOOLEAN Mapped);
+NTSTATUS STDCALL
+CcRosRequestCacheSegment (struct _BCB* Bcb,
+ ULONG FileOffset,
+ PVOID* BaseAddress,
+ PBOOLEAN UptoDate,
+ struct _CACHE_SEGMENT** CacheSeg);
+NTSTATUS STDCALL
+CcRosInitializeFileCache (PFILE_OBJECT FileObject,
+ struct _BCB** Bcb,
+ ULONG CacheSegmentSize);
+NTSTATUS STDCALL
+CcRosReleaseFileCache (PFILE_OBJECT FileObject,
+ struct _BCB* Bcb);
+
+#include <ddk/cctypes.h>
+
+#include <ddk/ccfuncs.h>
+
+#include <ddk/fstypes.h>
+#include <ddk/fsfuncs.h>
+
+#endif /* __INCLUDE_DDK_NTIFS_H */
--- /dev/null
+#ifndef _INCLUDE_DDK_OBFUNCS_H
+#define _INCLUDE_DDK_OBFUNCS_H
+/* OBJECT MANAGER ************************************************************/
+
+NTSTATUS STDCALL
+ObAssignSecurity(IN PACCESS_STATE AccessState,
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor,
+ IN PVOID Object,
+ IN POBJECT_TYPE Type);
+
+/*
+BOOLEAN STDCALL
+ObCheckCreateObjectAccess(IN PVOID Object,
+ IN ACCESS_MASK DesiredAccess,
+ ULONG Param3,
+ ULONG Param4,
+ ULONG Param5,
+ IN KPROCESSOR_MODE AccessMode,
+ OUT PNTSTATUS AccessStatus);
+*/
+
+/*
+BOOLEAN STDCALL
+ObCheckObjectAccess(IN PVOID Object,
+ ULONG Param2,
+ ULONG Param3,
+ IN KPROCESSOR_MODE AccessMode,
+ OUT PACCESS_MODE GrantedAccess);
+*/
+
+NTSTATUS STDCALL
+ObCreateObject(OUT PHANDLE Handle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN POBJECT_TYPE Type,
+ OUT PVOID *Object);
+
+#if 0
+/* original implementation */
+NTSTATUS STDCALL
+ObCreateObject(IN KPROCESSOR_MODE ObjectAttributesAccessMode OPTIONAL,
+ IN POBJECT_TYPE Type,
+ IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
+ IN KPROCESSOR_MODE AccessMode,
+ IN OUT PVOID ParseContext OPTIONAL,
+ IN ULONG ObjectSize,
+ IN ULONG PagedPoolCharge OPTIONAL,
+ IN ULONG NonPagedPoolCharge OPTIONAL,
+ OUT PVOID *Object);
+#endif
+
+VOID FASTCALL
+ObfDereferenceObject(IN PVOID Object);
+
+VOID FASTCALL
+ObfReferenceObject(IN PVOID Object);
+
+#define ObDereferenceObject(Object) \
+ ObfDereferenceObject(Object)
+
+#define ObReferenceObject(Object) \
+ ObfReferenceObject(Object)
+
+/*
+BOOLEAN STDCALL
+ObFindHandleForObject(ULONG Param1,
+ ULONG Param2,
+ ULONG Param3,
+ ULONG Param4);
+*/
+
+ULONG STDCALL
+ObGetObjectPointerCount(IN PVOID Object);
+
+NTSTATUS STDCALL
+ObGetObjectSecurity(IN PVOID Object,
+ OUT PSECURITY_DESCRIPTOR *SecurityDescriptor,
+ OUT PBOOLEAN MemoryAllocated);
+
+NTSTATUS STDCALL
+ObInsertObject(IN PVOID Object,
+ IN PACCESS_STATE PassedAccessState OPTIONAL,
+ IN ACCESS_MASK DesiredAccess,
+ IN ULONG AdditionalReferences,
+ OUT PVOID* ReferencedObject OPTIONAL,
+ OUT PHANDLE Handle);
+
+VOID STDCALL
+ObMakeTemporaryObject(IN PVOID ObjectBody);
+
+NTSTATUS STDCALL
+ObOpenObjectByName(IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN POBJECT_TYPE ObjectType,
+ IN OUT PVOID ParseContext OPTIONAL,
+ IN KPROCESSOR_MODE AccessMode,
+ IN ACCESS_MASK DesiredAccess,
+ IN PACCESS_STATE PassedAccessState,
+ OUT PHANDLE Handle);
+
+NTSTATUS STDCALL
+ObOpenObjectByPointer(IN PVOID Object,
+ IN ULONG HandleAttributes,
+ IN PACCESS_STATE PassedAccessState OPTIONAL,
+ IN ACCESS_MASK DesiredAccess OPTIONAL,
+ IN POBJECT_TYPE ObjectType OPTIONAL,
+ IN KPROCESSOR_MODE AccessMode,
+ OUT PHANDLE Handle);
+
+NTSTATUS STDCALL
+ObQueryNameString(IN PVOID Object,
+ OUT POBJECT_NAME_INFORMATION ObjectNameInfo,
+ IN ULONG Length,
+ OUT PULONG ReturnLength);
+
+NTSTATUS STDCALL
+ObQueryObjectAuditingByHandle(IN HANDLE Handle,
+ OUT PBOOLEAN GenerateOnClose);
+
+/*
+ * FUNCTION: Performs access validation on an object handle and if access
+ * is granted returns a pointer to the object's body
+ * ARGUMENTS:
+ * Handle = Handle to the object
+ * DesiredAccess = Desired access to the object
+ * ObjectType (OPTIONAL) = Pointer to the object's type definition
+ * AccessMode = Access mode to use for the check
+ * Object (OUT) = Caller supplied storage for a pointer to the object's
+ * body
+ * HandleInformation (OUT) = Points to a structure which receives
+ * information about the handle
+ * RETURNS: Status
+ */
+NTSTATUS STDCALL
+ObReferenceObjectByHandle(IN HANDLE Handle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_TYPE ObjectType OPTIONAL,
+ IN KPROCESSOR_MODE AccessMode,
+ OUT PVOID* Object,
+ OUT POBJECT_HANDLE_INFORMATION HandleInfo OPTIONAL);
+
+/*
+ * FUNCTION: Increments the reference count for a given object
+ * ARGUMENTS:
+ * Object = Points to the body of the object
+ * AccessMode = Requested access to the object
+ * ObjectType = Pointer to the object's type definition
+ * AccessMode = Access mode to use for the security check
+ * RETURNS: Status
+ */
+NTSTATUS STDCALL
+ObReferenceObjectByPointer(IN PVOID Object,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_TYPE ObjectType,
+ IN KPROCESSOR_MODE AccessMode);
+
+NTSTATUS STDCALL
+ObReferenceObjectByName(IN PUNICODE_STRING ObjectPath,
+ IN ULONG Attributes,
+ IN PACCESS_STATE PassedAccessState OPTIONAL,
+ IN ACCESS_MASK DesiredAccess OPTIONAL,
+ IN POBJECT_TYPE ObjectType,
+ IN KPROCESSOR_MODE AccessMode,
+ IN OUT PVOID ParseContext OPTIONAL,
+ OUT PVOID* ObjectPtr);
+
+VOID STDCALL
+ObReleaseObjectSecurity(IN PSECURITY_DESCRIPTOR SecurityDescriptor,
+ IN BOOLEAN MemoryAllocated);
+
+/*
+NTSTATUS STDCALL
+ObSetSecurityDescriptorInfo(IN PVOID Object,
+ IN PSECURITY_INFORMATION SecurityInformation,
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor,
+ ULONG Param4,
+ IN POOL_TYPE PoolType,
+ IN PGENERIC_MAPPING GenericMapping);
+*/
+
+#endif /* ndef _INCLUDE_DDK_OBFUNCS_H */
--- /dev/null
+#ifndef _INCLUDE_DDK_OBTYPES_H
+#define _INCLUDE_DDK_OBTYPES_H
+/* $Id: obtypes.h,v 1.18 2002/09/08 10:47:45 chorns Exp $ */
+struct _DIRECTORY_OBJECT;
+struct _OBJECT_ATTRIBUTES;
+
+typedef ULONG ACCESS_STATE, *PACCESS_STATE;
+
+typedef struct _OBJECT_HANDLE_INFORMATION {
+ ULONG HandleAttributes;
+ ACCESS_MASK GrantedAccess;
+} OBJECT_HANDLE_INFORMATION, *POBJECT_HANDLE_INFORMATION;
+
+typedef struct _OBJECT_TYPE
+{
+ /*
+ * PURPOSE: Tag to be used when allocating objects of this type
+ */
+ ULONG Tag;
+
+ /*
+ * PURPOSE: Name of the type
+ */
+ UNICODE_STRING TypeName;
+
+ /*
+ * PURPOSE: Total number of objects of this type
+ */
+ ULONG TotalObjects;
+
+ /*
+ * PURPOSE: Total number of handles of this type
+ */
+ ULONG TotalHandles;
+
+ /*
+ * PURPOSE: Maximum objects of this type
+ */
+ ULONG MaxObjects;
+
+ /*
+ * PURPOSE: Maximum handles of this type
+ */
+ ULONG MaxHandles;
+
+ /*
+ * PURPOSE: Paged pool charge
+ */
+ ULONG PagedPoolCharge;
+
+ /*
+ * PURPOSE: Nonpaged pool charge
+ */
+ ULONG NonpagedPoolCharge;
+
+ /*
+ * PURPOSE: Mapping of generic access rights
+ */
+ PGENERIC_MAPPING Mapping;
+
+ /*
+ * PURPOSE: Dumps the object
+ * NOTE: To be defined
+ */
+ VOID STDCALL (*Dump)(VOID);
+
+ /*
+ * PURPOSE: Opens the object
+ * NOTE: To be defined
+ */
+ VOID STDCALL (*Open)(VOID);
+
+ /*
+ * PURPOSE: Called to close an object if OkayToClose returns true
+ */
+ VOID STDCALL (*Close)(PVOID ObjectBody,
+ ULONG HandleCount);
+
+ /*
+ * PURPOSE: Called to delete an object when the last reference is removed
+ */
+ VOID STDCALL (*Delete)(PVOID ObjectBody);
+
+ /*
+ * PURPOSE: Called when an open attempts to open a file apparently
+ * residing within the object
+ * RETURNS
+ * STATUS_SUCCESS NextObject was found
+ * STATUS_UNSUCCESSFUL NextObject not found
+ * STATUS_REPARSE Path changed, restart parsing the path
+ */
+ NTSTATUS STDCALL (*Parse)(PVOID ParsedObject,
+ PVOID *NextObject,
+ PUNICODE_STRING FullPath,
+ PWSTR *Path,
+ ULONG Attributes);
+
+ /*
+ */
+ NTSTATUS STDCALL (*Security)(PVOID Object,
+ ULONG InfoClass,
+ PVOID Info,
+ PULONG InfoLength);
+
+ /*
+ */
+ VOID STDCALL (*QueryName)(VOID);
+
+ /*
+ * PURPOSE: Called when a process asks to close the object
+ */
+ VOID STDCALL (*OkayToClose)(VOID);
+
+ NTSTATUS STDCALL (*Create)(PVOID ObjectBody,
+ PVOID Parent,
+ PWSTR RemainingPath,
+ struct _OBJECT_ATTRIBUTES* ObjectAttributes);
+
+ VOID STDCALL (*DuplicationNotify)(PEPROCESS DuplicateTo,
+ PEPROCESS DuplicateFrom,
+ PVOID Object);
+} OBJECT_TYPE, *POBJECT_TYPE;
+
+
+typedef struct _OBJECT_HEADER
+/*
+ * PURPOSE: Header for every object managed by the object manager
+ */
+{
+ UNICODE_STRING Name;
+ LIST_ENTRY Entry;
+ LONG RefCount;
+ LONG HandleCount;
+ BOOLEAN CloseInProcess;
+ BOOLEAN Permanent;
+ struct _DIRECTORY_OBJECT* Parent;
+ POBJECT_TYPE ObjectType;
+
+ /*
+ * PURPOSE: Object type
+ * NOTE: This overlaps the first member of the object body
+ */
+ CSHORT Type;
+
+ /*
+ * PURPOSE: Object size
+ * NOTE: This overlaps the second member of the object body
+ */
+ CSHORT Size;
+
+
+} OBJECT_HEADER, *POBJECT_HEADER;
+
+typedef struct _OBJECT_ATTRIBUTES
+{
+ ULONG Length;
+ HANDLE RootDirectory;
+ PUNICODE_STRING ObjectName;
+ ULONG Attributes;
+ SECURITY_DESCRIPTOR *SecurityDescriptor;
+ SECURITY_QUALITY_OF_SERVICE *SecurityQualityOfService;
+} OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES;
+
+typedef struct _HANDLE_TABLE
+{
+ LIST_ENTRY ListHead;
+ KSPIN_LOCK ListLock;
+} HANDLE_TABLE, *PHANDLE_TABLE;
+
+extern POBJECT_TYPE ObDirectoryType;
+
+#if 0
+#define OBJECT_TYPE_0 0
+#define OBJECT_TYPE_1 1
+#define OBJECT_TYPE_DIRECTORY 2
+#define OBJECT_TYPE_SYMBOLICLINK 3
+#define OBJECT_TYPE_TOKEN 4
+#define OBJECT_TYPE_PROCESS 5
+#define OBJECT_TYPE_THREAD 6
+#define OBJECT_TYPE_EVENT 7
+#define OBJECT_TYPE_8 8
+#define OBJECT_TYPE_MUTANT 9
+#define OBJECT_TYPE_SEMAPHORE 10
+#define OBJECT_TYPE_TIMER 11
+#define OBJECT_TYPE_12 12
+#define OBJECT_TYPE_WINDOWSTATION 13
+#define OBJECT_TYPE_DESKTOP 14
+#define OBJECT_TYPE_SECTION 15
+#define OBJECT_TYPE_KEY 16
+#define OBJECT_TYPE_PORT 17
+#define OBJECT_TYPE_18 18
+#define OBJECT_TYPE_19 19
+#define OBJECT_TYPE_20 20
+#define OBJECT_TYPE_21 21
+#define OBJECT_TYPE_IOCOMPLETION 22
+#define OBJECT_TYPE_FILE 23
+#endif
+
+#endif /* ndef _INCLUDE_DDK_OBTYPES_H */
--- /dev/null
+#ifndef __INCLUDE_DDK_PNPFUNCS_H
+#define __INCLUDE_DDK_PNPFUNCS_H
+
+#define IoInitializeRemoveLock(Lock, Tag, Maxmin, HighWater) \
+ IoInitializeRemoveLockEx(Lock, Tag, Maxmin, HighWater, sizeof(IO_REMOVE_LOCK))
+
+VOID
+STDCALL
+IoInitializeRemoveLockEx(
+ IN PIO_REMOVE_LOCK Lock,
+ IN ULONG AllocateTag,
+ IN ULONG MaxLockedMinutes,
+ IN ULONG HighWatermark,
+ IN ULONG RemlockSize);
+
+#define IoAcquireRemoveLock(RemoveLock, Tag) \
+ IoAcquireRemoveLockEx(RemoveLock, Tag, __FILE__, __LINE__, sizeof(IO_REMOVE_LOCK))
+
+NTSTATUS
+STDCALL
+IoAcquireRemoveLockEx(
+ IN PIO_REMOVE_LOCK RemoveLock,
+ IN OPTIONAL PVOID Tag,
+ IN LPCSTR File,
+ IN ULONG Line,
+ IN ULONG RemlockSize);
+
+#define IoReleaseRemoveLock(RemoveLock, Tag) \
+ IoReleaseRemoveLockEx(RemoveLock, Tag, sizeof (IO_REMOVE_LOCK))
+
+VOID
+STDCALL
+IoReleaseRemoveLockEx(
+ IN PIO_REMOVE_LOCK RemoveLock,
+ IN PVOID Tag,
+ IN ULONG RemlockSize);
+
+#define IoReleaseRemoveLockAndWait(RemoveLock, Tag) \
+ IoReleaseRemoveLockAndWaitEx(RemoveLock, Tag, sizeof (IO_REMOVE_LOCK))
+
+VOID
+STDCALL
+IoReleaseRemoveLockAndWaitEx(
+ IN PIO_REMOVE_LOCK RemoveLock,
+ IN PVOID Tag,
+ IN ULONG RemlockSize);
+
+VOID
+STDCALL
+IoAdjustPagingPathCount(
+ IN PLONG Count,
+ IN BOOLEAN Increment);
+
+NTSTATUS
+STDCALL
+IoGetDeviceInterfaceAlias(
+ IN PUNICODE_STRING SymbolicLinkName,
+ IN CONST GUID *AliasInterfaceClassGuid,
+ OUT PUNICODE_STRING AliasSymbolicLinkName);
+
+NTSTATUS
+STDCALL
+IoGetDeviceInterfaces(
+ IN CONST GUID *InterfaceClassGuid,
+ IN PDEVICE_OBJECT PhysicalDeviceObject OPTIONAL,
+ IN ULONG Flags,
+ OUT PWSTR *SymbolicLinkList);
+
+NTSTATUS
+STDCALL
+IoGetDeviceProperty(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN DEVICE_REGISTRY_PROPERTY DeviceProperty,
+ IN ULONG BufferLength,
+ OUT PVOID PropertyBuffer,
+ OUT PULONG ResultLength);
+
+VOID
+STDCALL
+IoInvalidateDeviceRelations(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN DEVICE_RELATION_TYPE Type);
+
+VOID
+STDCALL
+IoInvalidateDeviceState(
+ IN PDEVICE_OBJECT PhysicalDeviceObject);
+
+NTSTATUS
+STDCALL
+IoOpenDeviceInterfaceRegistryKey(
+ IN PUNICODE_STRING SymbolicLinkName,
+ IN ACCESS_MASK DesiredAccess,
+ OUT PHANDLE DeviceInterfaceKey);
+
+NTSTATUS
+STDCALL
+IoOpenDeviceRegistryKey(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN ULONG DevInstKeyType,
+ IN ACCESS_MASK DesiredAccess,
+ OUT PHANDLE DevInstRegKey);
+
+NTSTATUS
+STDCALL
+IoRegisterDeviceInterface(
+ IN PDEVICE_OBJECT PhysicalDeviceObject,
+ IN CONST GUID *InterfaceClassGuid,
+ IN PUNICODE_STRING ReferenceString OPTIONAL,
+ OUT PUNICODE_STRING SymbolicLinkName);
+
+NTSTATUS
+STDCALL
+IoRegisterPlugPlayNotification(
+ IN IO_NOTIFICATION_EVENT_CATEGORY EventCategory,
+ IN ULONG EventCategoryFlags,
+ IN PVOID EventCategoryData OPTIONAL,
+ IN PDRIVER_OBJECT DriverObject,
+ IN PDRIVER_NOTIFICATION_CALLBACK_ROUTINE CallbackRoutine,
+ IN PVOID Context,
+ OUT PVOID *NotificationEntry);
+
+NTSTATUS
+STDCALL
+IoReportDetectedDevice(
+ IN PDRIVER_OBJECT DriverObject,
+ IN INTERFACE_TYPE LegacyBusType,
+ IN ULONG BusNumber,
+ IN ULONG SlotNumber,
+ IN PCM_RESOURCE_LIST ResourceList,
+ IN PIO_RESOURCE_REQUIREMENTS_LIST ResourceRequirements OPTIONAL,
+ IN BOOLEAN ResourceAssigned,
+ IN OUT PDEVICE_OBJECT *DeviceObject);
+
+NTSTATUS
+STDCALL
+IoReportResourceForDetection(
+ IN PDRIVER_OBJECT DriverObject,
+ IN PCM_RESOURCE_LIST DriverList OPTIONAL,
+ IN ULONG DriverListSize OPTIONAL,
+ IN PDEVICE_OBJECT DeviceObject OPTIONAL,
+ IN PCM_RESOURCE_LIST DeviceList OPTIONAL,
+ IN ULONG DeviceListSize OPTIONAL,
+ OUT PBOOLEAN ConflictDetected);
+
+NTSTATUS
+STDCALL
+IoReportTargetDeviceChange(
+ IN PDEVICE_OBJECT PhysicalDeviceObject,
+ IN PVOID NotificationStructure);
+
+NTSTATUS
+STDCALL
+IoReportTargetDeviceChangeAsynchronous(
+ IN PDEVICE_OBJECT PhysicalDeviceObject,
+ IN PVOID NotificationStructure,
+ IN PDEVICE_CHANGE_COMPLETE_CALLBACK Callback OPTIONAL,
+ IN PVOID Context OPTIONAL);
+
+VOID
+STDCALL
+IoRequestDeviceEject(
+ IN PDEVICE_OBJECT PhysicalDeviceObject);
+
+NTSTATUS
+STDCALL
+IoSetDeviceInterfaceState(
+ IN PUNICODE_STRING SymbolicLinkName,
+ IN BOOLEAN Enable);
+
+NTSTATUS
+STDCALL
+IoUnregisterPlugPlayNotification(
+ IN PVOID NotificationEntry);
+
+#endif /* __INCLUDE_DDK_PNPFUNCS_H */
--- /dev/null
+#ifndef __INCLUDE_DDK_PNPTYPES_H
+#define __INCLUDE_DDK_PNPTYPES_H
+
+struct _DEVICE_OBJECT;
+struct _FILE_OBJECT;
+
+// windows.h may be included before
+#ifndef GUID_DEFINED
+#define GUID_DEFINED
+
+typedef struct _GUID {
+ ULONG Data1;
+ USHORT Data2;
+ USHORT Data3;
+ UCHAR Data4[8];
+} GUID, *LPGUID;
+
+#endif
+
+typedef struct _PNP_BUS_INFORMATION {
+ GUID BusTypeGuid;
+ INTERFACE_TYPE LegacyBusType;
+ ULONG BusNumber;
+} PNP_BUS_INFORMATION, *PPNP_BUS_INFORMATION;
+
+typedef struct _DEVICE_CAPABILITIES {
+ USHORT Size;
+ USHORT Version;
+ ULONG DeviceD1:1;
+ ULONG DeviceD2:1;
+ ULONG LockSupported:1;
+ ULONG EjectSupported:1;
+ ULONG Removable:1;
+ ULONG DockDevice:1;
+ ULONG UniqueID:1;
+ ULONG SilentInstall:1;
+ ULONG RawDeviceOK:1;
+ ULONG SurpriseRemovalOK:1;
+ ULONG WakeFromD0:1;
+ ULONG WakeFromD1:1;
+ ULONG WakeFromD2:1;
+ ULONG WakeFromD3:1;
+ ULONG HardwareDisabled:1;
+ ULONG NonDynamic:1;
+ ULONG WarmEjectSupported:1;
+ ULONG Reserved:15;
+ ULONG Address;
+ ULONG UINumber;
+ DEVICE_POWER_STATE DeviceState[PowerSystemMaximum];
+ SYSTEM_POWER_STATE SystemWake;
+ DEVICE_POWER_STATE DeviceWake;
+ ULONG D1Latency;
+ ULONG D2Latency;
+ ULONG D3Latency;
+} DEVICE_CAPABILITIES, *PDEVICE_CAPABILITIES;
+
+typedef struct _DEVICE_INTERFACE_CHANGE_NOTIFICATION {
+ USHORT Version;
+ USHORT Size;
+ GUID Event;
+ //
+ // Event-specific data
+ //
+ GUID InterfaceClassGuid;
+ PUNICODE_STRING SymbolicLinkName;
+} DEVICE_INTERFACE_CHANGE_NOTIFICATION, *PDEVICE_INTERFACE_CHANGE_NOTIFICATION;
+
+typedef struct _HWPROFILE_CHANGE_NOTIFICATION {
+ USHORT Version;
+ USHORT Size;
+ GUID Event;
+ //
+ // (No event-specific data)
+ //
+} HWPROFILE_CHANGE_NOTIFICATION, *PHWPROFILE_CHANGE_NOTIFICATION;
+
+typedef struct _PLUGPLAY_NOTIFICATION_HEADER {
+ USHORT Version;
+ USHORT Size;
+ GUID Event;
+} PLUGPLAY_NOTIFICATION_HEADER, *PPLUGPLAY_NOTIFICATION_HEADER;
+
+typedef ULONG PNP_DEVICE_STATE, *PPNP_DEVICE_STATE;
+
+#define PNP_DEVICE_DISABLED 0x00000001
+#define PNP_DEVICE_DONT_DISPLAY_IN_UI 0x00000002
+#define PNP_DEVICE_FAILED 0x00000004
+#define PNP_DEVICE_REMOVED 0x00000008
+#define PNP_DEVICE_RESOURCE_REQUIREMENTS_CHANGED 0x00000010
+#define PNP_DEVICE_NOT_DISABLEABLE 0x00000020
+
+typedef struct _TARGET_DEVICE_CUSTOM_NOTIFICATION {
+ USHORT Version;
+ USHORT Size;
+ GUID Event;
+ //
+ // Event-specific data
+ //
+ struct _FILE_OBJECT *FileObject;
+ LONG NameBufferOffset;
+ UCHAR CustomDataBuffer[1];
+} TARGET_DEVICE_CUSTOM_NOTIFICATION, *PTARGET_DEVICE_CUSTOM_NOTIFICATION;
+
+typedef struct _TARGET_DEVICE_REMOVAL_NOTIFICATION {
+ USHORT Version;
+ USHORT Size;
+ GUID Event;
+ //
+ // Event-specific data
+ //
+ struct _FILE_OBJECT *FileObject;
+} TARGET_DEVICE_REMOVAL_NOTIFICATION, *PTARGET_DEVICE_REMOVAL_NOTIFICATION;
+
+
+// PnP Device Property for IoGetDeviceProperty
+typedef enum {
+ DevicePropertyDeviceDescription,
+ DevicePropertyHardwareID,
+ DevicePropertyCompatibleIDs,
+ DevicePropertyBootConfiguration,
+ DevicePropertyBootConfigurationTranslated,
+ DevicePropertyClassName,
+ DevicePropertyClassGuid,
+ DevicePropertyDriverKeyName,
+ DevicePropertyManufacturer,
+ DevicePropertyFriendlyName,
+ DevicePropertyLocationInformation,
+ DevicePropertyPhysicalDeviceObjectName,
+ DevicePropertyBusTypeGuid,
+ DevicePropertyLegacyBusType,
+ DevicePropertyBusNumber,
+ DevicePropertyEnumeratorName,
+ DevicePropertyAddress,
+ DevicePropertyUINumber
+} DEVICE_REGISTRY_PROPERTY;
+
+// DevInstKeyType values for IoOpenDeviceRegistryKey
+#define PLUGPLAY_REGKEY_DEVICE 1
+#define PLUGPLAY_REGKEY_DRIVER 2
+#define PLUGPLAY_REGKEY_CURRENT_HWPROFILE 4
+
+// EventCategory for IoRegisterPlugPlayNotification
+typedef enum _IO_NOTIFICATION_EVENT_CATEGORY {
+ EventCategoryReserved,
+ EventCategoryHardwareProfileChange,
+ EventCategoryDeviceInterfaceChange,
+ EventCategoryTargetDeviceChange
+} IO_NOTIFICATION_EVENT_CATEGORY;
+
+// CallbackRoutine for IoRegisterPlugPlayNotification
+typedef NTSTATUS STDCALL
+(*PDRIVER_NOTIFICATION_CALLBACK_ROUTINE)(
+ IN PVOID NotificationStructure,
+ IN PVOID Context);
+
+// Callback for IoReportTargetDeviceChangeAsynchronous
+typedef VOID STDCALL
+(*PDEVICE_CHANGE_COMPLETE_CALLBACK)(
+ IN PVOID Context);
+
+// PNP/POWER values for IRP_MJ_PNP/IRP_MJ_POWER
+typedef enum _DEVICE_RELATION_TYPE {
+ BusRelations,
+ EjectionRelations,
+ PowerRelations,
+ RemovalRelations,
+ TargetDeviceRelation
+} DEVICE_RELATION_TYPE, *PDEVICE_RELATION_TYPE;
+
+typedef struct _DEVICE_RELATIONS {
+ ULONG Count;
+ struct _DEVICE_OBJECT *Objects[1];
+} DEVICE_RELATIONS, *PDEVICE_RELATIONS;
+
+typedef enum _DEVICE_USAGE_NOTIFICATION_TYPE {
+ DeviceUsageTypeUndefined,
+ DeviceUsageTypePaging,
+ DeviceUsageTypeHibernation,
+ DeviceUsageTypeDumpFile
+} DEVICE_USAGE_NOTIFICATION_TYPE;
+
+
+typedef struct _IO_REMOVE_LOCK_COMMON_BLOCK {
+ BOOLEAN Removed;
+ BOOLEAN Reserved[3];
+ LONG IoCount;
+ KEVENT RemoveEvent;
+} IO_REMOVE_LOCK_COMMON_BLOCK;
+
+typedef struct _IO_REMOVE_LOCK {
+ IO_REMOVE_LOCK_COMMON_BLOCK Common;
+} IO_REMOVE_LOCK, *PIO_REMOVE_LOCK;
+
+#endif /* __INCLUDE_DDK_PNPTYPES_H */
--- /dev/null
+#ifndef __INCLUDE_DDK_POFUNCS_H
+#define __INCLUDE_DDK_POFUNCS_H
+
+NTSTATUS
+STDCALL
+PoCallDriver(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN OUT PIRP Irp);
+
+PULONG
+STDCALL
+PoRegisterDeviceForIdleDetection(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN ULONG ConservationIdleTime,
+ IN ULONG PerformanceIdleTime,
+ IN DEVICE_POWER_STATE State);
+
+PVOID
+STDCALL
+PoRegisterSystemState(
+ IN PVOID StateHandle,
+ IN EXECUTION_STATE Flags);
+
+NTSTATUS
+STDCALL
+PoRequestPowerIrp(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN UCHAR MinorFunction,
+ IN POWER_STATE PowerState,
+ IN PREQUEST_POWER_COMPLETE CompletionFunction,
+ IN PVOID Context,
+ OUT PIRP *Irp OPTIONAL);
+
+VOID
+STDCALL
+PoSetDeviceBusy(
+ PULONG IdlePointer);
+
+POWER_STATE
+STDCALL
+PoSetPowerState(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN POWER_STATE_TYPE Type,
+ IN POWER_STATE State);
+
+VOID
+STDCALL
+PoSetSystemState(
+ IN EXECUTION_STATE Flags);
+
+VOID
+STDCALL
+PoStartNextPowerIrp(
+ IN PIRP Irp);
+
+VOID
+STDCALL
+PoUnregisterSystemState(
+ IN PVOID StateHandle);
+
+#endif /* __INCLUDE_DDK_POFUNCS_H */
--- /dev/null
+#ifndef __INCLUDE_DDK_POTYPES_H
+#define __INCLUDE_DDK_POTYPES_H
+
+struct _DEVICE_OBJECT;
+struct _IO_STATUS_BLOCK;
+
+// Flags for PoSetSystemState
+typedef ULONG EXECUTION_STATE;
+
+#define ES_SYSTEM_REQUIRED ((EXECUTION_STATE)0x00000001)
+#define ES_DISPLAY_REQUIRED ((EXECUTION_STATE)0x00000002)
+#define ES_USER_PRESENT ((EXECUTION_STATE)0x00000004)
+#define ES_CONTINUOUS ((EXECUTION_STATE)0x80000000)
+
+// PowerState for PoRequestPowerIrp
+typedef enum _SYSTEM_POWER_STATE {
+ PowerSystemUnspecified = 0,
+ PowerSystemWorking,
+ PowerSystemSleeping1,
+ PowerSystemSleeping2,
+ PowerSystemSleeping3,
+ PowerSystemHibernate,
+ PowerSystemShutdown,
+ PowerSystemMaximum
+} SYSTEM_POWER_STATE, *PSYSTEM_POWER_STATE;
+
+// Values for IRP_MN_QUERY_POWER/IRP_MN_SET_POWER
+typedef enum {
+ PowerActionNone = 0,
+ PowerActionReserved,
+ PowerActionSleep,
+ PowerActionHibernate,
+ PowerActionShutdown,
+ PowerActionShutdownReset,
+ PowerActionShutdownOff,
+ PowerActionWarmEject
+} POWER_ACTION, *PPOWER_ACTION;
+
+// State for PoRegisterDeviceForIdleDetection
+typedef enum _DEVICE_POWER_STATE {
+ PowerDeviceUnspecified = 0,
+ PowerDeviceD0,
+ PowerDeviceD1,
+ PowerDeviceD2,
+ PowerDeviceD3,
+ PowerDeviceMaximum
+} DEVICE_POWER_STATE, *PDEVICE_POWER_STATE;
+
+// State for PoSetPowerState
+typedef union _POWER_STATE {
+ SYSTEM_POWER_STATE SystemState;
+ DEVICE_POWER_STATE DeviceState;
+} POWER_STATE, *PPOWER_STATE;
+
+// Type for PoSetPowerState
+typedef enum _POWER_STATE_TYPE {
+ SystemPowerState = 0,
+ DevicePowerState
+} POWER_STATE_TYPE, *PPOWER_STATE_TYPE;
+
+// CompletionFunction for PoRequestPowerIrp
+typedef VOID STDCALL
+(*PREQUEST_POWER_COMPLETE) (
+ IN struct _DEVICE_OBJECT *DeviceObject,
+ IN UCHAR MinorFunction,
+ IN POWER_STATE PowerState,
+ IN PVOID Context,
+ IN struct _IO_STATUS_BLOCK *IoStatus);
+
+
+typedef struct _POWER_SEQUENCE {
+ ULONG SequenceD1;
+ ULONG SequenceD2;
+ ULONG SequenceD3;
+} POWER_SEQUENCE, *PPOWER_SEQUENCE;
+
+typedef VOID STDCALL (*PINTERFACE_REFERENCE)(PVOID Context);
+typedef VOID STDCALL (*PINTERFACE_DEREFERENCE)(PVOID Context);
+
+typedef struct _INTERFACE {
+ USHORT Size;
+ USHORT Version;
+ PVOID Context;
+ PINTERFACE_REFERENCE InterfaceReference;
+ PINTERFACE_DEREFERENCE InterfaceDereference;
+} INTERFACE, *PINTERFACE;
+
+typedef enum {
+ BusQueryDeviceID = 0,
+ BusQueryHardwareIDs = 1,
+ BusQueryCompatibleIDs = 2,
+ BusQueryInstanceID = 3,
+ BusQueryDeviceSerialNumber = 4
+} BUS_QUERY_ID_TYPE, *PBUS_QUERY_ID_TYPE;
+
+typedef enum {
+ DeviceTextDescription = 0,
+ DeviceTextLocationInformation = 1
+} DEVICE_TEXT_TYPE, *PDEVICE_TEXT_TYPE;
+
+#endif /* __INCLUDE_DDK_POTYPES_H */
--- /dev/null
+/* $Id: psfuncs.h,v 1.22 2002/09/08 10:47:45 chorns Exp $
+ */
+#ifndef _INCLUDE_DDK_PSFUNCS_H
+#define _INCLUDE_DDK_PSFUNCS_H
+
+NTSTATUS STDCALL PsAssignImpersonationToken (struct _ETHREAD* Thread,
+ HANDLE TokenHandle);
+
+HANDLE STDCALL PsGetCurrentProcessId(VOID);
+HANDLE STDCALL PsGetCurrentThreadId(VOID);
+
+/*
+ * FUNCTION: Creates a thread which executes in kernel mode
+ * ARGUMENTS:
+ * ThreadHandle (OUT) = Caller supplied storage for the returned thread
+ * handle
+ * DesiredAccess = Requested access to the thread
+ * ObjectAttributes = Object attributes (optional)
+ * ProcessHandle = Handle of process thread will run in
+ * NULL to use system process
+ * ClientId (OUT) = Caller supplied storage for the returned client id
+ * of the thread (optional)
+ * StartRoutine = Entry point for the thread
+ * StartContext = Argument supplied to the thread when it begins
+ * execution
+ * RETURNS: Success or failure status
+ */
+NTSTATUS STDCALL PsCreateSystemThread(PHANDLE ThreadHandle,
+ ACCESS_MASK DesiredAccess,
+ POBJECT_ATTRIBUTES ObjectAttributes,
+ HANDLE ProcessHandle,
+ PCLIENT_ID ClientId,
+ PKSTART_ROUTINE StartRoutine,
+ PVOID StartContext);
+NTSTATUS STDCALL PsTerminateSystemThread(NTSTATUS ExitStatus);
+
+NTSTATUS STDCALL PsCreateSystemProcess(PHANDLE ProcessHandle,
+ ACCESS_MASK DesiredAccess,
+ POBJECT_ATTRIBUTES ObjectAttributes);
+
+NTSTATUS STDCALL PsCreateWin32Process(struct _EPROCESS* Process);
+NTSTATUS STDCALL PsCreateWin32Thread(struct _ETHREAD* Thread);
+
+VOID STDCALL PsEstablishWin32Callouts(PVOID Param1,
+ PVOID Param2,
+ PVOID Param3,
+ PVOID Param4,
+ ULONG W32ThreadSize,
+ ULONG W32ProcessSize);
+
+struct _ETHREAD* STDCALL PsGetCurrentThread(VOID);
+struct _EPROCESS* STDCALL PsGetCurrentProcess(VOID);
+PACCESS_TOKEN STDCALL PsReferenceImpersonationToken(struct _ETHREAD* Thread,
+ PULONG Unknown1,
+ PULONG Unknown2,
+ SECURITY_IMPERSONATION_LEVEL*
+ Level);
+PACCESS_TOKEN STDCALL PsReferencePrimaryToken(struct _EPROCESS* Process);
+NTSTATUS STDCALL PsAssignImpersonationToken(struct _ETHREAD* Thread,
+ HANDLE TokenHandle);
+
+VOID STDCALL PsImpersonateClient(struct _ETHREAD* Thread,
+ PACCESS_TOKEN Token,
+ UCHAR b,
+ UCHAR c,
+ SECURITY_IMPERSONATION_LEVEL Level);
+VOID STDCALL PsRevertToSelf(VOID);
+
+BOOLEAN STDCALL PsGetVersion (PULONG MajorVersion OPTIONAL,
+ PULONG MinorVersion OPTIONAL,
+ PULONG BuildNumber OPTIONAL,
+ PUNICODE_STRING CSDVersion OPTIONAL);
+
+LARGE_INTEGER STDCALL PsGetProcessExitTime(VOID);
+BOOLEAN STDCALL PsIsThreadTerminating(struct _ETHREAD* Thread);
+
+NTSTATUS STDCALL PsLookupProcessByProcessId(IN PVOID ProcessId,
+ OUT PEPROCESS *Process);
+
+NTSTATUS STDCALL PsLookupProcessThreadByCid(IN PCLIENT_ID Cid,
+ OUT PEPROCESS *Process OPTIONAL,
+ OUT struct _ETHREAD **Thread);
+// OUT PETHREAD *Thread);
+
+NTSTATUS STDCALL PsLookupThreadByThreadId(IN PVOID ThreadId,
+ OUT struct _ETHREAD **Thread);
+// OUT PETHREAD *Thread);
+
+NTSTATUS STDCALL
+PsSetCreateProcessNotifyRoutine(IN PCREATE_PROCESS_NOTIFY_ROUTINE NotifyRoutine,
+ IN BOOLEAN Remove);
+
+NTSTATUS STDCALL
+PsSetCreateThreadNotifyRoutine(IN PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine);
+
+#endif
+
+/* EOF */
--- /dev/null
+#ifndef __INCLUDE_DDK_PSTYPES_H
+#define __INCLUDE_DDK_PSTYPES_H
+
+#include <ntos/ps.h>
+
+#include <ddk/i386/tss.h>
+#include <napi/teb.h>
+
+#ifndef TLS_MINIMUM_AVAILABLE
+#define TLS_MINIMUM_AVAILABLE (64)
+#endif
+#ifndef MAX_PATH
+#define MAX_PATH (260)
+#endif
+
+struct _EPROCESS;
+struct _KPROCESS;
+struct _ETHREAD;
+struct _KTHREAD;
+
+typedef NTSTATUS STDCALL (*PKSTART_ROUTINE)(PVOID StartContext);
+
+typedef VOID STDCALL (*PCREATE_PROCESS_NOTIFY_ROUTINE)(HANDLE ParentId,
+ HANDLE ProcessId,
+ BOOLEAN Create);
+
+typedef VOID STDCALL (*PCREATE_THREAD_NOTIFY_ROUTINE)(HANDLE ProcessId,
+ HANDLE ThreadId,
+ BOOLEAN Create);
+
+typedef struct _STACK_INFORMATION
+{
+ PVOID BaseAddress;
+ PVOID UpperAddress;
+} STACK_INFORMATION, *PSTACK_INFORMATION;
+
+typedef ULONG THREADINFOCLASS;
+
+struct _KPROCESS;
+
+#define LOW_PRIORITY (0)
+#define LOW_REALTIME_PRIORITY (16)
+#define HIGH_PRIORITY (31)
+#define MAXIMUM_PRIORITY (32)
+
+
+#ifdef __NTOSKRNL__
+extern struct _EPROCESS* EXPORTED PsInitialSystemProcess;
+extern POBJECT_TYPE EXPORTED PsProcessType;
+extern POBJECT_TYPE EXPORTED PsThreadType;
+#else
+extern struct _EPROCESS* IMPORTED PsInitialSystemProcess;
+extern POBJECT_TYPE IMPORTED PsProcessType;
+extern POBJECT_TYPE IMPORTED PsThreadType;
+#endif
+
+#endif /* __INCLUDE_DDK_PSTYPES_H */
--- /dev/null
+/* $Id: rtl.h,v 1.67 2002/09/08 10:47:45 chorns Exp $
+ *
+ */
+
+#ifndef __DDK_RTL_H
+#define __DDK_RTL_H
+
+#if defined(__NTOSKRNL__) || defined(__NTDRIVER__) || defined(__NTHAL__) || defined(__NTDLL__) || defined (__NTAPP__)
+
+#include <stddef.h>
+#include <stdarg.h>
+
+#endif /* __NTOSKRNL__ || __NTDRIVER__ || __NTHAL__ || __NTDLL__ || __NTAPP__ */
+
+#include <pe.h>
+
+
+
+/*
+ * PURPOSE: Flags for RtlQueryRegistryValues
+ */
+#define RTL_QUERY_REGISTRY_SUBKEY (0x00000001)
+#define RTL_QUERY_REGISTRY_TOPKEY (0x00000002)
+#define RTL_QUERY_REGISTRY_REQUIRED (0x00000004)
+#define RTL_QUERY_REGISTRY_NOVALUE (0x00000008)
+#define RTL_QUERY_REGISTRY_NOEXPAND (0x00000010)
+#define RTL_QUERY_REGISTRY_DIRECT (0x00000020)
+#define RTL_QUERY_REGISTRY_DELETE (0x00000040)
+
+
+/*
+ * PURPOSE: Used with RtlCheckRegistryKey, RtlCreateRegistryKey,
+ * RtlDeleteRegistryKey
+ */
+#define RTL_REGISTRY_ABSOLUTE 0
+#define RTL_REGISTRY_SERVICES 1
+#define RTL_REGISTRY_CONTROL 2
+#define RTL_REGISTRY_WINDOWS_NT 3
+#define RTL_REGISTRY_DEVICEMAP 4
+#define RTL_REGISTRY_USER 5
+#define RTL_REGISTRY_ENUM 6 // ReactOS specific: Used internally in kernel only
+#define RTL_REGISTRY_MAXIMUM 7
+
+#define RTL_REGISTRY_HANDLE 0x40000000
+#define RTL_REGISTRY_OPTIONAL 0x80000000
+
+
+#define SHORT_SIZE (sizeof(USHORT))
+#define SHORT_MASK (SHORT_SIZE-1)
+#define LONG_SIZE (sizeof(ULONG))
+#define LONG_MASK (LONG_SIZE-1)
+#define LOWBYTE_MASK 0x00FF
+
+#define FIRSTBYTE(Value) ((Value) & LOWBYTE_MASK)
+#define SECONDBYTE(Value) (((Value) >> 8) & LOWBYTE_MASK)
+#define THIRDBYTE(Value) (((Value) >> 16) & LOWBYTE_MASK)
+#define FOURTHBYTE(Value) (((Value) >> 24) & LOWBYTE_MASK)
+
+/* FIXME: reverse byte-order on big-endian machines (e.g. MIPS) */
+#define SHORT_LEAST_SIGNIFICANT_BIT 0
+#define SHORT_MOST_SIGNIFICANT_BIT 1
+
+#define LONG_LEAST_SIGNIFICANT_BIT 0
+#define LONG_3RD_MOST_SIGNIFICANT_BIT 1
+#define LONG_2RD_MOST_SIGNIFICANT_BIT 2
+#define LONG_MOST_SIGNIFICANT_BIT 3
+
+
+
+#if defined(__NTOSKRNL__) || defined(__NTDLL__)
+#define NLS_MB_CODE_PAGE_TAG NlsMbCodePageTag
+#define NLS_MB_OEM_CODE_PAGE_TAG NlsMbOemCodePageTag
+#else
+#define NLS_MB_CODE_PAGE_TAG (*NlsMbCodePageTag)
+#define NLS_MB_OEM_CODE_PAGE_TAG (*NlsMbOemCodePageTag)
+#endif /* __NTOSKRNL__ || __NTDLL__ */
+
+extern BOOLEAN NLS_MB_CODE_PAGE_TAG;
+extern BOOLEAN NLS_MB_OEM_CODE_PAGE_TAG;
+
+
+/*
+ * NOTE: ReactOS extensions
+ */
+#define RtlMin(X,Y) (((X) < (Y))? (X) : (Y))
+#define RtlMax(X,Y) (((X) > (Y))? (X) : (Y))
+#define RtlMin3(X,Y,Z) (((X) < (Y)) ? RtlMin(X,Z) : RtlMin(Y,Z))
+#define RtlMax3(X,Y,Z) (((X) > (Y)) ? RtlMax(X,Z) : RtlMax(Y,Z))
+
+
+/*
+ * VOID
+ * InitializeObjectAttributes (
+ * POBJECT_ATTRIBUTES InitializedAttributes,
+ * PUNICODE_STRING ObjectName,
+ * ULONG Attributes,
+ * HANDLE RootDirectory,
+ * PSECURITY_DESCRIPTOR SecurityDescriptor
+ * );
+ *
+ * FUNCTION: Sets up a parameter of type OBJECT_ATTRIBUTES for a
+ * subsequent call to ZwCreateXXX or ZwOpenXXX
+ * ARGUMENTS:
+ * InitializedAttributes (OUT) = Caller supplied storage for the
+ * object attributes
+ * ObjectName = Full path name for object
+ * Attributes = Attributes for the object
+ * RootDirectory = Where the object should be placed or NULL
+ * SecurityDescriptor = Ignored
+ */
+#define InitializeObjectAttributes(p,n,a,r,s) \
+{ \
+ (p)->Length = sizeof(OBJECT_ATTRIBUTES); \
+ (p)->ObjectName = n; \
+ (p)->Attributes = a; \
+ (p)->RootDirectory = r; \
+ (p)->SecurityDescriptor = s; \
+ (p)->SecurityQualityOfService = NULL; \
+}
+
+
+/*
+ * VOID
+ * InitializeListHead (
+ * PLIST_ENTRY ListHead
+ * );
+ *
+ * FUNCTION: Initializes a double linked list
+ * ARGUMENTS:
+ * ListHead = Caller supplied storage for the head of the list
+ */
+#define InitializeListHead(ListHead) \
+{ \
+ (ListHead)->Flink = (ListHead); \
+ (ListHead)->Blink = (ListHead); \
+}
+
+
+/*
+ * VOID
+ * InsertHeadList (
+ * PLIST_ENTRY ListHead,
+ * PLIST_ENTRY Entry
+ * );
+ *
+ * FUNCTION: Inserts an entry in a double linked list
+ * ARGUMENTS:
+ * ListHead = Head of the list
+ * Entry = Entry to insert
+ */
+#define InsertHeadList(ListHead, ListEntry) \
+{ \
+ PLIST_ENTRY OldFlink; \
+ OldFlink = (ListHead)->Flink; \
+ (ListEntry)->Flink = OldFlink; \
+ (ListEntry)->Blink = (ListHead); \
+ OldFlink->Blink = (ListEntry); \
+ (ListHead)->Flink = (ListEntry); \
+ assert((ListEntry) != NULL); \
+ assert((ListEntry)->Blink!=NULL); \
+ assert((ListEntry)->Blink->Flink == (ListEntry)); \
+ assert((ListEntry)->Flink != NULL); \
+ assert((ListEntry)->Flink->Blink == (ListEntry)); \
+}
+
+
+/*
+ * VOID
+ * InsertTailList (
+ * PLIST_ENTRY ListHead,
+ * PLIST_ENTRY Entry
+ * );
+ *
+ * FUNCTION:
+ * Inserts an entry in a double linked list
+ *
+ * ARGUMENTS:
+ * ListHead = Head of the list
+ * Entry = Entry to insert
+ */
+#define InsertTailList(ListHead, ListEntry) \
+{ \
+ PLIST_ENTRY OldBlink; \
+ OldBlink = (ListHead)->Blink; \
+ (ListEntry)->Flink = (ListHead); \
+ (ListEntry)->Blink = OldBlink; \
+ OldBlink->Flink = (ListEntry); \
+ (ListHead)->Blink = (ListEntry); \
+ assert((ListEntry) != NULL); \
+ assert((ListEntry)->Blink != NULL); \
+ assert((ListEntry)->Blink->Flink == (ListEntry)); \
+ assert((ListEntry)->Flink != NULL); \
+ assert((ListEntry)->Flink->Blink == (ListEntry)); \
+}
+
+/*
+ * BOOLEAN
+ * IsListEmpty (
+ * PLIST_ENTRY ListHead
+ * );
+ *
+ * FUNCTION:
+ * Checks if a double linked list is empty
+ *
+ * ARGUMENTS:
+ * ListHead = Head of the list
+*/
+#define IsListEmpty(ListHead) \
+ ((ListHead)->Flink == (ListHead))
+
+
+/*
+ * PSINGLE_LIST_ENTRY
+ * PopEntryList (
+ * PSINGLE_LIST_ENTRY ListHead
+ * );
+ *
+ * FUNCTION:
+ * Removes an entry from the head of a single linked list
+ *
+ * ARGUMENTS:
+ * ListHead = Head of the list
+ *
+ * RETURNS:
+ * The removed entry
+ */
+/*
+#define PopEntryList(ListHead) \
+ (ListHead)->Next; \
+ { \
+ PSINGLE_LIST_ENTRY FirstEntry; \
+ FirstEntry = (ListHead)->Next; \
+ if (FirstEntry != NULL) \
+ { \
+ (ListHead)->Next = FirstEntry->Next; \
+ } \
+ }
+*/
+static
+inline
+PSINGLE_LIST_ENTRY
+ PopEntryList(
+ PSINGLE_LIST_ENTRY ListHead
+ )
+{
+ PSINGLE_LIST_ENTRY ListEntry;
+
+ ListEntry = ListHead->Next;
+ if (ListEntry!=NULL)
+ {
+ ListHead->Next = ListEntry->Next;
+ }
+ return ListEntry;
+}
+
+/*
+VOID
+PushEntryList (
+ PSINGLE_LIST_ENTRY ListHead,
+ PSINGLE_LIST_ENTRY Entry
+ );
+*/
+/*
+#define PushEntryList(ListHead,Entry) \
+ (Entry)->Next = (ListHead)->Next; \
+ (ListHead)->Next = (Entry)
+*/
+static
+inline
+VOID
+PushEntryList (
+ PSINGLE_LIST_ENTRY ListHead,
+ PSINGLE_LIST_ENTRY Entry
+ )
+{
+ Entry->Next = ListHead->Next;
+ ListHead->Next = Entry;
+}
+
+
+/*
+ * An ReactOS extension
+ */
+static
+inline
+PSINGLE_LIST_ENTRY
+ PopEntrySList(
+ PSLIST_HEADER ListHead
+ )
+{
+ PSINGLE_LIST_ENTRY ListEntry;
+
+ ListEntry = ListHead->s.Next.Next;
+ if (ListEntry!=NULL)
+ {
+ ListHead->s.Next.Next = ListEntry->Next;
+ ListHead->s.Depth++;
+ ListHead->s.Sequence++;
+ }
+ return ListEntry;
+}
+
+
+/*
+ * An ReactOS extension
+ */
+static
+inline
+VOID
+PushEntrySList (
+ PSLIST_HEADER ListHead,
+ PSINGLE_LIST_ENTRY Entry
+ )
+{
+ Entry->Next = ListHead->s.Next.Next;
+ ListHead->s.Next.Next = Entry;
+ ListHead->s.Depth++;
+ ListHead->s.Sequence++;
+}
+
+
+/*
+ *VOID
+ *RemoveEntryList (
+ * PLIST_ENTRY Entry
+ * );
+ *
+ * FUNCTION:
+ * Removes an entry from a double linked list
+ *
+ * ARGUMENTS:
+ * ListEntry = Entry to remove
+ */
+#define RemoveEntryList(ListEntry) \
+{ \
+ PLIST_ENTRY OldFlink; \
+ PLIST_ENTRY OldBlink; \
+ assert((ListEntry) != NULL); \
+ assert((ListEntry)->Blink!=NULL); \
+ assert((ListEntry)->Blink->Flink == (ListEntry)); \
+ assert((ListEntry)->Flink != NULL); \
+ assert((ListEntry)->Flink->Blink == (ListEntry)); \
+ OldFlink = (ListEntry)->Flink; \
+ OldBlink = (ListEntry)->Blink; \
+ OldFlink->Blink = OldBlink; \
+ OldBlink->Flink = OldFlink; \
+ (ListEntry)->Flink = NULL; \
+ (ListEntry)->Blink = NULL; \
+}
+
+
+/*
+ * PLIST_ENTRY
+ * RemoveHeadList (
+ * PLIST_ENTRY ListHead
+ * );
+ *
+ * FUNCTION:
+ * Removes the head entry from a double linked list
+ *
+ * ARGUMENTS:
+ * ListHead = Head of the list
+ *
+ * RETURNS:
+ * The removed entry
+ */
+/*
+#define RemoveHeadList(ListHead) \
+ (ListHead)->Flink; \
+ {RemoveEntryList((ListHead)->Flink)}
+*/
+/*
+PLIST_ENTRY
+RemoveHeadList (
+ PLIST_ENTRY ListHead
+ );
+*/
+
+static
+inline
+PLIST_ENTRY
+RemoveHeadList (
+ PLIST_ENTRY ListHead
+ )
+{
+ PLIST_ENTRY Old;
+ PLIST_ENTRY OldFlink;
+ PLIST_ENTRY OldBlink;
+
+ Old = ListHead->Flink;
+
+ OldFlink = ListHead->Flink->Flink;
+ OldBlink = ListHead->Flink->Blink;
+ OldFlink->Blink = OldBlink;
+ OldBlink->Flink = OldFlink;
+ if (Old != ListHead)
+ {
+ Old->Flink = NULL;
+ Old->Blink = NULL;
+ }
+
+ return(Old);
+}
+
+
+/*
+ * PLIST_ENTRY
+ * RemoveTailList (
+ * PLIST_ENTRY ListHead
+ * );
+ *
+ * FUNCTION:
+ * Removes the tail entry from a double linked list
+ *
+ * ARGUMENTS:
+ * ListHead = Head of the list
+ *
+ * RETURNS:
+ * The removed entry
+ */
+/*
+#define RemoveTailList(ListHead) \
+ (ListHead)->Blink; \
+ {RemoveEntryList((ListHead)->Blink)}
+*/
+/*
+PLIST_ENTRY
+RemoveTailList (
+ PLIST_ENTRY ListHead
+ );
+*/
+
+static
+inline
+PLIST_ENTRY
+RemoveTailList (
+ PLIST_ENTRY ListHead
+ )
+{
+ PLIST_ENTRY Old;
+ PLIST_ENTRY OldFlink;
+ PLIST_ENTRY OldBlink;
+
+ Old = ListHead->Blink;
+
+ OldFlink = ListHead->Blink->Flink;
+ OldBlink = ListHead->Blink->Blink;
+ OldFlink->Blink = OldBlink;
+ OldBlink->Flink = OldFlink;
+ if (Old != ListHead)
+ {
+ Old->Flink = NULL;
+ Old->Blink = NULL;
+ }
+
+ return(Old);
+}
+
+
+NTSTATUS
+STDCALL
+RtlAddAtomToAtomTable (
+ IN PRTL_ATOM_TABLE AtomTable,
+ IN PWSTR AtomName,
+ OUT PRTL_ATOM Atom
+ );
+
+PVOID STDCALL
+RtlAllocateHeap (
+ HANDLE Heap,
+ ULONG Flags,
+ ULONG Size
+ );
+
+WCHAR
+STDCALL
+RtlAnsiCharToUnicodeChar (
+ CHAR AnsiChar
+ );
+
+ULONG
+STDCALL
+RtlAnsiStringToUnicodeSize (
+ PANSI_STRING AnsiString
+ );
+
+NTSTATUS
+STDCALL
+RtlAnsiStringToUnicodeString (
+ PUNICODE_STRING DestinationString,
+ PANSI_STRING SourceString,
+ BOOLEAN AllocateDestinationString
+ );
+
+NTSTATUS
+STDCALL
+RtlAppendAsciizToString(
+ PSTRING Destination,
+ PCSZ Source
+ );
+
+NTSTATUS
+STDCALL
+RtlAppendStringToString (
+ PSTRING Destination,
+ PSTRING Source
+ );
+
+NTSTATUS
+STDCALL
+RtlAppendUnicodeStringToString (
+ PUNICODE_STRING Destination,
+ PUNICODE_STRING Source
+ );
+
+NTSTATUS
+STDCALL
+RtlAppendUnicodeToString (
+ PUNICODE_STRING Destination,
+ PWSTR Source
+ );
+
+BOOLEAN
+STDCALL
+RtlAreBitsClear (
+ PRTL_BITMAP BitMapHeader,
+ ULONG StartingIndex,
+ ULONG Length
+ );
+
+BOOLEAN
+STDCALL
+RtlAreBitsSet (
+ PRTL_BITMAP BitMapHeader,
+ ULONG StartingIndex,
+ ULONG Length
+ );
+
+VOID
+STDCALL
+RtlAssert (
+ PVOID FailedAssertion,
+ PVOID FileName,
+ ULONG LineNumber,
+ PCHAR Message
+ );
+
+NTSTATUS
+STDCALL
+RtlCharToInteger (
+ PCSZ String,
+ ULONG Base,
+ PULONG Value
+ );
+
+NTSTATUS
+STDCALL
+RtlCheckRegistryKey (
+ ULONG RelativeTo,
+ PWSTR Path
+ );
+
+VOID
+STDCALL
+RtlClearAllBits (
+ IN PRTL_BITMAP BitMapHeader
+ );
+
+VOID
+STDCALL
+RtlClearBits (
+ IN PRTL_BITMAP BitMapHeader,
+ IN ULONG StartingIndex,
+ IN ULONG NumberToClear
+ );
+
+DWORD
+STDCALL
+RtlCompactHeap (
+ HANDLE hheap,
+ DWORD flags
+ );
+
+ULONG
+STDCALL
+RtlCompareMemory (
+ PVOID Source1,
+ PVOID Source2,
+ ULONG Length
+ );
+
+LONG
+STDCALL
+RtlCompareString (
+ PSTRING String1,
+ PSTRING String2,
+ BOOLEAN CaseInsensitive
+ );
+
+LONG
+STDCALL
+RtlCompareUnicodeString (
+ PUNICODE_STRING String1,
+ PUNICODE_STRING String2,
+ BOOLEAN BaseInsensitive
+ );
+
+NTSTATUS STDCALL
+RtlCompressBuffer(IN USHORT CompressionFormatAndEngine,
+ IN PUCHAR UncompressedBuffer,
+ IN ULONG UncompressedBufferSize,
+ OUT PUCHAR CompressedBuffer,
+ IN ULONG CompressedBufferSize,
+ IN ULONG UncompressedChunkSize,
+ OUT PULONG FinalCompressedSize,
+ IN PVOID WorkSpace);
+
+NTSTATUS STDCALL
+RtlCompressChunks(IN PUCHAR UncompressedBuffer,
+ IN ULONG UncompressedBufferSize,
+ OUT PUCHAR CompressedBuffer,
+ IN ULONG CompressedBufferSize,
+ IN OUT PCOMPRESSED_DATA_INFO CompressedDataInfo,
+ IN ULONG CompressedDataInfoLength,
+ IN PVOID WorkSpace);
+
+LARGE_INTEGER STDCALL
+RtlConvertLongToLargeInteger(IN LONG SignedInteger);
+
+NTSTATUS STDCALL
+RtlConvertSidToUnicodeString(IN OUT PUNICODE_STRING String,
+ IN PSID Sid,
+ IN BOOLEAN AllocateString);
+
+LARGE_INTEGER STDCALL
+RtlConvertUlongToLargeInteger(IN ULONG UnsignedInteger);
+
+#if 0
+VOID
+RtlCopyBytes (
+ PVOID Destination,
+ CONST VOID * Source,
+ ULONG Length
+ );
+
+VOID
+RtlCopyMemory (
+ VOID * Destination,
+ CONST VOID * Source,
+ ULONG Length
+ );
+#endif
+
+#define RtlCopyMemory(Destination,Source,Length) \
+ memcpy((Destination),(Source),(Length))
+
+#define RtlCopyBytes RtlCopyMemory
+
+VOID STDCALL
+RtlCopyLuid(IN PLUID LuidDest,
+ IN PLUID LuidSrc);
+
+VOID STDCALL
+RtlCopyLuidAndAttributesArray(ULONG Count,
+ PLUID_AND_ATTRIBUTES Src,
+ PLUID_AND_ATTRIBUTES Dest);
+
+NTSTATUS STDCALL
+RtlCopySid(ULONG BufferLength,
+ PSID Dest,
+ PSID Src);
+
+NTSTATUS STDCALL
+RtlCopySidAndAttributesArray(ULONG Count,
+ PSID_AND_ATTRIBUTES Src,
+ ULONG SidAreaSize,
+ PSID_AND_ATTRIBUTES Dest,
+ PVOID SidArea,
+ PVOID* RemainingSidArea,
+ PULONG RemainingSidAreaSize);
+
+VOID STDCALL
+RtlCopyString(PSTRING DestinationString,
+ PSTRING SourceString);
+
+VOID STDCALL
+RtlCopyUnicodeString(PUNICODE_STRING DestinationString,
+ PUNICODE_STRING SourceString);
+
+NTSTATUS STDCALL
+RtlCreateAtomTable(IN ULONG TableSize,
+ IN OUT PRTL_ATOM_TABLE *AtomTable);
+
+HANDLE
+STDCALL
+RtlCreateHeap (
+ ULONG Flags,
+ PVOID BaseAddress,
+ ULONG SizeToReserve,
+ ULONG SizeToCommit,
+ PVOID Unknown,
+ PRTL_HEAP_DEFINITION Definition
+ );
+
+NTSTATUS
+STDCALL
+RtlCreateRegistryKey (
+ ULONG RelativeTo,
+ PWSTR Path
+ );
+
+NTSTATUS
+STDCALL
+RtlCreateSecurityDescriptor (
+ PSECURITY_DESCRIPTOR SecurityDescriptor,
+ ULONG Revision
+ );
+
+BOOLEAN
+STDCALL
+RtlCreateUnicodeString (
+ OUT PUNICODE_STRING Destination,
+ IN PWSTR Source
+ );
+
+BOOLEAN
+STDCALL
+RtlCreateUnicodeStringFromAsciiz (
+ OUT PUNICODE_STRING Destination,
+ IN PCSZ Source
+ );
+
+NTSTATUS
+STDCALL
+RtlCustomCPToUnicodeN (
+ PRTL_NLS_DATA NlsData,
+ PWCHAR UnicodeString,
+ ULONG UnicodeSize,
+ PULONG ResultSize,
+ PCHAR CustomString,
+ ULONG CustomSize
+ );
+
+NTSTATUS STDCALL
+RtlDecompressBuffer(IN USHORT CompressionFormat,
+ OUT PUCHAR UncompressedBuffer,
+ IN ULONG UncompressedBufferSize,
+ IN PUCHAR CompressedBuffer,
+ IN ULONG CompressedBufferSize,
+ OUT PULONG FinalUncompressedSize);
+
+NTSTATUS STDCALL
+RtlDecompressChunks(OUT PUCHAR UncompressedBuffer,
+ IN ULONG UncompressedBufferSize,
+ IN PUCHAR CompressedBuffer,
+ IN ULONG CompressedBufferSize,
+ IN PUCHAR CompressedTail,
+ IN ULONG CompressedTailSize,
+ IN PCOMPRESSED_DATA_INFO CompressedDataInfo);
+
+NTSTATUS STDCALL
+RtlDecompressFragment(IN USHORT CompressionFormat,
+ OUT PUCHAR UncompressedFragment,
+ IN ULONG UncompressedFragmentSize,
+ IN PUCHAR CompressedBuffer,
+ IN ULONG CompressedBufferSize,
+ IN ULONG FragmentOffset,
+ OUT PULONG FinalUncompressedSize,
+ IN PVOID WorkSpace);
+
+NTSTATUS STDCALL
+RtlDeleteAtomFromAtomTable(IN PRTL_ATOM_TABLE AtomTable,
+ IN RTL_ATOM Atom);
+
+NTSTATUS STDCALL
+RtlDeleteRegistryValue(IN ULONG RelativeTo,
+ IN PWSTR Path,
+ IN PWSTR ValueName);
+
+NTSTATUS STDCALL
+RtlDescribeChunk(IN USHORT CompressionFormat,
+ IN OUT PUCHAR *CompressedBuffer,
+ IN PUCHAR EndOfCompressedBufferPlus1,
+ OUT PUCHAR *ChunkBuffer,
+ OUT PULONG ChunkSize);
+
+NTSTATUS STDCALL
+RtlDestroyAtomTable(IN PRTL_ATOM_TABLE AtomTable);
+
+BOOL STDCALL
+RtlDestroyHeap(HANDLE hheap);
+
+NTSTATUS
+STDCALL
+RtlDowncaseUnicodeString (
+ IN OUT PUNICODE_STRING DestinationString,
+ IN PUNICODE_STRING SourceString,
+ IN BOOLEAN AllocateDestinationString
+ );
+
+NTSTATUS
+STDCALL
+RtlEmptyAtomTable (
+ IN PRTL_ATOM_TABLE AtomTable,
+ IN BOOLEAN DeletePinned
+ );
+
+LARGE_INTEGER
+STDCALL
+RtlEnlargedIntegerMultiply (
+ LONG Multiplicand,
+ LONG Multiplier
+ );
+
+ULONG
+STDCALL
+RtlEnlargedUnsignedDivide (
+ ULARGE_INTEGER Dividend,
+ ULONG Divisor,
+ PULONG Remainder
+ );
+
+LARGE_INTEGER
+STDCALL
+RtlEnlargedUnsignedMultiply (
+ ULONG Multiplicand,
+ ULONG Multiplier
+ );
+
+BOOLEAN STDCALL
+RtlEqualLuid(IN PLUID Luid1,
+ IN PLUID Luid2);
+
+BOOLEAN
+STDCALL
+RtlEqualString (
+ PSTRING String1,
+ PSTRING String2,
+ BOOLEAN CaseInSensitive
+ );
+
+BOOLEAN
+STDCALL
+RtlEqualUnicodeString (
+ PUNICODE_STRING String1,
+ PUNICODE_STRING String2,
+ BOOLEAN CaseInSensitive
+ );
+
+LARGE_INTEGER
+STDCALL
+RtlExtendedIntegerMultiply (
+ LARGE_INTEGER Multiplicand,
+ LONG Multiplier
+ );
+
+LARGE_INTEGER
+STDCALL
+RtlExtendedLargeIntegerDivide (
+ LARGE_INTEGER Dividend,
+ ULONG Divisor,
+ PULONG Remainder
+ );
+
+LARGE_INTEGER
+STDCALL
+RtlExtendedMagicDivide (
+ LARGE_INTEGER Dividend,
+ LARGE_INTEGER MagicDivisor,
+ CCHAR ShiftCount
+ );
+
+VOID
+STDCALL
+RtlFillMemory (
+ PVOID Destination,
+ ULONG Length,
+ UCHAR Fill
+ );
+
+VOID
+STDCALL
+RtlFillMemoryUlong (
+ PVOID Destination,
+ ULONG Length,
+ ULONG Fill
+ );
+
+ULONG
+STDCALL
+RtlFindClearBits (
+ PRTL_BITMAP BitMapHeader,
+ ULONG NumberToFind,
+ ULONG HintIndex
+ );
+
+ULONG
+STDCALL
+RtlFindClearBitsAndSet (
+ PRTL_BITMAP BitMapHeader,
+ ULONG NumberToFind,
+ ULONG HintIndex
+ );
+
+ULONG
+STDCALL
+RtlFindFirstRunClear (
+ PRTL_BITMAP BitMapHeader,
+ PULONG StartingIndex
+ );
+
+ULONG
+STDCALL
+RtlFindFirstRunSet (
+ PRTL_BITMAP BitMapHeader,
+ PULONG StartingIndex
+ );
+
+ULONG
+STDCALL
+RtlFindLongestRunClear (
+ PRTL_BITMAP BitMapHeader,
+ PULONG StartingIndex
+ );
+
+ULONG
+STDCALL
+RtlFindLongestRunSet (
+ PRTL_BITMAP BitMapHeader,
+ PULONG StartingIndex
+ );
+
+NTSTATUS
+STDCALL
+RtlFindMessage (
+ IN PVOID BaseAddress,
+ IN ULONG Type,
+ IN ULONG Language,
+ IN ULONG MessageId,
+ OUT PRTL_MESSAGE_RESOURCE_ENTRY *MessageResourceEntry
+ );
+
+ULONG
+STDCALL
+RtlFindSetBits (
+ PRTL_BITMAP BitMapHeader,
+ ULONG NumberToFind,
+ ULONG HintIndex
+ );
+
+ULONG
+STDCALL
+RtlFindSetBitsAndClear (
+ PRTL_BITMAP BitMapHeader,
+ ULONG NumberToFind,
+ ULONG HintIndex
+ );
+
+NTSTATUS
+STDCALL
+RtlFormatCurrentUserKeyPath (
+ IN OUT PUNICODE_STRING KeyPath
+ );
+
+VOID
+STDCALL
+RtlFreeAnsiString (
+ PANSI_STRING AnsiString
+ );
+
+BOOLEAN
+STDCALL
+RtlFreeHeap (
+ HANDLE Heap,
+ ULONG Flags,
+ PVOID Address
+ );
+
+VOID
+STDCALL
+RtlFreeOemString (
+ POEM_STRING OemString
+ );
+
+VOID
+STDCALL
+RtlFreeUnicodeString (
+ PUNICODE_STRING UnicodeString
+ );
+
+VOID STDCALL
+RtlGenerate8dot3Name(IN PUNICODE_STRING Name,
+ IN BOOLEAN AllowExtendedCharacters,
+ IN OUT PGENERATE_NAME_CONTEXT Context,
+ OUT PUNICODE_STRING Name8dot3);
+
+VOID
+RtlGetCallersAddress (
+ PVOID * CallersAddress
+ );
+
+NTSTATUS STDCALL
+RtlGetCompressionWorkSpaceSize(IN USHORT CompressionFormatAndEngine,
+ OUT PULONG CompressBufferAndWorkSpaceSize,
+ OUT PULONG CompressFragmentWorkSpaceSize);
+
+VOID
+STDCALL
+RtlGetDefaultCodePage (
+ PUSHORT AnsiCodePage,
+ PUSHORT OemCodePage
+ );
+
+#define RtlGetProcessHeap() (NtCurrentPeb()->ProcessHeap)
+
+PVOID
+STDCALL
+RtlImageDirectoryEntryToData (
+ PVOID BaseAddress,
+ BOOLEAN bFlag,
+ ULONG Directory,
+ PULONG Size
+ );
+
+PIMAGE_NT_HEADERS
+STDCALL
+RtlImageNtHeader (
+ PVOID BaseAddress
+ );
+
+PIMAGE_SECTION_HEADER
+STDCALL
+RtlImageRvaToSection (
+ PIMAGE_NT_HEADERS NtHeader,
+ PVOID BaseAddress,
+ ULONG Rva
+ );
+
+ULONG
+STDCALL
+RtlImageRvaToVa (
+ PIMAGE_NT_HEADERS NtHeader,
+ PVOID BaseAddress,
+ ULONG Rva,
+ PIMAGE_SECTION_HEADER *SectionHeader
+ );
+
+VOID
+STDCALL
+RtlInitAnsiString (
+ PANSI_STRING DestinationString,
+ PCSZ SourceString
+ );
+
+VOID
+STDCALL
+RtlInitString (
+ PSTRING DestinationString,
+ PCSZ SourceString
+ );
+
+VOID
+STDCALL
+RtlInitUnicodeString (
+ PUNICODE_STRING DestinationString,
+ PCWSTR SourceString
+ );
+
+/*
+VOID
+InitializeUnicodeString (
+ PUNICODE_STRING DestinationString,
+ USHORT Lenght,
+ USHORT MaximumLength,
+ PCWSTR Buffer
+ );
+
+ Initialize an UNICODE_STRING from its fields. Use when you know the values of
+ all the fields in advance
+
+ */
+
+#define InitializeUnicodeString(__PDEST_STRING__,__LENGTH__,__MAXLENGTH__,__BUFFER__) \
+{ \
+ (__PDEST_STRING__)->Length = (__LENGTH__); \
+ (__PDEST_STRING__)->MaximumLength = (__MAXLENGTH__); \
+ (__PDEST_STRING__)->Buffer = (__BUFFER__); \
+}
+
+/*
+VOID
+RtlInitUnicodeStringFromLiteral (
+ PUNICODE_STRING DestinationString,
+ PCWSTR SourceString
+ );
+
+ Initialize an UNICODE_STRING from a wide string literal. WARNING: use only with
+ string literals and statically initialized arrays, it will calculate the wrong
+ length otherwise
+
+ */
+
+#define RtlInitUnicodeStringFromLiteral(__PDEST_STRING__,__SOURCE_STRING__) \
+ InitializeUnicodeString( \
+ (__PDEST_STRING__), \
+ sizeof(__SOURCE_STRING__) - sizeof(WCHAR), \
+ sizeof(__SOURCE_STRING__), \
+ (__SOURCE_STRING__) \
+ )
+
+/*
+ Static initializer for UNICODE_STRING variables. Usage:
+
+ UNICODE_STRING wstr = UNICODE_STRING_INITIALIZER(L"string");
+
+*/
+
+#define UNICODE_STRING_INITIALIZER(__SOURCE_STRING__) \
+{ \
+ sizeof((__SOURCE_STRING__)) - sizeof(WCHAR), \
+ sizeof((__SOURCE_STRING__)), \
+ (__SOURCE_STRING__) \
+}
+
+/*
+ Initializer for empty UNICODE_STRING variables. Usage:
+
+ UNICODE_STRING wstr = EMPTY_UNICODE_STRING;
+
+*/
+#define EMPTY_UNICODE_STRING {0, 0, NULL}
+
+VOID
+STDCALL
+RtlInitializeBitMap (
+ IN OUT PRTL_BITMAP BitMapHeader,
+ IN PULONG BitMapBuffer,
+ IN ULONG SizeOfBitMap
+ );
+
+NTSTATUS
+STDCALL
+RtlInitializeContext (
+ IN HANDLE ProcessHandle,
+ IN PCONTEXT Context,
+ IN PVOID Parameter,
+ IN PTHREAD_START_ROUTINE StartAddress,
+ IN OUT PINITIAL_TEB InitialTeb
+ );
+
+VOID
+STDCALL
+RtlInitializeGenericTable (
+ IN OUT PRTL_GENERIC_TABLE Table,
+ IN PVOID CompareRoutine,
+ IN PVOID AllocateRoutine,
+ IN PVOID FreeRoutine,
+ IN ULONG UserParameter
+ );
+
+PVOID
+STDCALL
+RtlInsertElementGenericTable (
+ IN OUT PRTL_GENERIC_TABLE Table,
+ IN PVOID Element,
+ IN ULONG ElementSize,
+ IN ULONG Unknown4
+ );
+
+NTSTATUS
+STDCALL
+RtlIntegerToChar (
+ IN ULONG Value,
+ IN ULONG Base,
+ IN ULONG Length,
+ IN OUT PCHAR String
+ );
+
+NTSTATUS
+STDCALL
+RtlIntegerToUnicodeString (
+ IN ULONG Value,
+ IN ULONG Base,
+ IN OUT PUNICODE_STRING String
+ );
+
+BOOLEAN
+STDCALL
+RtlIsGenericTableEmpty (
+ IN PRTL_GENERIC_TABLE Table
+ );
+
+BOOLEAN STDCALL
+RtlIsNameLegalDOS8Dot3(IN PUNICODE_STRING UnicodeName,
+ IN PANSI_STRING AnsiName,
+ OUT PBOOLEAN SpacesFound);
+
+LARGE_INTEGER
+STDCALL
+RtlLargeIntegerAdd (
+ LARGE_INTEGER Addend1,
+ LARGE_INTEGER Addend2
+ );
+
+/*
+ * VOID
+ * RtlLargeIntegerAnd (
+ * PLARGE_INTEGER Result,
+ * LARGE_INTEGER Source,
+ * LARGE_INTEGER Mask
+ * );
+ */
+#define RtlLargeIntegerAnd(Result, Source, Mask) \
+{ \
+ Result.HighPart = Source.HighPart & Mask.HighPart; \
+ Result.LowPart = Source.LowPart & Mask.LowPart; \
+}
+
+LARGE_INTEGER
+STDCALL
+RtlLargeIntegerArithmeticShift (
+ LARGE_INTEGER LargeInteger,
+ CCHAR ShiftCount
+ );
+
+LARGE_INTEGER
+STDCALL
+RtlLargeIntegerDivide (
+ LARGE_INTEGER Dividend,
+ LARGE_INTEGER Divisor,
+ PLARGE_INTEGER Remainder
+ );
+
+/*
+ * BOOLEAN
+ * RtlLargeIntegerEqualTo (
+ * LARGE_INTEGER Operand1,
+ * LARGE_INTEGER Operand2
+ * );
+ */
+#define RtlLargeIntegerEqualTo(X,Y) \
+ (!(((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)))
+
+/*
+ * BOOLEAN
+ * RtlLargeIntegerEqualToZero (
+ * LARGE_INTEGER Operand
+ * );
+ */
+#define RtlLargeIntegerEqualToZero(X) \
+ (!((X).LowPart | (X).HighPart))
+
+/*
+ * BOOLEAN
+ * RtlLargeIntegerGreaterThan (
+ * LARGE_INTEGER Operand1,
+ * LARGE_INTEGER Operand2
+ * );
+ */
+#define RtlLargeIntegerGreaterThan(X,Y) \
+ ((((X).HighPart == (Y).HighPart) && ((X).LowPart > (Y).LowPart)) || \
+ ((X).HighPart > (Y).HighPart))
+
+/*
+ * BOOLEAN
+ * RtlLargeIntegerGreaterThanOrEqualTo (
+ * LARGE_INTEGER Operand1,
+ * LARGE_INTEGER Operand2
+ * );
+ */
+#define RtlLargeIntegerGreaterThanOrEqualTo(X,Y) \
+ ((((X).HighPart == (Y).HighPart) && ((X).LowPart >= (Y).LowPart)) || \
+ ((X).HighPart > (Y).HighPart))
+
+/*
+ * BOOLEAN
+ * RtlLargeIntegerGreaterThanOrEqualToZero (
+ * LARGE_INTEGER Operand1
+ * );
+ */
+#define RtlLargeIntegerGreaterOrEqualToZero(X) \
+ ((X).HighPart >= 0)
+
+/*
+ * BOOLEAN
+ * RtlLargeIntegerGreaterThanZero (
+ * LARGE_INTEGER Operand1
+ * );
+ */
+#define RtlLargeIntegerGreaterThanZero(X) \
+ ((((X).HighPart == 0) && ((X).LowPart > 0)) || \
+ ((X).HighPart > 0 ))
+
+/*
+ * BOOLEAN
+ * RtlLargeIntegerLessThan (
+ * LARGE_INTEGER Operand1,
+ * LARGE_INTEGER Operand2
+ * );
+ */
+#define RtlLargeIntegerLessThan(X,Y) \
+ ((((X).HighPart == (Y).HighPart) && ((X).LowPart < (Y).LowPart)) || \
+ ((X).HighPart < (Y).HighPart))
+
+/*
+ * BOOLEAN
+ * RtlLargeIntegerLessThanOrEqualTo (
+ * LARGE_INTEGER Operand1,
+ * LARGE_INTEGER Operand2
+ * );
+ */
+#define RtlLargeIntegerLessThanOrEqualTo(X,Y) \
+ ((((X).HighPart == (Y).HighPart) && ((X).LowPart <= (Y).LowPart)) || \
+ ((X).HighPart < (Y).HighPart))
+
+/*
+ * BOOLEAN
+ * RtlLargeIntegerLessThanOrEqualToZero (
+ * LARGE_INTEGER Operand
+ * );
+ */
+#define RtlLargeIntegerLessOrEqualToZero(X) \
+ (((X).HighPart < 0) || !((X).LowPart | (X).HighPart))
+
+/*
+ * BOOLEAN
+ * RtlLargeIntegerLessThanZero (
+ * LARGE_INTEGER Operand
+ * );
+ */
+#define RtlLargeIntegerLessThanZero(X) \
+ (((X).HighPart < 0))
+
+LARGE_INTEGER
+STDCALL
+RtlLargeIntegerNegate (
+ LARGE_INTEGER Subtrahend
+ );
+
+/*
+ * BOOLEAN
+ * RtlLargeIntegerNotEqualTo (
+ * LARGE_INTEGER Operand1,
+ * LARGE_INTEGER Operand2
+ * );
+ */
+#define RtlLargeIntegerNotEqualTo(X,Y) \
+ ((((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)))
+
+/*
+ * BOOLEAN
+ * RtlLargeIntegerNotEqualToZero (
+ * LARGE_INTEGER Operand
+ * );
+ */
+#define RtlLargeIntegerNotEqualToZero(X) \
+ (((X).LowPart | (X).HighPart))
+
+LARGE_INTEGER
+STDCALL
+RtlLargeIntegerShiftLeft (
+ LARGE_INTEGER LargeInteger,
+ CCHAR ShiftCount
+ );
+
+LARGE_INTEGER
+STDCALL
+RtlLargeIntegerShiftRight (
+ LARGE_INTEGER LargeInteger,
+ CCHAR ShiftCount
+ );
+
+LARGE_INTEGER
+STDCALL
+RtlLargeIntegerSubtract (
+ LARGE_INTEGER Minuend,
+ LARGE_INTEGER Subtrahend
+ );
+
+ULONG
+STDCALL
+RtlLengthSecurityDescriptor (
+ PSECURITY_DESCRIPTOR SecurityDescriptor
+ );
+
+BOOL
+STDCALL
+RtlLockHeap (
+ HANDLE hheap
+ );
+
+NTSTATUS
+STDCALL
+RtlLookupAtomInAtomTable (
+ IN PRTL_ATOM_TABLE AtomTable,
+ IN PWSTR AtomName,
+ OUT PRTL_ATOM Atom
+ );
+
+VOID STDCALL
+RtlMoveMemory (PVOID Destination, CONST VOID* Source, ULONG Length);
+
+NTSTATUS
+STDCALL
+RtlMultiByteToUnicodeN (
+ PWCHAR UnicodeString,
+ ULONG UnicodeSize,
+ PULONG ResultSize,
+ PCHAR MbString,
+ ULONG MbSize
+ );
+
+NTSTATUS
+STDCALL
+RtlMultiByteToUnicodeSize (
+ PULONG UnicodeSize,
+ PCHAR MbString,
+ ULONG MbSize
+ );
+
+DWORD
+STDCALL
+RtlNtStatusToDosError (
+ NTSTATUS StatusCode
+ );
+
+DWORD
+STDCALL
+RtlNtStatusToDosErrorNoTeb (
+ NTSTATUS StatusCode
+ );
+
+int
+STDCALL
+RtlNtStatusToPsxErrno (
+ NTSTATUS StatusCode
+ );
+
+ULONG
+STDCALL
+RtlNumberGenericTableElements (
+ IN PRTL_GENERIC_TABLE Table
+ );
+
+ULONG
+STDCALL
+RtlNumberOfClearBits (
+ PRTL_BITMAP BitMapHeader
+ );
+
+ULONG
+STDCALL
+RtlNumberOfSetBits (
+ PRTL_BITMAP BitMapHeader
+ );
+
+ULONG
+STDCALL
+RtlOemStringToUnicodeSize (
+ POEM_STRING AnsiString
+ );
+
+NTSTATUS
+STDCALL
+RtlOemStringToUnicodeString (
+ PUNICODE_STRING DestinationString,
+ POEM_STRING SourceString,
+ BOOLEAN AllocateDestinationString
+ );
+
+NTSTATUS
+STDCALL
+RtlOemToUnicodeN (
+ PWCHAR UnicodeString,
+ ULONG UnicodeSize,
+ PULONG ResultSize,
+ PCHAR OemString,
+ ULONG OemSize
+ );
+
+NTSTATUS
+STDCALL
+RtlOpenCurrentUser (
+ IN ACCESS_MASK DesiredAccess,
+ OUT PHANDLE KeyHandle
+ );
+
+NTSTATUS STDCALL
+RtlPinAtomInAtomTable (
+ IN PRTL_ATOM_TABLE AtomTable,
+ IN RTL_ATOM Atom
+ );
+
+BOOLEAN
+STDCALL
+RtlPrefixString (
+ PANSI_STRING String1,
+ PANSI_STRING String2,
+ BOOLEAN CaseInsensitive
+ );
+
+BOOLEAN
+STDCALL
+RtlPrefixUnicodeString (
+ PUNICODE_STRING String1,
+ PUNICODE_STRING String2,
+ BOOLEAN CaseInsensitive
+ );
+
+NTSTATUS
+STDCALL
+RtlQueryAtomInAtomTable (
+ IN PRTL_ATOM_TABLE AtomTable,
+ IN RTL_ATOM Atom,
+ IN OUT PULONG RefCount OPTIONAL,
+ IN OUT PULONG PinCount OPTIONAL,
+ IN OUT PWSTR AtomName OPTIONAL,
+ IN OUT PULONG NameLength OPTIONAL
+ );
+
+NTSTATUS
+STDCALL
+RtlQueryRegistryValues (
+ IN ULONG RelativeTo,
+ IN PWSTR Path,
+ IN PRTL_QUERY_REGISTRY_TABLE QueryTable,
+ IN PVOID Context,
+ IN PVOID Environment
+ );
+
+NTSTATUS
+STDCALL
+RtlQueryTimeZoneInformation (
+ IN OUT PTIME_ZONE_INFORMATION TimeZoneInformation
+ );
+
+VOID
+STDCALL
+RtlRaiseException (
+ IN PEXCEPTION_RECORD ExceptionRecord
+ );
+
+LPVOID
+STDCALL
+RtlReAllocateHeap (
+ HANDLE hheap,
+ DWORD flags,
+ LPVOID ptr,
+ DWORD size
+ );
+
+NTSTATUS STDCALL
+RtlReserveChunk(IN USHORT CompressionFormat,
+ IN OUT PUCHAR *CompressedBuffer,
+ IN PUCHAR EndOfCompressedBufferPlus1,
+ OUT PUCHAR *ChunkBuffer,
+ IN ULONG ChunkSize);
+
+/*
+ * VOID
+ * RtlRetrieveUlong (
+ * PULONG DestinationAddress,
+ * PULONG SourceAddress
+ * );
+ */
+#define RtlRetrieveUlong(DestAddress,SrcAddress) \
+ if ((ULONG)(SrcAddress) & LONG_MASK) \
+ { \
+ ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
+ ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
+ ((PUCHAR)(DestAddress))[2]=((PUCHAR)(SrcAddress))[2]; \
+ ((PUCHAR)(DestAddress))[3]=((PUCHAR)(SrcAddress))[3]; \
+ } \
+ else \
+ { \
+ *((PULONG)(DestAddress))=*((PULONG)(SrcAddress)); \
+ }
+
+/*
+ * VOID
+ * RtlRetrieveUshort (
+ * PUSHORT DestinationAddress,
+ * PUSHORT SourceAddress
+ * );
+ */
+#define RtlRetrieveUshort(DestAddress,SrcAddress) \
+ if ((ULONG)(SrcAddress) & SHORT_MASK) \
+ { \
+ ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
+ ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
+ } \
+ else \
+ { \
+ *((PUSHORT)(DestAddress))=*((PUSHORT)(SrcAddress)); \
+ }
+
+VOID
+STDCALL
+RtlSecondsSince1970ToTime (
+ ULONG SecondsSince1970,
+ PLARGE_INTEGER Time
+ );
+
+VOID
+STDCALL
+RtlSecondsSince1980ToTime (
+ ULONG SecondsSince1980,
+ PLARGE_INTEGER Time
+ );
+
+VOID
+STDCALL
+RtlSetAllBits (
+ IN PRTL_BITMAP BitMapHeader
+ );
+
+VOID
+STDCALL
+RtlSetBits (
+ PRTL_BITMAP BitMapHeader,
+ ULONG StartingIndex,
+ ULONG NumberToSet
+ );
+
+NTSTATUS
+STDCALL
+RtlSetDaclSecurityDescriptor (
+ PSECURITY_DESCRIPTOR SecurityDescriptor,
+ BOOLEAN DaclPresent,
+ PACL Dacl,
+ BOOLEAN DaclDefaulted
+ );
+
+NTSTATUS
+STDCALL
+RtlSetTimeZoneInformation (
+ IN OUT PTIME_ZONE_INFORMATION TimeZoneInformation
+ );
+
+DWORD
+STDCALL
+RtlSizeHeap (
+ HANDLE hheap,
+ DWORD flags,
+ PVOID pmem
+ );
+
+/*
+ * VOID
+ * RtlStoreUlong (
+ * PULONG Address,
+ * ULONG Value
+ * );
+ */
+#define RtlStoreUlong(Address,Value) \
+ if ((ULONG)(Address) & LONG_MASK) \
+ { \
+ ((PUCHAR)(Address))[LONG_LEAST_SIGNIFICANT_BIT]=(UCHAR)(FIRSTBYTE(Value)); \
+ ((PUCHAR)(Address))[LONG_3RD_MOST_SIGNIFICANT_BIT]=(UCHAR)(FIRSTBYTE(Value)); \
+ ((PUCHAR)(Address))[LONG_2ND_MOST_SIGNIFICANT_BIT]=(UCHAR)(THIRDBYTE(Value)); \
+ ((PUCHAR)(Address))[LONG_MOST_SIGNIFICANT_BIT]=(UCHAR)(FOURTHBYTE(Value)); \
+ } \
+ else \
+ { \
+ *((PULONG)(Address))=(ULONG)(Value); \
+ }
+
+/*
+ * VOID
+ * RtlStoreUshort (
+ * PUSHORT Address,
+ * USHORT Value
+ * );
+ */
+#define RtlStoreUshort(Address,Value) \
+ if ((ULONG)(Address) & SHORT_MASK) \
+ { \
+ ((PUCHAR)(Address))[SHORT_LEAST_SIGNIFICANT_BIT]=(UCHAR)(FIRSTBYTE(Value)); \
+ ((PUCHAR)(Address))[SHORT_MOST_SIGNIFICANT_BIT]=(UCHAR)(SECONDBYTE(Value)); \
+ } \
+ else \
+ { \
+ *((PUSHORT)(Address))=(USHORT)(Value); \
+ }
+
+BOOLEAN
+STDCALL
+RtlTimeFieldsToTime (
+ PTIME_FIELDS TimeFields,
+ PLARGE_INTEGER Time
+ );
+
+BOOLEAN
+STDCALL
+RtlTimeToSecondsSince1970 (
+ PLARGE_INTEGER Time,
+ PULONG SecondsSince1970
+ );
+
+BOOLEAN
+STDCALL
+RtlTimeToSecondsSince1980 (
+ PLARGE_INTEGER Time,
+ PULONG SecondsSince1980
+ );
+
+VOID
+STDCALL
+RtlTimeToTimeFields (
+ PLARGE_INTEGER Time,
+ PTIME_FIELDS TimeFields
+ );
+
+ULONG
+STDCALL
+RtlUnicodeStringToAnsiSize (
+ IN PUNICODE_STRING UnicodeString
+ );
+
+NTSTATUS
+STDCALL
+RtlUnicodeStringToAnsiString (
+ IN OUT PANSI_STRING DestinationString,
+ IN PUNICODE_STRING SourceString,
+ IN BOOLEAN AllocateDestinationString
+ );
+
+NTSTATUS
+STDCALL
+RtlUnicodeStringToInteger (
+ IN PUNICODE_STRING String,
+ IN ULONG Base,
+ OUT PULONG Value
+ );
+
+ULONG
+STDCALL
+RtlUnicodeStringToOemSize (
+ IN PUNICODE_STRING UnicodeString
+ );
+
+NTSTATUS
+STDCALL
+RtlUnicodeStringToCountedOemString (
+ IN OUT POEM_STRING DestinationString,
+ IN PUNICODE_STRING SourceString,
+ IN BOOLEAN AllocateDestinationString
+ );
+
+NTSTATUS
+STDCALL
+RtlUnicodeStringToOemString (
+ IN OUT POEM_STRING DestinationString,
+ IN PUNICODE_STRING SourceString,
+ IN BOOLEAN AllocateDestinationString
+ );
+
+NTSTATUS
+STDCALL
+RtlUnicodeToCustomCPN (
+ PRTL_NLS_DATA NlsData,
+ PCHAR MbString,
+ ULONG MbSize,
+ PULONG ResultSize,
+ PWCHAR UnicodeString,
+ ULONG UnicodeSize
+ );
+
+NTSTATUS
+STDCALL
+RtlUnicodeToMultiByteN (
+ PCHAR MbString,
+ ULONG MbSize,
+ PULONG ResultSize,
+ PWCHAR UnicodeString,
+ ULONG UnicodeSize
+ );
+
+NTSTATUS
+STDCALL
+RtlUnicodeToMultiByteSize (
+ PULONG MbSize,
+ PWCHAR UnicodeString,
+ ULONG UnicodeSize
+ );
+
+NTSTATUS
+STDCALL
+RtlUnicodeToOemN (
+ PCHAR OemString,
+ ULONG OemSize,
+ PULONG ResultSize,
+ PWCHAR UnicodeString,
+ ULONG UnicodeSize
+ );
+
+BOOL
+STDCALL
+RtlUnlockHeap (
+ HANDLE hheap
+ );
+
+VOID
+STDCALL
+RtlUnwind (
+ PEXCEPTION_REGISTRATION RegistrationFrame,
+ PVOID ReturnAddress,
+ PEXCEPTION_RECORD ExceptionRecord,
+ DWORD EaxValue
+ );
+
+WCHAR
+STDCALL
+RtlUpcaseUnicodeChar (
+ WCHAR Source
+ );
+
+NTSTATUS
+STDCALL
+RtlUpcaseUnicodeString (
+ IN OUT PUNICODE_STRING DestinationString,
+ IN PUNICODE_STRING SourceString,
+ IN BOOLEAN AllocateDestinationString
+ );
+
+NTSTATUS
+STDCALL
+RtlUpcaseUnicodeStringToAnsiString (
+ IN OUT PANSI_STRING DestinationString,
+ IN PUNICODE_STRING SourceString,
+ IN BOOLEAN AllocateDestinationString
+ );
+
+NTSTATUS
+STDCALL
+RtlUpcaseUnicodeStringToCountedOemString (
+ IN OUT POEM_STRING DestinationString,
+ IN PUNICODE_STRING SourceString,
+ IN BOOLEAN AllocateDestinationString
+ );
+
+NTSTATUS
+STDCALL
+RtlUpcaseUnicodeStringToOemString (
+ IN OUT POEM_STRING DestinationString,
+ IN PUNICODE_STRING SourceString,
+ IN BOOLEAN AllocateDestinationString
+ );
+
+NTSTATUS
+STDCALL
+RtlUpcaseUnicodeToCustomCPN (
+ PRTL_NLS_DATA NlsData,
+ PCHAR MbString,
+ ULONG MbSize,
+ PULONG ResultSize,
+ PWCHAR UnicodeString,
+ ULONG UnicodeSize
+ );
+
+NTSTATUS
+STDCALL
+RtlUpcaseUnicodeToMultiByteN (
+ PCHAR MbString,
+ ULONG MbSize,
+ PULONG ResultSize,
+ PWCHAR UnicodeString,
+ ULONG UnicodeSize
+ );
+
+NTSTATUS
+STDCALL
+RtlUpcaseUnicodeToOemN (
+ PCHAR OemString,
+ ULONG OemSize,
+ PULONG ResultSize,
+ PWCHAR UnicodeString,
+ ULONG UnicodeSize
+ );
+
+CHAR
+STDCALL
+RtlUpperChar (
+ CHAR Source
+ );
+
+VOID
+STDCALL
+RtlUpperString (
+ PSTRING DestinationString,
+ PSTRING SourceString
+ );
+
+BOOL
+STDCALL
+RtlValidateHeap (
+ HANDLE hheap,
+ DWORD flags,
+ PVOID pmem
+ );
+
+BOOLEAN
+STDCALL
+RtlValidSecurityDescriptor (
+ PSECURITY_DESCRIPTOR SecurityDescriptor
+ );
+
+BOOLEAN STDCALL
+RtlValidSid(IN PSID Sid);
+
+NTSTATUS
+STDCALL
+RtlWriteRegistryValue (
+ ULONG RelativeTo,
+ PWSTR Path,
+ PWSTR ValueName,
+ ULONG ValueType,
+ PVOID ValueData,
+ ULONG ValueLength
+ );
+
+VOID STDCALL
+RtlZeroMemory (PVOID Destination, ULONG Length);
+
+ULONG
+STDCALL
+RtlxAnsiStringToUnicodeSize (
+ IN PANSI_STRING AnsiString
+ );
+
+ULONG
+STDCALL
+RtlxOemStringToUnicodeSize (
+ IN POEM_STRING OemString
+ );
+
+ULONG
+STDCALL
+RtlxUnicodeStringToAnsiSize (
+ IN PUNICODE_STRING UnicodeString
+ );
+
+ULONG
+STDCALL
+RtlxUnicodeStringToOemSize (
+ IN PUNICODE_STRING UnicodeString
+ );
+
+
+/* Register io functions */
+
+UCHAR
+STDCALL
+READ_REGISTER_UCHAR (
+ PUCHAR Register
+ );
+
+USHORT
+STDCALL
+READ_REGISTER_USHORT (
+ PUSHORT Register
+ );
+
+ULONG
+STDCALL
+READ_REGISTER_ULONG (
+ PULONG Register
+ );
+
+VOID
+STDCALL
+READ_REGISTER_BUFFER_UCHAR (
+ PUCHAR Register,
+ PUCHAR Buffer,
+ ULONG Count
+ );
+
+VOID
+STDCALL
+READ_REGISTER_BUFFER_USHORT (
+ PUSHORT Register,
+ PUSHORT Buffer,
+ ULONG Count
+ );
+
+VOID
+STDCALL
+READ_REGISTER_BUFFER_ULONG (
+ PULONG Register,
+ PULONG Buffer,
+ ULONG Count
+ );
+
+VOID
+STDCALL
+WRITE_REGISTER_UCHAR (
+ PUCHAR Register,
+ UCHAR Value
+ );
+
+VOID
+STDCALL
+WRITE_REGISTER_USHORT (
+ PUSHORT Register,
+ USHORT Value
+ );
+
+VOID
+STDCALL
+WRITE_REGISTER_ULONG (
+ PULONG Register,
+ ULONG Value
+ );
+
+VOID
+STDCALL
+WRITE_REGISTER_BUFFER_UCHAR (
+ PUCHAR Register,
+ PUCHAR Buffer,
+ ULONG Count
+ );
+
+VOID
+STDCALL
+WRITE_REGISTER_BUFFER_USHORT (
+ PUSHORT Register,
+ PUSHORT Buffer,
+ ULONG Count
+ );
+
+VOID
+STDCALL
+WRITE_REGISTER_BUFFER_ULONG (
+ PULONG Register,
+ PULONG Buffer,
+ ULONG Count
+ );
+
+
+NTSTATUS STDCALL RtlCreateAcl(PACL Acl, ULONG AclSize, ULONG AclRevision);
+NTSTATUS STDCALL RtlQueryInformationAcl (PACL Acl, PVOID Information, ULONG InformationLength, ACL_INFORMATION_CLASS InformationClass);
+NTSTATUS STDCALL RtlSetInformationAcl (PACL Acl, PVOID Information, ULONG InformationLength, ACL_INFORMATION_CLASS InformationClass);
+BOOLEAN STDCALL RtlValidAcl (PACL Acl);
+
+NTSTATUS STDCALL RtlAddAccessAllowedAce(PACL Acl, ULONG Revision, ACCESS_MASK AccessMask, PSID Sid);
+NTSTATUS STDCALL RtlAddAccessDeniedAce(PACL Acl, ULONG Revision, ACCESS_MASK AccessMask, PSID Sid);
+NTSTATUS STDCALL RtlAddAce(PACL Acl, ULONG Revision, ULONG StartingIndex, PACE AceList, ULONG AceListLength);
+NTSTATUS STDCALL RtlAddAuditAccessAce (PACL Acl, ULONG Revision, ACCESS_MASK AccessMask, PSID Sid, BOOLEAN Success, BOOLEAN Failure);
+NTSTATUS STDCALL RtlDeleteAce(PACL Acl, ULONG AceIndex);
+BOOLEAN STDCALL RtlFirstFreeAce(PACL Acl, PACE* Ace);
+NTSTATUS STDCALL RtlGetAce(PACL Acl, ULONG AceIndex, PACE *Ace);
+
+NTSTATUS STDCALL RtlAbsoluteToSelfRelativeSD (PSECURITY_DESCRIPTOR AbsSD, PSECURITY_DESCRIPTOR RelSD, PULONG BufferLength);
+NTSTATUS STDCALL RtlMakeSelfRelativeSD (PSECURITY_DESCRIPTOR AbsSD, PSECURITY_DESCRIPTOR RelSD, PULONG BufferLength);
+NTSTATUS STDCALL RtlCreateSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, ULONG Revision);
+BOOLEAN STDCALL RtlValidSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor);
+ULONG STDCALL RtlLengthSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor);
+NTSTATUS STDCALL RtlSetDaclSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, BOOLEAN DaclPresent, PACL Dacl, BOOLEAN DaclDefaulted);
+NTSTATUS STDCALL RtlGetDaclSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PBOOLEAN DaclPresent, PACL* Dacl, PBOOLEAN DaclDefauted);
+NTSTATUS STDCALL RtlSetOwnerSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSID Owner, BOOLEAN OwnerDefaulted);
+NTSTATUS STDCALL RtlGetOwnerSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSID* Owner, PBOOLEAN OwnerDefaulted);
+NTSTATUS STDCALL RtlSetGroupSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSID Group, BOOLEAN GroupDefaulted);
+NTSTATUS STDCALL RtlGetGroupSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSID* Group, PBOOLEAN GroupDefaulted);
+NTSTATUS STDCALL RtlGetControlSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSECURITY_DESCRIPTOR_CONTROL Control, PULONG Revision);
+NTSTATUS STDCALL RtlSetSaclSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, BOOLEAN SaclPresent, PACL Sacl, BOOLEAN SaclDefaulted);
+NTSTATUS STDCALL RtlGetSaclSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PBOOLEAN SaclPresent, PACL* Sacl, PBOOLEAN SaclDefauted);
+NTSTATUS STDCALL RtlSelfRelativeToAbsoluteSD (PSECURITY_DESCRIPTOR RelSD,
+ PSECURITY_DESCRIPTOR AbsSD,
+ PDWORD AbsSDSize,
+ PACL Dacl,
+ PDWORD DaclSize,
+ PACL Sacl,
+ PDWORD SaclSize,
+ PSID Owner,
+ PDWORD OwnerSize,
+ PSID Group,
+ PDWORD GroupSize);
+
+NTSTATUS STDCALL RtlAllocateAndInitializeSid (PSID_IDENTIFIER_AUTHORITY IdentifierAuthority,
+ UCHAR SubAuthorityCount,
+ ULONG SubAuthority0,
+ ULONG SubAuthority1,
+ ULONG SubAuthority2,
+ ULONG SubAuthority3,
+ ULONG SubAuthority4,
+ ULONG SubAuthority5,
+ ULONG SubAuthority6,
+ ULONG SubAuthority7,
+ PSID *Sid);
+ULONG STDCALL RtlLengthRequiredSid (UCHAR SubAuthorityCount);
+PSID_IDENTIFIER_AUTHORITY STDCALL RtlIdentifierAuthoritySid (PSID Sid);
+NTSTATUS STDCALL RtlInitializeSid (PSID Sid, PSID_IDENTIFIER_AUTHORITY IdentifierAuthority, UCHAR SubAuthorityCount);
+PULONG STDCALL RtlSubAuthoritySid (PSID Sid, ULONG SubAuthority);
+BOOLEAN STDCALL RtlEqualPrefixSid (PSID Sid1, PSID Sid2);
+BOOLEAN STDCALL RtlEqualSid(PSID Sid1, PSID Sid2);
+PSID STDCALL RtlFreeSid (PSID Sid);
+ULONG STDCALL RtlLengthSid (PSID Sid);
+PULONG STDCALL RtlSubAuthoritySid (PSID Sid, ULONG SubAuthority);
+PUCHAR STDCALL RtlSubAuthorityCountSid (PSID Sid);
+BOOLEAN STDCALL RtlValidSid (PSID Sid);
+NTSTATUS STDCALL RtlConvertSidToUnicodeString (PUNICODE_STRING String, PSID Sid, BOOLEAN AllocateBuffer);
+
+BOOLEAN STDCALL RtlAreAllAccessesGranted (ACCESS_MASK GrantedAccess, ACCESS_MASK DesiredAccess);
+BOOLEAN STDCALL RtlAreAnyAccessesGranted (ACCESS_MASK GrantedAccess, ACCESS_MASK DesiredAccess);
+VOID STDCALL RtlMapGenericMask (PACCESS_MASK AccessMask, PGENERIC_MAPPING GenericMapping);
+
+
+/* functions exported from NTOSKRNL.EXE which are considered RTL */
+
+#if defined(__NTOSKRNL__) || defined(__NTDRIVER__) || defined(__NTHAL__) || defined(__NTDLL__) || defined(__NTAPP__)
+
+char *_itoa (int value, char *string, int radix);
+int _snprintf(char * buf, size_t cnt, const char *fmt, ...);
+int _snwprintf(wchar_t *buf, size_t cnt, const wchar_t *fmt, ...);
+int _stricmp(const char *s1, const char *s2);
+char * _strlwr(char *x);
+int _strnicmp(const char *s1, const char *s2, size_t n);
+char * _strnset(char* szToFill, int szFill, size_t sizeMaxFill);
+char * _strrev(char *s);
+char * _strset(char* szToFill, int szFill);
+char * _strupr(char *x);
+int _vsnprintf(char *buf, size_t cnt, const char *fmt, va_list args);
+int _wcsicmp (const wchar_t* cs, const wchar_t* ct);
+wchar_t * _wcslwr (wchar_t *x);
+int _wcsnicmp (const wchar_t * cs,const wchar_t * ct,size_t count);
+wchar_t* _wcsnset (wchar_t* wsToFill, wchar_t wcFill, size_t sizeMaxFill);
+wchar_t * _wcsrev(wchar_t *s);
+wchar_t *_wcsupr(wchar_t *x);
+
+int atoi(const char *str);
+long atol(const char *str);
+int isdigit(int c);
+int islower(int c);
+int isprint(int c);
+int isspace(int c);
+int isupper(int c);
+int isxdigit(int c);
+size_t mbstowcs (wchar_t *wcstr, const char *mbstr, size_t count);
+int mbtowc (wchar_t *wchar, const char *mbchar, size_t count);
+void * memchr(const void *s, int c, size_t n);
+void * memcpy(void *to, const void *from, size_t count);
+void * memmove(void *dest,const void *src, size_t count);
+void * memset(void *src, int val, size_t count);
+
+#if 0
+qsort
+#endif
+
+int rand(void);
+int sprintf(char * buf, const char *fmt, ...);
+void srand(unsigned seed);
+char * strcat(char *s, const char *append);
+char * strchr(const char *s, int c);
+int strcmp(const char *s1, const char *s2);
+char * strcpy(char *to, const char *from);
+size_t strlen(const char *str);
+char * strncat(char *dst, const char *src, size_t n);
+int strncmp(const char *s1, const char *s2, size_t n);
+char *strncpy(char *dst, const char *src, size_t n);
+char *strrchr(const char *s, int c);
+size_t strspn(const char *s1, const char *s2);
+char *strstr(const char *s, const char *find);
+int swprintf(wchar_t *buf, const wchar_t *fmt, ...);
+int tolower(int c);
+int toupper(int c);
+wchar_t towlower(wchar_t c);
+wchar_t towupper(wchar_t c);
+int vsprintf(char *buf, const char *fmt, va_list args);
+wchar_t * wcscat(wchar_t *dest, const wchar_t *src);
+wchar_t * wcschr(const wchar_t *str, wchar_t ch);
+int wcscmp(const wchar_t *cs, const wchar_t *ct);
+wchar_t* wcscpy(wchar_t* str1, const wchar_t* str2);
+size_t wcscspn(const wchar_t *str,const wchar_t *reject);
+size_t wcslen(const wchar_t *s);
+wchar_t * wcsncat(wchar_t *dest, const wchar_t *src, size_t count);
+int wcsncmp(const wchar_t *cs, const wchar_t *ct, size_t count);
+wchar_t * wcsncpy(wchar_t *dest, const wchar_t *src, size_t count);
+wchar_t * wcsrchr(const wchar_t *str, wchar_t ch);
+size_t wcsspn(const wchar_t *str,const wchar_t *accept);
+wchar_t *wcsstr(const wchar_t *s,const wchar_t *b);
+size_t wcstombs (char *mbstr, const wchar_t *wcstr, size_t count);
+int wctomb (char *mbchar, wchar_t wchar);
+
+#endif /* __NTOSKRNL__ || __NTDRIVER__ || __NTHAL__ || __NTDLL__ || __NTAPP__ */
+
+#endif /* __DDK_RTL_H */
--- /dev/null
+/* $Id: rtltypes.h,v 1.6 2002/09/08 10:47:45 chorns Exp $
+ *
+ */
+
+#ifndef __DDK_RTLTYPES_H
+#define __DDK_RTLTYPES_H
+
+
+#define COMPRESSION_FORMAT_NONE 0x0000
+#define COMPRESSION_FORMAT_DEFAULT 0x0001
+#define COMPRESSION_FORMAT_LZNT1 0x0002
+
+#define COMPRESSION_ENGINE_STANDARD 0x0000
+#define COMPRESSION_ENGINE_MAXIMUM 0x0100
+#define COMPRESSION_ENGINE_HIBER 0x0200
+
+
+typedef struct _INITIAL_TEB
+{
+ ULONG StackCommit;
+ ULONG StackReserve;
+ PVOID StackBase;
+ PVOID StackLimit;
+ PVOID StackAllocate;
+} INITIAL_TEB, *PINITIAL_TEB;
+
+typedef struct _CONTROLLER_OBJECT
+{
+ CSHORT Type;
+ CSHORT Size;
+ PVOID ControllerExtension;
+ KDEVICE_QUEUE DeviceWaitQueue;
+ ULONG Spare1;
+ LARGE_INTEGER Spare2;
+} CONTROLLER_OBJECT, *PCONTROLLER_OBJECT;
+
+typedef struct _STRING
+{
+ /*
+ * Length in bytes of the string stored in buffer
+ */
+ USHORT Length;
+
+ /*
+ * Maximum length of the string
+ */
+ USHORT MaximumLength;
+
+ /*
+ * String
+ */
+ PCHAR Buffer;
+} STRING, *PSTRING;
+
+typedef STRING ANSI_STRING;
+typedef PSTRING PANSI_STRING;
+
+typedef STRING OEM_STRING;
+typedef PSTRING POEM_STRING;
+
+
+typedef struct _TIME_FIELDS
+{
+ CSHORT Year;
+ CSHORT Month;
+ CSHORT Day;
+ CSHORT Hour;
+ CSHORT Minute;
+ CSHORT Second;
+ CSHORT Milliseconds;
+ CSHORT Weekday;
+} TIME_FIELDS, *PTIME_FIELDS;
+
+typedef struct _RTL_BITMAP
+{
+ ULONG SizeOfBitMap;
+ PULONG Buffer;
+} RTL_BITMAP, *PRTL_BITMAP;
+
+typedef struct _RTL_HEAP_DEFINITION
+{
+ ULONG Length;
+ ULONG Unknown[11];
+} RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
+
+typedef struct _RTL_ATOM_TABLE
+{
+ ULONG TableSize;
+ ULONG NumberOfAtoms;
+ PVOID Lock; /* fast mutex (kernel mode)/ critical section (user mode) */
+ PVOID HandleTable;
+ LIST_ENTRY Slot[0];
+} RTL_ATOM_TABLE, *PRTL_ATOM_TABLE;
+
+typedef struct _LB_RANGE
+{
+ UCHAR upper;
+ UCHAR lower;
+} LB_RANGE;
+
+typedef struct _RTL_NLS_DATA
+{
+ USHORT CodePage;
+ USHORT MaxCharacterSize; // SBCS = 1, DBCS = 2
+ WCHAR DefaultCharacter;
+ WCHAR char1;
+ WCHAR char2;
+ WCHAR char3;
+ USHORT DbcsFlag;
+ LB_RANGE LeadByteRange[6];
+ USHORT reserved;
+ PWCHAR MultiByteToUnicode;
+ PCHAR UnicodeToMultiByte;
+ PWCHAR DosMultiByteToUnicode;
+ PCHAR DbcsTags;
+} RTL_NLS_DATA, *PRTL_NLS_DATA;
+
+typedef struct _RTL_NLS_TABLE
+{
+ RTL_NLS_DATA OemInfo;
+ RTL_NLS_DATA AnsiInfo;
+ PWCHAR UpcaseTable;
+ PWCHAR DowncaseTable;
+} RTL_NLS_TABLE, *PRTL_NLS_TABLE;
+
+
+typedef struct _RTL_SPLAY_LINKS
+{
+ struct _RTL_SPLAY_LINKS *Parent;
+ struct _RTL_SPLAY_LINKS *LeftChild;
+ struct _RTL_SPLAY_LINKS *RightChild;
+} RTL_SPLAY_LINKS, *PRTL_SPLAY_LINKS;
+
+
+typedef struct _RTL_GENERIC_TABLE
+{
+ PVOID RootElement;
+ ULONG Unknown2;
+ ULONG Unknown3;
+ ULONG Unknown4;
+ ULONG Unknown5;
+ ULONG ElementCount;
+ PVOID CompareRoutine;
+ PVOID AllocateRoutine;
+ PVOID FreeRoutine;
+ ULONG UserParameter;
+} RTL_GENERIC_TABLE, *PRTL_GENERIC_TABLE;
+
+
+typedef struct _RTL_MESSAGE_RESOURCE_ENTRY
+{
+ USHORT Length;
+ USHORT Flags;
+ UCHAR Text[1];
+} RTL_MESSAGE_RESOURCE_ENTRY, *PRTL_MESSAGE_RESOURCE_ENTRY;
+
+typedef struct _RTL_MESSAGE_RESOURCE_BLOCK
+{
+ ULONG LowId;
+ ULONG HighId;
+ ULONG OffsetToEntries;
+} RTL_MESSAGE_RESOURCE_BLOCK, *PRTL_MESSAGE_RESOURCE_BLOCK;
+
+typedef struct _RTL_MESSAGE_RESOURCE_DATA
+{
+ ULONG NumberOfBlocks;
+ RTL_MESSAGE_RESOURCE_BLOCK Blocks[1];
+} RTL_MESSAGE_RESOURCE_DATA, *PRTL_MESSAGE_RESOURCE_DATA;
+
+
+typedef NTSTATUS STDCALL
+(*PRTL_QUERY_REGISTRY_ROUTINE)(PWSTR ValueName,
+ ULONG ValueType,
+ PVOID ValueData,
+ ULONG ValueLength,
+ PVOID Context,
+ PVOID EntryContext);
+
+typedef struct _RTL_QUERY_REGISTRY_TABLE
+{
+ PRTL_QUERY_REGISTRY_ROUTINE QueryRoutine;
+ ULONG Flags;
+ PWSTR Name;
+ PVOID EntryContext;
+ ULONG DefaultType;
+ PVOID DefaultData;
+ ULONG DefaultLength;
+} RTL_QUERY_REGISTRY_TABLE, *PRTL_QUERY_REGISTRY_TABLE;
+
+
+typedef struct _GENERATE_NAME_CONTEXT
+{
+ USHORT Checksum;
+ BOOLEAN CheckSumInserted;
+ UCHAR NameLength;
+ WCHAR NameBuffer[8];
+ ULONG ExtensionLength;
+ WCHAR ExtensionBuffer[4];
+ ULONG LastIndexValue;
+} GENERATE_NAME_CONTEXT, *PGENERATE_NAME_CONTEXT;
+
+
+typedef struct _COMPRESSED_DATA_INFO
+{
+ USHORT CompressionFormatAndEngine;
+ UCHAR CompressionUnitShift;
+ UCHAR ChunkShift;
+ UCHAR ClusterShift;
+ UCHAR Reserved;
+ USHORT NumberOfChunks;
+ ULONG CompressedChunkSizes[1];
+} COMPRESSED_DATA_INFO, *PCOMPRESSED_DATA_INFO;
+
+#endif /* __DDK_RTLTYPES_H */
--- /dev/null
+#ifndef _INCLUDE_DDK_SEFUNCS_H
+#define _INCLUDE_DDK_SEFUNCS_H
+/* $Id: sefuncs.h,v 1.19 2002/09/08 10:47:45 chorns Exp $ */
+
+BOOLEAN STDCALL
+SeAccessCheck(IN PSECURITY_DESCRIPTOR SecurityDescriptor,
+ IN PSECURITY_SUBJECT_CONTEXT SubjectSecurityContext,
+ IN BOOLEAN SubjectContextLocked,
+ IN ACCESS_MASK DesiredAccess,
+ IN ACCESS_MASK PreviouslyGrantedAccess,
+ OUT PPRIVILEGE_SET* Privileges OPTIONAL,
+ IN PGENERIC_MAPPING GenericMapping,
+ IN KPROCESSOR_MODE AccessMode,
+ OUT PACCESS_MODE GrantedAccess,
+ OUT PNTSTATUS AccessStatus);
+
+NTSTATUS STDCALL
+SeAppendPrivileges(IN PACCESS_STATE AccessState,
+ IN PPRIVILEGE_SET Privileges);
+
+NTSTATUS STDCALL
+SeAssignSecurity(IN PSECURITY_DESCRIPTOR ParentDescriptor OPTIONAL,
+ IN PSECURITY_DESCRIPTOR ExplicitDescriptor,
+ OUT PSECURITY_DESCRIPTOR* NewDescriptor,
+ IN BOOLEAN IsDirectoryObject,
+ IN PSECURITY_SUBJECT_CONTEXT SubjectContext,
+ IN PGENERIC_MAPPING GenericMapping,
+ IN POOL_TYPE PoolType);
+
+BOOLEAN STDCALL
+SeAuditingFileEvents(IN BOOLEAN AccessGranted,
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor);
+
+BOOLEAN STDCALL
+SeAuditingFileOrGlobalEvents(IN BOOLEAN AccessGranted,
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor,
+ IN PSECURITY_SUBJECT_CONTEXT SubjectContext);
+
+VOID STDCALL
+SeCaptureSubjectContext(OUT PSECURITY_SUBJECT_CONTEXT SubjectContext);
+
+NTSTATUS STDCALL
+SeCreateAccessState(OUT PACCESS_STATE AccessState,
+ IN PVOID AuxData,
+ IN ACCESS_MASK AccessMask,
+ IN PGENERIC_MAPPING Mapping);
+
+NTSTATUS STDCALL
+SeCreateClientSecurity(IN struct _ETHREAD *Thread,
+ IN PSECURITY_QUALITY_OF_SERVICE Qos,
+ IN BOOLEAN RemoteClient,
+ OUT PSECURITY_CLIENT_CONTEXT ClientContext);
+
+NTSTATUS STDCALL
+SeDeassignSecurity(IN OUT PSECURITY_DESCRIPTOR* SecurityDescriptor);
+
+VOID STDCALL
+SeDeleteAccessState(IN PACCESS_STATE AccessState);
+
+VOID STDCALL
+SeDeleteObjectAuditAlarm(IN PVOID Object,
+ IN HANDLE Handle);
+
+VOID STDCALL
+SeFreePrivileges(IN PPRIVILEGE_SET Privileges);
+
+VOID STDCALL
+SeImpersonateClient(IN PSECURITY_CLIENT_CONTEXT ClientContext,
+ IN struct _ETHREAD *ServerThread OPTIONAL);
+
+VOID STDCALL
+SeLockSubjectContext(IN PSECURITY_SUBJECT_CONTEXT SubjectContext);
+
+NTSTATUS STDCALL
+SeMarkLogonSessionForTerminationNotification(IN PLUID LogonId);
+
+VOID STDCALL
+SeOpenObjectAuditAlarm(IN PUNICODE_STRING ObjectTypeName,
+ IN PVOID Object OPTIONAL,
+ IN PUNICODE_STRING AbsoluteObjectName OPTIONAL,
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor,
+ IN PACCESS_STATE AccessState,
+ IN BOOLEAN ObjectCreated,
+ IN BOOLEAN AccessGranted,
+ IN KPROCESSOR_MODE AccessMode,
+ OUT PBOOLEAN GenerateOnClose);
+
+VOID STDCALL
+SeOpenObjectForDeleteAuditAlarm(IN PUNICODE_STRING ObjectTypeName,
+ IN PVOID Object OPTIONAL,
+ IN PUNICODE_STRING AbsoluteObjectName OPTIONAL,
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor,
+ IN PACCESS_STATE AccessState,
+ IN BOOLEAN ObjectCreated,
+ IN BOOLEAN AccessGranted,
+ IN KPROCESSOR_MODE AccessMode,
+ OUT PBOOLEAN GenerateOnClose);
+
+BOOLEAN STDCALL
+SePrivilegeCheck(IN OUT PPRIVILEGE_SET RequiredPrivileges,
+ IN PSECURITY_SUBJECT_CONTEXT SubjectContext,
+ IN KPROCESSOR_MODE AccessMode);
+
+NTSTATUS STDCALL
+SeQueryAuthenticationIdToken(IN PACCESS_TOKEN Token,
+ OUT PLUID LogonId);
+
+NTSTATUS STDCALL
+SeQuerySecurityDescriptorInfo(IN PSECURITY_INFORMATION SecurityInformation,
+ OUT PSECURITY_DESCRIPTOR SecurityDescriptor,
+ IN OUT PULONG Length,
+ IN PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor);
+
+NTSTATUS STDCALL
+SeRegisterLogonSessionTerminatedRoutine(IN PSE_LOGON_SESSION_TERMINATED_ROUTINE CallbackRoutine);
+
+VOID STDCALL
+SeReleaseSubjectContext(IN PSECURITY_SUBJECT_CONTEXT SubjectContext);
+
+VOID STDCALL
+SeSetAccessStateGenericMapping(IN PACCESS_STATE AccessState,
+ IN PGENERIC_MAPPING GenericMapping);
+
+NTSTATUS STDCALL
+SeSetSecurityDescriptorInfo(IN PVOID Object OPTIONAL,
+ IN PSECURITY_INFORMATION SecurityInformation,
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor,
+ IN OUT PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor,
+ IN POOL_TYPE PoolType,
+ IN PGENERIC_MAPPING GenericMapping);
+
+BOOLEAN STDCALL
+SeSinglePrivilegeCheck(IN LUID PrivilegeValue,
+ IN KPROCESSOR_MODE PreviousMode);
+
+SECURITY_IMPERSONATION_LEVEL STDCALL
+SeTokenImpersonationLevel(IN PACCESS_TOKEN Token);
+
+TOKEN_TYPE STDCALL
+SeTokenType(IN PACCESS_TOKEN Token);
+
+VOID STDCALL
+SeUnlockSubjectContext(IN PSECURITY_SUBJECT_CONTEXT SubjectContext);
+
+NTSTATUS STDCALL
+SeUnregisterLogonSessionTerminatedRoutine(IN PSE_LOGON_SESSION_TERMINATED_ROUTINE CallbackRoutine);
+
+BOOLEAN STDCALL
+SeValidSecurityDescriptor(IN ULONG Length,
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor);
+
+#endif /* ndef _INCLUDE_DDK_SEFUNCS_H */
--- /dev/null
+
+#ifndef __INTERNAL_SERVICE_H
+#define __INTERNAL_SERVICE_H
+
+
+/* number of entries in the service descriptor tables */
+#define SSDT_MAX_ENTRIES 4
+
+
+#pragma pack(1)
+
+// System Service Dispatch Table
+typedef struct t_SSDT {
+ ULONG SysCallPtr;
+} SSDT, *PSSDT;
+
+// System Service Parameters Table
+typedef struct t_SSPT {
+ unsigned int ParamBytes;
+} SSPT, *PSSPT;
+
+typedef struct t_KeServiceDescriptorTableEntry {
+ PSSDT SSDT;
+ PULONG ServiceCounterTable;
+ unsigned int NumberOfServices;
+ PSSPT SSPT;
+
+} KE_SERVICE_DESCRIPTOR_TABLE_ENTRY, *PKE_SERVICE_DESCRIPTOR_TABLE_ENTRY;
+
+#pragma pack()
+
+
+/* --- NTOSKRNL.EXE --- */
+#if defined(__NTOSKRNL__)
+extern
+KE_SERVICE_DESCRIPTOR_TABLE_ENTRY
+KeServiceDescriptorTable[SSDT_MAX_ENTRIES] __declspec(dllexport);
+#else
+extern
+KE_SERVICE_DESCRIPTOR_TABLE_ENTRY
+KeServiceDescriptorTable[SSDT_MAX_ENTRIES] __declspec(dllimport);
+#endif
+
+extern
+KE_SERVICE_DESCRIPTOR_TABLE_ENTRY
+KeServiceDescriptorTableShadow[SSDT_MAX_ENTRIES];
+
+
+BOOLEAN
+STDCALL
+KeAddSystemServiceTable (
+ PSSDT SSDT,
+ PULONG ServiceCounterTable,
+ ULONG NumberOfServices,
+ PSSPT SSPT,
+ ULONG TableIndex
+ );
+
+#endif
+
--- /dev/null
+/* $Id: setypes.h,v 1.9 2002/09/08 10:47:45 chorns Exp $
+ *
+ * COPYRIGHT: See COPYING in the top level directory for details
+ * PROJECT: ReactOS kernel
+ * FILE: include/ddk/setypes.h
+ * PURPOSE: Security manager types
+ * REVISION HISTORY:
+ * ??/??/??: Created with empty stubs by David Welch
+ * 29/08/98: ACCESS_TOKEN definition from Boudewijn Dekker
+ */
+
+#ifndef __INCLUDE_DDK_SETYPES_H
+#define __INCLUDE_DDK_SETYPES_H
+
+#include <ntos/security.h>
+
+/* TOKEN_GROUPS structure */
+#define SE_GROUP_MANDATORY (0x1L)
+#define SE_GROUP_ENABLED_BY_DEFAULT (0x2L)
+#define SE_GROUP_ENABLED (0x4L)
+#define SE_GROUP_OWNER (0x8L)
+#define SE_GROUP_LOGON_ID (0xc0000000L)
+
+/* ACL Defines */
+#define ACL_REVISION (2)
+
+/* ACE_HEADER structure */
+#define ACCESS_ALLOWED_ACE_TYPE (0x0)
+#define ACCESS_DENIED_ACE_TYPE (0x1)
+#define SYSTEM_AUDIT_ACE_TYPE (0x2)
+#define SYSTEM_ALARM_ACE_TYPE (0x3)
+
+/* ACE flags in the ACE_HEADER structure */
+#define OBJECT_INHERIT_ACE (0x1)
+#define CONTAINER_INHERIT_ACE (0x2)
+#define NO_PROPAGATE_INHERIT_ACE (0x4)
+#define INHERIT_ONLY_ACE (0x8)
+#define SUCCESSFUL_ACCESS_ACE_FLAG (0x40)
+#define FAILED_ACCESS_ACE_FLAG (0x80)
+
+/* SECURITY_DESCRIPTOR_CONTROL */
+#define SECURITY_DESCRIPTOR_REVISION (1)
+#define SECURITY_DESCRIPTOR_MIN_LENGTH (20)
+#define SE_OWNER_DEFAULTED (1)
+#define SE_GROUP_DEFAULTED (2)
+#define SE_DACL_PRESENT (4)
+#define SE_DACL_DEFAULTED (8)
+#define SE_SACL_PRESENT (16)
+#define SE_SACL_DEFAULTED (32)
+#define SE_SELF_RELATIVE (32768)
+
+/* PRIVILEGE_SET */
+#define SE_PRIVILEGE_ENABLED_BY_DEFAULT (0x1L)
+#define SE_PRIVILEGE_ENABLED (0x2L)
+#define SE_PRIVILEGE_USED_FOR_ACCESS (0x80000000L)
+#define PRIVILEGE_SET_ALL_NECESSARY (0x1)
+
+typedef struct _ACCESS_TOKEN
+{
+ TOKEN_SOURCE TokenSource; // 0x00
+ LUID TokenId; // 0x10
+ LUID AuthenticationId; // 0x18
+ LARGE_INTEGER ExpirationTime; // 0x20
+ LUID ModifiedId; // 0x28
+ ULONG UserAndGroupCount; // 0x30
+ ULONG PrivilegeCount; // 0x34
+ ULONG VariableLength; // 0x38
+ ULONG DynamicCharged; // 0x3C
+ ULONG DynamicAvailable; // 0x40
+ ULONG DefaultOwnerIndex; // 0x44
+ PSID_AND_ATTRIBUTES UserAndGroups; // 0x48
+ PSID PrimaryGroup; // 0x4C
+ PLUID_AND_ATTRIBUTES Privileges; // 0x50
+ ULONG Unknown1; // 0x54
+ PACL DefaultDacl; // 0x58
+ TOKEN_TYPE TokenType; // 0x5C
+ SECURITY_IMPERSONATION_LEVEL ImpersonationLevel; // 0x60
+ UCHAR TokenFlags; // 0x64
+ UCHAR TokenInUse; // 0x65
+ UCHAR Unused[2]; // 0x66
+ PVOID ProxyData; // 0x68
+ PVOID AuditData; // 0x6c
+ UCHAR VariablePart[0]; // 0x70
+} ACCESS_TOKEN, *PACCESS_TOKEN;
+
+
+typedef struct _SECURITY_SUBJECT_CONTEXT
+{
+ PACCESS_TOKEN ClientToken; // 0x0
+ SECURITY_IMPERSONATION_LEVEL ImpersonationLevel; // 0x4
+ PACCESS_TOKEN PrimaryToken; // 0x8
+ PVOID ProcessAuditId; // 0xC
+} SECURITY_SUBJECT_CONTEXT, *PSECURITY_SUBJECT_CONTEXT;
+
+
+typedef struct _SECURITY_CLIENT_CONTEXT
+{
+ SECURITY_QUALITY_OF_SERVICE SecurityQos; // 0x00
+ PACCESS_TOKEN Token; // 0x0C
+ BOOLEAN DirectlyAccessClientToken; // 0x10
+ BOOLEAN DirectAccessEffectiveOnly; // 0x11
+ BOOLEAN ServerIsRemote; // 0x12
+ TOKEN_CONTROL ClientTokenControl; // 0x14
+} SECURITY_CLIENT_CONTEXT, *PSECURITY_CLIENT_CONTEXT;
+
+
+typedef struct _SE_EXPORTS
+{
+ /* Privilege values */
+ LUID SeCreateTokenPrivilege;
+ LUID SeAssignPrimaryTokenPrivilege;
+ LUID SeLockMemoryPrivilege;
+ LUID SeIncreaseQuotaPrivilege;
+ LUID SeUnsolicitedInputPrivilege;
+ LUID SeTcbPrivilege;
+ LUID SeSecurityPrivilege;
+ LUID SeTakeOwnershipPrivilege;
+ LUID SeLoadDriverPrivilege;
+ LUID SeCreatePagefilePrivilege;
+ LUID SeIncreaseBasePriorityPrivilege;
+ LUID SeSystemProfilePrivilege;
+ LUID SeSystemtimePrivilege;
+ LUID SeProfileSingleProcessPrivilege;
+ LUID SeCreatePermanentPrivilege;
+ LUID SeBackupPrivilege;
+ LUID SeRestorePrivilege;
+ LUID SeShutdownPrivilege;
+ LUID SeDebugPrivilege;
+ LUID SeAuditPrivilege;
+ LUID SeSystemEnvironmentPrivilege;
+ LUID SeChangeNotifyPrivilege;
+ LUID SeRemoteShutdownPrivilege;
+
+ /* Universally defined SIDs */
+ PSID SeNullSid;
+ PSID SeWorldSid;
+ PSID SeLocalSid;
+ PSID SeCreatorOwnerSid;
+ PSID SeCreatorGroupSid;
+
+ /* Nt defined SIDs */
+ PSID SeNtAuthoritySid;
+ PSID SeDialupSid;
+ PSID SeNetworkSid;
+ PSID SeBatchSid;
+ PSID SeInteractiveSid;
+ PSID SeLocalSystemSid;
+ PSID SeAliasAdminsSid;
+ PSID SeAliasUsersSid;
+ PSID SeAliasGuestsSid;
+ PSID SeAliasPowerUsersSid;
+ PSID SeAliasAccountOpsSid;
+ PSID SeAliasSystemOpsSid;
+ PSID SeAliasPrintOpsSid;
+ PSID SeAliasBackupOpsSid;
+} SE_EXPORTS, *PSE_EXPORTS;
+
+
+typedef NTSTATUS STDCALL
+(*PSE_LOGON_SESSION_TERMINATED_ROUTINE)(IN PLUID LogonId);
+
+#endif
+
+/* EOF */
--- /dev/null
+#ifndef __INCLUDE_DDK_STATUS_H
+#define __INCLUDE_DDK_STATUS_H
+
+#define NTSTAT_SEVERITY_SHIFT 30
+#define NTSTAT_SEVERITY_MASK 0x00000003
+#define NTSTAT_FACILITY_SHIFT 16
+#define NTSTAT_FACILITY_MASK 0x00000FFF
+#define NTSTAT_CUSTOMER_MASK 0x20000000
+
+#define NT_SEVERITY(StatCode) (((StatCode) >> NTSTAT_SEVERITY_SHIFT) & NTSTAT_SEVERITY_MASK)
+#define NT_FACILITY(StatCode) (((StatCode) >> NTSTAT_FACILITY_SHIFT) & NTSTAT_FACILITY_MASK)
+#define NT_CUSTOMER(StatCode) ((StatCode) & NTSTAT_CUSTOMER_MASK)
+#define NT_SUCCESS(StatCode) ((NTSTATUS)(StatCode) >= 0)
+
+/*
+ * Possible status codes
+ * FIXME: These may not be the actual values used by NT
+ */
+
+#define STATUS_SUCCESS (0x00000000)
+#ifndef STATUS_WAIT_0
+#define STATUS_WAIT_0 (0x00000000)
+#endif
+#define STATUS_WAIT_63 (0x0000003F)
+#define STATUS_ABANDONED (0x00000080)
+#ifndef STATUS_ABANDONED_WAIT_0
+#define STATUS_ABANDONED_WAIT_0 (0x00000080)
+#endif
+#define STATUS_ABANDONED_WAIT_63 (0x000000BF)
+#ifndef STATUS_USER_APC
+#define STATUS_USER_APC (0x000000C0)
+#endif
+#define STATUS_KERNEL_APC (0x00000100)
+#define STATUS_ALERTED (0x00000101)
+#ifndef STATUS_TIMEOUT
+#define STATUS_TIMEOUT (0x00000102)
+#endif
+#ifndef STATUS_PENDING
+#define STATUS_PENDING (0x00000103)
+#endif
+#define STATUS_REPARSE (0x00000104)
+#define STATUS_MORE_ENTRIES (0x00000105)
+#define STATUS_NOT_ALL_ASSIGNED (0x00000106)
+#define STATUS_SOME_NOT_MAPPED (0x00000107)
+#define STATUS_OPLOCK_BREAK_IN_PROCESS (0x00000108)
+#define STATUS_VOLUME_MOUNTED (0x00000109)
+#define STATUS_RXACT_COMMITTED (0x0000010A)
+#define STATUS_NOTIFY_CLEANUP (0x0000010B)
+#define STATUS_NOTIFY_ENUM_DIR (0x0000010C)
+#define STATUS_NO_QUOTAS_NO_ACCOUNT (0x0000010D)
+#define STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED (0x0000010E)
+
+#define STATUS_OBJECT_EXISTS (0x40000000)
+#define STATUS_THREAD_WAS_SUSPENDED (0x40000001)
+#define STATUS_WORKING_SET_LIMIT_RANGE (0x40000002)
+#define STATUS_IMAGE_NOT_AT_BASE (0x40000003)
+#define STATUS_RXACT_STATE_CREATED (0x40000004)
+#define STATUS_SEGMENT_NOTIFICATION (0x40000005)
+#define STATUS_LOCAL_USER_SESSION_KEY (0x40000006)
+#define STATUS_BAD_CURRENT_DIRECTORY (0x40000007)
+#define STATUS_SERIAL_MORE_WRITES (0x40000008)
+#define STATUS_REGISTRY_RECOVERED (0x40000009)
+#define STATUS_FT_READ_RECOVERING_FROM_BACKUP (0x4000000A)
+#define STATUS_FT_WRITE_RECOVERY (0x4000000B)
+#define STATUS_SERIAL_COUNTER_TIMEOUT (0x4000000C)
+#define STATUS_NULL_LM_PASSWORD (0x4000000D)
+#define STATUS_IMAGE_MACHINE_TYPE_MISMATCH (0x4000000E)
+#define STATUS_RECEIVE_PARTIAL (0x4000000F)
+#define STATUS_RECEIVE_EXPEDITED (0x40000010)
+#define STATUS_RECEIVE_PARTIAL_EXPEDITED (0x40000011)
+#define STATUS_EVENT_DONE (0x40000012)
+#define STATUS_EVENT_PENDING (0x40000013)
+#define STATUS_CHECKING_FILE_SYSTEM (0x40000014)
+#define STATUS_FATAL_APP_EXIT (0x40000015)
+#define STATUS_PREDEFINED_HANDLE (0x40000016)
+#define STATUS_WAS_UNLOCKED (0x40000017)
+#define STATUS_SERVICE_NOTIFICATION (0x40000018)
+#define STATUS_WAS_LOCKED (0x40000019)
+#define STATUS_LOG_HARD_ERROR (0x4000001A)
+#define STATUS_ALREADY_WIN32 (0x4000001B)
+#define STATUS_WX86_UNSIMULATE (0x4000001C)
+#define STATUS_WX86_CONTINUE (0x4000001D)
+#define STATUS_WX86_SINGLE_STEP (0x4000001E)
+#define STATUS_WX86_BREAKPOINT (0x4000001F)
+#define STATUS_WX86_EXCEPTION_CONTINUE (0x40000020)
+#define STATUS_WX86_EXCEPTION_LASTCHANCE (0x40000021)
+#define STATUS_WX86_EXCEPTION_CHAIN (0x40000022)
+#define STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE (0x40000023)
+#define STATUS_NO_YIELD_PERFORMED (0x40000024)
+#define STATUS_TIMER_RESUME_IGNORED (0x40000025)
+#define STATUS_ARBITRATION_UNHANDLED (0x40000026)
+#define STATUS_CARDBUS_NOT_SUPPORTED (0x40000027)
+#define STATUS_WX86_CREATEWX86TIB (0x40000028)
+
+#define STATUS_GUARD_PAGE_VIOLATION (0x80000001)
+#define STATUS_DATATYPE_MISALIGNMENT (0x80000002)
+#define STATUS_BREAKPOINT (0x80000003)
+#define STATUS_SINGLE_STEP (0x80000004)
+#define STATUS_BUFFER_OVERFLOW (0x80000005)
+#define STATUS_NO_MORE_FILES (0x80000006)
+#define STATUS_WAKE_SYSTEM_DEBUGGER (0x80000007)
+
+#define STATUS_HANDLES_CLOSED (0x8000000A)
+#define STATUS_NO_INHERITANCE (0x8000000B)
+#define STATUS_GUID_SUBSTITUTION_MADE (0x8000000C)
+#define STATUS_PARTIAL_COPY (0x8000000D)
+#define STATUS_DEVICE_PAPER_EMPTY (0x8000000E)
+#define STATUS_DEVICE_POWERED_OFF (0x8000000F)
+#define STATUS_DEVICE_OFF_LINE (0x80000010)
+#define STATUS_DEVICE_BUSY (0x80000011)
+#define STATUS_NO_MORE_EAS (0x80000012)
+#define STATUS_INVALID_EA_NAME (0x80000013)
+#define STATUS_EA_LIST_INCONSISTENT (0x80000014)
+#define STATUS_INVALID_EA_FLAG (0x80000015)
+#define STATUS_VERIFY_REQUIRED (0x80000016)
+#define STATUS_EXTRANEOUS_INFORMATION (0x80000017)
+#define STATUS_RXACT_COMMIT_NECESSARY (0x80000018)
+
+#define STATUS_NO_MORE_ENTRIES (0x8000001A)
+#define STATUS_FILEMARK_DETECTED (0x8000001B)
+#define STATUS_MEDIA_CHANGED (0x8000001C)
+#define STATUS_BUS_RESET (0x8000001D)
+#define STATUS_END_OF_MEDIA (0x8000001E)
+#define STATUS_BEGINNING_OF_MEDIA (0x8000001F)
+#define STATUS_MEDIA_CHECK (0x80000020)
+#define STATUS_SETMARK_DETECTED (0x80000021)
+#define STATUS_NO_DATA_DETECTED (0x80000022)
+#define STATUS_REDIRECTOR_HAS_OPEN_HANDLES (0x80000023)
+#define STATUS_SERVER_HAS_OPEN_HANDLES (0x80000024)
+#define STATUS_ALREADY_DISCONNECTED (0x80000025)
+#define STATUS_LONGJUMP (0x80000026)
+
+#define STATUS_UNSUCCESSFUL (0xc0000001)
+#define STATUS_NOT_IMPLEMENTED (0xc0000002)
+#define STATUS_INVALID_INFO_CLASS (0xc0000003)
+#define STATUS_INFO_LENGTH_MISMATCH (0xc0000004)
+#define STATUS_ACCESS_VIOLATION (0xc0000005)
+#define STATUS_IN_PAGE_ERROR (0xc0000006)
+#define STATUS_PAGEFILE_QUOTA (0xc0000007)
+#define STATUS_INVALID_HANDLE (0xc0000008)
+#define STATUS_BAD_INITIAL_STACK (0xc0000009)
+#define STATUS_BAD_INITIAL_PC (0xc000000a)
+#define STATUS_INVALID_CID (0xc000000b)
+#define STATUS_TIMER_NOT_CANCELED (0xc000000c)
+#define STATUS_INVALID_PARAMETER (0xc000000d)
+#define STATUS_NO_SUCH_DEVICE (0xc000000e)
+#define STATUS_NO_SUCH_FILE (0xc000000f)
+#define STATUS_INVALID_DEVICE_REQUEST (0xc0000010)
+#define STATUS_END_OF_FILE (0xc0000011)
+#define STATUS_WRONG_VOLUME (0xc0000012)
+#define STATUS_NO_MEDIA_IN_DEVICE (0xc0000013)
+#define STATUS_UNRECOGNIZED_MEDIA (0xc0000014)
+#define STATUS_NONEXISTENT_SECTOR (0xc0000015)
+#define STATUS_MORE_PROCESSING_REQUIRED (0xc0000016)
+#define STATUS_NO_MEMORY (0xc0000017)
+#define STATUS_CONFLICTING_ADDRESSES (0xc0000018)
+#define STATUS_NOT_MAPPED_VIEW (0xc0000019)
+#define STATUS_UNABLE_TO_FREE_VM (0xc000001a)
+#define STATUS_UNABLE_TO_DELETE_SECTION (0xc000001b)
+#define STATUS_INVALID_SYSTEM_SERVICE (0xc000001c)
+#define STATUS_ILLEGAL_INSTRUCTION (0xc000001d)
+#define STATUS_INVALID_LOCK_SEQUENCE (0xc000001e)
+#define STATUS_INVALID_VIEW_SIZE (0xc000001f)
+#define STATUS_INVALID_FILE_FOR_SECTION (0xc0000020)
+#define STATUS_ALREADY_COMMITTED (0xc0000021)
+#define STATUS_ACCESS_DENIED (0xc0000022)
+#define STATUS_BUFFER_TOO_SMALL (0xc0000023)
+#define STATUS_OBJECT_TYPE_MISMATCH (0xc0000024)
+#define STATUS_NONCONTINUABLE_EXCEPTION (0xc0000025)
+#define STATUS_INVALID_DISPOSITION (0xc0000026)
+#define STATUS_UNWIND (0xc0000027)
+#define STATUS_BAD_STACK (0xc0000028)
+#define STATUS_INVALID_UNWIND_TARGET (0xc0000029)
+#define STATUS_NOT_LOCKED (0xc000002a)
+#define STATUS_PARITY_ERROR (0xc000002b)
+#define STATUS_UNABLE_TO_DECOMMIT_VM (0xc000002c)
+#define STATUS_NOT_COMMITTED (0xc000002d)
+#define STATUS_INVALID_PORT_ATTRIBUTES (0xc000002e)
+#define STATUS_PORT_MESSAGE_TOO_LONG (0xc000002f)
+#define STATUS_INVALID_PARAMETER_MIX (0xc0000030)
+#define STATUS_INVALID_QUOTA_LOWER (0xc0000031)
+#define STATUS_DISK_CORRUPT_ERROR (0xc0000032)
+#define STATUS_OBJECT_NAME_INVALID (0xc0000033)
+#define STATUS_OBJECT_NAME_NOT_FOUND (0xc0000034)
+#define STATUS_OBJECT_NAME_COLLISION (0xc0000035)
+
+#define STATUS_PORT_DISCONNECTED (0xc0000037)
+#define STATUS_DEVICE_ALREADY_ATTACHED (0xc0000038)
+#define STATUS_OBJECT_PATH_INVALID (0xc0000039)
+#define STATUS_OBJECT_PATH_NOT_FOUND (0xc000003a)
+#define STATUS_PATH_SYNTAX_BAD (0xc000003b)
+#define STATUS_DATA_OVERRUN (0xc000003c)
+#define STATUS_DATA_LATE_ERROR (0xc000003d)
+#define STATUS_DATA_ERROR (0xc000003e)
+#define STATUS_CRC_ERROR (0xc000003f)
+#define STATUS_SECTION_TOO_BIG (0xc0000040)
+#define STATUS_PORT_CONNECTION_REFUSED (0xc0000041)
+#define STATUS_INVALID_PORT_HANDLE (0xc0000042)
+#define STATUS_SHARING_VIOLATION (0xc0000043)
+#define STATUS_QUOTA_EXCEEDED (0xc0000044)
+#define STATUS_INVALID_PAGE_PROTECTION (0xc0000045)
+#define STATUS_MUTANT_NOT_OWNED (0xc0000046)
+#define STATUS_SEMAPHORE_LIMIT_EXCEEDED (0xc0000047)
+#define STATUS_PORT_ALREADY_SET (0xc0000048)
+#define STATUS_SECTION_NOT_IMAGE (0xc0000049)
+#define STATUS_SUSPEND_COUNT_EXCEEDED (0xc000004a)
+#define STATUS_THREAD_IS_TERMINATING (0xc000004b)
+#define STATUS_BAD_WORKING_SET_LIMIT (0xc000004c)
+#define STATUS_INCOMPATIBLE_FILE_MAP (0xc000004d)
+#define STATUS_SECTION_PROTECTION (0xc000004e)
+#define STATUS_EAS_NOT_SUPPORTED (0xc000004f)
+#define STATUS_EA_TOO_LARGE (0xc0000050)
+#define STATUS_NONEXISTENT_EA_ENTRY (0xc0000051)
+#define STATUS_NO_EAS_ON_FILE (0xc0000052)
+#define STATUS_EA_CORRUPT_ERROR (0xc0000053)
+#define STATUS_FILE_LOCK_CONFLICT (0xc0000054)
+#define STATUS_LOCK_NOT_GRANTED (0xc0000055)
+#define STATUS_DELETE_PENDING (0xc0000056)
+#define STATUS_CTL_FILE_NOT_SUPPORTED (0xc0000057)
+#define STATUS_UNKNOWN_REVISION (0xc0000058)
+#define STATUS_REVISION_MISMATCH (0xc0000059)
+#define STATUS_INVALID_OWNER (0xc000005a)
+#define STATUS_INVALID_PRIMARY_GROUP (0xc000005b)
+#define STATUS_NO_IMPERSONATION_TOKEN (0xc000005c)
+#define STATUS_CANT_DISABLE_MANDATORY (0xc000005d)
+#define STATUS_NO_LOGON_SERVERS (0xc000005e)
+#define STATUS_NO_SUCH_LOGON_SESSION (0xc000005f)
+#define STATUS_NO_SUCH_PRIVILEGE (0xc0000060)
+#define STATUS_PRIVILEGE_NOT_HELD (0xc0000061)
+#define STATUS_INVALID_ACCOUNT_NAME (0xc0000062)
+#define STATUS_USER_EXISTS (0xc0000063)
+#define STATUS_NO_SUCH_USER (0xc0000064)
+#define STATUS_GROUP_EXISTS (0xc0000065)
+#define STATUS_NO_SUCH_GROUP (0xc0000066)
+#define STATUS_MEMBER_IN_GROUP (0xc0000067)
+#define STATUS_MEMBER_NOT_IN_GROUP (0xc0000068)
+#define STATUS_LAST_ADMIN (0xc0000069)
+#define STATUS_WRONG_PASSWORD (0xc000006a)
+#define STATUS_ILL_FORMED_PASSWORD (0xc000006b)
+#define STATUS_PASSWORD_RESTRICTION (0xc000006c)
+#define STATUS_LOGON_FAILURE (0xc000006d)
+#define STATUS_ACCOUNT_RESTRICTION (0xc000006e)
+#define STATUS_INVALID_LOGON_HOURS (0xc000006f)
+#define STATUS_INVALID_WORKSTATION (0xc0000070)
+#define STATUS_PASSWORD_EXPIRED (0xc0000071)
+#define STATUS_ACCOUNT_DISABLED (0xc0000072)
+#define STATUS_NONE_MAPPED (0xc0000073)
+#define STATUS_TOO_MANY_LUIDS_REQUESTED (0xc0000074)
+#define STATUS_LUIDS_EXHAUSTED (0xc0000075)
+#define STATUS_INVALID_SUB_AUTHORITY (0xc0000076)
+#define STATUS_INVALID_ACL (0xc0000077)
+#define STATUS_INVALID_SID (0xc0000078)
+#define STATUS_INVALID_SECURITY_DESCR (0xc0000079)
+#define STATUS_PROCEDURE_NOT_FOUND (0xc000007a)
+#define STATUS_INVALID_IMAGE_FORMAT (0xc000007b)
+#define STATUS_NO_TOKEN (0xc000007c)
+#define STATUS_BAD_INHERITANCE_ACL (0xc000007d)
+#define STATUS_RANGE_NOT_LOCKED (0xc000007e)
+#define STATUS_DISK_FULL (0xc000007f)
+#define STATUS_SERVER_DISABLED (0xc0000080)
+#define STATUS_SERVER_NOT_DISABLED (0xc0000081)
+#define STATUS_TOO_MANY_GUIDS_REQUESTED (0xc0000082)
+#define STATUS_GUIDS_EXHAUSTED (0xc0000083)
+#define STATUS_INVALID_ID_AUTHORITY (0xc0000084)
+#define STATUS_AGENTS_EXHAUSTED (0xc0000085)
+#define STATUS_INVALID_VOLUME_LABEL (0xc0000086)
+#define STATUS_SECTION_NOT_EXTENDED (0xc0000087)
+#define STATUS_NOT_MAPPED_DATA (0xc0000088)
+#define STATUS_RESOURCE_DATA_NOT_FOUND (0xc0000089)
+#define STATUS_RESOURCE_TYPE_NOT_FOUND (0xc000008a)
+#define STATUS_RESOURCE_NAME_NOT_FOUND (0xc000008b)
+#define STATUS_ARRAY_BOUNDS_EXCEEDED (0xc000008c)
+#define STATUS_FLOAT_DENORMAL_OPERAND (0xc000008d)
+#define STATUS_FLOAT_DIVIDE_BY_ZERO (0xc000008e)
+#define STATUS_FLOAT_INEXACT_RESULT (0xc000008f)
+#define STATUS_FLOAT_INVALID_OPERATION (0xc0000090)
+#define STATUS_FLOAT_OVERFLOW (0xc0000091)
+#define STATUS_FLOAT_STACK_CHECK (0xc0000092)
+#define STATUS_FLOAT_UNDERFLOW (0xc0000093)
+#define STATUS_INTEGER_DIVIDE_BY_ZERO (0xc0000094)
+#define STATUS_INTEGER_OVERFLOW (0xc0000095)
+#define STATUS_PRIVILEGED_INSTRUCTION (0xc0000096)
+#define STATUS_TOO_MANY_PAGING_FILES (0xc0000097)
+#define STATUS_FILE_INVALID (0xc0000098)
+#define STATUS_ALLOTTED_SPACE_EXCEEDED (0xc0000099)
+#define STATUS_INSUFFICIENT_RESOURCES (0xc000009a)
+#define STATUS_DFS_EXIT_PATH_FOUND (0xc000009b)
+#define STATUS_DEVICE_DATA_ERROR (0xc000009c)
+#define STATUS_DEVICE_NOT_CONNECTED (0xc000009d)
+#define STATUS_DEVICE_POWER_FAILURE (0xc000009e)
+#define STATUS_FREE_VM_NOT_AT_BASE (0xc000009f)
+#define STATUS_MEMORY_NOT_ALLOCATED (0xc00000a0)
+#define STATUS_WORKING_SET_QUOTA (0xc00000a1)
+#define STATUS_MEDIA_WRITE_PROTECTED (0xc00000a2)
+#define STATUS_DEVICE_NOT_READY (0xc00000a3)
+#define STATUS_INVALID_GROUP_ATTRIBUTES (0xc00000a4)
+#define STATUS_BAD_IMPERSONATION_LEVEL (0xc00000a5)
+#define STATUS_CANT_OPEN_ANONYMOUS (0xc00000a6)
+#define STATUS_BAD_VALIDATION_CLASS (0xc00000a7)
+#define STATUS_BAD_TOKEN_TYPE (0xc00000a8)
+#define STATUS_BAD_MASTER_BOOT_RECORD (0xc00000a9)
+#define STATUS_INSTRUCTION_MISALIGNMENT (0xc00000aa)
+#define STATUS_INSTANCE_NOT_AVAILABLE (0xc00000ab)
+#define STATUS_PIPE_NOT_AVAILABLE (0xc00000ac)
+#define STATUS_INVALID_PIPE_STATE (0xc00000ad)
+#define STATUS_PIPE_BUSY (0xc00000ae)
+#define STATUS_ILLEGAL_FUNCTION (0xc00000af)
+#define STATUS_PIPE_DISCONNECTED (0xc00000b0)
+#define STATUS_PIPE_CLOSING (0xc00000b1)
+#define STATUS_PIPE_CONNECTED (0xc00000b2)
+#define STATUS_PIPE_LISTENING (0xc00000b3)
+#define STATUS_INVALID_READ_MODE (0xc00000b4)
+#define STATUS_IO_TIMEOUT (0xc00000b5)
+#define STATUS_FILE_FORCED_CLOSED (0xc00000b6)
+#define STATUS_PROFILING_NOT_STARTED (0xc00000b7)
+#define STATUS_PROFILING_NOT_STOPPED (0xc00000b8)
+#define STATUS_COULD_NOT_INTERPRET (0xc00000b9)
+#define STATUS_FILE_IS_A_DIRECTORY (0xc00000ba)
+#define STATUS_NOT_SUPPORTED (0xc00000bb)
+#define STATUS_REMOTE_NOT_LISTENING (0xc00000bc)
+#define STATUS_DUPLICATE_NAME (0xc00000bd)
+#define STATUS_BAD_NETWORK_PATH (0xc00000be)
+#define STATUS_NETWORK_BUSY (0xc00000bf)
+#define STATUS_DEVICE_DOES_NOT_EXIST (0xc00000c0)
+#define STATUS_TOO_MANY_COMMANDS (0xc00000c1)
+#define STATUS_ADAPTER_HARDWARE_ERROR (0xc00000c2)
+#define STATUS_INVALID_NETWORK_RESPONSE (0xc00000c3)
+#define STATUS_UNEXPECTED_NETWORK_ERROR (0xc00000c4)
+#define STATUS_BAD_REMOTE_ADAPTER (0xc00000c5)
+#define STATUS_PRINT_QUEUE_FULL (0xc00000c6)
+#define STATUS_NO_SPOOL_SPACE (0xc00000c7)
+#define STATUS_PRINT_CANCELLED (0xc00000c8)
+#define STATUS_NETWORK_NAME_DELETED (0xc00000c9)
+#define STATUS_NETWORK_ACCESS_DENIED (0xc00000ca)
+#define STATUS_BAD_DEVICE_TYPE (0xc00000cb)
+#define STATUS_BAD_NETWORK_NAME (0xc00000cc)
+#define STATUS_TOO_MANY_NAMES (0xc00000cd)
+#define STATUS_TOO_MANY_SESSIONS (0xc00000ce)
+#define STATUS_SHARING_PAUSED (0xc00000cf)
+#define STATUS_REQUEST_NOT_ACCEPTED (0xc00000d0)
+#define STATUS_REDIRECTOR_PAUSED (0xc00000d1)
+#define STATUS_NET_WRITE_FAULT (0xc00000d2)
+#define STATUS_PROFILING_AT_LIMIT (0xc00000d3)
+#define STATUS_NOT_SAME_DEVICE (0xc00000d4)
+#define STATUS_FILE_RENAMED (0xc00000d5)
+#define STATUS_VIRTUAL_CIRCUIT_CLOSED (0xc00000d6)
+#define STATUS_NO_SECURITY_ON_OBJECT (0xc00000d7)
+#define STATUS_CANT_WAIT (0xc00000d8)
+#define STATUS_PIPE_EMPTY (0xc00000d9)
+#define STATUS_CANT_ACCESS_DOMAIN_INFO (0xc00000da)
+#define STATUS_CANT_TERMINATE_SELF (0xc00000db)
+#define STATUS_INVALID_SERVER_STATE (0xc00000dc)
+#define STATUS_INVALID_DOMAIN_STATE (0xc00000dd)
+#define STATUS_INVALID_DOMAIN_ROLE (0xc00000de)
+#define STATUS_NO_SUCH_DOMAIN (0xc00000df)
+#define STATUS_DOMAIN_EXISTS (0xc00000e0)
+#define STATUS_DOMAIN_LIMIT_EXCEEDED (0xc00000e1)
+#define STATUS_OPLOCK_NOT_GRANTED (0xc00000e2)
+#define STATUS_INVALID_OPLOCK_PROTOCOL (0xc00000e3)
+#define STATUS_INTERNAL_DB_CORRUPTION (0xc00000e4)
+#define STATUS_INTERNAL_ERROR (0xc00000e5)
+#define STATUS_GENERIC_NOT_MAPPED (0xc00000e6)
+#define STATUS_BAD_DESCRIPTOR_FORMAT (0xc00000e7)
+#define STATUS_INVALID_USER_BUFFER (0xc00000e8)
+#define STATUS_UNEXPECTED_IO_ERROR (0xc00000e9)
+#define STATUS_UNEXPECTED_MM_CREATE_ERR (0xc00000ea)
+#define STATUS_UNEXPECTED_MM_MAP_ERROR (0xc00000eb)
+#define STATUS_UNEXPECTED_MM_EXTEND_ERR (0xc00000ec)
+#define STATUS_NOT_LOGON_PROCESS (0xc00000ed)
+#define STATUS_LOGON_SESSION_EXISTS (0xc00000ee)
+#define STATUS_INVALID_PARAMETER_1 (0xc00000ef)
+#define STATUS_INVALID_PARAMETER_2 (0xc00000f0)
+#define STATUS_INVALID_PARAMETER_3 (0xc00000f1)
+#define STATUS_INVALID_PARAMETER_4 (0xc00000f2)
+#define STATUS_INVALID_PARAMETER_5 (0xc00000f3)
+#define STATUS_INVALID_PARAMETER_6 (0xc00000f4)
+#define STATUS_INVALID_PARAMETER_7 (0xc00000f5)
+#define STATUS_INVALID_PARAMETER_8 (0xc00000f6)
+#define STATUS_INVALID_PARAMETER_9 (0xc00000f7)
+#define STATUS_INVALID_PARAMETER_10 (0xc00000f8)
+#define STATUS_INVALID_PARAMETER_11 (0xc00000f9)
+#define STATUS_INVALID_PARAMETER_12 (0xc00000fa)
+#define STATUS_REDIRECTOR_NOT_STARTED (0xc00000fb)
+#define STATUS_REDIRECTOR_STARTED (0xc00000fc)
+#define STATUS_STACK_OVERFLOW (0xc00000fd)
+#define STATUS_NO_SUCH_PACKAGE (0xc00000fe)
+#define STATUS_BAD_FUNCTION_TABLE (0xc00000ff)
+#define STATUS_VARIABLE_NOT_FOUND (0xc0000100)
+#define STATUS_DIRECTORY_NOT_EMPTY (0xc0000101)
+#define STATUS_FILE_CORRUPT_ERROR (0xc0000102)
+#define STATUS_NOT_A_DIRECTORY (0xc0000103)
+#define STATUS_BAD_LOGON_SESSION_STATE (0xc0000104)
+#define STATUS_LOGON_SESSION_COLLISION (0xc0000105)
+#define STATUS_NAME_TOO_LONG (0xc0000106)
+#define STATUS_FILES_OPEN (0xc0000107)
+#define STATUS_CONNECTION_IN_USE (0xc0000108)
+#define STATUS_MESSAGE_NOT_FOUND (0xc0000109)
+#define STATUS_PROCESS_IS_TERMINATING (0xc000010a)
+#define STATUS_INVALID_LOGON_TYPE (0xc000010b)
+#define STATUS_NO_GUID_TRANSLATION (0xc000010c)
+#define STATUS_CANNOT_IMPERSONATE (0xc000010d)
+#define STATUS_IMAGE_ALREADY_LOADED (0xc000010e)
+#define STATUS_ABIOS_NOT_PRESENT (0xc000010f)
+#define STATUS_ABIOS_LID_NOT_EXIST (0xc0000110)
+#define STATUS_ABIOS_LID_ALREADY_OWNED (0xc0000111)
+#define STATUS_ABIOS_NOT_LID_OWNER (0xc0000112)
+#define STATUS_ABIOS_INVALID_COMMAND (0xc0000113)
+#define STATUS_ABIOS_INVALID_LID (0xc0000114)
+#define STATUS_ABIOS_SELECTOR_NOT_AVAILABLE (0xc0000115)
+#define STATUS_ABIOS_INVALID_SELECTOR (0xc0000116)
+#define STATUS_NO_LDT (0xc0000117)
+#define STATUS_INVALID_LDT_SIZE (0xc0000118)
+#define STATUS_INVALID_LDT_OFFSET (0xc0000119)
+#define STATUS_INVALID_LDT_DESCRIPTOR (0xc000011a)
+#define STATUS_INVALID_IMAGE_NE_FORMAT (0xc000011b)
+#define STATUS_RXACT_INVALID_STATE (0xc000011c)
+#define STATUS_RXACT_COMMIT_FAILURE (0xc000011d)
+#define STATUS_MAPPED_FILE_SIZE_ZERO (0xc000011e)
+#define STATUS_TOO_MANY_OPENED_FILES (0xc000011f)
+#define STATUS_CANCELLED (0xc0000120)
+#define STATUS_CANNOT_DELETE (0xc0000121)
+#define STATUS_INVALID_COMPUTER_NAME (0xc0000122)
+#define STATUS_FILE_DELETED (0xc0000123)
+#define STATUS_SPECIAL_ACCOUNT (0xc0000124)
+#define STATUS_SPECIAL_GROUP (0xc0000125)
+#define STATUS_SPECIAL_USER (0xc0000126)
+#define STATUS_MEMBERS_PRIMARY_GROUP (0xc0000127)
+#define STATUS_FILE_CLOSED (0xc0000128)
+#define STATUS_TOO_MANY_THREADS (0xc0000129)
+#define STATUS_THREAD_NOT_IN_PROCESS (0xc000012a)
+#define STATUS_TOKEN_ALREADY_IN_USE (0xc000012b)
+#define STATUS_PAGEFILE_QUOTA_EXCEEDED (0xc000012c)
+#define STATUS_COMMITMENT_LIMIT (0xc000012d)
+#define STATUS_INVALID_IMAGE_LE_FORMAT (0xc000012e)
+#define STATUS_INVALID_IMAGE_NOT_MZ (0xc000012f)
+#define STATUS_INVALID_IMAGE_PROTECT (0xc0000130)
+#define STATUS_INVALID_IMAGE_WIN_16 (0xc0000131)
+#define STATUS_LOGON_SERVER_CONFLICT (0xc0000132)
+#define STATUS_TIME_DIFFERENCE_AT_DC (0xc0000133)
+#define STATUS_SYNCHRONIZATION_REQUIRED (0xc0000134)
+#define STATUS_DLL_NOT_FOUND (0xc0000135)
+#define STATUS_OPEN_FAILED (0xc0000136)
+#define STATUS_IO_PRIVILEGE_FAILED (0xc0000137)
+#define STATUS_ORDINAL_NOT_FOUND (0xc0000138)
+#define STATUS_ENTRYPOINT_NOT_FOUND (0xc0000139)
+#define STATUS_CONTROL_C_EXIT (0xc000013a)
+#define STATUS_LOCAL_DISCONNECT (0xc000013b)
+#define STATUS_REMOTE_DISCONNECT (0xc000013c)
+#define STATUS_REMOTE_RESOURCES (0xc000013d)
+#define STATUS_LINK_FAILED (0xc000013e)
+#define STATUS_LINK_TIMEOUT (0xc000013f)
+#define STATUS_INVALID_CONNECTION (0xc0000140)
+#define STATUS_INVALID_ADDRESS (0xc0000141)
+#define STATUS_DLL_INIT_FAILED (0xc0000142)
+#define STATUS_MISSING_SYSTEMFILE (0xc0000143)
+#define STATUS_UNHANDLED_EXCEPTION (0xc0000144)
+#define STATUS_APP_INIT_FAILURE (0xc0000145)
+#define STATUS_PAGEFILE_CREATE_FAILED (0xc0000146)
+#define STATUS_NO_PAGEFILE (0xc0000147)
+#define STATUS_INVALID_LEVEL (0xc0000148)
+#define STATUS_WRONG_PASSWORD_CORE (0xc0000149)
+#define STATUS_ILLEGAL_FLOAT_CONTEXT (0xc000014a)
+#define STATUS_PIPE_BROKEN (0xc000014b)
+#define STATUS_REGISTRY_CORRUPT (0xc000014c)
+#define STATUS_REGISTRY_IO_FAILED (0xc000014d)
+#define STATUS_NO_EVENT_PAIR (0xc000014e)
+#define STATUS_UNRECOGNIZED_VOLUME (0xc000014f)
+#define STATUS_SERIAL_NO_DEVICE_INITED (0xc0000150)
+#define STATUS_NO_SUCH_ALIAS (0xc0000151)
+#define STATUS_MEMBER_NOT_IN_ALIAS (0xc0000152)
+#define STATUS_MEMBER_IN_ALIAS (0xc0000153)
+#define STATUS_ALIAS_EXISTS (0xc0000154)
+#define STATUS_LOGON_NOT_GRANTED (0xc0000155)
+#define STATUS_TOO_MANY_SECRETS (0xc0000156)
+#define STATUS_SECRET_TOO_LONG (0xc0000157)
+#define STATUS_INTERNAL_DB_ERROR (0xc0000158)
+#define STATUS_FULLSCREEN_MODE (0xc0000159)
+#define STATUS_TOO_MANY_CONTEXT_IDS (0xc000015a)
+#define STATUS_LOGON_TYPE_NOT_GRANTED (0xc000015b)
+#define STATUS_NOT_REGISTRY_FILE (0xc000015c)
+#define STATUS_NT_CROSS_ENCRYPTION_REQUIRED (0xc000015d)
+#define STATUS_DOMAIN_CTRLR_CONFIG_ERROR (0xc000015e)
+#define STATUS_FT_MISSING_MEMBER (0xc000015f)
+#define STATUS_ILL_FORMED_SERVICE_ENTRY (0xc0000160)
+#define STATUS_ILLEGAL_CHARACTER (0xc0000161)
+#define STATUS_UNMAPPABLE_CHARACTER (0xc0000162)
+#define STATUS_UNDEFINED_CHARACTER (0xc0000163)
+#define STATUS_FLOPPY_VOLUME (0xc0000164)
+#define STATUS_FLOPPY_ID_MARK_NOT_FOUND (0xc0000165)
+#define STATUS_FLOPPY_WRONG_CYLINDER (0xc0000166)
+#define STATUS_FLOPPY_UNKNOWN_ERROR (0xc0000167)
+#define STATUS_FLOPPY_BAD_REGISTERS (0xc0000168)
+#define STATUS_DISK_RECALIBRATE_FAILED (0xc0000169)
+#define STATUS_DISK_OPERATION_FAILED (0xc000016a)
+#define STATUS_DISK_RESET_FAILED (0xc000016b)
+#define STATUS_SHARED_IRQ_BUSY (0xc000016c)
+#define STATUS_FT_ORPHANING (0xc000016d)
+#define STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT (0xc000016e)
+
+#define STATUS_PARTITION_FAILURE (0xc0000172)
+#define STATUS_INVALID_BLOCK_LENGTH (0xc0000173)
+#define STATUS_DEVICE_NOT_PARTITIONED (0xc0000174)
+#define STATUS_UNABLE_TO_LOCK_MEDIA (0xc0000175)
+#define STATUS_UNABLE_TO_UNLOAD_MEDIA (0xc0000176)
+#define STATUS_EOM_OVERFLOW (0xc0000177)
+#define STATUS_NO_MEDIA (0xc0000178)
+
+#define STATUS_NO_SUCH_MEMBER (0xc000017a)
+#define STATUS_INVALID_MEMBER (0xc000017b)
+#define STATUS_KEY_DELETED (0xc000017c)
+#define STATUS_NO_LOG_SPACE (0xc000017d)
+#define STATUS_TOO_MANY_SIDS (0xc000017e)
+#define STATUS_LM_CROSS_ENCRYPTION_REQUIRED (0xc000017f)
+#define STATUS_KEY_HAS_CHILDREN (0xc0000180)
+#define STATUS_CHILD_MUST_BE_VOLATILE (0xc0000181)
+#define STATUS_DEVICE_CONFIGURATION_ERROR (0xc0000182)
+#define STATUS_DRIVER_INTERNAL_ERROR (0xc0000183)
+#define STATUS_INVALID_DEVICE_STATE (0xc0000184)
+#define STATUS_IO_DEVICE_ERROR (0xc0000185)
+#define STATUS_DEVICE_PROTOCOL_ERROR (0xc0000186)
+#define STATUS_BACKUP_CONTROLLER (0xc0000187)
+#define STATUS_LOG_FILE_FULL (0xc0000188)
+#define STATUS_TOO_LATE (0xc0000189)
+#define STATUS_NO_TRUST_LSA_SECRET (0xc000018a)
+#define STATUS_NO_TRUST_SAM_ACCOUNT (0xc000018b)
+#define STATUS_TRUSTED_DOMAIN_FAILURE (0xc000018c)
+#define STATUS_TRUSTED_RELATIONSHIP_FAILURE (0xc000018d)
+#define STATUS_EVENTLOG_FILE_CORRUPT (0xc000018e)
+#define STATUS_EVENTLOG_CANT_START (0xc000018f)
+#define STATUS_TRUST_FAILURE (0xc0000190)
+#define STATUS_MUTANT_LIMIT_EXCEEDED (0xc0000191)
+#define STATUS_NETLOGON_NOT_STARTED (0xc0000192)
+#define STATUS_ACCOUNT_EXPIRED (0xc0000193)
+#define STATUS_POSSIBLE_DEADLOCK (0xc0000194)
+#define STATUS_NETWORK_CREDENTIAL_CONFLICT (0xc0000195)
+#define STATUS_REMOTE_SESSION_LIMIT (0xc0000196)
+#define STATUS_EVENTLOG_FILE_CHANGED (0xc0000197)
+#define STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT (0xc0000198)
+#define STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT (0xc0000199)
+#define STATUS_NOLOGON_SERVER_TRUST_ACCOUNT (0xc000019a)
+#define STATUS_DOMAIN_TRUST_INCONSISTENT (0xc000019b)
+#define STATUS_FS_DRIVER_REQUIRED (0xc000019c)
+
+#define STATUS_NO_USER_SESSION_KEY (0xc0000202)
+#define STATUS_USER_SESSION_DELETED (0xc0000203)
+#define STATUS_RESOURCE_LANG_NOT_FOUND (0xc0000204)
+#define STATUS_INSUFF_SERVER_RESOURCES (0xc0000205)
+#define STATUS_INVALID_BUFFER_SIZE (0xc0000206)
+#define STATUS_INVALID_ADDRESS_COMPONENT (0xc0000207)
+#define STATUS_INVALID_ADDRESS_WILDCARD (0xc0000208)
+#define STATUS_TOO_MANY_ADDRESSES (0xc0000209)
+#define STATUS_ADDRESS_ALREADY_EXISTS (0xc000020a)
+#define STATUS_ADDRESS_CLOSED (0xc000020b)
+#define STATUS_CONNECTION_DISCONNECTED (0xc000020c)
+#define STATUS_CONNECTION_RESET (0xc000020d)
+#define STATUS_TOO_MANY_NODES (0xc000020e)
+#define STATUS_TRANSACTION_ABORTED (0xc000020f)
+#define STATUS_TRANSACTION_TIMED_OUT (0xc0000210)
+#define STATUS_TRANSACTION_NO_RELEASE (0xc0000211)
+#define STATUS_TRANSACTION_NO_MATCH (0xc0000212)
+#define STATUS_TRANSACTION_RESPONDED (0xc0000213)
+#define STATUS_TRANSACTION_INVALID_ID (0xc0000214)
+#define STATUS_TRANSACTION_INVALID_TYPE (0xc0000215)
+#define STATUS_NOT_SERVER_SESSION (0xc0000216)
+#define STATUS_NOT_CLIENT_SESSION (0xc0000217)
+#define STATUS_CANNOT_LOAD_REGISTRY_FILE (0xc0000218)
+#define STATUS_DEBUG_ATTACH_FAILED (0xc0000219)
+#define STATUS_SYSTEM_PROCESS_TERMINATED (0xc000021a)
+#define STATUS_DATA_NOT_ACCEPTED (0xc000021b)
+#define STATUS_NO_BROWSER_SERVERS_FOUND (0xc000021c)
+#define STATUS_VDM_HARD_ERROR (0xc000021d)
+#define STATUS_DRIVER_CANCEL_TIMEOUT (0xc000021e)
+#define STATUS_REPLY_MESSAGE_MISMATCH (0xc000021f)
+#define STATUS_MAPPED_ALIGNMENT (0xc0000220)
+#define STATUS_IMAGE_CHECKSUM_MISMATCH (0xc0000221)
+#define STATUS_LOST_WRITEBEHIND_DATA (0xc0000222)
+#define STATUS_CLIENT_SERVER_PARAMETERS_INVALID (0xc0000223)
+#define STATUS_PASSWORD_MUST_CHANGE (0xc0000224)
+#define STATUS_NOT_FOUND (0xc0000225)
+#define STATUS_NOT_TINY_STREAM (0xc0000226)
+#define STATUS_RECOVERY_FAILURE (0xc0000227)
+#define STATUS_STACK_OVERFLOW_READ (0xc0000228)
+#define STATUS_FAIL_CHECK (0xc0000229)
+#define STATUS_DUPLICATE_OBJECTID (0xc000022a)
+#define STATUS_OBJECTID_EXISTS (0xc000022b)
+#define STATUS_CONVERT_TO_LARGE (0xc000022c)
+#define STATUS_RETRY (0xc000022d)
+#define STATUS_FOUND_OUT_OF_SCOPE (0xc000022e)
+#define STATUS_ALLOCATE_BUCKET (0xc000022f)
+#define STATUS_PROPSET_NOT_FOUND (0xc0000230)
+#define STATUS_MARSHALL_OVERFLOW (0xc0000231)
+#define STATUS_INVALID_VARIANT (0xc0000232)
+#define STATUS_DOMAIN_CONTROLLER_NOT_FOUND (0xc0000233)
+#define STATUS_ACCOUNT_LOCKED_OUT (0xc0000234)
+#define STATUS_HANDLE_NOT_CLOSABLE (0xc0000235)
+#define STATUS_CONNECTION_REFUSED (0xc0000236)
+#define STATUS_GRACEFUL_DISCONNECT (0xc0000237)
+#define STATUS_ADDRESS_ALREADY_ASSOCIATED (0xc0000238)
+#define STATUS_ADDRESS_NOT_ASSOCIATED (0xc0000239)
+#define STATUS_CONNECTION_INVALID (0xc000023a)
+#define STATUS_CONNECTION_ACTIVE (0xc000023b)
+#define STATUS_NETWORK_UNREACHABLE (0xc000023c)
+#define STATUS_HOST_UNREACHABLE (0xc000023d)
+#define STATUS_PROTOCOL_UNREACHABLE (0xc000023e)
+#define STATUS_PORT_UNREACHABLE (0xc000023f)
+#define STATUS_REQUEST_ABORTED (0xc0000240)
+#define STATUS_CONNECTION_ABORTED (0xc0000241)
+#define STATUS_BAD_COMPRESSION_BUFFER (0xc0000242)
+#define STATUS_USER_MAPPED_FILE (0xc0000243)
+#define STATUS_AUDIT_FAILED (0xc0000244)
+#define STATUS_TIMER_RESOLUTION_NOT_SET (0xc0000245)
+#define STATUS_CONNECTION_COUNT_LIMIT (0xc0000246)
+#define STATUS_LOGIN_TIME_RESTRICTION (0xc0000247)
+#define STATUS_LOGIN_WKSTA_RESTRICTION (0xc0000248)
+#define STATUS_IMAGE_MP_UP_MISMATCH (0xc0000249)
+
+#define STATUS_INSUFFICIENT_LOGON_INFO (0xc0000250)
+#define STATUS_BAD_DLL_ENTRYPOINT (0xc0000251)
+#define STATUS_BAD_SERVICE_ENTRYPOINT (0xc0000252)
+#define STATUS_LPC_REPLY_LOST (0xc0000253)
+#define STATUS_IP_ADDRESS_CONFLICT1 (0xc0000254)
+#define STATUS_IP_ADDRESS_CONFLICT2 (0xc0000255)
+#define STATUS_REGISTRY_QUOTA_LIMIT (0xc0000256)
+#define STATUS_PATH_NOT_COVERED (0xc0000257)
+#define STATUS_NO_CALLBACK_ACTIVE (0xc0000258)
+#define STATUS_LICENSE_QUOTA_EXCEEDED (0xc0000259)
+#define STATUS_PWD_TOO_SHORT (0xc000025a)
+#define STATUS_PWD_TOO_RECENT (0xc000025b)
+#define STATUS_PWD_HISTORY_CONFLICT (0xc000025c)
+#define STATUS_PLUGPLAY_NO_DEVICE (0xc000025e)
+#define STATUS_UNSUPPORTED_COMPRESSION (0xc000025f)
+#define STATUS_INVALID_HW_PROFILE (0xc0000260)
+#define STATUS_INVALID_PLUGPLAY_DEVICE_PATH (0xc0000261)
+#define STATUS_DRIVER_ORDINAL_NOT_FOUND (0xc0000262)
+#define STATUS_DRIVER_ENTRYPOINT_NOT_FOUND (0xc0000263)
+#define STATUS_RESOURCE_NOT_OWNED (0xc0000264)
+#define STATUS_TOO_MANY_LINKS (0xc0000265)
+#define STATUS_QUOTA_LIST_INCONSISTENT (0xc0000266)
+#define STATUS_FILE_IS_OFFLINE (0xc0000267)
+#define STATUS_EVALUATION_EXPIRATION (0xc0000268)
+#define STATUS_ILLEGAL_DLL_RELOCATION (0xc0000269)
+#define STATUS_LICENSE_VIOLATION (0xc000026a)
+#define STATUS_DLL_INIT_FAILED_LOGOFF (0xc000026b)
+#define STATUS_DRIVER_UNABLE_TO_LOAD (0xc000026c)
+#define STATUS_DFS_UNAVAILABLE (0xc000026d)
+#define STATUS_VOLUME_DISMOUNTED (0xc000026e)
+#define STATUS_WX86_INTERNAL_ERROR (0xc000026f)
+#define STATUS_WX86_FLOAT_STACK_CHECK (0xc0000270)
+#define STATUS_VALIDATE_CONTINUE (0xc0000271)
+#define STATUS_NO_MATCH (0xc0000272)
+#define STATUS_NO_MORE_MATCHES (0xc0000273)
+#define STATUS_INVALID_VLM_OPERATION (0xc0000274)
+#define STATUS_NOT_A_REPARSE_POINT (0xc0000275)
+#define STATUS_IO_REPARSE_TAG_INVALID (0xc0000276)
+#define STATUS_IO_REPARSE_TAG_MISMATCH (0xc0000277)
+#define STATUS_IO_REPARSE_DATA_INVALID (0xc0000278)
+#define STATUS_IO_REPARSE_TAG_NOT_HANDLED (0xc0000279)
+
+
+#define STATUS_SAM_INIT_FAILURE (0xC00002CB)
+
+
+#define RPC_NT_INVALID_STRING_BINDING (0xC0020001)
+#define RPC_NT_WRONG_KIND_OF_BINDING (0xC0020002)
+#define RPC_NT_INVALID_BINDING (0xC0020003)
+#define RPC_NT_PROTSEQ_NOT_SUPPORTED (0xC0020004)
+#define RPC_NT_INVALID_RPC_PROTSEQ (0xC0020005)
+#define RPC_NT_INVALID_STRING_UUID (0xC0020006)
+#define RPC_NT_INVALID_ENDPOINT_FORMAT (0xC0020007)
+#define RPC_NT_INVALID_NET_ADDR (0xC0020008)
+#define RPC_NT_NO_ENDPOINT_FOUND (0xC0020009)
+#define RPC_NT_INVALID_TIMEOUT (0xC002000A)
+#define RPC_NT_OBJECT_NOT_FOUND (0xC002000B)
+#define RPC_NT_ALREADY_REGISTERED (0xC002000C)
+#define RPC_NT_TYPE_ALREADY_REGISTERED (0xC002000D)
+#define RPC_NT_ALREADY_LISTENING (0xC002000E)
+#define RPC_NT_NO_PROTSEQS_REGISTERED (0xC002000F)
+#define RPC_NT_NOT_LISTENING (0xC0020010)
+#define RPC_NT_UNKNOWN_MGR_TYPE (0xC0020011)
+#define RPC_NT_UNKNOWN_IF (0xC0020012)
+#define RPC_NT_NO_BINDINGS (0xC0020013)
+#define RPC_NT_NO_PROTSEQS (0xC0020014)
+#define RPC_NT_CANT_CREATE_ENDPOINT (0xC0020015)
+#define RPC_NT_OUT_OF_RESOURCES (0xC0020016)
+#define RPC_NT_SERVER_UNAVAILABLE (0xC0020017)
+#define RPC_NT_SERVER_TOO_BUSY (0xC0020018)
+#define RPC_NT_INVALID_NETWORK_OPTIONS (0xC0020019)
+#define RPC_NT_NO_CALL_ACTIVE (0xC002001A)
+#define RPC_NT_CALL_FAILED (0xC002001B)
+#define RPC_NT_CALL_FAILED_DNE (0xC002001C)
+#define RPC_NT_PROTOCOL_ERROR (0xC002001D)
+
+
+#define RPC_NT_SS_IN_NULL_CONTEXT (0xC0030004)
+
+
+/* FIXME: Are these official values ?? */
+#define STATUS_FS_QUERY_REQUIRED (0xC1000001)
+#define STATUS_HANDLE_NOT_WAITABLE (0xC1000002)
+#define STATUS_OBJECT_FILE_MISMATCH (0xC1000003)
+#define STATUS_INVALID_PARAMETER_MAX (0xC1000004)
+#define STATUS_CONFLICTING_ADDRESS (0xC1000005)
+#define STATUS_NO_MEDIA_IN_DRIVE (0xC1000006)
+
+#endif /* __INCLUDE_DDK_STATUS_H */
+
+
+
+
+
+
--- /dev/null
+/* SYSTEM STRUCTURES ******************************************************/
+
+#include <ddk/cfgtypes.h>
+#include <ddk/ketypes.h>
+#include <ddk/obtypes.h>
+#include <ddk/mmtypes.h>
+#include <ddk/iotypes.h>
+#include <ddk/extypes.h>
+#include <ddk/pstypes.h>
+
--- /dev/null
+#ifndef __INCLUDE_DDK_TYPES_H
+#define __INCLUDE_DDK_TYPES_H
+
+// these should be moved to a file like ntdef.h
+
+
+
+typedef ULONG KAFFINITY, *PKAFFINITY;
+
+
+
+
+
+/*
+ * Various other types (all quite pointless)
+ */
+typedef CCHAR KPROCESSOR_MODE;
+typedef UCHAR KIRQL;
+typedef KIRQL* PKIRQL;
+typedef ULONG IO_ALLOCATION_ACTION;
+typedef ULONG POOL_TYPE;
+typedef ULONG TIMER_TYPE;
+typedef ULONG MM_SYSTEM_SIZE;
+typedef ULONG LOCK_OPERATION;
+
+typedef LARGE_INTEGER PHYSICAL_ADDRESS;
+typedef PHYSICAL_ADDRESS* PPHYSICAL_ADDRESS;
+
+
+
+
+#endif /* __INCLUDE_DDK_TYPES_H */
--- /dev/null
+/*
+ * WinDDI.h - definition of the GDI - DDI interface
+ */
+
+#ifndef __DDK_WINDDI_H
+#define __DDK_WINDDI_H
+
+#if defined(WIN32_LEAN_AND_MEAN) && defined(_GNU_H_WINDOWS32_STRUCTURES)
+#error "windows.h cannot be included before winddi.h if WIN32_LEAN_AND_MEAN is defined"
+#endif
+
+#ifdef WIN32_LEAN_AND_MEAN
+#undef WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#define WIN32_LEAN_AND_MEAN
+#else
+#include <windows.h>
+#endif
+
+#ifndef IN
+#define IN
+#define OUT
+#define OPTIONAL
+#endif
+
+#ifndef PTRDIFF
+typedef DWORD PTRDIFF;
+#endif
+
+#define GDI_DRIVER_VERSION 0x4000 // NT 4 compatibility
+
+/* FIXME: find definitions for these structs */
+typedef PVOID PCOLORADJUSTMENT;
+typedef PVOID PDD_CALLBACKS;
+typedef PVOID PDD_HALINFO;
+typedef PVOID PDD_PALETTECALLBACKS;
+typedef PVOID PDD_SURFACECALLBACKS;
+typedef PVOID PFONTINFO;
+typedef PVOID PGAMMA_TABLES;
+typedef PVOID PGLYPHDATA;
+typedef PVOID PLINEATTRS;
+typedef DWORD MIX;
+typedef DWORD ROP4;
+typedef PVOID PSTROBJ;
+typedef PVOID PTTPOLYGONHEADER;
+typedef PVOID PVIDEOMEMORY;
+
+#define DDI_DRIVER_VERSION 0x00010000
+
+/* FIXME: how big should this constant be? */
+#define HS_DDI_MAX 6
+
+/* XLate types */
+#define XO_TRIVIAL 0x00000001
+#define XO_TABLE 0x00000002
+#define XO_TO_MONO 0x00000004
+
+#define XO_SRCPALETTE 1
+#define XO_DESTPALETTE 2
+#define XO_DESTDCPALETTE 3
+
+/* EngCreateBitmap format types */
+enum _BMF_TYPES
+{
+ BMF_1BPP = 1,
+ BMF_4BPP,
+ BMF_8BPP,
+ BMF_16BPP,
+ BMF_24BPP,
+ BMF_32BPP,
+ BMF_4RLE,
+ BMF_8RLE
+};
+
+#define BMF_TOPDOWN 0x00000001
+#define BMF_NOZEROINIT 0x00000002
+#define BMF_DONTCACHE 0x00000004
+#define BMF_USERMEM 0x00000008
+#define BMF_KMSECTION 0x00000010
+
+#define DC_TRIVIAL 0
+#define DC_RECT 1
+#define DC_COMPLEX 3
+
+#define FC_RECT 1
+#define FC_RECT4 2
+#define FC_COMPLEX 3
+
+#define TC_RECTANGLES 0
+#define TC_PATHOBJ 2
+
+#define OC_BANK_CLIP 1
+
+#define CT_RECTANGLES 0L
+
+#define CD_LEFTWARDS 1L
+#define CD_UPWARDS 2L
+
+/* Options for CLIPOBJ_cEnumStart BuildOrder field */
+enum _CD_ORDERS
+{
+ CD_RIGHTDOWN,
+ CD_LEFTDOWN,
+ CD_RIGHTUP,
+ CD_LEFTUP,
+ CD_ANY
+};
+
+/* Options for CLIPOBJ_cEnumStart Type field */
+#define CT_RECTANGLE 1
+
+#define DCR_SOLID 0
+#define DCR_DRIVER 1
+#define DCR_HALFTONE 2
+
+#define DMMAXDEVICENAME 32
+#define DMMAXFORMNAME 32
+
+#define DM_DEFAULT 0x00000001
+#define DM_MONOCHROME 0x00000002
+
+#define ED_ABORTDOC 0x00000001
+
+enum _ESCAPE_CODES
+{
+ ESC_PASSTHROUGH,
+ ESC_QUERYESCSUPPORT
+};
+
+#define FM_INFO_TECH_TRUETYPE 0x00000001
+#define FM_INFO_TECH_BITMAP 0x00000002
+#define FM_INFO_TECH_STROKE 0x00000004
+#define FM_INFO_TECH_OUTLINE_NOT_TRUETYPE 0x00000008
+#define FM_INFO_ARB_XFORMS 0x00000010
+#define FM_INFO_1BPP 0x00000020
+#define FM_INFO_4BPP 0x00000040
+#define FM_INFO_8BPP 0x00000080
+#define FM_INFO_16BPP 0x00000100
+#define FM_INFO_24BPP 0x00000200
+#define FM_INFO_32BPP 0x00000400
+#define FM_INFO_INTEGER_WIDTH 0x00000800
+#define FM_INFO_CONSTANT_WIDTH 0x00001000
+#define FM_INFO_NOT_CONTIGUOUS 0x00002000
+#define FM_INFO_PID_EMBEDDED 0x00004000
+#define FM_INFO_RETURNS_OUTLINES 0x00008000
+#define FM_INFO_RETURNS_STROKES 0x00010000
+#define FM_INFO_RETURNS_BITMAPS 0x00020000
+#define FM_INFO_UNICODE_COMPLIANT 0x00040000
+#define FM_INFO_RIGHT_HANDED 0x00080000
+#define FM_INFO_INTEGRAL_SCALING 0x00100000
+#define FM_INFO_90DEGREE_ROTATIONS 0x00200000
+#define FM_INFO_OPTICALLY_FIXED_PITCH 0x00400000
+#define FM_INFO_DO_NOT_ENUMERATE 0x00800000
+#define FM_INFO_ISOTROPIC_SCALING_ONLY 0x01000000
+#define FM_INFO_ANISOTROPIC_SCALING_ONLY 0x02000000
+#define FM_INFO_TID_EMBEDDED 0x04000000
+#define FM_INFO_FAMILY_EQUIV 0x08000000
+#define FM_INFO_DBCS_FIXED_PITCH 0x10000000
+#define FM_INFO_NONNEGATIVE_AC 0x20000000
+#define FM_INFO_IGNORE_TC_RA_ABLE 0x40000000
+#define FM_INFO_TECH_TYPE1 0x80000000
+
+#define FM_SEL_ITALIC 0x00000001
+#define FM_SEL_UNDERSCORE 0x00000002
+#define FM_SEL_NEGATIVE 0x00000004
+#define FM_SEL_OUTLINED 0x00000008
+#define FM_SEL_STRIKEOUT 0x00000010
+#define FM_SEL_BOLD 0x00000020
+#define FM_SEL_REGULAR 0x00000040
+
+#define FM_TYPE_LICENSED 0x00000002
+#define FM_READONLY_EMBED 0x00000004
+#define FM_EDITABLE_EMBED 0x00000008
+#define FM_NO_EMBEDDING 0x00000002
+
+#define FO_TYPE_RASTER RASTER_FONTTYPE
+#define FO_TYPE_DEVICE DEVICE_FONTTYPE
+#define FO_TYPE_TRUETYPE TRUETYPE_FONTTYPE
+#define FO_SIM_BOLD 0x00002000
+#define FO_SIM_ITALIC 0x00004000
+#define FO_EM_HEIGHT 0x00008000
+#define FO_GRAY16 0x00010000
+#define FO_NOGRAY16 0x00020000
+#define FO_NOHINTS 0x00040000
+#define FO_NO_CHOICE 0x00080000
+
+enum _FP_MODES
+{
+ FP_ALTERNATEMODE = 1,
+ FP_WINDINGMODE
+};
+
+enum _GLYPH_MODE
+{
+ FO_HGLYPHS,
+ FO_GLYPHBITS,
+ FO_PATHOBJ
+};
+
+// Allowed values for GDIINFO.ulPrimaryOrder.
+
+#define PRIMARY_ORDER_ABC 0
+#define PRIMARY_ORDER_ACB 1
+#define PRIMARY_ORDER_BAC 2
+#define PRIMARY_ORDER_BCA 3
+#define PRIMARY_ORDER_CBA 4
+#define PRIMARY_ORDER_CAB 5
+
+// Allowed values for GDIINFO.ulHTPatternSize.
+
+#define HT_PATSIZE_2x2 0
+#define HT_PATSIZE_2x2_M 1
+#define HT_PATSIZE_4x4 2
+#define HT_PATSIZE_4x4_M 3
+#define HT_PATSIZE_6x6 4
+#define HT_PATSIZE_6x6_M 5
+#define HT_PATSIZE_8x8 6
+#define HT_PATSIZE_8x8_M 7
+#define HT_PATSIZE_10x10 8
+#define HT_PATSIZE_10x10_M 9
+#define HT_PATSIZE_12x12 10
+#define HT_PATSIZE_12x12_M 11
+#define HT_PATSIZE_14x14 12
+#define HT_PATSIZE_14x14_M 13
+#define HT_PATSIZE_16x16 14
+#define HT_PATSIZE_16x16_M 15
+#define HT_PATSIZE_MAX_INDEX HT_PATSIZE_16x16_M
+#define HT_PATSIZE_DEFAULT HT_PATSIZE_4x4_M
+
+// Allowed values for GDIINFO.ulHTOutputFormat.
+
+#define HT_FORMAT_1BPP 0
+#define HT_FORMAT_4BPP 2
+#define HT_FORMAT_4BPP_IRGB 3
+#define HT_FORMAT_8BPP 4
+#define HT_FORMAT_16BPP 5
+#define HT_FORMAT_24BPP 6
+#define HT_FORMAT_32BPP 7
+
+// Allowed values for GDIINFO.flHTFlags.
+
+#define HT_FLAG_SQUARE_DEVICE_PEL 0x00000001
+#define HT_FLAG_HAS_BLACK_DYE 0x00000002
+#define HT_FLAG_ADDITIVE_PRIMS 0x00000004
+#define HT_FLAG_OUTPUT_CMY 0x00000100
+
+#define GCAPS_BEZIERS 0x00000001
+#define GCAPS_GEOMETRICWIDE 0x00000002
+#define GCAPS_ALTERNATEFILL 0x00000004
+#define GCAPS_WINDINGFILL 0x00000008
+#define GCAPS_HALFTONE 0x00000010
+#define GCAPS_COLOR_DITHER 0x00000020
+#define GCAPS_HORIZSTRIKE 0x00000040
+#define GCAPS_VERTSTRIKE 0x00000080
+#define GCAPS_OPAQUERECT 0x00000100
+#define GCAPS_VECTORFONT 0x00000200
+#define GCAPS_MONO_DITHER 0x00000400
+#define GCAPS_ASYNCCHANGE 0x00000800
+#define GCAPS_ASYNCMOVE 0x00001000
+#define GCAPS_DONTJOURNAL 0x00002000
+#define GCAPS_DIRECTDRAW 0x00004000
+#define GCAPS_ARBRUSHOPAQUE 0x00008000
+#define GCAPS_PANNING 0x00010000
+#define GCAPS_HIGHRESTEXT 0x00040000
+#define GCAPS_PALMANAGED 0x00080000
+#define GCAPS_DITHERONREALIZE 0x00200000
+#define GCAPS_NO64BITMEMACCESS 0x00400000
+#define GCAPS_FORCEDITHER 0x00800000
+#define GCAPS_GRAY16 0x01000000
+
+/* EngAssocateSurface hook flags */
+#define HOOK_BITBLT 0x00000001
+#define HOOK_STRETCHBLT 0x00000002
+#define HOOK_PLGBLT 0x00000004
+#define HOOK_TEXTOUT 0x00000008
+#define HOOK_PAINT 0x00000010
+#define HOOK_STROKEPATH 0x00000020
+#define HOOK_FILLPATH 0x00000040
+#define HOOK_STROKEANDFILLPATH 0x00000080
+#define HOOK_LINETO 0x00000100
+#define HOOK_COPYBITS 0x00000400
+#define HOOK_SYNCHRONIZE 0x00001000
+#define HOOK_SYNCHRONIZEACCESS 0x00004000
+#define HOOK_TRANSPARENTBLT 0x00008000
+
+enum _DRV_HOOK_FUNCS
+{
+ INDEX_DrvEnablePDEV,
+ INDEX_DrvCompletePDEV,
+ INDEX_DrvDisablePDEV,
+ INDEX_DrvEnableSurface,
+ INDEX_DrvDisableSurface,
+ INDEX_DrvAssertMode,
+ INDEX_DrvResetPDEV = 7,
+ INDEX_DrvCreateDeviceBitmap = 10,
+ INDEX_DrvDeleteDeviceBitmap,
+ INDEX_DrvRealizeBrush,
+ INDEX_DrvDitherColor,
+ INDEX_DrvStrokePath,
+ INDEX_DrvFillPath,
+ INDEX_DrvStrokeAndFillPath,
+ INDEX_DrvPaint,
+ INDEX_DrvBitBlt,
+ INDEX_DrvCopyBits,
+ INDEX_DrvStretchBlt,
+ INDEX_DrvSetPalette = 22,
+ INDEX_DrvTextOut,
+ INDEX_DrvEscape,
+ INDEX_DrvDrawEscape,
+ INDEX_DrvQueryFont,
+ INDEX_DrvQueryFontTree,
+ INDEX_DrvQueryFontData,
+ INDEX_DrvSetPointerShape,
+ INDEX_DrvMovePointer,
+ INDEX_DrvLineTo,
+ INDEX_DrvSendPage,
+ INDEX_DrvStartPage,
+ INDEX_DrvEndDoc,
+ INDEX_DrvStartDoc,
+ INDEX_DrvGetGlyphMode = 37,
+ INDEX_DrvSynchronize,
+ INDEX_DrvSaveScreenBits = 40,
+ INDEX_DrvGetModes,
+ INDEX_DrvFree,
+ INDEX_DrvDestroyFont,
+ INDEX_DrvQueryFontCaps,
+ INDEX_DrvLoadFontFile,
+ INDEX_DrvUnloadFontFile,
+ INDEX_DrvFontManagement,
+ INDEX_DrvQueryTrueTypeTable,
+ INDEX_DrvQueryTrueTypeOutline,
+ INDEX_DrvGetTrueTypeFile,
+ INDEX_DrvQueryFontFile,
+ INDEX_DrvQueryAdvanceWidths = 53,
+ INDEX_DrvSetPixelFormat,
+ INDEX_DrvDescribePixelFormat,
+ INDEX_DrvSwapBuffers,
+ INDEX_DrvStartBanding,
+ INDEX_DrvNextBand,
+ INDEX_DrvGetDirectDrawInfo,
+ INDEX_DrvEnableDirectDraw,
+ INDEX_DrvDisableDirectDraw,
+ INDEX_DrvQuerySpoolType,
+ INDEX_DrvTransparentBlt = 74,
+ INDEX_LAST
+};
+
+/* EngCreatePalette mode types */
+#define PAL_INDEXED 0x00000001
+#define PAL_BITFIELDS 0x00000002
+#define PAL_RGB 0x00000004
+#define PAL_BGR 0x00000008
+
+enum _QUERY_ADVANCE_WIDTH_TYPES
+{
+ QAW_GETWIDTHS = 1,
+ QAW_GETEASYWIDTHS
+};
+
+#define QC_OUTLINES 0x00000001
+#define QC_1BIT 0x00000002
+#define QC_4BIT 0x00000004
+
+enum _QFF_MODES
+{
+ QFF_DESCRIPTION = 1,
+ QFF_NUMFACES
+};
+
+#define RB_DITHERCOLOR 0x80000000
+
+enum _SPS_RC
+{
+ SPS_ERROR,
+ SPS_DECLINE,
+ SPS_ACCEPT_NOEXCLUDE,
+ SPS_ACCEPT_EXCLUDE
+};
+
+#define SPS_CHANGE 0x00000001L
+#define SPS_ASYNCCHANGE 0x00000002L
+#define SPS_ANIMATESTART 0x00000004L
+#define SPS_ANIMATEUPDATE 0x00000008L
+
+#define SS_SAVE 0
+#define SS_RESTORE 1
+#define SS_FREE 2
+
+enum _SURF_TYPES
+{
+ STYPE_BITMAP = 1,
+ STYPE_DEVICE,
+ STYPE_DEVBITMAP
+};
+
+#define WO_RGN_CLIENT_DELTA 0x00000001
+#define WO_RGN_CLIENT 0x00000002
+#define WO_RGN_SURFACE_DELTA 0x00000004
+#define WO_RGN_SURFACE 0x00000008
+#define WO_RGN_UPDATE_ALL 0x00000010
+
+#define WOC_RGN_CLIENT_DELTA 0x00000001
+#define WOC_RGN_CLIENT 0x00000002
+#define WOC_RGN_SURFACE_DELTA 0x00000004
+#define WOC_RGN_SURFACE 0x00000008
+#define WOC_CHANGED 0x00000010
+#define WOC_DELETE 0x00000020
+
+typedef HANDLE HDEV;
+typedef HANDLE HGLYPH;
+typedef HANDLE HSURF;
+typedef HANDLE DHPDEV;
+typedef HANDLE DHSURF;
+typedef ULONG (*PFN)(VOID);
+typedef ULONG IDENT;
+
+typedef struct _DRVFN
+{
+ ULONG iFunc;
+ PFN pfn;
+} DRVFN, *PDRVFN;
+
+/*
+ * DRVENABLEDATA - this structure is passed to the DDI from the GDI
+ * in the function DrvEnableDriver to determine driver parameters.
+ */
+
+typedef struct _DRVENABLEDATA
+{
+ ULONG iDriverVersion;
+ ULONG c;
+ DRVFN *pdrvfn;
+} DRVENABLEDATA, *PDRVENABLEDATA;
+
+/* FIXME: replace this with correct def for LDECI4 */
+typedef DWORD LDECI4;
+
+typedef struct _CIECHROMA
+{
+ LDECI4 x;
+ LDECI4 y;
+ LDECI4 Y;
+} CIECHROMA, *PCIECHROMA;
+
+typedef struct _COLORINFO
+{
+ CIECHROMA Red;
+ CIECHROMA Green;
+ CIECHROMA Blue;
+ CIECHROMA Cyan;
+ CIECHROMA Magenta;
+ CIECHROMA Yellow;
+ CIECHROMA AlignmentWhite;
+ LDECI4 RedGamma;
+ LDECI4 GreenGamma;
+ LDECI4 BlueGamma;
+ LDECI4 MagentaInCyanDye;
+ LDECI4 YellowInCyanDye;
+ LDECI4 CyanInMagentaDye;
+ LDECI4 YellowInMagentaDye;
+ LDECI4 CyanInYellowDye;
+ LDECI4 MagentaInYellowDye;
+} COLORINFO, *PCOLORINFO;
+
+typedef struct _DEVINFO
+{
+ ULONG flGraphicsCaps;
+ LOGFONTW lfDefaultFont;
+ LOGFONTW lfAnsiVarFont;
+ LOGFONTW lfAnsiFixFont;
+ ULONG cFonts;
+ ULONG iDitherFormat;
+ USHORT cxDither;
+ USHORT cyDither;
+ HPALETTE hpalDefault;
+} DEVINFO, *PDEVINFO;
+
+typedef struct _GDIINFO
+{
+ ULONG ulVersion;
+ ULONG ulTechnology;
+ ULONG ulHorzSize;
+ ULONG ulVertSize;
+ ULONG ulHorzRes;
+ ULONG ulVertRes;
+ ULONG cBitsPixel;
+ ULONG cPlanes;
+ ULONG ulNumColors;
+ ULONG flRaster;
+ ULONG ulLogPixelsX;
+ ULONG ulLogPixelsY;
+ ULONG flTextCaps;
+ ULONG ulDACRed;
+ ULONG ulDACGreen;
+ ULONG ulDACBlue;
+ ULONG ulAspectX;
+ ULONG ulAspectY;
+ ULONG ulAspectXY;
+ LONG xStyleStep;
+ LONG yStyleStep;
+ LONG denStyleStep;
+ POINTL ptlPhysOffset;
+ SIZEL szlPhysSize;
+ ULONG ulNumPalReg;
+ COLORINFO ciDevice;
+ ULONG ulDevicePelsDPI;
+ ULONG ulPrimaryOrder;
+ ULONG ulHTPatternSize;
+ ULONG ulHTOutputFormat;
+ ULONG flHTFlags;
+ ULONG ulVRefresh;
+ ULONG ulBltAlignment;
+ ULONG ulPanningHorzRes;
+ ULONG ulPanningVertRes;
+} GDIINFO, *PGDIINFO;
+
+typedef struct _BRUSHOBJ
+{
+ ULONG iSolidColor;
+ PVOID pvRbrush;
+
+ /* remainder of fields are for GDI internal use */
+ LOGBRUSH logbrush;
+} BRUSHOBJ, *PBRUSHOBJ;
+
+typedef struct _CLIPOBJ
+{
+ ULONG iUniq;
+ RECTL rclBounds;
+ BYTE iDComplexity;
+ BYTE iFComplexity;
+ BYTE iMode;
+ BYTE fjOptions;
+} CLIPOBJ, *PCLIPOBJ;
+
+typedef struct _ENUMRECTS
+{
+ ULONG c;
+ RECTL arcl[1];
+} ENUMRECTS, *PENUMRECTS;
+
+typedef struct _FONTOBJ
+{
+ ULONG iUniq;
+ ULONG iFace;
+ ULONG cxMax;
+ ULONG flFontType;
+ ULONG iTTUniq;
+ ULONG iFile;
+ SIZE sizLogResPpi;
+ ULONG ulStyleSize;
+ PVOID pvConsumer;
+ PVOID pvProducer;
+} FONTOBJ, *PFONTOBJ;
+
+typedef struct _IFIMETRICS
+{
+ ULONG cjThis;
+ ULONG ulVersion;
+ PTRDIFF dpwszFamilyName;
+ PTRDIFF dpwszStyleName;
+ PTRDIFF dpwszFaceName;
+ PTRDIFF dpwszUniqueName;
+ PTRDIFF dpFontSim;
+ LONG lEmbedId;
+ LONG lItalicAngle;
+ LONG lCharBias;
+ PTRDIFF dpCharSets;
+ BYTE jWinCharSet;
+ BYTE jWinPitchAndFamily;
+ USHORT usWinWeight;
+ ULONG flInfo;
+ USHORT fsSelection;
+ USHORT fsType;
+ WORD fwdUnitsPerEm;
+ WORD fwdLowestPPEm;
+ WORD fwdWinAscender;
+ WORD fwdWinDescender;
+ WORD fwdMacAscender;
+ WORD fwdMacDescender;
+ WORD fwdMacLineGap;
+ WORD fwdTypoAscender;
+ WORD fwdTypoDescender;
+ WORD fwdTypoLineGap;
+ WORD fwdAveCharWidth;
+ WORD fwdMaxCharInc;
+ WORD fwdCapHeight;
+ WORD fwdXHeight;
+ WORD fwdSubScriptXSize;
+ WORD fwdSubScriptYSize;
+ WORD fwdSubScriptXOffset;
+ WORD fwdSubScriptYOffset;
+ WORD fwdSuperScriptXSize;
+ WORD fwdSuperScriptYSize;
+ WORD fwdSuperScriptXOffset;
+ WORD fwdSuperScriptYOffset;
+ WORD fwdUnderscoreSize;
+ WORD fwdUnderscorePosition;
+ WORD fwdStrikeoutSize;
+ WORD fwdStrikeoutPosition;
+ BYTE chFirstChar;
+ BYTE chLastChar;
+ BYTE chDefaultChar;
+ BYTE chBreakChar;
+ WCHAR wcFirstChar;
+ WCHAR wcLastChar;
+ WCHAR wcDefaultChar;
+ WCHAR wcBreakChar;
+ POINTL ptlBaseline;
+ POINTL ptlAspect;
+ POINTL ptlCaret;
+ RECTL rclFontBox;
+ BYTE achVendId[4];
+ ULONG cKerningPairs;
+ ULONG ulPanoseCulture;
+ PANOSE panose;
+} IFIMETRICS, *PIFIMETRICS;
+
+#define NB_RESERVED_COLORS 20 // number of fixed colors in system palette
+
+typedef struct _XLATEOBJ
+{
+ ULONG iUniq;
+ ULONG flXlate;
+ USHORT iSrcType;
+ USHORT iDstType;
+ ULONG cEntries;
+ ULONG *pulXlate;
+} XLATEOBJ, *PXLATEOBJ;
+
+typedef struct _PALOBJ
+{
+ PXLATEOBJ logicalToSystem;
+ int *mapping;
+ PLOGPALETTE logpalette; // _MUST_ be the last field
+} PALOBJ, *PPALOBJ;
+
+typedef struct _PATHOBJ
+{
+ ULONG fl;
+ ULONG cCurves;
+} PATHOBJ, *PPATHOBJ;
+
+typedef struct _SURFOBJ
+{
+ DHSURF dhsurf;
+ HSURF hsurf;
+ DHPDEV dhpdev;
+ HDEV hdev;
+ SIZEL sizlBitmap;
+ ULONG cjBits;
+ PVOID pvBits;
+ PVOID pvScan0;
+ LONG lDelta;
+ ULONG iUniq;
+ ULONG iBitmapFormat;
+ USHORT iType;
+ USHORT fjBitmap;
+} SURFOBJ, *PSURFOBJ;
+
+typedef struct _WNDOBJ
+{
+ CLIPOBJ coClient;
+ PVOID pvConsumer;
+ RECTL rclClient;
+} WNDOBJ, *PWNDOBJ;
+
+typedef VOID (CALLBACK * WNDOBJCHANGEPROC)(PWNDOBJ WndObj, ULONG Flags);
+
+typedef struct _XFORMOBJ
+{
+ /* FIXME: what does this beast look like? */
+} XFORMOBJ, *PXFORMOBJ;
+
+/*
+ * Functions Prefixed with Drv are calls made from GDI to DDI, and
+ * everything else are calls made from DDI to GDI. DDI is
+ * not allowed to make calls to any other kernel or user modules.
+ */
+
+/* GDI --> DDI calls */
+BOOL STDCALL
+DrvAssertMode(IN DHPDEV PDev,
+ IN BOOL ShouldEnable);
+BOOL STDCALL
+DrvBitBlt(IN PSURFOBJ DestSurface,
+ IN PSURFOBJ SrcSurface,
+ IN PSURFOBJ MaskSurface,
+ IN PCLIPOBJ ClipObj,
+ IN PXLATEOBJ XLateObj,
+ IN PRECTL DestRectL,
+ IN PPOINTL SrcPointL,
+ IN PPOINTL MaskPointL,
+ IN PBRUSHOBJ BrushObj,
+ IN PPOINTL BrushPointL,
+ IN ROP4 RasterOp);
+VOID STDCALL
+DrvCompletePDEV(IN DHPDEV PDev,
+ IN HDEV Dev);
+BOOL STDCALL
+DrvCopyBits(OUT PSURFOBJ DestSurface,
+ IN PSURFOBJ SrcSurface,
+ IN PCLIPOBJ ClipObj,
+ IN PXLATEOBJ XLateObj,
+ IN PRECTL DestRectL,
+ IN PPOINTL SrcPointL);
+HBITMAP STDCALL
+DrvCreateDeviceBitmap(IN DHPDEV DPev,
+ IN SIZEL SizeL,
+ IN ULONG Format);
+VOID STDCALL
+DrvDeleteDeviceBitmap(IN DHSURF Surface);
+LONG STDCALL
+DrvDescribePixelFormat(IN DHPDEV DPev,
+ IN LONG PixelFormat,
+ IN ULONG DescriptorSize,
+ OUT PPIXELFORMATDESCRIPTOR PFD);
+VOID STDCALL
+DrvDestroyFont(IN PFONTOBJ FontObj);
+VOID STDCALL
+DrvDisableDirectDraw(IN DHPDEV PDev);
+VOID STDCALL
+DrvDisableDriver(VOID);
+VOID STDCALL
+DrvDisablePDEV(IN DHPDEV PDev);
+VOID STDCALL
+DrvDisableSurface(IN DHPDEV PDev);
+ULONG STDCALL
+DrvDitherColor(IN DHPDEV DPev,
+ IN ULONG Mode,
+ IN ULONG RGB,
+ OUT PULONG DitherBits);
+ULONG STDCALL
+DrvDrawEscape(IN PSURFOBJ SurfObj,
+ IN ULONG EscCode,
+ IN PCLIPOBJ ClipObj,
+ IN PRECTL RectL,
+ IN ULONG InputSize,
+ IN PVOID *InputData);
+BOOL STDCALL
+DrvEnableDirectDraw(IN DHPDEV PDev,
+ IN PDD_CALLBACKS Callbacks,
+ IN PDD_SURFACECALLBACKS SurfaceCallbacks,
+ IN PDD_PALETTECALLBACKS PaletteCallbacks);
+BOOL STDCALL
+DrvEnableDriver(IN ULONG Version,
+ IN ULONG DEDSize,
+ OUT PDRVENABLEDATA DED);
+DHPDEV STDCALL
+DrvEnablePDEV(IN DEVMODEW *DM,
+ IN LPWSTR LogAddress,
+ IN ULONG PatternCount,
+ OUT HSURF *SurfPatterns,
+ IN ULONG CapsSize,
+ OUT ULONG *DevCaps,
+ IN ULONG DevInfoSize,
+ OUT DEVINFO *DI,
+ IN LPWSTR DevDataFile,
+ IN LPWSTR DeviceName,
+ IN HANDLE Driver);
+HSURF STDCALL
+DrvEnableSurface(IN DHPDEV PDev);
+BOOL STDCALL
+DrvEndDoc(IN PSURFOBJ SurfObj,
+ IN ULONG Flags);
+ULONG STDCALL
+DrvEscape(IN PSURFOBJ SurfObj,
+ IN ULONG EscCode,
+ IN ULONG InputSize,
+ IN PVOID *InputData,
+ IN ULONG OutputSize,
+ OUT PVOID *OutputData);
+BOOL STDCALL
+DrvFillPath(IN PSURFOBJ SurfObj,
+ IN PPATHOBJ PathObj,
+ IN PCLIPOBJ ClipObj,
+ IN PBRUSHOBJ BrushObj,
+ IN PPOINTL BrushOrg,
+ IN MIX Mix,
+ IN ULONG Options);
+ULONG STDCALL
+DrvFontManagement(IN PSURFOBJ SurfObj,
+ IN PFONTOBJ FontObj,
+ IN ULONG Mode,
+ IN ULONG InputSize,
+ IN PVOID InputData,
+ IN ULONG OutputSize,
+ OUT PVOID OutputData);
+VOID STDCALL
+DrvFree(IN PVOID Obj,
+ IN ULONG ID);
+BOOL STDCALL
+DrvGetDirectDrawInfo(IN DHPDEV PDev,
+ IN PDD_HALINFO HalInfo,
+ IN PDWORD NumHeaps,
+ IN PVIDEOMEMORY List,
+ IN PDWORD NumFourCCCodes,
+ IN PDWORD FourCC);
+ULONG STDCALL
+DrvGetGlyphMode(IN DHPDEV DPev,
+ IN PFONTOBJ FontObj);
+ULONG STDCALL
+DrvGetModes(IN HANDLE Driver,
+ IN ULONG DataSize,
+ OUT PDEVMODEW DM);
+PVOID STDCALL
+DrvGetTrueTypeFile(IN ULONG FileNumber,
+ IN PULONG Size);
+BOOL STDCALL
+DrvLineTo(IN PSURFOBJ SurfObj,
+ IN PCLIPOBJ ClipObj,
+ IN PBRUSHOBJ BrushObj,
+ IN LONG x1,
+ IN LONG y1,
+ IN LONG x2,
+ IN LONG y2,
+ IN PRECTL Bounds,
+ IN MIX Mix);
+ULONG STDCALL
+DrvLoadFontFile(IN ULONG FileNumber,
+ IN PVOID ViewData,
+ IN ULONG ViewSize,
+ IN ULONG LangID);
+VOID STDCALL
+DrvMovePointer(IN PSURFOBJ SurfObj,
+ IN LONG x,
+ IN LONG y,
+ IN PRECTL RectL);
+BOOL STDCALL
+DrvNextBand(IN PSURFOBJ SurfObj,
+ OUT PPOINTL PointL);
+BOOL STDCALL
+DrvPaint(IN PSURFOBJ SurfObj,
+ IN PCLIPOBJ ClipObj,
+ IN PBRUSHOBJ BrushObj,
+ IN PPOINTL BrushOrg,
+ IN MIX Mix);
+BOOL STDCALL
+DrvQueryAdvanceWidths(IN DHPDEV DPev,
+ IN PFONTOBJ FontObj,
+ IN ULONG Mode,
+ IN HGLYPH Glyph,
+ OUT PVOID *Widths,
+ IN ULONG NumGlyphs);
+PIFIMETRICS STDCALL
+DrvQueryFont(IN DHPDEV PDev,
+ IN ULONG FileNumber,
+ IN ULONG FaceIndex,
+ IN PULONG Identifier);
+LONG STDCALL
+DrvQueryFontCaps(IN ULONG CapsSize,
+ OUT PULONG CapsData);
+LONG STDCALL
+DrvQueryFontData(IN DHPDEV DPev,
+ IN PFONTOBJ FontObj,
+ IN ULONG Mode,
+ IN HGLYPH Glyph,
+ IN PGLYPHDATA GlyphData,
+ IN PVOID DataBuffer,
+ IN ULONG BufferSize);
+LONG STDCALL
+DrvQueryFontFile(IN ULONG FileNumber,
+ IN ULONG Mode,
+ IN ULONG BufSize,
+ OUT PULONG Buf);
+PVOID STDCALL
+DrvQueryFontTree(IN DHPDEV PDev,
+ IN ULONG FileNumber,
+ IN ULONG FaceIndex,
+ IN ULONG Mode,
+ OUT ULONG *ID);
+BOOL STDCALL
+DrvQuerySpoolType(DHPDEV PDev,
+ LPWSTR SpoolType);
+LONG STDCALL
+DrvQueryTrueTypeOutline(IN DHPDEV PDev,
+ IN PFONTOBJ FontObj,
+ IN HGLYPH Glyph,
+ IN BOOL MetricsOnly,
+ IN PGLYPHDATA GlyphData,
+ IN ULONG BufSize,
+ OUT PTTPOLYGONHEADER Polygons);
+LONG STDCALL
+DrvQueryTrueTypeTable(IN ULONG FileNumber,
+ IN ULONG Font,
+ IN ULONG Tag,
+ IN PTRDIFF Start,
+ IN ULONG BufSize,
+ OUT BYTE *Buf);
+BOOL STDCALL
+DrvRealizeBrush(IN PBRUSHOBJ BrushObj,
+ IN PSURFOBJ TargetSurface,
+ IN PSURFOBJ PatternSurface,
+ IN PSURFOBJ MaskSurface,
+ IN PXLATEOBJ XLateObj,
+ IN ULONG iHatch);
+BOOL STDCALL
+DrvResetPDEV(IN DHPDEV PDevOld,
+ IN DHPDEV PDevNew);
+ULONG STDCALL
+DrvSaveScreenBits(IN PSURFOBJ SurfObj,
+ IN ULONG Mode,
+ IN ULONG ID,
+ IN PRECTL RectL);
+BOOL STDCALL
+DrvSendPage(IN PSURFOBJ SurfObj);
+BOOL STDCALL
+DrvSetPalette(IN DHPDEV PDev,
+ IN PPALOBJ PaletteObj,
+ IN ULONG Flags,
+ IN ULONG Start,
+ IN ULONG NumColors);
+ULONG STDCALL
+DrvSetPointerShape(IN PSURFOBJ SurfObj,
+ IN PSURFOBJ MaskSurface,
+ IN PSURFOBJ ColorSurface,
+ IN PXLATEOBJ XLateObj,
+ IN LONG xHot,
+ IN LONG yHot,
+ IN LONG x,
+ IN LONG y,
+ IN PRECTL RectL,
+ IN ULONG Flags);
+BOOL STDCALL
+DrvStartBanding(IN PSURFOBJ SurfObj,
+ IN PPOINTL PointL);
+BOOL STDCALL
+DrvStartDoc(IN PSURFOBJ SurfObj,
+ IN LPWSTR DocName,
+ IN DWORD JobID);
+BOOL STDCALL
+DrvStartPage(IN PSURFOBJ SurfObj);
+BOOL STDCALL
+DrvStretchBlt(IN PSURFOBJ DestSurface,
+ IN PSURFOBJ SrcSurface,
+ IN PSURFOBJ MaskSurface,
+ IN PCLIPOBJ ClipObj,
+ IN PXLATEOBJ XLateObj,
+ IN PCOLORADJUSTMENT CA,
+ IN PPOINTL HTOrg,
+ IN PRECTL Dest,
+ IN PRECTL Src,
+ IN PPOINTL Mask,
+ IN ULONG Mode);
+BOOL STDCALL
+DrvStrokeAndFillPath(IN PSURFOBJ SurfObj,
+ IN PPATHOBJ PathObj,
+ IN PCLIPOBJ ClipObj,
+ IN PXFORMOBJ XFormObj,
+ IN PBRUSHOBJ StrokeBrush,
+ IN PLINEATTRS LineAttrs,
+ IN PBRUSHOBJ FillBrush,
+ IN PPOINTL BrushOrg,
+ IN MIX MixFill,
+ IN ULONG Options);
+BOOL STDCALL
+DrvStrokePath(IN PSURFOBJ SurfObj,
+ IN PPATHOBJ PathObj,
+ IN PCLIPOBJ PClipObj,
+ IN PXFORMOBJ XFormObj,
+ IN PBRUSHOBJ BrushObj,
+ IN PPOINTL BrushOrg,
+ IN PLINEATTRS LineAttrs,
+ IN MIX Mix);
+VOID STDCALL
+DrvSynchronize(IN DHPDEV PDev,
+ IN PRECTL RectL);
+BOOL STDCALL
+DrvTextOut(IN PSURFOBJ SurfObj,
+ IN PSTROBJ StrObj,
+ IN PFONTOBJ FontObj,
+ IN PCLIPOBJ ClipObj,
+ IN PRECTL ExtraRect,
+ IN PRECTL OpaqueRect,
+ IN PBRUSHOBJ ForegroundBrush,
+ IN PBRUSHOBJ OpaqueBrush,
+ IN PPOINTL OrgPoint,
+ IN MIX Mix);
+BOOL STDCALL
+DrvTransparentBlt(PSURFOBJ Dest,
+ PSURFOBJ Source,
+ PCLIPOBJ Clip,
+ PXLATEOBJ ColorTranslation,
+ PRECTL DestRect,
+ PRECTL SourceRect,
+ ULONG TransparentColor,
+ ULONG Reserved);
+BOOL STDCALL
+DrvUnloadFontFile(IN ULONG FileNumber);
+
+/* DDI --> GDI calls */
+PVOID STDCALL
+BRUSHOBJ_pvAllocRbrush(IN PBRUSHOBJ BrushObj,
+ IN ULONG ObjSize);
+PVOID STDCALL
+BRUSHOBJ_pvGetRbrush(IN PBRUSHOBJ BrushObj);
+
+BOOL STDCALL
+CLIPOBJ_bEnum(IN PCLIPOBJ ClipObj,
+ IN ULONG ObjSize,
+ OUT ULONG *EnumRects);
+
+ULONG STDCALL
+CLIPOBJ_cEnumStart(IN PCLIPOBJ ClipObj,
+ IN BOOL ShouldDoAll,
+ IN ULONG ClipType,
+ IN ULONG BuildOrder,
+ IN ULONG MaxRects);
+
+PPATHOBJ STDCALL
+CLIPOBJ_ppoGetPath(PCLIPOBJ ClipObj);
+
+/*
+EngAcquireSemaphore
+*/
+
+/* FIXME: find correct defines for following symbols */
+#define FL_ZERO_MEMORY 1
+
+PVOID STDCALL
+EngAllocMem(ULONG Flags,
+ ULONG MemSize,
+ ULONG Tag);
+
+PVOID STDCALL
+EngAllocUserMem(ULONG cj,
+ ULONG tag);
+
+BOOL STDCALL
+EngAssociateSurface(IN HSURF Surface,
+ IN HDEV Dev,
+ IN ULONG Hooks);
+
+BOOL STDCALL
+EngBitBlt(SURFOBJ *Dest,
+ SURFOBJ *Source,
+ SURFOBJ *Mask,
+ CLIPOBJ *ClipRegion,
+ XLATEOBJ *ColorTranslation,
+ RECTL *DestRect,
+ POINTL *SourcePoint,
+ POINTL *MaskRect,
+ BRUSHOBJ *Brush,
+ POINTL *BrushOrigin,
+ ROP4 rop4);
+
+/*
+EngCheckAbort
+EngComputeGlyphSet
+*/
+
+BOOL STDCALL
+EngCopyBits(SURFOBJ *Dest,
+ SURFOBJ *Source,
+ CLIPOBJ *Clip,
+ XLATEOBJ *ColorTranslation,
+ RECTL *DestRect,
+ POINTL *SourcePoint);
+
+HBITMAP STDCALL
+EngCreateBitmap(IN SIZEL Size,
+ IN LONG Width,
+ IN ULONG Format,
+ IN ULONG Flags,
+ IN PVOID Bits);
+
+PCLIPOBJ STDCALL
+EngCreateClip(VOID);
+
+HBITMAP STDCALL
+EngCreateDeviceBitmap(IN DHSURF Surface,
+ IN SIZEL Size,
+ IN ULONG Format);
+
+HSURF STDCALL
+EngCreateDeviceSurface(IN DHSURF Surface,
+ IN SIZEL Size,
+ IN ULONG FormatVersion);
+
+/*
+EngCreateDriverObj
+EngCreateEvent
+*/
+
+HPALETTE STDCALL
+EngCreatePalette(IN ULONG Mode,
+ IN ULONG NumColors,
+ IN PULONG *Colors,
+ IN ULONG Red,
+ IN ULONG Green,
+ IN ULONG Blue);
+
+/*
+EngCreatePath
+EngCreateSemaphore
+EngCreateWnd
+*/
+
+VOID STDCALL
+EngDebugBreak(VOID);
+
+VOID STDCALL
+EngDebugPrint(PCHAR StandardPrefix,
+ PCHAR DebugMessage,
+ va_list ArgList);
+
+VOID STDCALL
+EngDeleteClip(CLIPOBJ *ClipRegion);
+
+/*
+EngDeleteDriverObj
+EngDeleteEvent
+*/
+
+BOOL STDCALL
+EngDeletePalette(IN HPALETTE Palette);
+
+/*
+EngDeletePath
+EngDeleteSemaphore
+*/
+
+BOOL STDCALL
+EngDeleteSurface(IN HSURF Surface);
+
+/*
+EngDeleteWnd
+*/
+
+DWORD STDCALL
+EngDeviceIoControl(HANDLE hDevice,
+ DWORD dwIoControlCode,
+ LPVOID lpInBuffer,
+ DWORD nInBufferSize,
+ LPVOID lpOutBuffer,
+ DWORD nOutBufferSize,
+ DWORD *lpBytesReturned);
+
+/*
+EngEnumForms
+*/
+
+BOOL STDCALL
+EngEraseSurface(SURFOBJ *Surface,
+ RECTL *Rect,
+ ULONG iColor);
+
+/*
+EngFillPath
+EngFindImageProcAddress
+EngFindResource
+*/
+
+VOID STDCALL
+EngFreeMem(PVOID Mem);
+
+/*
+EngFreeModule
+*/
+
+VOID STDCALL
+EngFreeUserMem(PVOID pv);
+
+/*
+EngGetCurrentCodePage
+EngGetDriverName
+EngGetFileChangeTime
+EngGetFilePath
+EngGetForm
+EngGetLastError
+EngGetPrinter
+EngGetPrinterData
+EngGetPrinterDataFileName
+EngGetProcessHandle
+EngGetType1FontList
+*/
+
+BOOL STDCALL
+EngLineTo(SURFOBJ *Surface,
+ CLIPOBJ *Clip,
+ BRUSHOBJ *Brush,
+ LONG x1,
+ LONG y1,
+ LONG x2,
+ LONG y2,
+ RECTL *RectBounds,
+ MIX mix);
+
+HANDLE STDCALL
+EngLoadImage(LPWSTR DriverName);
+
+/*
+EngLoadModule
+EngLoadModuleForWrite
+EngLockDriverObj
+*/
+
+SURFOBJ * STDCALL
+EngLockSurface(IN HSURF Surface);
+
+/*
+EngMapEvent
+EngMapFontFile
+EngMapModule
+EngMarkBandingSurface
+EngMovePointer
+EngMultiByteToUnicodeN
+EngMultiByteToWideChar
+*/
+
+INT STDCALL EngMulDiv(
+ INT nMultiplicand,
+ INT nMultiplier,
+ INT nDivisor);
+
+BOOL STDCALL
+EngPaint(IN SURFOBJ *Surface,
+ IN CLIPOBJ *ClipRegion,
+ IN BRUSHOBJ *Brush,
+ IN POINTL *BrushOrigin,
+ IN MIX Mix);
+
+/*
+EngProbeForRead
+EngProbeForReadAndWrite = NTOSKRNL.ProbeForWrite
+EngQueryLocalTime
+EngQueryPalette
+EngQueryPerformanceCounter
+EngQueryPerformanceFrequency
+EngReleaseSemaphore
+EngRestoreFloatingPointState
+EngSaveFloatingPointState
+EngSecureMem
+EngSetEvent
+EngSetLastError
+EngSetPointerShape
+EngSetPointerTag
+EngSetPrinterData
+EngSort
+EngStretchBlt
+EngStrokeAndFillPath
+EngStrokePath
+EngTextOut
+*/
+
+BOOL STDCALL
+EngTransparentBlt(PSURFOBJ Dest,
+ PSURFOBJ Source,
+ PCLIPOBJ Clip,
+ PXLATEOBJ ColorTranslation,
+ PRECTL DestRect,
+ PRECTL SourceRect,
+ ULONG TransparentColor,
+ ULONG Reserved);
+
+/*
+EngUnicodeToMultiByteN
+EngUnloadImage
+EngUnlockDriverObj
+EngUnlockSurface
+EngUnmapEvent
+EngUnmapFontFile
+EngUnsecureMem = NTOSKRNL.MmUnsecureVirtualMemory
+EngWaitForSingleObject
+EngWideCharToMultiByte
+EngWritePrinter
+FLOATOBJ_Add
+FLOATOBJ_AddFloat
+FLOATOBJ_AddFloatObj
+FLOATOBJ_AddLong
+FLOATOBJ_Div
+FLOATOBJ_DivFloat
+FLOATOBJ_DivFloatObj
+FLOATOBJ_DivLong
+FLOATOBJ_Equal
+FLOATOBJ_EqualLong
+FLOATOBJ_GetFloat
+FLOATOBJ_GetLong
+FLOATOBJ_GreaterThan
+FLOATOBJ_GreaterThanLong
+FLOATOBJ_LessThan
+FLOATOBJ_LessThanLong
+FLOATOBJ_Mul
+FLOATOBJ_MulFloat
+FLOATOBJ_MulFloatObj
+FLOATOBJ_MulLong
+FLOATOBJ_Neg
+FLOATOBJ_SetFloat
+FLOATOBJ_SetLong
+FLOATOBJ_Sub
+FLOATOBJ_SubFloat
+FLOATOBJ_SubFloatObj
+FLOATOBJ_SubLong
+*/
+
+ULONG FONTOBJ_cGetAllGlyphHandles(IN PFONTOBJ FontObj,
+ IN HGLYPH *Glyphs);
+ULONG FONTOBJ_cGetGlyphs(IN PFONTOBJ FontObj,
+ IN ULONG Mode,
+ IN ULONG NumGlyphs,
+ IN HGLYPH *GlyphHandles,
+ IN PVOID *OutGlyphs);
+PGAMMA_TABLES FONTOBJ_pGetGammaTables(IN PFONTOBJ FontObj);
+IFIMETRICS *FONTOBJ_pifi(IN PFONTOBJ FontObj);
+PVOID FONTOBJ_pvTrueTypeFontFile(IN PFONTOBJ FontObj,
+ IN ULONG *FileSize);
+XFORMOBJ *FONTOBJ_pxoGetXform(IN PFONTOBJ FontObj);
+VOID FONTOBJ_vGetInfo(IN PFONTOBJ FontObj,
+ IN ULONG InfoSize,
+ OUT PFONTINFO FontInfo);
+
+/*
+HT_ComputeRGBGammaTable
+HT_Get8BPPFormatPalette
+*/
+
+ULONG STDCALL
+PALOBJ_cGetColors(PALOBJ *PalObj,
+ ULONG Start,
+ ULONG Colors,
+ ULONG *PaletteEntry);
+
+/*
+PATHOBJ_bCloseFigure
+PATHOBJ_bEnum
+PATHOBJ_bEnumClipLines
+PATHOBJ_bMoveTo
+PATHOBJ_bPolyBezierTo
+PATHOBJ_bPolyLineTo
+PATHOBJ_vEnumStart
+PATHOBJ_vEnumStartClipLines
+PATHOBJ_vGetBounds
+RtlAnsiCharToUnicodeChar = NTOSKRNL.RtlAnsiCharToUnicodeChar
+RtlMultiByteToUnicodeN = NTOSKRNL.RtlMultiByteToUnicodeN
+RtlRaiseException = NTOSKRNL.RtlRaiseException
+RtlUnicodeToMultiByteN = NTOSKRNL.RtlUnicodeToMultiByteN
+RtlUnicodeToMultiByteSize = NTOSKRNL.RtlUnicodeToMultiByteSize
+RtlUnwind = NTOSKRNL.RtlUnwind
+RtlUpcaseUnicodeChar = NTOSKRNL.RtlUpcaseUnicodeChar
+RtlUpcaseUnicodeToMultiByteN = NTOSKRNL.RtlUpcaseUnicodeToMultiByteN
+STROBJ_bEnum
+STROBJ_dwGetCodePage
+STROBJ_vEnumStart
+WNDOBJ_bEnum
+WNDOBJ_cEnumStart
+WNDOBJ_vSetConsumer
+XFORMOBJ_bApplyXform
+XFORMOBJ_iGetFloatObjXform
+XFORMOBJ_iGetXform
+*/
+
+ULONG STDCALL
+XLATEOBJ_cGetPalette(XLATEOBJ *XlateObj,
+ ULONG PalOutType,
+ ULONG cPal,
+ ULONG *OutPal);
+
+ULONG STDCALL
+XLATEOBJ_iXlate(XLATEOBJ *XlateObj,
+ ULONG Color);
+
+ULONG * STDCALL
+XLATEOBJ_piVector(XLATEOBJ *XlateObj);
+
+#endif
+
--- /dev/null
+
+/* $Id: zw.h,v 1.53 2002/09/08 10:47:45 chorns Exp $
+ *
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS kernel
+ * PURPOSE: System call definitions
+ * FILE: include/ddk/zw.h
+ * REVISION HISTORY:
+ * ??/??/??: First few functions (David Welch)
+ * ??/??/??: Complete implementation by Ariadne
+ * 13/07/98: Reorganised things a bit (David Welch)
+ * 04/08/98: Added some documentation (Ariadne)
+ * 14/08/98: Added type TIME and change variable type from [1] to [0]
+ * 14/09/98: Added for each Nt call a corresponding Zw Call
+ */
+
+#ifndef __DDK_ZW_H
+#define __DDK_ZW_H
+
+#include <ntos/security.h>
+#include <napi/npipe.h>
+
+//#define LCID ULONG
+//#define SECURITY_INFORMATION ULONG
+//typedef ULONG SECURITY_INFORMATION;
+
+
+/*
+ * FUNCTION: Checks a clients access rights to a object
+ * ARGUMENTS:
+ * SecurityDescriptor = Security information against which the access is checked
+ * ClientToken = Represents a client
+ * DesiredAcces =
+ * GenericMapping =
+ * PrivilegeSet =
+ * ReturnLength = Bytes written
+ * GrantedAccess =
+ * AccessStatus = Indicates if the ClientToken allows the requested access
+ * REMARKS: The arguments map to the win32 AccessCheck
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtAccessCheck(
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor,
+ IN HANDLE ClientToken,
+ IN ACCESS_MASK DesiredAcces,
+ IN PGENERIC_MAPPING GenericMapping,
+ OUT PPRIVILEGE_SET PrivilegeSet,
+ OUT PULONG ReturnLength,
+ OUT PULONG GrantedAccess,
+ OUT PBOOLEAN AccessStatus
+ );
+
+NTSTATUS
+STDCALL
+ZwAccessCheck(
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor,
+ IN HANDLE ClientToken,
+ IN ACCESS_MASK DesiredAcces,
+ IN PGENERIC_MAPPING GenericMapping,
+ OUT PPRIVILEGE_SET PrivilegeSet,
+ OUT PULONG ReturnLength,
+ OUT PULONG GrantedAccess,
+ OUT PBOOLEAN AccessStatus
+ );
+
+/*
+ * FUNCTION: Checks a clients access rights to a object and issues a audit a alarm. ( it logs the access )
+ * ARGUMENTS:
+ * SubsystemName = Specifies the name of the subsystem, can be "WIN32" or "DEBUG"
+ * ObjectHandle =
+ * ObjectAttributes =
+ * DesiredAcces =
+ * GenericMapping =
+ * ObjectCreation =
+ * GrantedAccess =
+ * AccessStatus =
+ * GenerateOnClose =
+ * REMARKS: The arguments map to the win32 AccessCheck
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtAccessCheckAndAuditAlarm(
+ IN PUNICODE_STRING SubsystemName,
+ IN PHANDLE ObjectHandle,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN ACCESS_MASK DesiredAccess,
+ IN PGENERIC_MAPPING GenericMapping,
+ IN BOOLEAN ObjectCreation,
+ OUT PULONG GrantedAccess,
+ OUT PBOOLEAN AccessStatus,
+ OUT PBOOLEAN GenerateOnClose
+ );
+
+NTSTATUS
+STDCALL
+ZwAccessCheckAndAuditAlarm(
+ IN PUNICODE_STRING SubsystemName,
+ IN PHANDLE ObjectHandle,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN ACCESS_MASK DesiredAccess,
+ IN PGENERIC_MAPPING GenericMapping,
+ IN BOOLEAN ObjectCreation,
+ OUT PULONG GrantedAccess,
+ OUT PBOOLEAN AccessStatus,
+ OUT PBOOLEAN GenerateOnClose
+ );
+
+/*
+ * FUNCTION: Adds an atom to the global atom table
+ * ARGUMENTS:
+ * AtomString = The string to add to the atom table.
+ * Atom (OUT) = Caller supplies storage for the resulting atom.
+ * REMARKS: The arguments map to the win32 add GlobalAddAtom.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtAddAtom(
+ IN PWSTR AtomName,
+ IN OUT PRTL_ATOM Atom
+ );
+
+
+NTSTATUS
+STDCALL
+ZwAddAtom(
+ IN PWSTR AtomName,
+ IN OUT PRTL_ATOM Atom
+ );
+
+
+/*
+ * FUNCTION: Adjusts the groups in an access token
+ * ARGUMENTS:
+ * TokenHandle = Specifies the access token
+ * ResetToDefault = If true the NewState parameter is ignored and the groups are set to
+ * their default state, if false the groups specified in
+ * NewState are set.
+ * NewState =
+ * BufferLength = Specifies the size of the buffer for the PreviousState.
+ * PreviousState =
+ * ReturnLength = Bytes written in PreviousState buffer.
+ * REMARKS: The arguments map to the win32 AdjustTokenGroups
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtAdjustGroupsToken(
+ IN HANDLE TokenHandle,
+ IN BOOLEAN ResetToDefault,
+ IN PTOKEN_GROUPS NewState,
+ IN ULONG BufferLength,
+ OUT PTOKEN_GROUPS PreviousState OPTIONAL,
+ OUT PULONG ReturnLength
+ );
+
+NTSTATUS
+STDCALL
+ZwAdjustGroupsToken(
+ IN HANDLE TokenHandle,
+ IN BOOLEAN ResetToDefault,
+ IN PTOKEN_GROUPS NewState,
+ IN ULONG BufferLength,
+ OUT PTOKEN_GROUPS PreviousState,
+ OUT PULONG ReturnLength
+ );
+
+
+/*
+ * FUNCTION:
+ *
+ * ARGUMENTS:
+ * TokenHandle = Handle to the access token
+ * DisableAllPrivileges = The resulting suspend count.
+ NewState =
+ BufferLength =
+ PreviousState =
+ ReturnLength =
+ * REMARK:
+ * The arguments map to the win32 AdjustTokenPrivileges
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtAdjustPrivilegesToken(
+ IN HANDLE TokenHandle,
+ IN BOOLEAN DisableAllPrivileges,
+ IN PTOKEN_PRIVILEGES NewState,
+ IN ULONG BufferLength,
+ OUT PTOKEN_PRIVILEGES PreviousState,
+ OUT PULONG ReturnLength
+ );
+
+NTSTATUS
+STDCALL
+ZwAdjustPrivilegesToken(
+ IN HANDLE TokenHandle,
+ IN BOOLEAN DisableAllPrivileges,
+ IN PTOKEN_PRIVILEGES NewState,
+ IN ULONG BufferLength,
+ OUT PTOKEN_PRIVILEGES PreviousState,
+ OUT PULONG ReturnLength
+ );
+
+
+/*
+ * FUNCTION: Decrements a thread's suspend count and places it in an alerted
+ * state.
+ * ARGUMENTS:
+ * ThreadHandle = Handle to the thread that should be resumed
+ * SuspendCount = The resulting suspend count.
+ * REMARK:
+ * A thread is resumed if its suspend count is 0
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtAlertResumeThread(
+ IN HANDLE ThreadHandle,
+ OUT PULONG SuspendCount
+ );
+
+NTSTATUS
+STDCALL
+ZwAlertResumeThread(
+ IN HANDLE ThreadHandle,
+ OUT PULONG SuspendCount
+ );
+
+/*
+ * FUNCTION: Puts the thread in a alerted state
+ * ARGUMENTS:
+ * ThreadHandle = Handle to the thread that should be alerted
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtAlertThread(
+ IN HANDLE ThreadHandle
+ );
+
+NTSTATUS
+STDCALL
+ZwAlertThread(
+ IN HANDLE ThreadHandle
+ );
+
+
+/*
+ * FUNCTION: Allocates a locally unique id
+ * ARGUMENTS:
+ * LocallyUniqueId = Locally unique number
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtAllocateLocallyUniqueId(
+ OUT LUID *LocallyUniqueId
+ );
+
+NTSTATUS
+STDCALL
+ZwAllocateLocallyUniqueId(
+ OUT PLUID Luid
+ );
+
+NTSTATUS
+STDCALL
+NtAllocateUuids(
+ PULARGE_INTEGER Time,
+ PULONG Range,
+ PULONG Sequence
+ );
+
+NTSTATUS
+STDCALL
+ZwAllocateUuids(
+ PULARGE_INTEGER Time,
+ PULONG Range,
+ PULONG Sequence
+ );
+
+
+/*
+ * FUNCTION: Allocates a block of virtual memory in the process address space
+ * ARGUMENTS:
+ * ProcessHandle = The handle of the process which owns the virtual memory
+ * BaseAddress = A pointer to the virtual memory allocated. If you supply a non zero
+ * value the system will try to allocate the memory at the address supplied. It rounds
+ * it down to a multiple if the page size.
+ * ZeroBits = (OPTIONAL) You can specify the number of high order bits that must be zero, ensuring that
+ * the memory will be allocated at a address below a certain value.
+ * RegionSize = The number of bytes to allocate
+ * AllocationType = Indicates the type of virtual memory you like to allocated,
+ * can be one of the values : MEM_COMMIT, MEM_RESERVE, MEM_RESET, MEM_TOP_DOWN
+ * Protect = Indicates the protection type of the pages allocated, can be a combination of
+ * PAGE_READONLY, PAGE_READWRITE, PAGE_EXECUTE_READ,
+ * PAGE_EXECUTE_READWRITE, PAGE_GUARD, PAGE_NOACCESS, PAGE_NOACCESS
+ * REMARKS:
+ * This function maps to the win32 VirtualAllocEx. Virtual memory is process based so the
+ * protocol starts with a ProcessHandle. I splitted the functionality of obtaining the actual address and specifying
+ * the start address in two parameters ( BaseAddress and StartAddress ) The NumberOfBytesAllocated specify the range
+ * and the AllocationType and ProctectionType map to the other two parameters.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtAllocateVirtualMemory (
+ IN HANDLE ProcessHandle,
+ IN OUT PVOID *BaseAddress,
+ IN ULONG ZeroBits,
+ IN OUT PULONG RegionSize,
+ IN ULONG AllocationType,
+ IN ULONG Protect
+ );
+
+NTSTATUS
+STDCALL
+ZwAllocateVirtualMemory (
+ IN HANDLE ProcessHandle,
+ IN OUT PVOID *BaseAddress,
+ IN ULONG ZeroBits,
+ IN OUT PULONG RegionSize,
+ IN ULONG AllocationType,
+ IN ULONG Protect);
+
+/*
+ * FUNCTION: Returns from a callback into user mode
+ * ARGUMENTS:
+ * RETURN Status
+ */
+//FIXME: this function might need 3 parameters
+NTSTATUS STDCALL NtCallbackReturn(PVOID Result,
+ ULONG ResultLength,
+ NTSTATUS Status);
+
+NTSTATUS STDCALL ZwCallbackReturn(PVOID Result,
+ ULONG ResultLength,
+ NTSTATUS Status);
+
+/*
+ * FUNCTION: Cancels a IO request
+ * ARGUMENTS:
+ * FileHandle = Handle to the file
+ * IoStatusBlock =
+ *
+ * REMARKS:
+ * This function maps to the win32 CancelIo.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtCancelIoFile(
+ IN HANDLE FileHandle,
+ OUT PIO_STATUS_BLOCK IoStatusBlock
+ );
+
+NTSTATUS
+STDCALL
+ZwCancelIoFile(
+ IN HANDLE FileHandle,
+ OUT PIO_STATUS_BLOCK IoStatusBlock
+ );
+/*
+ * FUNCTION: Cancels a timer
+ * ARGUMENTS:
+ * TimerHandle = Handle to the timer
+ * CurrentState = Specifies the state of the timer when cancelled.
+ * REMARKS:
+ * The arguments to this function map to the function CancelWaitableTimer.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtCancelTimer(
+ IN HANDLE TimerHandle,
+ OUT PBOOLEAN CurrentState OPTIONAL
+ );
+
+NTSTATUS
+STDCALL
+ZwCancelTimer(
+ IN HANDLE TimerHandle,
+ OUT ULONG ElapsedTime
+ );
+/*
+ * FUNCTION: Sets the status of the event back to non-signaled
+ * ARGUMENTS:
+ * EventHandle = Handle to the event
+ * REMARKS:
+ * This function maps to win32 function ResetEvent.
+ * RETURcNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtClearEvent(
+ IN HANDLE EventHandle
+ );
+
+NTSTATUS
+STDCALL
+ZwClearEvent(
+ IN HANDLE EventHandle
+ );
+
+/*
+ * FUNCTION: Closes an object handle
+ * ARGUMENTS:
+ * Handle = Handle to the object
+ * REMARKS:
+ * This function maps to the win32 function CloseHandle.
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtClose(
+ IN HANDLE Handle
+ );
+
+NTSTATUS
+STDCALL
+ZwClose(
+ IN HANDLE Handle
+ );
+
+/*
+ * FUNCTION: Generates an audit message when a handle to an object is dereferenced
+ * ARGUMENTS:
+ * SubsystemName =
+ HandleId = Handle to the object
+ GenerateOnClose =
+ * REMARKS:
+ * This function maps to the win32 function ObjectCloseAuditAlarm.
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtCloseObjectAuditAlarm(
+ IN PUNICODE_STRING SubsystemName,
+ IN PVOID HandleId,
+ IN BOOLEAN GenerateOnClose
+ );
+
+NTSTATUS
+STDCALL
+ZwCloseObjectAuditAlarm(
+ IN PUNICODE_STRING SubsystemName,
+ IN PVOID HandleId,
+ IN BOOLEAN GenerateOnClose
+ );
+
+/*
+ * FUNCTION: Continues a thread with the specified context
+ * ARGUMENTS:
+ * Context = Specifies the processor context
+ * IrqLevel = Specifies the Interupt Request Level to continue with. Can
+ * be PASSIVE_LEVEL or APC_LEVEL
+ * REMARKS
+ * NtContinue can be used to continue after an exception or apc.
+ * RETURNS: Status
+ */
+//FIXME This function might need another parameter
+
+NTSTATUS
+STDCALL
+NtContinue(
+ IN PCONTEXT Context,
+ IN BOOLEAN TestAlert
+ );
+
+NTSTATUS STDCALL ZwContinue(IN PCONTEXT Context, IN CINT IrqLevel);
+
+
+/*
+ * FUNCTION: Creates a directory object
+ * ARGUMENTS:
+ * DirectoryHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Specifies access to the directory
+ * ObjectAttribute = Initialized attributes for the object
+ * REMARKS: This function maps to the win32 CreateDirectory. A directory is like a file so it needs a
+ * handle, a access mask and a OBJECT_ATTRIBUTES structure to map the path name and the SECURITY_ATTRIBUTES.
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtCreateDirectoryObject(
+ OUT PHANDLE DirectoryHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+
+NTSTATUS
+STDCALL
+ZwCreateDirectoryObject(
+ OUT PHANDLE DirectoryHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+
+/*
+ * FUNCTION: Creates an event object
+ * ARGUMENTS:
+ * EventHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Specifies access to the event
+ * ObjectAttribute = Initialized attributes for the object
+ * ManualReset = manual-reset or auto-reset if true you have to reset the state of the event manually
+ * using NtResetEvent/NtClearEvent. if false the system will reset the event to a non-signalled state
+ * automatically after the system has rescheduled a thread waiting on the event.
+ * InitialState = specifies the initial state of the event to be signaled ( TRUE ) or non-signalled (FALSE).
+ * REMARKS: This function maps to the win32 CreateEvent. Demanding a out variable of type HANDLE,
+ * a access mask and a OBJECT_ATTRIBUTES structure mapping to the SECURITY_ATTRIBUTES. ManualReset and InitialState are
+ * both parameters aswell ( possibly the order is reversed ).
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtCreateEvent(
+ OUT PHANDLE EventHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN BOOLEAN ManualReset,
+ IN BOOLEAN InitialState
+ );
+
+NTSTATUS
+STDCALL
+ZwCreateEvent(
+ OUT PHANDLE EventHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN BOOLEAN ManualReset,
+ IN BOOLEAN InitialState
+ );
+
+/*
+ * FUNCTION: Creates an eventpair object
+ * ARGUMENTS:
+ * EventPairHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Specifies access to the event
+ * ObjectAttribute = Initialized attributes for the object
+ */
+
+NTSTATUS
+STDCALL
+NtCreateEventPair(
+ OUT PHANDLE EventPairHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+
+NTSTATUS
+STDCALL
+ZwCreateEventPair(
+ OUT PHANDLE EventPairHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+
+
+/*
+ * FUNCTION: Creates or opens a file, directory or device object.
+ * ARGUMENTS:
+ * FileHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Specifies the allowed or desired access to the file can
+ * be a combination of DELETE | FILE_READ_DATA ..
+ * ObjectAttribute = Initialized attributes for the object, contains the rootdirectory and the filename
+ * IoStatusBlock (OUT) = Caller supplied storage for the resulting status information, indicating if the
+ * the file is created and opened or allready existed and is just opened.
+ * FileAttributes = file attributes can be a combination of FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN ...
+ * ShareAccess = can be a combination of the following: FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE
+ * CreateDisposition = specifies what the behavior of the system if the file allready exists.
+ * CreateOptions = specifies the behavior of the system on file creation.
+ * EaBuffer (OPTIONAL) = Extended Attributes buffer, applies only to files and directories.
+ * EaLength = Extended Attributes buffer size, applies only to files and directories.
+ * REMARKS: This function maps to the win32 CreateFile.
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtCreateFile(
+ OUT PHANDLE FileHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN PLARGE_INTEGER AllocationSize OPTIONAL,
+ IN ULONG FileAttributes,
+ IN ULONG ShareAccess,
+ IN ULONG CreateDisposition,
+ IN ULONG CreateOptions,
+ IN PVOID EaBuffer OPTIONAL,
+ IN ULONG EaLength
+ );
+
+NTSTATUS
+STDCALL
+ZwCreateFile(
+ OUT PHANDLE FileHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN PLARGE_INTEGER AllocationSize OPTIONAL,
+ IN ULONG FileAttributes,
+ IN ULONG ShareAccess,
+ IN ULONG CreateDisposition,
+ IN ULONG CreateOptions,
+ IN PVOID EaBuffer OPTIONAL,
+ IN ULONG EaLength
+ );
+
+/*
+ * FUNCTION: Creates or opens a file, directory or device object.
+ * ARGUMENTS:
+ * CompletionPort (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Specifies the allowed or desired access to the port
+ * IoStatusBlock =
+ * NumberOfConcurrentThreads =
+ * REMARKS: This function maps to the win32 CreateIoCompletionPort
+ * RETURNS:
+ * Status
+ */
+
+NTSTATUS
+STDCALL
+NtCreateIoCompletion(
+ OUT PHANDLE CompletionPort,
+ IN ACCESS_MASK DesiredAccess,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG NumberOfConcurrentThreads
+ );
+
+NTSTATUS
+STDCALL
+ZwCreateIoCompletion(
+ OUT PHANDLE CompletionPort,
+ IN ACCESS_MASK DesiredAccess,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG NumberOfConcurrentThreads
+ );
+
+
+/*
+ * FUNCTION: Creates a mail slot file
+ * ARGUMENTS:
+ * MailSlotFileHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Specifies the allowed or desired access to the file
+ * ObjectAttributes = Contains the name of the mailslotfile.
+ * IoStatusBlock =
+ * FileAttributes =
+ * ShareAccess =
+ * MaxMessageSize =
+ * TimeOut =
+ *
+ * REMARKS: This funciton maps to the win32 function CreateMailSlot
+ * RETURNS:
+ * Status
+ */
+
+NTSTATUS
+STDCALL
+NtCreateMailslotFile(
+ OUT PHANDLE MailSlotFileHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG FileAttributes,
+ IN ULONG ShareAccess,
+ IN ULONG MaxMessageSize,
+ IN PLARGE_INTEGER TimeOut
+ );
+
+NTSTATUS
+STDCALL
+ZwCreateMailslotFile(
+ OUT PHANDLE MailSlotFileHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG FileAttributes,
+ IN ULONG ShareAccess,
+ IN ULONG MaxMessageSize,
+ IN PLARGE_INTEGER TimeOut
+ );
+
+/*
+ * FUNCTION: Creates or opens a mutex
+ * ARGUMENTS:
+ * MutantHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Specifies the allowed or desired access to the port
+ * ObjectAttributes = Contains the name of the mutex.
+ * InitialOwner = If true the calling thread acquires ownership
+ * of the mutex.
+ * REMARKS: This funciton maps to the win32 function CreateMutex
+ * RETURNS:
+ * Status
+ */
+NTSTATUS
+STDCALL
+NtCreateMutant(
+ OUT PHANDLE MutantHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN BOOLEAN InitialOwner
+ );
+
+NTSTATUS
+STDCALL
+ZwCreateMutant(
+ OUT PHANDLE MutantHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN BOOLEAN InitialOwner
+ );
+
+
+/*
+ * FUNCTION: Creates a paging file.
+ * ARGUMENTS:
+ * FileName = Name of the pagefile
+ * InitialSize = Specifies the initial size in bytes
+ * MaximumSize = Specifies the maximum size in bytes
+ * Reserved = Reserved for future use
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtCreatePagingFile(
+ IN PUNICODE_STRING FileName,
+ IN PLARGE_INTEGER InitialSize,
+ IN PLARGE_INTEGER MaxiumSize,
+ IN ULONG Reserved
+ );
+
+NTSTATUS
+STDCALL
+ZwCreatePagingFile(
+ IN PUNICODE_STRING FileName,
+ IN PLARGE_INTEGER InitialSize,
+ IN PLARGE_INTEGER MaxiumSize,
+ IN ULONG Reserved
+ );
+
+/*
+ * FUNCTION: Creates a process.
+ * ARGUMENTS:
+ * ProcessHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Specifies the allowed or desired access to the process can
+ * be a combinate of STANDARD_RIGHTS_REQUIRED| ..
+ * ObjectAttribute = Initialized attributes for the object, contains the rootdirectory and the filename
+ * ParentProcess = Handle to the parent process.
+ * InheritObjectTable = Specifies to inherit the objects of the parent process if true.
+ * SectionHandle = Handle to a section object to back the image file
+ * DebugPort = Handle to a DebugPort if NULL the system default debug port will be used.
+ * ExceptionPort = Handle to a exception port.
+ * REMARKS:
+ * This function maps to the win32 CreateProcess.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtCreateProcess(
+ OUT PHANDLE ProcessHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
+ IN HANDLE ParentProcess,
+ IN BOOLEAN InheritObjectTable,
+ IN HANDLE SectionHandle OPTIONAL,
+ IN HANDLE DebugPort OPTIONAL,
+ IN HANDLE ExceptionPort OPTIONAL
+ );
+
+NTSTATUS
+STDCALL
+ZwCreateProcess(
+ OUT PHANDLE ProcessHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
+ IN HANDLE ParentProcess,
+ IN BOOLEAN InheritObjectTable,
+ IN HANDLE SectionHandle OPTIONAL,
+ IN HANDLE DebugPort OPTIONAL,
+ IN HANDLE ExceptionPort OPTIONAL
+ );
+
+/*
+ * FUNCTION: Creates a profile
+ * ARGUMENTS:
+ * ProfileHandle (OUT) = Caller supplied storage for the resulting handle
+ * ObjectAttribute = Initialized attributes for the object
+ * ImageBase = Start address of executable image
+ * ImageSize = Size of the image
+ * Granularity = Bucket size
+ * Buffer = Caller supplies buffer for profiling info
+ * ProfilingSize = Buffer size
+ * ClockSource = Specify 0 / FALSE ??
+ * ProcessorMask = A value of -1 indicates disables per processor profiling,
+ otherwise bit set for the processor to profile.
+ * REMARKS:
+ * This function maps to the win32 CreateProcess.
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtCreateProfile(OUT PHANDLE ProfileHandle,
+ IN HANDLE ProcessHandle,
+ IN PVOID ImageBase,
+ IN ULONG ImageSize,
+ IN ULONG Granularity,
+ OUT PULONG Buffer,
+ IN ULONG ProfilingSize,
+ IN KPROFILE_SOURCE Source,
+ IN ULONG ProcessorMask);
+
+NTSTATUS
+STDCALL
+ZwCreateProfile(
+ OUT PHANDLE ProfileHandle,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN ULONG ImageBase,
+ IN ULONG ImageSize,
+ IN ULONG Granularity,
+ OUT PVOID Buffer,
+ IN ULONG ProfilingSize,
+ IN ULONG ClockSource,
+ IN ULONG ProcessorMask
+ );
+
+/*
+ * FUNCTION: Creates a section object.
+ * ARGUMENTS:
+ * SectionHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Specifies the desired access to the section can be a combination of STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_WRITE |
+ * SECTION_MAP_READ | SECTION_MAP_EXECUTE.
+ * ObjectAttribute = Initialized attributes for the object can be used to create a named section
+ * MaxiumSize = Maximizes the size of the memory section. Must be non-NULL for a page-file backed section.
+ * If value specified for a mapped file and the file is not large enough, file will be extended.
+ * SectionPageProtection = Can be a combination of PAGE_READONLY | PAGE_READWRITE | PAGE_WRITEONLY | PAGE_WRITECOPY.
+ * AllocationAttributes = can be a combination of SEC_IMAGE | SEC_RESERVE
+ * FileHanlde = Handle to a file to create a section mapped to a file instead of a memory backed section.
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtCreateSection(
+ OUT PHANDLE SectionHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
+ IN PLARGE_INTEGER MaximumSize OPTIONAL,
+ IN ULONG SectionPageProtection OPTIONAL,
+ IN ULONG AllocationAttributes,
+ IN HANDLE FileHandle OPTIONAL
+ );
+
+NTSTATUS
+STDCALL
+ZwCreateSection(
+ OUT PHANDLE SectionHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
+ IN PLARGE_INTEGER MaximumSize OPTIONAL,
+ IN ULONG SectionPageProtection OPTIONAL,
+ IN ULONG AllocationAttributes,
+ IN HANDLE FileHandle OPTIONAL
+ );
+
+/*
+ * FUNCTION: Creates a semaphore object for interprocess synchronization.
+ * ARGUMENTS:
+ * SemaphoreHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Specifies the allowed or desired access to the semaphore.
+ * ObjectAttribute = Initialized attributes for the object.
+ * InitialCount = Not necessary zero, might be smaller than zero.
+ * MaximumCount = Maxiumum count the semaphore can reach.
+ * RETURNS: Status
+ * REMARKS:
+ * The semaphore is set to signaled when its count is greater than zero, and non-signaled when its count is zero.
+ */
+
+//FIXME: should a semaphore's initial count allowed to be smaller than zero ??
+NTSTATUS
+STDCALL
+NtCreateSemaphore(
+ OUT PHANDLE SemaphoreHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
+ IN LONG InitialCount,
+ IN LONG MaximumCount
+ );
+
+NTSTATUS
+STDCALL
+ZwCreateSemaphore(
+ OUT PHANDLE SemaphoreHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
+ IN LONG InitialCount,
+ IN LONG MaximumCount
+ );
+
+/*
+ * FUNCTION: Creates a symbolic link object
+ * ARGUMENTS:
+ * SymbolicLinkHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Specifies the allowed or desired access to the thread.
+ * ObjectAttributes = Initialized attributes for the object.
+ * Name = Target name of the symbolic link
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtCreateSymbolicLinkObject(
+ OUT PHANDLE SymbolicLinkHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN PUNICODE_STRING Name
+ );
+
+NTSTATUS
+STDCALL
+ZwCreateSymbolicLinkObject(
+ OUT PHANDLE SymbolicLinkHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN PUNICODE_STRING Name
+ );
+
+/*
+ * FUNCTION: Creates a user mode thread
+ * ARGUMENTS:
+ * ThreadHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Specifies the allowed or desired access to the thread.
+ * ObjectAttributes = Initialized attributes for the object.
+ * ProcessHandle = Handle to the threads parent process.
+ * ClientId (OUT) = Caller supplies storage for returned process id and thread id.
+ * ThreadContext = Initial processor context for the thread.
+ * InitialTeb = Initial user mode stack context for the thread.
+ * CreateSuspended = Specifies if the thread is ready for scheduling
+ * REMARKS:
+ * This function maps to the win32 function CreateThread.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtCreateThread(
+ OUT PHANDLE ThreadHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
+ IN HANDLE ProcessHandle,
+ OUT PCLIENT_ID ClientId,
+ IN PCONTEXT ThreadContext,
+ IN PINITIAL_TEB InitialTeb,
+ IN BOOLEAN CreateSuspended
+ );
+
+NTSTATUS
+STDCALL
+ZwCreateThread(
+ OUT PHANDLE ThreadHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
+ IN HANDLE ProcessHandle,
+ OUT PCLIENT_ID ClientId,
+ IN PCONTEXT ThreadContext,
+ IN PINITIAL_TEB InitialTeb,
+ IN BOOLEAN CreateSuspended
+ );
+
+/*
+ * FUNCTION: Creates a waitable timer.
+ * ARGUMENTS:
+ * TimerHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Specifies the allowed or desired access to the timer.
+ * ObjectAttributes = Initialized attributes for the object.
+ * TimerType = Specifies if the timer should be reset manually.
+ * REMARKS:
+ * This function maps to the win32 CreateWaitableTimer. lpTimerAttributes and lpTimerName map to
+ * corresponding fields in OBJECT_ATTRIBUTES structure.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtCreateTimer(
+ OUT PHANDLE TimerHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
+ IN TIMER_TYPE TimerType
+ );
+
+NTSTATUS
+STDCALL
+ZwCreateTimer(
+ OUT PHANDLE TimerHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
+ IN TIMER_TYPE TimerType
+ );
+
+/*
+ * FUNCTION: Creates a token.
+ * ARGUMENTS:
+ * TokenHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Specifies the allowed or desired access to the process can
+ * be a combinate of STANDARD_RIGHTS_REQUIRED| ..
+ * ObjectAttribute = Initialized attributes for the object, contains the rootdirectory and the filename
+ * TokenType =
+ * AuthenticationId =
+ * ExpirationTime =
+ * TokenUser =
+ * TokenGroups =
+ * TokenPrivileges =
+ * TokenOwner =
+ * TokenPrimaryGroup =
+ * TokenDefaultDacl =
+ * TokenSource =
+ * REMARKS:
+ * This function does not map to a win32 function
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtCreateToken(
+ OUT PHANDLE TokenHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN TOKEN_TYPE TokenType,
+ IN PLUID AuthenticationId,
+ IN PLARGE_INTEGER ExpirationTime,
+ IN PTOKEN_USER TokenUser,
+ IN PTOKEN_GROUPS TokenGroups,
+ IN PTOKEN_PRIVILEGES TokenPrivileges,
+ IN PTOKEN_OWNER TokenOwner,
+ IN PTOKEN_PRIMARY_GROUP TokenPrimaryGroup,
+ IN PTOKEN_DEFAULT_DACL TokenDefaultDacl,
+ IN PTOKEN_SOURCE TokenSource
+ );
+
+NTSTATUS
+STDCALL
+ZwCreateToken(
+ OUT PHANDLE TokenHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN TOKEN_TYPE TokenType,
+ IN PLUID AuthenticationId,
+ IN PLARGE_INTEGER ExpirationTime,
+ IN PTOKEN_USER TokenUser,
+ IN PTOKEN_GROUPS TokenGroups,
+ IN PTOKEN_PRIVILEGES TokenPrivileges,
+ IN PTOKEN_OWNER TokenOwner,
+ IN PTOKEN_PRIMARY_GROUP TokenPrimaryGroup,
+ IN PTOKEN_DEFAULT_DACL TokenDefaultDacl,
+ IN PTOKEN_SOURCE TokenSource
+ );
+
+/*
+ * FUNCTION: Returns the callers thread TEB.
+ * RETURNS: The resulting teb.
+ */
+#if 0
+ NT_TEB *
+STDCALL
+NtCurrentTeb(VOID
+ );
+#endif
+
+/*
+ * FUNCTION: Delays the execution of the calling thread.
+ * ARGUMENTS:
+ * Alertable = If TRUE the thread is alertable during is wait period
+ * Interval = Specifies the interval to wait.
+ * RETURNS: Status
+ */
+NTSTATUS STDCALL NtDelayExecution(IN ULONG Alertable, IN TIME* Interval);
+
+NTSTATUS
+STDCALL
+ZwDelayExecution(
+ IN BOOLEAN Alertable,
+ IN TIME *Interval
+ );
+
+
+/*
+ * FUNCTION: Deletes an atom from the global atom table
+ * ARGUMENTS:
+ * Atom = Identifies the atom to delete
+ * REMARKS:
+ * The function maps to the win32 GlobalDeleteAtom
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtDeleteAtom(
+ IN RTL_ATOM Atom
+ );
+
+NTSTATUS
+STDCALL
+ZwDeleteAtom(
+ IN RTL_ATOM Atom
+ );
+
+/*
+ * FUNCTION: Deletes a file or a directory
+ * ARGUMENTS:
+ * ObjectAttributes = Name of the file which should be deleted
+ * REMARKS:
+ * This system call is functionally equivalent to NtSetInformationFile
+ * setting the disposition information.
+ * The function maps to the win32 DeleteFile.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtDeleteFile(
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+
+NTSTATUS
+STDCALL
+ZwDeleteFile(
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+
+/*
+ * FUNCTION: Deletes a registry key
+ * ARGUMENTS:
+ * KeyHandle = Handle of the key
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtDeleteKey(
+ IN HANDLE KeyHandle
+ );
+NTSTATUS
+STDCALL
+ZwDeleteKey(
+ IN HANDLE KeyHandle
+ );
+
+/*
+ * FUNCTION: Generates a audit message when an object is deleted
+ * ARGUMENTS:
+ * SubsystemName = Spefies the name of the subsystem can be 'WIN32' or 'DEBUG'
+ * HandleId= Handle to an audit object
+ * GenerateOnClose = Value returned by NtAccessCheckAndAuditAlarm
+ * REMARKS: This function maps to the win32 ObjectCloseAuditAlarm
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtDeleteObjectAuditAlarm (
+ IN PUNICODE_STRING SubsystemName,
+ IN PVOID HandleId,
+ IN BOOLEAN GenerateOnClose
+ );
+
+NTSTATUS
+STDCALL
+ZwDeleteObjectAuditAlarm (
+ IN PUNICODE_STRING SubsystemName,
+ IN PVOID HandleId,
+ IN BOOLEAN GenerateOnClose
+ );
+
+
+/*
+ * FUNCTION: Deletes a value from a registry key
+ * ARGUMENTS:
+ * KeyHandle = Handle of the key
+ * ValueName = Name of the value to delete
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtDeleteValueKey(
+ IN HANDLE KeyHandle,
+ IN PUNICODE_STRING ValueName
+ );
+
+NTSTATUS
+STDCALL
+ZwDeleteValueKey(
+ IN HANDLE KeyHandle,
+ IN PUNICODE_STRING ValueName
+ );
+/*
+ * FUNCTION: Sends IOCTL to the io sub system
+ * ARGUMENTS:
+ * DeviceHandle = Points to the handle that is created by NtCreateFile
+ * Event = Event to synchronize on STATUS_PENDING
+ * ApcRoutine = Asynchroneous procedure callback
+ * ApcContext = Callback context.
+ * IoStatusBlock = Caller should supply storage for extra information..
+ * IoControlCode = Contains the IO Control command. This is an
+ * index to the structures in InputBuffer and OutputBuffer.
+ * InputBuffer = Caller should supply storage for input buffer if IOTL expects one.
+ * InputBufferSize = Size of the input bufffer
+ * OutputBuffer = Caller should supply storage for output buffer if IOTL expects one.
+ * OutputBufferSize = Size of the input bufffer
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtDeviceIoControlFile(
+ IN HANDLE DeviceHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL,
+ IN PVOID UserApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG IoControlCode,
+ IN PVOID InputBuffer,
+ IN ULONG InputBufferSize,
+ OUT PVOID OutputBuffer,
+ IN ULONG OutputBufferSize
+ );
+
+NTSTATUS
+STDCALL
+ZwDeviceIoControlFile(
+ IN HANDLE DeviceHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL,
+ IN PVOID UserApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG IoControlCode,
+ IN PVOID InputBuffer,
+ IN ULONG InputBufferSize,
+ OUT PVOID OutputBuffer,
+ IN ULONG OutputBufferSize
+ );
+/*
+ * FUNCTION: Displays a string on the blue screen
+ * ARGUMENTS:
+ * DisplayString = The string to display
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtDisplayString(
+ IN PUNICODE_STRING DisplayString
+ );
+
+NTSTATUS
+STDCALL
+ZwDisplayString(
+ IN PUNICODE_STRING DisplayString
+ );
+
+/*
+ * FUNCTION: Copies a handle from one process space to another
+ * ARGUMENTS:
+ * SourceProcessHandle = The source process owning the handle. The source process should have opened
+ * the SourceHandle with PROCESS_DUP_HANDLE access.
+ * SourceHandle = The handle to the object.
+ * TargetProcessHandle = The destination process owning the handle
+ * TargetHandle (OUT) = Caller should supply storage for the duplicated handle.
+ * DesiredAccess = The desired access to the handle.
+ * InheritHandle = Indicates wheter the new handle will be inheritable or not.
+ * Options = Specifies special actions upon duplicating the handle. Can be
+ * one of the values DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS.
+ * DUPLICATE_CLOSE_SOURCE specifies that the source handle should be
+ * closed after duplicating. DUPLICATE_SAME_ACCESS specifies to ignore
+ * the DesiredAccess paramter and just grant the same access to the new
+ * handle.
+ * RETURNS: Status
+ * REMARKS: This function maps to the win32 DuplicateHandle.
+ */
+
+NTSTATUS
+STDCALL
+NtDuplicateObject(
+ IN HANDLE SourceProcessHandle,
+ IN HANDLE SourceHandle,
+ IN HANDLE TargetProcessHandle,
+ OUT PHANDLE TargetHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN BOOLEAN InheritHandle,
+ IN ULONG Options
+ );
+
+NTSTATUS
+STDCALL
+ZwDuplicateObject(
+ IN HANDLE SourceProcessHandle,
+ IN PHANDLE SourceHandle,
+ IN HANDLE TargetProcessHandle,
+ OUT PHANDLE TargetHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN BOOLEAN InheritHandle,
+ IN ULONG Options
+ );
+
+NTSTATUS
+STDCALL
+NtDuplicateToken(
+ IN HANDLE ExistingToken,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
+ IN TOKEN_TYPE TokenType,
+ OUT PHANDLE NewToken
+ );
+
+NTSTATUS
+STDCALL
+ZwDuplicateToken(
+ IN HANDLE ExistingToken,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
+ IN TOKEN_TYPE TokenType,
+ OUT PHANDLE NewToken
+ );
+/*
+ * FUNCTION: Returns information about the subkeys of an open key
+ * ARGUMENTS:
+ * KeyHandle = Handle of the key whose subkeys are to enumerated
+ * Index = zero based index of the subkey for which information is
+ * request
+ * KeyInformationClass = Type of information returned
+ * KeyInformation (OUT) = Caller allocated buffer for the information
+ * about the key
+ * Length = Length in bytes of the KeyInformation buffer
+ * ResultLength (OUT) = Caller allocated storage which holds
+ * the number of bytes of information retrieved
+ * on return
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtEnumerateKey(
+ IN HANDLE KeyHandle,
+ IN ULONG Index,
+ IN KEY_INFORMATION_CLASS KeyInformationClass,
+ OUT PVOID KeyInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+
+NTSTATUS
+STDCALL
+ZwEnumerateKey(
+ IN HANDLE KeyHandle,
+ IN ULONG Index,
+ IN KEY_INFORMATION_CLASS KeyInformationClass,
+ OUT PVOID KeyInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+/*
+ * FUNCTION: Returns information about the value entries of an open key
+ * ARGUMENTS:
+ * KeyHandle = Handle of the key whose value entries are to enumerated
+ * Index = zero based index of the subkey for which information is
+ * request
+ * KeyInformationClass = Type of information returned
+ * KeyInformation (OUT) = Caller allocated buffer for the information
+ * about the key
+ * Length = Length in bytes of the KeyInformation buffer
+ * ResultLength (OUT) = Caller allocated storage which holds
+ * the number of bytes of information retrieved
+ * on return
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtEnumerateValueKey(
+ IN HANDLE KeyHandle,
+ IN ULONG Index,
+ IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,
+ OUT PVOID KeyValueInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+
+NTSTATUS
+STDCALL
+ZwEnumerateValueKey(
+ IN HANDLE KeyHandle,
+ IN ULONG Index,
+ IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,
+ OUT PVOID KeyValueInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+/*
+ * FUNCTION: Extends a section
+ * ARGUMENTS:
+ * SectionHandle = Handle to the section
+ * NewMaximumSize = Adjusted size
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtExtendSection(
+ IN HANDLE SectionHandle,
+ IN ULONG NewMaximumSize
+ );
+NTSTATUS
+STDCALL
+ZwExtendSection(
+ IN HANDLE SectionHandle,
+ IN ULONG NewMaximumSize
+ );
+
+/*
+ * FUNCTION: Finds a atom
+ * ARGUMENTS:
+ * AtomName = Name to search for.
+ * Atom = Caller supplies storage for the resulting atom
+ * RETURNS: Status
+ * REMARKS:
+ * This funciton maps to the win32 GlobalFindAtom
+ */
+NTSTATUS
+STDCALL
+NtFindAtom(
+ IN PWSTR AtomName,
+ OUT PRTL_ATOM Atom OPTIONAL
+ );
+
+NTSTATUS
+STDCALL
+ZwFindAtom(
+ IN PWSTR AtomName,
+ OUT PRTL_ATOM Atom OPTIONAL
+ );
+
+/*
+ * FUNCTION: Flushes chached file data to disk
+ * ARGUMENTS:
+ * FileHandle = Points to the file
+ * IoStatusBlock = Caller must supply storage to receive the result of the flush
+ * buffers operation. The information field is set to number of bytes
+ * flushed to disk.
+ * RETURNS: Status
+ * REMARKS:
+ * This funciton maps to the win32 FlushFileBuffers
+ */
+NTSTATUS
+STDCALL
+NtFlushBuffersFile(
+ IN HANDLE FileHandle,
+ OUT PIO_STATUS_BLOCK IoStatusBlock
+ );
+
+NTSTATUS
+STDCALL
+ZwFlushBuffersFile(
+ IN HANDLE FileHandle,
+ OUT PIO_STATUS_BLOCK IoStatusBlock
+ );
+/*
+ * FUNCTION: Flushes a the processors instruction cache
+ * ARGUMENTS:
+ * ProcessHandle = Points to the process owning the cache
+ * BaseAddress = // might this be a image address ????
+ * NumberOfBytesToFlush =
+ * RETURNS: Status
+ * REMARKS:
+ * This funciton is used by debuggers
+ */
+NTSTATUS
+STDCALL
+NtFlushInstructionCache(
+ IN HANDLE ProcessHandle,
+ IN PVOID BaseAddress,
+ IN UINT NumberOfBytesToFlush
+ );
+NTSTATUS
+STDCALL
+ZwFlushInstructionCache(
+ IN HANDLE ProcessHandle,
+ IN PVOID BaseAddress,
+ IN UINT NumberOfBytesToFlush
+ );
+/*
+ * FUNCTION: Flushes a registry key to disk
+ * ARGUMENTS:
+ * KeyHandle = Points to the registry key handle
+ * RETURNS: Status
+ * REMARKS:
+ * This funciton maps to the win32 RegFlushKey.
+ */
+NTSTATUS
+STDCALL
+NtFlushKey(
+ IN HANDLE KeyHandle
+ );
+
+NTSTATUS
+STDCALL
+ZwFlushKey(
+ IN HANDLE KeyHandle
+ );
+
+/*
+ * FUNCTION: Flushes virtual memory to file
+ * ARGUMENTS:
+ * ProcessHandle = Points to the process that allocated the virtual memory
+ * BaseAddress = Points to the memory address
+ * NumberOfBytesToFlush = Limits the range to flush,
+ * NumberOfBytesFlushed = Actual number of bytes flushed
+ * RETURNS: Status
+ * REMARKS:
+ * Check return status on STATUS_NOT_MAPPED_DATA
+ */
+NTSTATUS
+STDCALL
+NtFlushVirtualMemory(
+ IN HANDLE ProcessHandle,
+ IN PVOID BaseAddress,
+ IN ULONG NumberOfBytesToFlush,
+ OUT PULONG NumberOfBytesFlushed OPTIONAL
+ );
+NTSTATUS
+STDCALL
+ZwFlushVirtualMemory(
+ IN HANDLE ProcessHandle,
+ IN PVOID BaseAddress,
+ IN ULONG NumberOfBytesToFlush,
+ OUT PULONG NumberOfBytesFlushed OPTIONAL
+ );
+
+/*
+ * FUNCTION: Flushes the dirty pages to file
+ * RETURNS: Status
+ * FIXME: Not sure this does (how is the file specified)
+ */
+NTSTATUS STDCALL NtFlushWriteBuffer(VOID);
+NTSTATUS STDCALL ZwFlushWriteBuffer(VOID);
+
+ /*
+ * FUNCTION: Frees a range of virtual memory
+ * ARGUMENTS:
+ * ProcessHandle = Points to the process that allocated the virtual
+ * memory
+ * BaseAddress = Points to the memory address, rounded down to a
+ * multiple of the pagesize
+ * RegionSize = Limits the range to free, rounded up to a multiple of
+ * the paging size
+ * FreeType = Can be one of the values: MEM_DECOMMIT, or MEM_RELEASE
+ * RETURNS: Status
+ */
+NTSTATUS STDCALL NtFreeVirtualMemory(IN HANDLE ProcessHandle,
+ IN PVOID *BaseAddress,
+ IN PULONG RegionSize,
+ IN ULONG FreeType);
+NTSTATUS STDCALL ZwFreeVirtualMemory(IN HANDLE ProcessHandle,
+ IN PVOID *BaseAddress,
+ IN PULONG RegionSize,
+ IN ULONG FreeType);
+
+/*
+ * FUNCTION: Sends FSCTL to the filesystem
+ * ARGUMENTS:
+ * DeviceHandle = Points to the handle that is created by NtCreateFile
+ * Event = Event to synchronize on STATUS_PENDING
+ * ApcRoutine =
+ * ApcContext =
+ * IoStatusBlock = Caller should supply storage for
+ * IoControlCode = Contains the File System Control command. This is an
+ * index to the structures in InputBuffer and OutputBuffer.
+ * FSCTL_GET_RETRIEVAL_POINTERS MAPPING_PAIR
+ * FSCTL_GET_RETRIEVAL_POINTERS GET_RETRIEVAL_DESCRIPTOR
+ * FSCTL_GET_VOLUME_BITMAP BITMAP_DESCRIPTOR
+ * FSCTL_MOVE_FILE MOVEFILE_DESCRIPTOR
+ *
+ * InputBuffer = Caller should supply storage for input buffer if FCTL expects one.
+ * InputBufferSize = Size of the input bufffer
+ * OutputBuffer = Caller should supply storage for output buffer if FCTL expects one.
+ * OutputBufferSize = Size of the input bufffer
+ * RETURNS: Status [ STATUS_SUCCESS | STATUS_PENDING | STATUS_ACCESS_DENIED | STATUS_INSUFFICIENT_RESOURCES |
+ * STATUS_INVALID_PARAMETER | STATUS_INVALID_DEVICE_REQUEST ]
+ */
+NTSTATUS
+STDCALL
+NtFsControlFile(
+ IN HANDLE DeviceHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
+ IN PVOID ApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG IoControlCode,
+ IN PVOID InputBuffer,
+ IN ULONG InputBufferSize,
+ OUT PVOID OutputBuffer,
+ IN ULONG OutputBufferSize
+ );
+
+NTSTATUS
+STDCALL
+ZwFsControlFile(
+ IN HANDLE DeviceHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
+ IN PVOID ApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG IoControlCode,
+ IN PVOID InputBuffer,
+ IN ULONG InputBufferSize,
+ OUT PVOID OutputBuffer,
+ IN ULONG OutputBufferSize
+ );
+
+/*
+ * FUNCTION: Retrieves the processor context of a thread
+ * ARGUMENTS:
+ * ThreadHandle = Handle to a thread
+ * Context (OUT) = Caller allocated storage for the processor context
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtGetContextThread(
+ IN HANDLE ThreadHandle,
+ OUT PCONTEXT Context
+ );
+
+NTSTATUS
+STDCALL
+ZwGetContextThread(
+ IN HANDLE ThreadHandle,
+ OUT PCONTEXT Context
+ );
+/*
+ * FUNCTION: Retrieves the uptime of the system
+ * ARGUMENTS:
+ * UpTime = Number of clock ticks since boot.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtGetTickCount(
+ PULONG UpTime
+ );
+
+NTSTATUS
+STDCALL
+ZwGetTickCount(
+ PULONG UpTime
+ );
+
+/*
+ * FUNCTION: Sets a thread to impersonate another
+ * ARGUMENTS:
+ * ThreadHandle = Server thread that will impersonate a client.
+ ThreadToImpersonate = Client thread that will be impersonated
+ SecurityQualityOfService = Specifies the impersonation level.
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtImpersonateThread(
+ IN HANDLE ThreadHandle,
+ IN HANDLE ThreadToImpersonate,
+ IN PSECURITY_QUALITY_OF_SERVICE SecurityQualityOfService
+ );
+
+NTSTATUS
+STDCALL
+ZwImpersonateThread(
+ IN HANDLE ThreadHandle,
+ IN HANDLE ThreadToImpersonate,
+ IN PSECURITY_QUALITY_OF_SERVICE SecurityQualityOfService
+ );
+
+/*
+ * FUNCTION: Initializes the registry.
+ * ARGUMENTS:
+ * SetUpBoot = This parameter is true for a setup boot.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtInitializeRegistry(
+ BOOLEAN SetUpBoot
+ );
+NTSTATUS
+STDCALL
+ZwInitializeRegistry(
+ BOOLEAN SetUpBoot
+ );
+
+/*
+ * FUNCTION: Loads a driver.
+ * ARGUMENTS:
+ * DriverServiceName = Name of the driver to load
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtLoadDriver(
+ IN PUNICODE_STRING DriverServiceName
+ );
+
+NTSTATUS
+STDCALL
+ZwLoadDriver(
+ IN PUNICODE_STRING DriverServiceName
+ );
+
+/*
+ * FUNCTION: Loads a registry key.
+ * ARGUMENTS:
+ * KeyHandle = Handle to the registry key
+ * ObjectAttributes = ???
+ * REMARK:
+ * This procedure maps to the win32 procedure RegLoadKey
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtLoadKey(
+ PHANDLE KeyHandle,
+ POBJECT_ATTRIBUTES ObjectAttributes
+ );
+NTSTATUS
+STDCALL
+ZwLoadKey(
+ PHANDLE KeyHandle,
+ POBJECT_ATTRIBUTES ObjectAttributes
+ );
+
+/*
+ * FUNCTION: Loads a registry key.
+ * ARGUMENTS:
+ * KeyHandle = Handle to the registry key
+ * ObjectAttributes = ???
+ * Unknown3 = ???
+ * REMARK:
+ * This procedure maps to the win32 procedure RegLoadKey
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtLoadKey2 (
+ PHANDLE KeyHandle,
+ POBJECT_ATTRIBUTES ObjectAttributes,
+ ULONG Unknown3
+ );
+NTSTATUS
+STDCALL
+ZwLoadKey2 (
+ PHANDLE KeyHandle,
+ POBJECT_ATTRIBUTES ObjectAttributes,
+ ULONG Unknown3
+ );
+
+/*
+ * FUNCTION: Locks a range of bytes in a file.
+ * ARGUMENTS:
+ * FileHandle = Handle to the file
+ * Event = Should be null if apc is specified.
+ * ApcRoutine = Asynchroneous Procedure Callback
+ * ApcContext = Argument to the callback
+ * IoStatusBlock (OUT) = Caller should supply storage for a structure containing
+ * the completion status and information about the requested lock operation.
+ * ByteOffset = Offset
+ * Length = Number of bytes to lock.
+ * Key = Special value to give other threads the possibility to unlock the file
+ by supplying the key in a call to NtUnlockFile.
+ * FailImmediatedly = If false the request will block untill the lock is obtained.
+ * ExclusiveLock = Specifies whether a exclusive or a shared lock is obtained.
+ * REMARK:
+ This procedure maps to the win32 procedure LockFileEx. STATUS_PENDING is returned if the lock could
+ not be obtained immediately, the device queue is busy and the IRP is queued.
+ * RETURNS: Status [ STATUS_SUCCESS | STATUS_PENDING | STATUS_ACCESS_DENIED | STATUS_INSUFFICIENT_RESOURCES |
+ STATUS_INVALID_PARAMETER | STATUS_INVALID_DEVICE_REQUEST | STATUS_LOCK_NOT_GRANTED ]
+
+ */
+NTSTATUS
+STDCALL
+NtLockFile(
+ IN HANDLE FileHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
+ IN PVOID ApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN PLARGE_INTEGER ByteOffset,
+ IN PLARGE_INTEGER Length,
+ IN PULONG Key,
+ IN BOOLEAN FailImmediatedly,
+ IN BOOLEAN ExclusiveLock
+ );
+
+NTSTATUS
+STDCALL
+ZwLockFile(
+ IN HANDLE FileHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
+ IN PVOID ApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN PLARGE_INTEGER ByteOffset,
+ IN PLARGE_INTEGER Length,
+ IN PULONG Key,
+ IN BOOLEAN FailImmediatedly,
+ IN BOOLEAN ExclusiveLock
+ );
+/*
+ * FUNCTION: Locks a range of virtual memory.
+ * ARGUMENTS:
+ * ProcessHandle = Handle to the process
+ * BaseAddress = Lower boundary of the range of bytes to lock.
+ * NumberOfBytesLock = Offset to the upper boundary.
+ * NumberOfBytesLocked (OUT) = Number of bytes actually locked.
+ * REMARK:
+ This procedure maps to the win32 procedure VirtualLock
+ * RETURNS: Status [STATUS_SUCCESS | STATUS_WAS_LOCKED ]
+ */
+NTSTATUS
+STDCALL
+NtLockVirtualMemory(
+ HANDLE ProcessHandle,
+ PVOID BaseAddress,
+ ULONG NumberOfBytesToLock,
+ PULONG NumberOfBytesLocked
+ );
+NTSTATUS
+STDCALL
+ZwLockVirtualMemory(
+ HANDLE ProcessHandle,
+ PVOID BaseAddress,
+ ULONG NumberOfBytesToLock,
+ PULONG NumberOfBytesLocked
+ );
+/*
+ * FUNCTION: Makes temporary object that will be removed at next boot.
+ * ARGUMENTS:
+ * Handle = Handle to object
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtMakeTemporaryObject(
+ IN HANDLE Handle
+ );
+
+NTSTATUS
+STDCALL
+ZwMakeTemporaryObject(
+ IN HANDLE Handle
+ );
+/*
+ * FUNCTION: Maps a view of a section into the virtual address space of a
+ * process
+ * ARGUMENTS:
+ * SectionHandle = Handle of the section
+ * ProcessHandle = Handle of the process
+ * BaseAddress = Desired base address (or NULL) on entry
+ * Actual base address of the view on exit
+ * ZeroBits = Number of high order address bits that must be zero
+ * CommitSize = Size in bytes of the initially committed section of
+ * the view
+ * SectionOffset = Offset in bytes from the beginning of the section
+ * to the beginning of the view
+ * ViewSize = Desired length of map (or zero to map all) on entry
+ * Actual length mapped on exit
+ * InheritDisposition = Specified how the view is to be shared with
+ * child processes
+ * AllocateType = Type of allocation for the pages
+ * Protect = Protection for the committed region of the view
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtMapViewOfSection(
+ IN HANDLE SectionHandle,
+ IN HANDLE ProcessHandle,
+ IN OUT PVOID *BaseAddress,
+ IN ULONG ZeroBits,
+ IN ULONG CommitSize,
+ IN OUT PLARGE_INTEGER SectionOffset OPTIONAL,
+ IN OUT PULONG ViewSize,
+ IN SECTION_INHERIT InheritDisposition,
+ IN ULONG AllocationType,
+ IN ULONG AccessProtection
+ );
+
+NTSTATUS
+STDCALL
+ZwMapViewOfSection(
+ IN HANDLE SectionHandle,
+ IN HANDLE ProcessHandle,
+ IN OUT PVOID *BaseAddress,
+ IN ULONG ZeroBits,
+ IN ULONG CommitSize,
+ IN OUT PLARGE_INTEGER SectionOffset OPTIONAL,
+ IN OUT PULONG ViewSize,
+ IN SECTION_INHERIT InheritDisposition,
+ IN ULONG AllocationType,
+ IN ULONG AccessProtection
+ );
+
+/*
+ * FUNCTION: Installs a notify for the change of a directory's contents
+ * ARGUMENTS:
+ * FileHandle = Handle to the directory
+ Event =
+ * ApcRoutine = Start address
+ * ApcContext = Delimits the range of virtual memory
+ * for which the new access protection holds
+ * IoStatusBlock = The new access proctection for the pages
+ * Buffer = Caller supplies storage for resulting information --> FILE_NOTIFY_INFORMATION
+ * BufferSize = Size of the buffer
+ CompletionFilter = Can be one of the following values:
+ FILE_NOTIFY_CHANGE_FILE_NAME
+ FILE_NOTIFY_CHANGE_DIR_NAME
+ FILE_NOTIFY_CHANGE_NAME ( FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME )
+ FILE_NOTIFY_CHANGE_ATTRIBUTES
+ FILE_NOTIFY_CHANGE_SIZE
+ FILE_NOTIFY_CHANGE_LAST_WRITE
+ FILE_NOTIFY_CHANGE_LAST_ACCESS
+ FILE_NOTIFY_CHANGE_CREATION ( change of creation timestamp )
+ FILE_NOTIFY_CHANGE_EA
+ FILE_NOTIFY_CHANGE_SECURITY
+ FILE_NOTIFY_CHANGE_STREAM_NAME
+ FILE_NOTIFY_CHANGE_STREAM_SIZE
+ FILE_NOTIFY_CHANGE_STREAM_WRITE
+ WatchTree = If true the notify will be installed recursively on the targetdirectory and all subdirectories.
+ *
+ * REMARKS:
+ * The function maps to the win32 FindFirstChangeNotification, FindNextChangeNotification
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtNotifyChangeDirectoryFile(
+ IN HANDLE FileHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
+ IN PVOID ApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PVOID Buffer,
+ IN ULONG BufferSize,
+ IN ULONG CompletionFilter,
+ IN BOOLEAN WatchTree
+ );
+
+NTSTATUS
+STDCALL
+ZwNotifyChangeDirectoryFile(
+ IN HANDLE FileHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
+ IN PVOID ApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PVOID Buffer,
+ IN ULONG BufferSize,
+ IN ULONG CompletionFilter,
+ IN BOOLEAN WatchTree
+ );
+
+/*
+ * FUNCTION: Installs a notfication callback on registry changes
+ * ARGUMENTS:
+ KeyHandle = Handle to the registry key
+ Event = Event that should be signalled on modification of the key
+ ApcRoutine = Routine that should be called on modification of the key
+ ApcContext = Argument to the ApcRoutine
+ IoStatusBlock = ???
+ CompletionFilter = Specifies the kind of notification the caller likes to receive.
+ Can be a combination of the following values:
+
+ REG_NOTIFY_CHANGE_NAME
+ REG_NOTIFY_CHANGE_ATTRIBUTES
+ REG_NOTIFY_CHANGE_LAST_SET
+ REG_NOTIFY_CHANGE_SECURITY
+
+
+ Asynchroneous = If TRUE the changes are reported by signalling an event if false
+ the function will not return before a change occurs.
+ ChangeBuffer = Will return the old value
+ Length = Size of the change buffer
+ WatchSubtree = Indicates if the caller likes to receive a notification of changes in
+ sub keys or not.
+ * REMARKS: If the key is closed the event is signalled aswell.
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtNotifyChangeKey(
+ IN HANDLE KeyHandle,
+ IN HANDLE Event,
+ IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
+ IN PVOID ApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG CompletionFilter,
+ IN BOOLEAN Asynchroneous,
+ OUT PVOID ChangeBuffer,
+ IN ULONG Length,
+ IN BOOLEAN WatchSubtree
+ );
+
+NTSTATUS
+STDCALL
+ZwNotifyChangeKey(
+ IN HANDLE KeyHandle,
+ IN HANDLE Event,
+ IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
+ IN PVOID ApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG CompletionFilter,
+ IN BOOLEAN Asynchroneous,
+ OUT PVOID ChangeBuffer,
+ IN ULONG Length,
+ IN BOOLEAN WatchSubtree
+ );
+
+/*
+ * FUNCTION: Opens an existing directory object
+ * ARGUMENTS:
+ * FileHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Requested access to the directory
+ * ObjectAttributes = Initialized attributes for the object
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtOpenDirectoryObject(
+ OUT PHANDLE FileHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+NTSTATUS
+STDCALL
+ZwOpenDirectoryObject(
+ OUT PHANDLE FileHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+
+/*
+ * FUNCTION: Opens an existing event
+ * ARGUMENTS:
+ * EventHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Requested access to the event
+ * ObjectAttributes = Initialized attributes for the object
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtOpenEvent(
+ OUT PHANDLE EventHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+
+NTSTATUS
+STDCALL
+ZwOpenEvent(
+ OUT PHANDLE EventHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+
+/*
+ * FUNCTION: Opens an existing event pair
+ * ARGUMENTS:
+ * EventHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Requested access to the event
+ * ObjectAttributes = Initialized attributes for the object
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtOpenEventPair(
+ OUT PHANDLE EventPairHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+
+NTSTATUS
+STDCALL
+ZwOpenEventPair(
+ OUT PHANDLE EventPairHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+/*
+ * FUNCTION: Opens an existing file
+ * ARGUMENTS:
+ * FileHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Requested access to the file
+ * ObjectAttributes = Initialized attributes for the object
+ * IoStatusBlock =
+ * ShareAccess =
+ * OpenOptions =
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtOpenFile(
+ OUT PHANDLE FileHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG ShareAccess,
+ IN ULONG OpenOptions
+ );
+
+NTSTATUS
+STDCALL
+ZwOpenFile(
+ OUT PHANDLE FileHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG ShareAccess,
+ IN ULONG OpenOptions
+ );
+
+/*
+ * FUNCTION: Opens an existing io completion object
+ * ARGUMENTS:
+ * CompletionPort (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Requested access to the io completion object
+ * ObjectAttributes = Initialized attributes for the object
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtOpenIoCompletion(
+ OUT PHANDLE CompetionPort,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+
+NTSTATUS
+STDCALL
+ZwOpenIoCompletion(
+ OUT PHANDLE CompetionPort,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+
+/*
+ * FUNCTION: Opens an existing key in the registry
+ * ARGUMENTS:
+ * KeyHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Requested access to the key
+ * ObjectAttributes = Initialized attributes for the object
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtOpenKey(
+ OUT PHANDLE KeyHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+
+NTSTATUS
+STDCALL
+ZwOpenKey(
+ OUT PHANDLE KeyHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+/*
+ * FUNCTION: Opens an existing key in the registry
+ * ARGUMENTS:
+ * MutantHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Requested access to the mutant
+ * ObjectAttribute = Initialized attributes for the object
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtOpenMutant(
+ OUT PHANDLE MutantHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+NTSTATUS
+STDCALL
+ZwOpenMutant(
+ OUT PHANDLE MutantHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+
+NTSTATUS
+STDCALL
+NtOpenObjectAuditAlarm(
+ IN PUNICODE_STRING SubsystemName,
+ IN PVOID HandleId,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN HANDLE ClientToken,
+ IN ULONG DesiredAccess,
+ IN ULONG GrantedAccess,
+ IN PPRIVILEGE_SET Privileges,
+ IN BOOLEAN ObjectCreation,
+ IN BOOLEAN AccessGranted,
+ OUT PBOOLEAN GenerateOnClose
+ );
+
+NTSTATUS
+STDCALL
+ZwOpenObjectAuditAlarm(
+ IN PUNICODE_STRING SubsystemName,
+ IN PVOID HandleId,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN HANDLE ClientToken,
+ IN ULONG DesiredAccess,
+ IN ULONG GrantedAccess,
+ IN PPRIVILEGE_SET Privileges,
+ IN BOOLEAN ObjectCreation,
+ IN BOOLEAN AccessGranted,
+ OUT PBOOLEAN GenerateOnClose
+ );
+/*
+ * FUNCTION: Opens an existing process
+ * ARGUMENTS:
+ * ProcessHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Requested access to the process
+ * ObjectAttribute = Initialized attributes for the object
+ * ClientId = Identifies the process id to open
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtOpenProcess (
+ OUT PHANDLE ProcessHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN PCLIENT_ID ClientId
+ );
+NTSTATUS
+STDCALL
+ZwOpenProcess (
+ OUT PHANDLE ProcessHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN PCLIENT_ID ClientId
+ );
+/*
+ * FUNCTION: Opens an existing process
+ * ARGUMENTS:
+ * ProcessHandle = Handle of the process of which owns the token
+ * DesiredAccess = Requested access to the token
+ * TokenHandle (OUT) = Caller supplies storage for the resulting token.
+ * REMARKS:
+ This function maps to the win32
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtOpenProcessToken(
+ IN HANDLE ProcessHandle,
+ IN ACCESS_MASK DesiredAccess,
+ OUT PHANDLE TokenHandle
+ );
+
+NTSTATUS
+STDCALL
+ZwOpenProcessToken(
+ IN HANDLE ProcessHandle,
+ IN ACCESS_MASK DesiredAccess,
+ OUT PHANDLE TokenHandle
+ );
+
+/*
+ * FUNCTION: Opens an existing section object
+ * ARGUMENTS:
+ * KeyHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Requested access to the key
+ * ObjectAttribute = Initialized attributes for the object
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtOpenSection(
+ OUT PHANDLE SectionHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+NTSTATUS
+STDCALL
+ZwOpenSection(
+ OUT PHANDLE SectionHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+/*
+ * FUNCTION: Opens an existing semaphore
+ * ARGUMENTS:
+ * SemaphoreHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Requested access to the semaphore
+ * ObjectAttribute = Initialized attributes for the object
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtOpenSemaphore(
+ IN HANDLE SemaphoreHandle,
+ IN ACCESS_MASK DesiredAcces,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+NTSTATUS
+STDCALL
+ZwOpenSemaphore(
+ IN HANDLE SemaphoreHandle,
+ IN ACCESS_MASK DesiredAcces,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+/*
+ * FUNCTION: Opens an existing symbolic link
+ * ARGUMENTS:
+ * SymbolicLinkHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Requested access to the symbolic link
+ * ObjectAttribute = Initialized attributes for the object
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtOpenSymbolicLinkObject(
+ OUT PHANDLE SymbolicLinkHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+NTSTATUS
+STDCALL
+ZwOpenSymbolicLinkObject(
+ OUT PHANDLE SymbolicLinkHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+/*
+ * FUNCTION: Opens an existing thread
+ * ARGUMENTS:
+ * ThreadHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Requested access to the thread
+ * ObjectAttribute = Initialized attributes for the object
+ * ClientId = Identifies the thread to open.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtOpenThread(
+ OUT PHANDLE ThreadHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN PCLIENT_ID ClientId
+ );
+NTSTATUS
+STDCALL
+ZwOpenThread(
+ OUT PHANDLE ThreadHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN PCLIENT_ID ClientId
+ );
+
+NTSTATUS
+STDCALL
+NtOpenThreadToken(
+ IN HANDLE ThreadHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN BOOLEAN OpenAsSelf,
+ OUT PHANDLE TokenHandle
+ );
+
+NTSTATUS
+STDCALL
+ZwOpenThreadToken(
+ IN HANDLE ThreadHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN BOOLEAN OpenAsSelf,
+ OUT PHANDLE TokenHandle
+ );
+/*
+ * FUNCTION: Opens an existing timer
+ * ARGUMENTS:
+ * TimerHandle (OUT) = Caller supplied storage for the resulting handle
+ * DesiredAccess = Requested access to the timer
+ * ObjectAttribute = Initialized attributes for the object
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtOpenTimer(
+ OUT PHANDLE TimerHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+NTSTATUS
+STDCALL
+ZwOpenTimer(
+ OUT PHANDLE TimerHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes
+ );
+
+/*
+ * FUNCTION: Checks an access token for specific privileges
+ * ARGUMENTS:
+ * ClientToken = Handle to a access token structure
+ * RequiredPrivileges = Specifies the requested privileges.
+ * Result = Caller supplies storage for the result. If PRIVILEGE_SET_ALL_NECESSARY is
+ set in the Control member of PRIVILEGES_SET Result
+ will only be TRUE if all privileges are present in the access token.
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtPrivilegeCheck(
+ IN HANDLE ClientToken,
+ IN PPRIVILEGE_SET RequiredPrivileges,
+ IN PBOOLEAN Result
+ );
+
+NTSTATUS
+STDCALL
+ZwPrivilegeCheck(
+ IN HANDLE ClientToken,
+ IN PPRIVILEGE_SET RequiredPrivileges,
+ IN PBOOLEAN Result
+ );
+
+NTSTATUS
+STDCALL
+NtPrivilegedServiceAuditAlarm(
+ IN PUNICODE_STRING SubsystemName,
+ IN PUNICODE_STRING ServiceName,
+ IN HANDLE ClientToken,
+ IN PPRIVILEGE_SET Privileges,
+ IN BOOLEAN AccessGranted
+ );
+
+NTSTATUS
+STDCALL
+ZwPrivilegedServiceAuditAlarm(
+ IN PUNICODE_STRING SubsystemName,
+ IN PUNICODE_STRING ServiceName,
+ IN HANDLE ClientToken,
+ IN PPRIVILEGE_SET Privileges,
+ IN BOOLEAN AccessGranted
+ );
+
+NTSTATUS
+STDCALL
+NtPrivilegeObjectAuditAlarm(
+ IN PUNICODE_STRING SubsystemName,
+ IN PVOID HandleId,
+ IN HANDLE ClientToken,
+ IN ULONG DesiredAccess,
+ IN PPRIVILEGE_SET Privileges,
+ IN BOOLEAN AccessGranted
+ );
+
+NTSTATUS
+STDCALL
+ZwPrivilegeObjectAuditAlarm(
+ IN PUNICODE_STRING SubsystemName,
+ IN PVOID HandleId,
+ IN HANDLE ClientToken,
+ IN ULONG DesiredAccess,
+ IN PPRIVILEGE_SET Privileges,
+ IN BOOLEAN AccessGranted
+ );
+
+/*
+ * FUNCTION: Entry point for native applications
+ * ARGUMENTS:
+ * Peb = Pointes to the Process Environment Block (PEB)
+ * REMARKS:
+ * Native applications should use this function instead of a main.
+ * Calling proces should terminate itself.
+ * RETURNS: Status
+ */
+VOID
+NtProcessStartup(
+ IN PPEB Peb
+ );
+
+/*
+ * FUNCTION: Set the access protection of a range of virtual memory
+ * ARGUMENTS:
+ * ProcessHandle = Handle to process owning the virtual address space
+ * BaseAddress = Start address
+ * NumberOfBytesToProtect = Delimits the range of virtual memory
+ * for which the new access protection holds
+ * NewAccessProtection = The new access proctection for the pages
+ * OldAccessProtection = Caller should supply storage for the old
+ * access protection
+ *
+ * REMARKS:
+ * The function maps to the win32 VirtualProtectEx
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtProtectVirtualMemory(
+ IN HANDLE ProcessHandle,
+ IN PVOID BaseAddress,
+ IN ULONG NumberOfBytesToProtect,
+ IN ULONG NewAccessProtection,
+ OUT PULONG OldAccessProtection
+ );
+
+NTSTATUS
+STDCALL
+ZwProtectVirtualMemory(
+ IN HANDLE ProcessHandle,
+ IN PVOID BaseAddress,
+ IN ULONG NumberOfBytesToProtect,
+ IN ULONG NewAccessProtection,
+ OUT PULONG OldAccessProtection
+ );
+
+
+/*
+ * FUNCTION: Signals an event and resets it afterwards.
+ * ARGUMENTS:
+ * EventHandle = Handle to the event
+ * PulseCount = Number of times the action is repeated
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtPulseEvent(
+ IN HANDLE EventHandle,
+ IN PULONG PulseCount OPTIONAL
+ );
+
+NTSTATUS
+STDCALL
+ZwPulseEvent(
+ IN HANDLE EventHandle,
+ IN PULONG PulseCount OPTIONAL
+ );
+
+/*
+ * FUNCTION: Queries the attributes of a file
+ * ARGUMENTS:
+ * ObjectAttributes = Initialized attributes for the object
+ * Buffer = Caller supplies storage for the attributes
+ * RETURNS: Status
+ */
+
+NTSTATUS STDCALL
+NtQueryAttributesFile(IN POBJECT_ATTRIBUTES ObjectAttributes,
+ OUT PFILE_BASIC_INFORMATION FileInformation);
+
+NTSTATUS STDCALL
+ZwQueryAttributesFile(IN POBJECT_ATTRIBUTES ObjectAttributes,
+ OUT PFILE_BASIC_INFORMATION FileInformation);
+
+/*
+ * FUNCTION: Queries the default locale id
+ * ARGUMENTS:
+ * UserProfile = Type of locale id
+ * TRUE: thread locale id
+ * FALSE: system locale id
+ * DefaultLocaleId = Caller supplies storage for the locale id
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtQueryDefaultLocale(
+ IN BOOLEAN UserProfile,
+ OUT PLCID DefaultLocaleId
+ );
+
+NTSTATUS
+STDCALL
+ZwQueryDefaultLocale(
+ IN BOOLEAN UserProfile,
+ OUT PLCID DefaultLocaleId
+ );
+
+/*
+ * FUNCTION: Queries a directory file.
+ * ARGUMENTS:
+ * FileHandle = Handle to a directory file
+ * EventHandle = Handle to the event signaled on completion
+ * ApcRoutine = Asynchroneous procedure callback, called on completion
+ * ApcContext = Argument to the apc.
+ * IoStatusBlock = Caller supplies storage for extended status information.
+ * FileInformation = Caller supplies storage for the resulting information.
+ *
+ * FileNameInformation FILE_NAMES_INFORMATION
+ * FileDirectoryInformation FILE_DIRECTORY_INFORMATION
+ * FileFullDirectoryInformation FILE_FULL_DIRECTORY_INFORMATION
+ * FileBothDirectoryInformation FILE_BOTH_DIR_INFORMATION
+ *
+ * Length = Size of the storage supplied
+ * FileInformationClass = Indicates the type of information requested.
+ * ReturnSingleEntry = Specify true if caller only requests the first directory found.
+ * FileName = Initial directory name to query, that may contain wild cards.
+ * RestartScan = Number of times the action should be repeated
+ * RETURNS: Status [ STATUS_SUCCESS, STATUS_ACCESS_DENIED, STATUS_INSUFFICIENT_RESOURCES,
+ * STATUS_INVALID_PARAMETER, STATUS_INVALID_DEVICE_REQUEST, STATUS_BUFFER_OVERFLOW,
+ * STATUS_INVALID_INFO_CLASS, STATUS_NO_SUCH_FILE, STATUS_NO_MORE_FILES ]
+ */
+
+NTSTATUS
+STDCALL
+NtQueryDirectoryFile(
+ IN HANDLE FileHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
+ IN PVOID ApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PVOID FileInformation,
+ IN ULONG Length,
+ IN FILE_INFORMATION_CLASS FileInformationClass,
+ IN BOOLEAN ReturnSingleEntry,
+ IN PUNICODE_STRING FileName OPTIONAL,
+ IN BOOLEAN RestartScan
+ );
+
+NTSTATUS
+STDCALL
+ZwQueryDirectoryFile(
+ IN HANDLE FileHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
+ IN PVOID ApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PVOID FileInformation,
+ IN ULONG Length,
+ IN FILE_INFORMATION_CLASS FileInformationClass,
+ IN BOOLEAN ReturnSingleEntry,
+ IN PUNICODE_STRING FileName OPTIONAL,
+ IN BOOLEAN RestartScan
+ );
+
+/*
+ * FUNCTION: Query information about the content of a directory object
+ * ARGUMENTS:
+ DirObjInformation = Buffer must be large enough to hold the name strings too
+ GetNextIndex = If TRUE :return the index of the next object in this directory in ObjectIndex
+ If FALSE: return the number of objects in this directory in ObjectIndex
+ IgnoreInputIndex= If TRUE: ignore input value of ObjectIndex always start at index 0
+ If FALSE use input value of ObjectIndex
+ ObjectIndex = zero based index of object in the directory depends on GetNextIndex and IgnoreInputIndex
+ DataWritten = Actual size of the ObjectIndex ???
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtQueryDirectoryObject(
+ IN HANDLE DirObjHandle,
+ OUT POBJDIR_INFORMATION DirObjInformation,
+ IN ULONG BufferLength,
+ IN BOOLEAN GetNextIndex,
+ IN BOOLEAN IgnoreInputIndex,
+ IN OUT PULONG ObjectIndex,
+ OUT PULONG DataWritten OPTIONAL
+ );
+
+NTSTATUS
+STDCALL
+ZwQueryDirectoryObject(
+ IN HANDLE DirObjHandle,
+ OUT POBJDIR_INFORMATION DirObjInformation,
+ IN ULONG BufferLength,
+ IN BOOLEAN GetNextIndex,
+ IN BOOLEAN IgnoreInputIndex,
+ IN OUT PULONG ObjectIndex,
+ OUT PULONG DataWritten OPTIONAL
+ );
+
+/*
+ * FUNCTION: Queries the extended attributes of a file
+ * ARGUMENTS:
+ * FileHandle = Handle to the event
+ * IoStatusBlock = Number of times the action is repeated
+ * Buffer
+ * Length
+ * ReturnSingleEntry
+ * EaList
+ * EaListLength
+ * EaIndex
+ * RestartScan
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtQueryEaFile(
+ IN HANDLE FileHandle,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PVOID Buffer,
+ IN ULONG Length,
+ IN BOOLEAN ReturnSingleEntry,
+ IN PVOID EaList OPTIONAL,
+ IN ULONG EaListLength,
+ IN PULONG EaIndex OPTIONAL,
+ IN BOOLEAN RestartScan
+ );
+
+NTSTATUS
+STDCALL
+ZwQueryEaFile(
+ IN HANDLE FileHandle,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PVOID Buffer,
+ IN ULONG Length,
+ IN BOOLEAN ReturnSingleEntry,
+ IN PVOID EaList OPTIONAL,
+ IN ULONG EaListLength,
+ IN PULONG EaIndex OPTIONAL,
+ IN BOOLEAN RestartScan
+ );
+
+/*
+ * FUNCTION: Queries an event
+ * ARGUMENTS:
+ * EventHandle = Handle to the event
+ * EventInformationClass = Index of the information structure
+
+ EventBasicInformation EVENT_BASIC_INFORMATION
+
+ * EventInformation = Caller supplies storage for the information structure
+ * EventInformationLength = Size of the information structure
+ * ReturnLength = Data written
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtQueryEvent(
+ IN HANDLE EventHandle,
+ IN EVENT_INFORMATION_CLASS EventInformationClass,
+ OUT PVOID EventInformation,
+ IN ULONG EventInformationLength,
+ OUT PULONG ReturnLength
+ );
+NTSTATUS
+STDCALL
+ZwQueryEvent(
+ IN HANDLE EventHandle,
+ IN EVENT_INFORMATION_CLASS EventInformationClass,
+ OUT PVOID EventInformation,
+ IN ULONG EventInformationLength,
+ OUT PULONG ReturnLength
+ );
+
+NTSTATUS STDCALL
+NtQueryFullAttributesFile(IN POBJECT_ATTRIBUTES ObjectAttributes,
+ OUT PFILE_NETWORK_OPEN_INFORMATION FileInformation);
+
+NTSTATUS STDCALL
+ZwQueryFullAttributesFile(IN POBJECT_ATTRIBUTES ObjectAttributes,
+ OUT PFILE_NETWORK_OPEN_INFORMATION FileInformation);
+
+NTSTATUS
+STDCALL
+NtQueryInformationAtom(
+ IN RTL_ATOM Atom,
+ IN ATOM_INFORMATION_CLASS AtomInformationClass,
+ OUT PVOID AtomInformation,
+ IN ULONG AtomInformationLength,
+ OUT PULONG ReturnLength OPTIONAL
+ );
+
+NTSTATUS
+STDCALL
+NtQueryInformationAtom(
+ IN RTL_ATOM Atom,
+ IN ATOM_INFORMATION_CLASS AtomInformationClass,
+ OUT PVOID AtomInformation,
+ IN ULONG AtomInformationLength,
+ OUT PULONG ReturnLength OPTIONAL
+ );
+
+
+/*
+ * FUNCTION: Queries the information of a file object.
+ * ARGUMENTS:
+ * FileHandle = Handle to the file object
+ * IoStatusBlock = Caller supplies storage for extended information
+ * on the current operation.
+ * FileInformation = Storage for the new file information
+ * Lenght = Size of the storage for the file information.
+ * FileInformationClass = Indicates which file information is queried
+
+ FileDirectoryInformation FILE_DIRECTORY_INFORMATION
+ FileFullDirectoryInformation FILE_FULL_DIRECTORY_INFORMATION
+ FileBothDirectoryInformation FILE_BOTH_DIRECTORY_INFORMATION
+ FileBasicInformation FILE_BASIC_INFORMATION
+ FileStandardInformation FILE_STANDARD_INFORMATION
+ FileInternalInformation FILE_INTERNAL_INFORMATION
+ FileEaInformation FILE_EA_INFORMATION
+ FileAccessInformation FILE_ACCESS_INFORMATION
+ FileNameInformation FILE_NAME_INFORMATION
+ FileRenameInformation FILE_RENAME_INFORMATION
+ FileLinkInformation
+ FileNamesInformation FILE_NAMES_INFORMATION
+ FileDispositionInformation FILE_DISPOSITION_INFORMATION
+ FilePositionInformation FILE_POSITION_INFORMATION
+ FileFullEaInformation FILE_FULL_EA_INFORMATION
+ FileModeInformation FILE_MODE_INFORMATION
+ FileAlignmentInformation FILE_ALIGNMENT_INFORMATION
+ FileAllInformation FILE_ALL_INFORMATION
+
+ FileEndOfFileInformation FILE_END_OF_FILE_INFORMATION
+ FileAlternateNameInformation
+ FileStreamInformation FILE_STREAM_INFORMATION
+ FilePipeInformation
+ FilePipeLocalInformation
+ FilePipeRemoteInformation
+ FileMailslotQueryInformation
+ FileMailslotSetInformation
+ FileCompressionInformation FILE_COMPRESSION_INFORMATION
+ FileCopyOnWriteInformation
+ FileCompletionInformation IO_COMPLETION_CONTEXT
+ FileMoveClusterInformation
+ FileOleClassIdInformation
+ FileOleStateBitsInformation
+ FileNetworkOpenInformation FILE_NETWORK_OPEN_INFORMATION
+ FileObjectIdInformation
+ FileOleAllInformation
+ FileOleDirectoryInformation
+ FileContentIndexInformation
+ FileInheritContentIndexInformation
+ FileOleInformation
+ FileMaximumInformation
+
+ * REMARK:
+ * This procedure maps to the win32 GetShortPathName, GetLongPathName,
+ GetFullPathName, GetFileType, GetFileSize, GetFileTime functions.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtQueryInformationFile(
+ IN HANDLE FileHandle,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PVOID FileInformation,
+ IN ULONG Length,
+ IN FILE_INFORMATION_CLASS FileInformationClass
+ );
+
+NTSTATUS
+STDCALL
+ZwQueryInformationFile(
+ HANDLE FileHandle,
+ PIO_STATUS_BLOCK IoStatusBlock,
+ PVOID FileInformation,
+ ULONG Length,
+ FILE_INFORMATION_CLASS FileInformationClass
+ );
+
+/*
+ * FUNCTION: Queries the information of a process object.
+ * ARGUMENTS:
+ * ProcessHandle = Handle to the process object
+ * ProcessInformation = Index to a certain information structure
+
+ ProcessBasicInformation PROCESS_BASIC_INFORMATION
+ ProcessQuotaLimits QUOTA_LIMITS
+ ProcessIoCounters IO_COUNTERS
+ ProcessVmCounters VM_COUNTERS
+ ProcessTimes KERNEL_USER_TIMES
+ ProcessBasePriority KPRIORITY
+ ProcessRaisePriority KPRIORITY
+ ProcessDebugPort HANDLE
+ ProcessExceptionPort HANDLE
+ ProcessAccessToken PROCESS_ACCESS_TOKEN
+ ProcessLdtInformation LDT_ENTRY ??
+ ProcessLdtSize ULONG
+ ProcessDefaultHardErrorMode ULONG
+ ProcessIoPortHandlers // kernel mode only
+ ProcessPooledUsageAndLimits POOLED_USAGE_AND_LIMITS
+ ProcessWorkingSetWatch PROCESS_WS_WATCH_INFORMATION
+ ProcessUserModeIOPL (I/O Privilege Level)
+ ProcessEnableAlignmentFaultFixup BOOLEAN
+ ProcessPriorityClass ULONG
+ ProcessWx86Information ULONG
+ ProcessHandleCount ULONG
+ ProcessAffinityMask ULONG
+ ProcessPooledQuotaLimits QUOTA_LIMITS
+ MaxProcessInfoClass
+
+ * ProcessInformation = Caller supplies storage for the process information structure
+ * ProcessInformationLength = Size of the process information structure
+ * ReturnLength = Actual number of bytes written
+
+ * REMARK:
+ * This procedure maps to the win32 GetProcessTimes, GetProcessVersion,
+ GetProcessWorkingSetSize, GetProcessPriorityBoost, GetProcessAffinityMask, GetPriorityClass,
+ GetProcessShutdownParameters functions.
+ * RETURNS: Status
+*/
+
+NTSTATUS
+STDCALL
+NtQueryInformationProcess(
+ IN HANDLE ProcessHandle,
+ IN CINT ProcessInformationClass,
+ OUT PVOID ProcessInformation,
+ IN ULONG ProcessInformationLength,
+ OUT PULONG ReturnLength
+ );
+
+NTSTATUS
+STDCALL
+ZwQueryInformationProcess(
+ IN HANDLE ProcessHandle,
+ IN CINT ProcessInformationClass,
+ OUT PVOID ProcessInformation,
+ IN ULONG ProcessInformationLength,
+ OUT PULONG ReturnLength
+ );
+
+
+/*
+ * FUNCTION: Queries the information of a thread object.
+ * ARGUMENTS:
+ * ThreadHandle = Handle to the thread object
+ * ThreadInformationClass = Index to a certain information structure
+
+ ThreadBasicInformation THREAD_BASIC_INFORMATION
+ ThreadTimes KERNEL_USER_TIMES
+ ThreadPriority KPRIORITY
+ ThreadBasePriority KPRIORITY
+ ThreadAffinityMask KAFFINITY
+ ThreadImpersonationToken
+ ThreadDescriptorTableEntry
+ ThreadEnableAlignmentFaultFixup
+ ThreadEventPair
+ ThreadQuerySetWin32StartAddress
+ ThreadZeroTlsCell
+ ThreadPerformanceCount
+ ThreadAmILastThread BOOLEAN
+ ThreadIdealProcessor ULONG
+ ThreadPriorityBoost ULONG
+ MaxThreadInfoClass
+
+
+ * ThreadInformation = Caller supplies torage for the thread information
+ * ThreadInformationLength = Size of the thread information structure
+ * ReturnLength = Actual number of bytes written
+
+ * REMARK:
+ * This procedure maps to the win32 GetThreadTimes, GetThreadPriority,
+ GetThreadPriorityBoost functions.
+ * RETURNS: Status
+*/
+
+
+NTSTATUS
+STDCALL
+NtQueryInformationThread(
+ IN HANDLE ThreadHandle,
+ IN THREADINFOCLASS ThreadInformationClass,
+ OUT PVOID ThreadInformation,
+ IN ULONG ThreadInformationLength,
+ OUT PULONG ReturnLength
+ );
+
+
+NTSTATUS
+STDCALL
+NtQueryInformationToken(
+ IN HANDLE TokenHandle,
+ IN TOKEN_INFORMATION_CLASS TokenInformationClass,
+ OUT PVOID TokenInformation,
+ IN ULONG TokenInformationLength,
+ OUT PULONG ReturnLength
+ );
+
+NTSTATUS
+STDCALL
+ZwQueryInformationToken(
+ IN HANDLE TokenHandle,
+ IN TOKEN_INFORMATION_CLASS TokenInformationClass,
+ OUT PVOID TokenInformation,
+ IN ULONG TokenInformationLength,
+ OUT PULONG ReturnLength
+ );
+
+/*
+ * FUNCTION: Query the interval and the clocksource for profiling
+ * ARGUMENTS:
+ Interval =
+ ClockSource =
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtQueryIntervalProfile(
+ OUT PULONG Interval,
+ OUT KPROFILE_SOURCE ClockSource
+ );
+
+NTSTATUS
+STDCALL
+ZwQueryIntervalProfile(
+ OUT PULONG Interval,
+ OUT KPROFILE_SOURCE ClockSource
+ );
+
+
+
+NTSTATUS
+STDCALL
+NtQueryIoCompletion(
+ IN HANDLE CompletionPort,
+ IN ULONG CompletionKey,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PULONG NumberOfBytesTransferred
+ );
+NTSTATUS
+STDCALL
+ZwQueryIoCompletion(
+ IN HANDLE CompletionPort,
+ IN ULONG CompletionKey,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PULONG NumberOfBytesTransferred
+ );
+
+
+/*
+ * FUNCTION: Queries the information of a registry key object.
+ * ARGUMENTS:
+ KeyHandle = Handle to a registry key
+ KeyInformationClass = Index to a certain information structure
+ KeyInformation = Caller supplies storage for resulting information
+ Length = Size of the supplied storage
+ ResultLength = Bytes written
+ */
+NTSTATUS
+STDCALL
+NtQueryKey(
+ IN HANDLE KeyHandle,
+ IN KEY_INFORMATION_CLASS KeyInformationClass,
+ OUT PVOID KeyInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+
+NTSTATUS
+STDCALL
+ZwQueryKey(
+ IN HANDLE KeyHandle,
+ IN KEY_INFORMATION_CLASS KeyInformationClass,
+ OUT PVOID KeyInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+
+
+// draft
+
+NTSTATUS
+STDCALL
+NtQueryMultipleValueKey(
+ IN HANDLE KeyHandle,
+ IN OUT PKEY_VALUE_ENTRY ValueList,
+ IN ULONG NumberOfValues,
+ OUT PVOID Buffer,
+ IN OUT PULONG Length,
+ OUT PULONG ReturnLength
+ );
+
+NTSTATUS
+STDCALL
+ZwQueryMultipleValueKey(
+ IN HANDLE KeyHandle,
+ IN OUT PKEY_VALUE_ENTRY ValueList,
+ IN ULONG NumberOfValues,
+ OUT PVOID Buffer,
+ IN OUT PULONG Length,
+ OUT PULONG ReturnLength
+ );
+
+/*
+ * FUNCTION: Queries the information of a mutant object.
+ * ARGUMENTS:
+ MutantHandle = Handle to a mutant
+ MutantInformationClass = Index to a certain information structure
+ MutantInformation = Caller supplies storage for resulting information
+ Length = Size of the supplied storage
+ ResultLength = Bytes written
+ */
+NTSTATUS
+STDCALL
+NtQueryMutant(
+ IN HANDLE MutantHandle,
+ IN CINT MutantInformationClass,
+ OUT PVOID MutantInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+
+NTSTATUS
+STDCALL
+ZwQueryMutant(
+ IN HANDLE MutantHandle,
+ IN CINT MutantInformationClass,
+ OUT PVOID MutantInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+/*
+ * FUNCTION: Queries the information of a object.
+ * ARGUMENTS:
+ ObjectHandle = Handle to a object
+ ObjectInformationClass = Index to a certain information structure
+
+ ObjectBasicInformation
+ ObjectTypeInformation OBJECT_TYPE_INFORMATION
+ ObjectNameInformation OBJECT_NAME_INFORMATION
+ ObjectDataInformation OBJECT_DATA_INFORMATION
+
+ ObjectInformation = Caller supplies storage for resulting information
+ Length = Size of the supplied storage
+ ResultLength = Bytes written
+ */
+
+NTSTATUS
+STDCALL
+NtQueryObject(
+ IN HANDLE ObjectHandle,
+ IN CINT ObjectInformationClass,
+ OUT PVOID ObjectInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+
+NTSTATUS
+STDCALL
+ZwQueryObject(
+ IN HANDLE ObjectHandle,
+ IN CINT ObjectInformationClass,
+ OUT PVOID ObjectInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+
+/*
+ * FUNCTION: Queries the system ( high-resolution ) performance counter.
+ * ARGUMENTS:
+ * Counter = Performance counter
+ * Frequency = Performance frequency
+ * REMARKS:
+ This procedure queries a tick count faster than 10ms ( The resolution for Intel®-based CPUs is about 0.8 microseconds.)
+ This procedure maps to the win32 QueryPerformanceCounter, QueryPerformanceFrequency
+ * RETURNS: Status
+ *
+*/
+NTSTATUS
+STDCALL
+NtQueryPerformanceCounter(
+ IN PLARGE_INTEGER Counter,
+ IN PLARGE_INTEGER Frequency
+ );
+
+NTSTATUS
+STDCALL
+ZwQueryPerformanceCounter(
+ IN PLARGE_INTEGER Counter,
+ IN PLARGE_INTEGER Frequency
+ );
+/*
+ * FUNCTION: Queries the information of a section object.
+ * ARGUMENTS:
+ * SectionHandle = Handle to the section link object
+ * SectionInformationClass = Index to a certain information structure
+ * SectionInformation (OUT)= Caller supplies storage for resulting information
+ * Length = Size of the supplied storage
+ * ResultLength = Data written
+ * RETURNS: Status
+ *
+*/
+NTSTATUS
+STDCALL
+NtQuerySection(
+ IN HANDLE SectionHandle,
+ IN CINT SectionInformationClass,
+ OUT PVOID SectionInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+
+NTSTATUS
+STDCALL
+ZwQuerySection(
+ IN HANDLE SectionHandle,
+ IN CINT SectionInformationClass,
+ OUT PVOID SectionInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+
+NTSTATUS
+STDCALL
+NtQuerySecurityObject(
+ IN HANDLE Object,
+ IN CINT SecurityObjectInformationClass,
+ OUT PVOID SecurityObjectInformation,
+ IN ULONG Length,
+ OUT PULONG ReturnLength
+ );
+
+NTSTATUS
+STDCALL
+ZwQuerySecurityObject(
+ IN HANDLE Object,
+ IN CINT SecurityObjectInformationClass,
+ OUT PVOID SecurityObjectInformation,
+ IN ULONG Length,
+ OUT PULONG ReturnLength
+ );
+
+
+/*
+ * FUNCTION: Queries the information of a semaphore.
+ * ARGUMENTS:
+ * SemaphoreHandle = Handle to the semaphore object
+ * SemaphoreInformationClass = Index to a certain information structure
+
+ SemaphoreBasicInformation SEMAPHORE_BASIC_INFORMATION
+
+ * SemaphoreInformation = Caller supplies storage for the semaphore information structure
+ * Length = Size of the infomation structure
+ */
+NTSTATUS
+STDCALL
+NtQuerySemaphore(
+ IN HANDLE SemaphoreHandle,
+ IN SEMAPHORE_INFORMATION_CLASS SemaphoreInformationClass,
+ OUT PVOID SemaphoreInformation,
+ IN ULONG Length,
+ OUT PULONG ReturnLength
+ );
+
+NTSTATUS
+STDCALL
+ZwQuerySemaphore(
+ IN HANDLE SemaphoreHandle,
+ IN SEMAPHORE_INFORMATION_CLASS SemaphoreInformationClass,
+ OUT PVOID SemaphoreInformation,
+ IN ULONG Length,
+ OUT PULONG ReturnLength
+ );
+
+
+/*
+ * FUNCTION: Queries the information of a symbolic link object.
+ * ARGUMENTS:
+ * SymbolicLinkHandle = Handle to the symbolic link object
+ * LinkTarget = resolved name of link
+ * DataWritten = size of the LinkName.
+ * RETURNS: Status
+ *
+*/
+NTSTATUS
+STDCALL
+NtQuerySymbolicLinkObject(
+ IN HANDLE SymLinkObjHandle,
+ OUT PUNICODE_STRING LinkTarget,
+ OUT PULONG DataWritten OPTIONAL
+ );
+
+NTSTATUS
+STDCALL
+ZwQuerySymbolicLinkObject(
+ IN HANDLE SymLinkObjHandle,
+ OUT PUNICODE_STRING LinkName,
+ OUT PULONG DataWritten OPTIONAL
+ );
+
+
+/*
+ * FUNCTION: Queries a system environment variable.
+ * ARGUMENTS:
+ * Name = Name of the variable
+ * Value (OUT) = value of the variable
+ * Length = size of the buffer
+ * ReturnLength = data written
+ * RETURNS: Status
+ *
+*/
+NTSTATUS
+STDCALL
+NtQuerySystemEnvironmentValue(
+ IN PUNICODE_STRING Name,
+ OUT PVOID Value,
+ ULONG Length,
+ PULONG ReturnLength
+ );
+
+NTSTATUS
+STDCALL
+ZwQuerySystemEnvironmentValue(
+ IN PUNICODE_STRING Name,
+ OUT PVOID Value,
+ ULONG Length,
+ PULONG ReturnLength
+ );
+
+
+/*
+ * FUNCTION: Queries the system information.
+ * ARGUMENTS:
+ * SystemInformationClass = Index to a certain information structure
+
+ SystemTimeAdjustmentInformation SYSTEM_TIME_ADJUSTMENT
+ SystemCacheInformation SYSTEM_CACHE_INFORMATION
+ SystemConfigurationInformation CONFIGURATION_INFORMATION
+
+ * SystemInformation = caller supplies storage for the information structure
+ * Length = size of the structure
+ ResultLength = Data written
+ * RETURNS: Status
+ *
+*/
+NTSTATUS
+STDCALL
+NtQuerySystemInformation(
+ IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
+ OUT PVOID SystemInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+
+NTSTATUS
+STDCALL
+ZwQuerySystemInformation(
+ IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
+ OUT PVOID SystemInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+
+/*
+ * FUNCTION: Retrieves the system time
+ * ARGUMENTS:
+ * CurrentTime (OUT) = Caller should supply storage for the resulting time.
+ * RETURNS: Status
+ *
+*/
+
+NTSTATUS
+STDCALL
+NtQuerySystemTime (
+ OUT TIME *CurrentTime
+ );
+
+NTSTATUS
+STDCALL
+ZwQuerySystemTime (
+ OUT TIME *CurrentTime
+ );
+
+/*
+ * FUNCTION: Queries information about a timer
+ * ARGUMENTS:
+ * TimerHandle = Handle to the timer
+ TimerValueInformationClass = Index to a certain information structure
+ TimerValueInformation = Caller supplies storage for the information structure
+ Length = Size of the information structure
+ ResultLength = Data written
+ * RETURNS: Status
+ *
+*/
+NTSTATUS
+STDCALL
+NtQueryTimer(
+ IN HANDLE TimerHandle,
+ IN CINT TimerInformationClass,
+ OUT PVOID TimerInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+NTSTATUS
+STDCALL
+ZwQueryTimer(
+ IN HANDLE TimerHandle,
+ IN CINT TimerInformationClass,
+ OUT PVOID TimerInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+
+/*
+ * FUNCTION: Queries the timer resolution
+ * ARGUMENTS:
+ * MinimumResolution (OUT) = Caller should supply storage for the resulting time.
+ Maximum Resolution (OUT) = Caller should supply storage for the resulting time.
+ ActualResolution (OUT) = Caller should supply storage for the resulting time.
+ * RETURNS: Status
+ *
+*/
+
+
+NTSTATUS
+STDCALL
+NtQueryTimerResolution (
+ OUT PULONG MinimumResolution,
+ OUT PULONG MaximumResolution,
+ OUT PULONG ActualResolution
+ );
+
+NTSTATUS
+STDCALL
+ZwQueryTimerResolution (
+ OUT PULONG MinimumResolution,
+ OUT PULONG MaximumResolution,
+ OUT PULONG ActualResolution
+ );
+
+/*
+ * FUNCTION: Queries a registry key value
+ * ARGUMENTS:
+ * KeyHandle = Handle to the registry key
+ ValueName = Name of the value in the registry key
+ KeyValueInformationClass = Index to a certain information structure
+
+ KeyValueBasicInformation = KEY_VALUE_BASIC_INFORMATION
+ KeyValueFullInformation = KEY_FULL_INFORMATION
+ KeyValuePartialInformation = KEY_VALUE_PARTIAL_INFORMATION
+
+ KeyValueInformation = Caller supplies storage for the information structure
+ Length = Size of the information structure
+ ResultLength = Data written
+ * RETURNS: Status
+ *
+*/
+NTSTATUS
+STDCALL
+NtQueryValueKey(
+ IN HANDLE KeyHandle,
+ IN PUNICODE_STRING ValueName,
+ IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,
+ OUT PVOID KeyValueInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+
+NTSTATUS
+STDCALL
+ZwQueryValueKey(
+ IN HANDLE KeyHandle,
+ IN PUNICODE_STRING ValueName,
+ IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,
+ OUT PVOID KeyValueInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+
+
+
+
+/*
+ * FUNCTION: Queries the virtual memory information.
+ * ARGUMENTS:
+ ProcessHandle = Process owning the virtual address space
+ BaseAddress = Points to the page where the information is queried for.
+ * VirtualMemoryInformationClass = Index to a certain information structure
+
+ MemoryBasicInformation MEMORY_BASIC_INFORMATION
+
+ * VirtualMemoryInformation = caller supplies storage for the information structure
+ * Length = size of the structure
+ ResultLength = Data written
+ * RETURNS: Status
+ *
+*/
+
+NTSTATUS
+STDCALL
+NtQueryVirtualMemory(
+ IN HANDLE ProcessHandle,
+ IN PVOID Address,
+ IN IN CINT VirtualMemoryInformationClass,
+ OUT PVOID VirtualMemoryInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+NTSTATUS
+STDCALL
+ZwQueryVirtualMemory(
+ IN HANDLE ProcessHandle,
+ IN PVOID Address,
+ IN IN CINT VirtualMemoryInformationClass,
+ OUT PVOID VirtualMemoryInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength
+ );
+
+/*
+ * FUNCTION: Queries the volume information
+ * ARGUMENTS:
+ * FileHandle = Handle to a file object on the target volume
+ * IoStatusBlock = Caller should supply storage for additional status information
+ * ReturnLength = DataWritten
+ * FsInformation = Caller should supply storage for the information structure.
+ * Length = Size of the information structure
+ * FsInformationClass = Index to a information structure
+
+ FileFsVolumeInformation FILE_FS_VOLUME_INFORMATION
+ FileFsLabelInformation FILE_FS_LABEL_INFORMATION
+ FileFsSizeInformation FILE_FS_SIZE_INFORMATION
+ FileFsDeviceInformation FILE_FS_DEVICE_INFORMATION
+ FileFsAttributeInformation FILE_FS_ATTRIBUTE_INFORMATION
+ FileFsControlInformation
+ FileFsQuotaQueryInformation --
+ FileFsQuotaSetInformation --
+ FileFsMaximumInformation
+
+ * RETURNS: Status [ STATUS_SUCCESS | STATUS_INSUFFICIENT_RESOURCES | STATUS_INVALID_PARAMETER |
+ STATUS_INVALID_DEVICE_REQUEST | STATUS_BUFFER_OVERFLOW ]
+ *
+*/
+NTSTATUS
+STDCALL
+NtQueryVolumeInformationFile(
+ IN HANDLE FileHandle,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PVOID FsInformation,
+ IN ULONG Length,
+ IN FS_INFORMATION_CLASS FsInformationClass
+ );
+
+NTSTATUS
+STDCALL
+ZwQueryVolumeInformationFile(
+ IN HANDLE FileHandle,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PVOID FsInformation,
+ IN ULONG Length,
+ IN FS_INFORMATION_CLASS FsInformationClass
+ );
+// draft
+// FIXME: Should I specify if the apc is user or kernel mode somewhere ??
+/*
+ * FUNCTION: Queues a (user) apc to a thread.
+ * ARGUMENTS:
+ ThreadHandle = Thread to which the apc is queued.
+ ApcRoutine = Points to the apc routine
+ NormalContext = Argument to Apc Routine
+ * SystemArgument1 = Argument of the Apc Routine
+ SystemArgument2 = Argument of the Apc Routine
+ * REMARK: If the apc is queued against a thread of a different process than the calling thread
+ the apc routine should be specified in the address space of the queued thread's process.
+ * RETURNS: Status
+*/
+
+NTSTATUS
+STDCALL
+NtQueueApcThread(
+ HANDLE ThreadHandle,
+ PKNORMAL_ROUTINE ApcRoutine,
+ PVOID NormalContext,
+ PVOID SystemArgument1,
+ PVOID SystemArgument2);
+
+NTSTATUS
+STDCALL
+ZwQueueApcThread(
+ HANDLE ThreadHandle,
+ PKNORMAL_ROUTINE ApcRoutine,
+ PVOID NormalContext,
+ PVOID SystemArgument1,
+ PVOID SystemArgument2);
+
+
+/*
+ * FUNCTION: Raises an exception
+ * ARGUMENTS:
+ * ExceptionRecord = Structure specifying the exception
+ * Context = Context in which the excpetion is raised
+ * IsDebugger =
+ * RETURNS: Status
+ *
+*/
+
+NTSTATUS
+STDCALL
+NtRaiseException(
+ IN PEXCEPTION_RECORD ExceptionRecord,
+ IN PCONTEXT Context,
+ IN BOOLEAN SearchFrames
+ );
+
+NTSTATUS
+STDCALL
+ZwRaiseException(
+ IN PEXCEPTION_RECORD ExceptionRecord,
+ IN PCONTEXT Context,
+ IN BOOLEAN SearchFrames
+ );
+
+/*
+ * FUNCTION: Raises a hard error (stops the system)
+ * ARGUMENTS:
+ * Status = Status code of the hard error
+ * Unknown2 = ??
+ * Unknown3 = ??
+ * Unknown4 = ??
+ * Unknown5 = ??
+ * Unknown6 = ??
+ * RETURNS: Status
+ *
+ */
+
+NTSTATUS
+STDCALL
+NtRaiseHardError(
+ IN NTSTATUS Status,
+ ULONG Unknown2,
+ ULONG Unknown3,
+ ULONG Unknown4,
+ ULONG Unknown5,
+ ULONG Unknown6
+ );
+
+NTSTATUS
+STDCALL
+ZwRaiseHardError(
+ IN NTSTATUS Status,
+ ULONG Unknown2,
+ ULONG Unknown3,
+ ULONG Unknown4,
+ ULONG Unknown5,
+ ULONG Unknown6
+ );
+
+/*
+ * FUNCTION: Read a file
+ * ARGUMENTS:
+ * FileHandle = Handle of a file to read
+ * Event = This event is signalled when the read operation completes
+ * UserApcRoutine = Call back , if supplied Event should be NULL
+ * UserApcContext = Argument to the callback
+ * IoStatusBlock = Caller should supply storage for additional status information
+ * Buffer = Caller should supply storage to receive the information
+ * BufferLength = Size of the buffer
+ * ByteOffset = Offset to start reading the file
+ * Key = If a range is lock a matching key will allow the read to continue.
+ * RETURNS: Status
+ *
+ */
+
+NTSTATUS
+STDCALL
+NtReadFile(
+ IN HANDLE FileHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL,
+ IN PVOID UserApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PVOID Buffer,
+ IN ULONG BufferLength,
+ IN PLARGE_INTEGER ByteOffset OPTIONAL,
+ IN PULONG Key OPTIONAL
+ );
+
+NTSTATUS
+STDCALL
+ZwReadFile(
+ IN HANDLE FileHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL,
+ IN PVOID UserApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PVOID Buffer,
+ IN ULONG BufferLength,
+ IN PLARGE_INTEGER ByteOffset OPTIONAL,
+ IN PULONG Key OPTIONAL
+ );
+/*
+ * FUNCTION: Read a file using scattered io
+ * ARGUMENTS:
+ FileHandle = Handle of a file to read
+ Event = This event is signalled when the read operation completes
+ * UserApcRoutine = Call back , if supplied Event should be NULL
+ UserApcContext = Argument to the callback
+ IoStatusBlock = Caller should supply storage for additional status information
+ BufferDescription = Caller should supply storage to receive the information
+ BufferLength = Size of the buffer
+ ByteOffset = Offset to start reading the file
+ Key = Key = If a range is lock a matching key will allow the read to continue.
+ * RETURNS: Status
+ *
+*/
+NTSTATUS
+STDCALL
+NtReadFileScatter(
+ IN HANDLE FileHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL,
+ IN PVOID UserApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK UserIoStatusBlock,
+ IN FILE_SEGMENT_ELEMENT BufferDescription[],
+ IN ULONG BufferLength,
+ IN PLARGE_INTEGER ByteOffset,
+ IN PULONG Key OPTIONAL
+ );
+
+NTSTATUS
+STDCALL
+ZwReadFileScatter(
+ IN HANDLE FileHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL,
+ IN PVOID UserApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK UserIoStatusBlock,
+ IN FILE_SEGMENT_ELEMENT BufferDescription[],
+ IN ULONG BufferLength,
+ IN PLARGE_INTEGER ByteOffset,
+ IN PULONG Key OPTIONAL
+ );
+/*
+ * FUNCTION: Copies a range of virtual memory to a buffer
+ * ARGUMENTS:
+ * ProcessHandle = Specifies the process owning the virtual address space
+ * BaseAddress = Points to the address of virtual memory to start the read
+ * Buffer = Caller supplies storage to copy the virtual memory to.
+ * NumberOfBytesToRead = Limits the range to read
+ * NumberOfBytesRead = The actual number of bytes read.
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtReadVirtualMemory(
+ IN HANDLE ProcessHandle,
+ IN PVOID BaseAddress,
+ OUT PVOID Buffer,
+ IN ULONG NumberOfBytesToRead,
+ OUT PULONG NumberOfBytesRead
+ );
+NTSTATUS
+STDCALL
+ZwReadVirtualMemory(
+ IN HANDLE ProcessHandle,
+ IN PVOID BaseAddress,
+ OUT PVOID Buffer,
+ IN ULONG NumberOfBytesToRead,
+ OUT PULONG NumberOfBytesRead
+ );
+
+
+/*
+ * FUNCTION: Debugger can register for thread termination
+ * ARGUMENTS:
+ * TerminationPort = Port on which the debugger likes to be notified.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtRegisterThreadTerminatePort(
+ HANDLE TerminationPort
+ );
+NTSTATUS
+STDCALL
+ZwRegisterThreadTerminatePort(
+ HANDLE TerminationPort
+ );
+
+/*
+ * FUNCTION: Releases a mutant
+ * ARGUMENTS:
+ * MutantHandle = Handle to the mutant
+ * ReleaseCount =
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtReleaseMutant(
+ IN HANDLE MutantHandle,
+ IN PULONG ReleaseCount OPTIONAL
+ );
+
+NTSTATUS
+STDCALL
+ZwReleaseMutant(
+ IN HANDLE MutantHandle,
+ IN PULONG ReleaseCount OPTIONAL
+ );
+
+/*
+ * FUNCTION: Releases a semaphore
+ * ARGUMENTS:
+ * SemaphoreHandle = Handle to the semaphore object
+ * ReleaseCount = Number to decrease the semaphore count
+ * PreviousCount = Previous semaphore count
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtReleaseSemaphore(
+ IN HANDLE SemaphoreHandle,
+ IN LONG ReleaseCount,
+ OUT PLONG PreviousCount
+ );
+
+NTSTATUS
+STDCALL
+ZwReleaseSemaphore(
+ IN HANDLE SemaphoreHandle,
+ IN LONG ReleaseCount,
+ OUT PLONG PreviousCount
+ );
+
+/*
+ * FUNCTION: Removes an io completion
+ * ARGUMENTS:
+ * CompletionPort (OUT) = Caller supplied storage for the resulting handle
+ * CompletionKey = Requested access to the key
+ * IoStatusBlock = Caller provides storage for extended status information
+ * CompletionStatus = Current status of the io operation.
+ * WaitTime = Time to wait if ..
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtRemoveIoCompletion(
+ IN HANDLE CompletionPort,
+ OUT PULONG CompletionKey,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PULONG CompletionStatus,
+ IN PLARGE_INTEGER WaitTime
+ );
+
+NTSTATUS
+STDCALL
+ZwRemoveIoCompletion(
+ IN HANDLE CompletionPort,
+ OUT PULONG CompletionKey,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PULONG CompletionStatus,
+ IN PLARGE_INTEGER WaitTime
+ );
+/*
+ * FUNCTION: Replaces one registry key with another
+ * ARGUMENTS:
+ * ObjectAttributes = Specifies the attributes of the key
+ * Key = Handle to the key
+ * ReplacedObjectAttributes = The function returns the old object attributes
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtReplaceKey(
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN HANDLE Key,
+ IN POBJECT_ATTRIBUTES ReplacedObjectAttributes
+ );
+NTSTATUS
+STDCALL
+ZwReplaceKey(
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN HANDLE Key,
+ IN POBJECT_ATTRIBUTES ReplacedObjectAttributes
+ );
+
+/*
+ * FUNCTION: Resets a event to a non signaled state
+ * ARGUMENTS:
+ * EventHandle = Handle to the event that should be reset
+ * NumberOfWaitingThreads = The number of threads released.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtResetEvent(
+ HANDLE EventHandle,
+ PULONG NumberOfWaitingThreads OPTIONAL
+ );
+NTSTATUS
+STDCALL
+ZwResetEvent(
+ HANDLE EventHandle,
+ PULONG NumberOfWaitingThreads OPTIONAL
+ );
+//draft
+NTSTATUS
+STDCALL
+NtRestoreKey(
+ HANDLE KeyHandle,
+ HANDLE FileHandle,
+ ULONG RestoreFlags
+ );
+
+NTSTATUS
+STDCALL
+ZwRestoreKey(
+ HANDLE KeyHandle,
+ HANDLE FileHandle,
+ ULONG RestoreFlags
+ );
+/*
+ * FUNCTION: Decrements a thread's resume count
+ * ARGUMENTS:
+ * ThreadHandle = Handle to the thread that should be resumed
+ * ResumeCount = The resulting resume count.
+ * REMARK:
+ * A thread is resumed if its suspend count is 0. This procedure maps to
+ * the win32 ResumeThread function. ( documentation about the the suspend count can be found here aswell )
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtResumeThread(
+ IN HANDLE ThreadHandle,
+ OUT PULONG SuspendCount
+ );
+NTSTATUS
+STDCALL
+ZwResumeThread(
+ IN HANDLE ThreadHandle,
+ OUT PULONG SuspendCount
+ );
+/*
+ * FUNCTION: Writes the content of a registry key to ascii file
+ * ARGUMENTS:
+ * KeyHandle = Handle to the key
+ * FileHandle = Handle of the file
+ * REMARKS:
+ This function maps to the Win32 RegSaveKey.
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtSaveKey(
+ IN HANDLE KeyHandle,
+ IN HANDLE FileHandle
+ );
+NTSTATUS
+STDCALL
+ZwSaveKey(
+ IN HANDLE KeyHandle,
+ IN HANDLE FileHandle
+ );
+
+/*
+ * FUNCTION: Sets the context of a specified thread.
+ * ARGUMENTS:
+ * ThreadHandle = Handle to the thread
+ * Context = The processor context.
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtSetContextThread(
+ IN HANDLE ThreadHandle,
+ IN PCONTEXT Context
+ );
+NTSTATUS
+STDCALL
+ZwSetContextThread(
+ IN HANDLE ThreadHandle,
+ IN PCONTEXT Context
+ );
+
+/*
+ * FUNCTION: Sets the default locale id
+ * ARGUMENTS:
+ * UserProfile = Type of locale id
+ * TRUE: thread locale id
+ * FALSE: system locale id
+ * DefaultLocaleId = Locale id
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtSetDefaultLocale(
+ IN BOOLEAN UserProfile,
+ IN LCID DefaultLocaleId
+ );
+
+NTSTATUS
+STDCALL
+ZwSetDefaultLocale(
+ IN BOOLEAN UserProfile,
+ IN LCID DefaultLocaleId
+ );
+
+/*
+ * FUNCTION: Sets the default hard error port
+ * ARGUMENTS:
+ * PortHandle = Handle to the port
+ * NOTE: The hard error port is used for first change exception handling
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtSetDefaultHardErrorPort(
+ IN HANDLE PortHandle
+ );
+NTSTATUS
+STDCALL
+ZwSetDefaultHardErrorPort(
+ IN HANDLE PortHandle
+ );
+
+/*
+ * FUNCTION: Sets the extended attributes of a file.
+ * ARGUMENTS:
+ * FileHandle = Handle to the file
+ * IoStatusBlock = Storage for a resulting status and information
+ * on the current operation.
+ * EaBuffer = Extended Attributes buffer.
+ * EaBufferSize = Size of the extended attributes buffer
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtSetEaFile(
+ IN HANDLE FileHandle,
+ IN PIO_STATUS_BLOCK IoStatusBlock,
+ PVOID EaBuffer,
+ ULONG EaBufferSize
+ );
+NTSTATUS
+STDCALL
+ZwSetEaFile(
+ IN HANDLE FileHandle,
+ IN PIO_STATUS_BLOCK IoStatusBlock,
+ PVOID EaBuffer,
+ ULONG EaBufferSize
+ );
+
+//FIXME: should I return the event state ?
+
+/*
+ * FUNCTION: Sets the event to a signalled state.
+ * ARGUMENTS:
+ * EventHandle = Handle to the event
+ * NumberOfThreadsReleased = The number of threads released
+ * REMARK:
+ * This procedure maps to the win32 SetEvent function.
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtSetEvent(
+ IN HANDLE EventHandle,
+ PULONG NumberOfThreadsReleased
+ );
+
+NTSTATUS
+STDCALL
+ZwSetEvent(
+ IN HANDLE EventHandle,
+ PULONG NumberOfThreadsReleased
+ );
+
+/*
+ * FUNCTION: Sets the high part of an event pair
+ * ARGUMENTS:
+ EventPair = Handle to the event pair
+ * RETURNS: Status
+*/
+
+NTSTATUS
+STDCALL
+NtSetHighEventPair(
+ IN HANDLE EventPairHandle
+ );
+
+NTSTATUS
+STDCALL
+ZwSetHighEventPair(
+ IN HANDLE EventPairHandle
+ );
+/*
+ * FUNCTION: Sets the high part of an event pair and wait for the low part
+ * ARGUMENTS:
+ EventPair = Handle to the event pair
+ * RETURNS: Status
+*/
+NTSTATUS
+STDCALL
+NtSetHighWaitLowEventPair(
+ IN HANDLE EventPairHandle
+ );
+NTSTATUS
+STDCALL
+ZwSetHighWaitLowEventPair(
+ IN HANDLE EventPairHandle
+ );
+
+/*
+ * FUNCTION: Sets the information of a file object.
+ * ARGUMENTS:
+ * FileHandle = Handle to the file object
+ * IoStatusBlock = Caller supplies storage for extended information
+ * on the current operation.
+ * FileInformation = Storage for the new file information
+ * Lenght = Size of the new file information.
+ * FileInformationClass = Indicates to a certain information structure
+
+ FileNameInformation FILE_NAME_INFORMATION
+ FileRenameInformation FILE_RENAME_INFORMATION
+ FileStreamInformation FILE_STREAM_INFORMATION
+ * FileCompletionInformation IO_COMPLETION_CONTEXT
+
+ * REMARK:
+ * This procedure maps to the win32 SetEndOfFile, SetFileAttributes,
+ * SetNamedPipeHandleState, SetMailslotInfo functions.
+ * RETURNS: Status
+ */
+
+
+NTSTATUS
+STDCALL
+NtSetInformationFile(
+ IN HANDLE FileHandle,
+ IN PIO_STATUS_BLOCK IoStatusBlock,
+ IN PVOID FileInformation,
+ IN ULONG Length,
+ IN FILE_INFORMATION_CLASS FileInformationClass
+ );
+NTSTATUS
+STDCALL
+ZwSetInformationFile(
+ IN HANDLE FileHandle,
+ IN PIO_STATUS_BLOCK IoStatusBlock,
+ IN PVOID FileInformation,
+ IN ULONG Length,
+ IN FILE_INFORMATION_CLASS FileInformationClass
+ );
+
+
+
+/*
+ * FUNCTION: Sets the information of a registry key.
+ * ARGUMENTS:
+ * KeyHandle = Handle to the registry key
+ * KeyInformationClass = Index to the a certain information structure.
+ Can be one of the following values:
+
+ * KeyWriteTimeInformation KEY_WRITE_TIME_INFORMATION
+
+ KeyInformation = Storage for the new information
+ * KeyInformationLength = Size of the information strucure
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtSetInformationKey(
+ IN HANDLE KeyHandle,
+ IN CINT KeyInformationClass,
+ IN PVOID KeyInformation,
+ IN ULONG KeyInformationLength
+ );
+
+NTSTATUS
+STDCALL
+ZwSetInformationKey(
+ IN HANDLE KeyHandle,
+ IN CINT KeyInformationClass,
+ IN PVOID KeyInformation,
+ IN ULONG KeyInformationLength
+ );
+/*
+ * FUNCTION: Changes a set of object specific parameters
+ * ARGUMENTS:
+ * ObjectHandle =
+ * ObjectInformationClass = Index to the set of parameters to change.
+
+
+ ObjectBasicInformation
+ ObjectTypeInformation OBJECT_TYPE_INFORMATION
+ ObjectAllInformation
+ ObjectDataInformation OBJECT_DATA_INFORMATION
+ ObjectNameInformation OBJECT_NAME_INFORMATION
+
+
+ * ObjectInformation = Caller supplies storage for parameters to set.
+ * Length = Size of the storage supplied
+ * RETURNS: Status
+*/
+NTSTATUS
+STDCALL
+NtSetInformationObject(
+ IN HANDLE ObjectHandle,
+ IN CINT ObjectInformationClass,
+ IN PVOID ObjectInformation,
+ IN ULONG Length
+ );
+
+NTSTATUS
+STDCALL
+ZwSetInformationObject(
+ IN HANDLE ObjectHandle,
+ IN CINT ObjectInformationClass,
+ IN PVOID ObjectInformation,
+ IN ULONG Length
+ );
+
+/*
+ * FUNCTION: Changes a set of process specific parameters
+ * ARGUMENTS:
+ * ProcessHandle = Handle to the process
+ * ProcessInformationClass = Index to a information structure.
+ *
+ * ProcessBasicInformation PROCESS_BASIC_INFORMATION
+ * ProcessQuotaLimits QUOTA_LIMITS
+ * ProcessBasePriority KPRIORITY
+ * ProcessRaisePriority KPRIORITY
+ * ProcessDebugPort HANDLE
+ * ProcessExceptionPort HANDLE
+ * ProcessAccessToken PROCESS_ACCESS_TOKEN
+ * ProcessDefaultHardErrorMode ULONG
+ * ProcessPriorityClass ULONG
+ * ProcessAffinityMask KAFFINITY //??
+ *
+ * ProcessInformation = Caller supplies storage for information to set.
+ * ProcessInformationLength = Size of the information structure
+ * RETURNS: Status
+*/
+NTSTATUS
+STDCALL
+NtSetInformationProcess(
+ IN HANDLE ProcessHandle,
+ IN CINT ProcessInformationClass,
+ IN PVOID ProcessInformation,
+ IN ULONG ProcessInformationLength
+ );
+NTSTATUS
+STDCALL
+ZwSetInformationProcess(
+ IN HANDLE ProcessHandle,
+ IN CINT ProcessInformationClass,
+ IN PVOID ProcessInformation,
+ IN ULONG ProcessInformationLength
+ );
+/*
+ * FUNCTION: Changes a set of thread specific parameters
+ * ARGUMENTS:
+ * ThreadHandle = Handle to the thread
+ * ThreadInformationClass = Index to the set of parameters to change.
+ * Can be one of the following values:
+ *
+ * ThreadBasicInformation THREAD_BASIC_INFORMATION
+ * ThreadPriority KPRIORITY //???
+ * ThreadBasePriority KPRIORITY
+ * ThreadAffinityMask KAFFINITY //??
+ * ThreadImpersonationToken ACCESS_TOKEN
+ * ThreadIdealProcessor ULONG
+ * ThreadPriorityBoost ULONG
+ *
+ * ThreadInformation = Caller supplies storage for parameters to set.
+ * ThreadInformationLength = Size of the storage supplied
+ * RETURNS: Status
+*/
+NTSTATUS
+STDCALL
+NtSetInformationThread(
+ IN HANDLE ThreadHandle,
+ IN THREADINFOCLASS ThreadInformationClass,
+ IN PVOID ThreadInformation,
+ IN ULONG ThreadInformationLength
+ );
+NTSTATUS
+STDCALL
+ZwSetInformationThread(
+ IN HANDLE ThreadHandle,
+ IN THREADINFOCLASS ThreadInformationClass,
+ IN PVOID ThreadInformation,
+ IN ULONG ThreadInformationLength
+ );
+
+/*
+ * FUNCTION: Changes a set of token specific parameters
+ * ARGUMENTS:
+ * TokenHandle = Handle to the token
+ * TokenInformationClass = Index to a certain information structure.
+ * Can be one of the following values:
+ *
+ TokenUser TOKEN_USER
+ TokenGroups TOKEN_GROUPS
+ TokenPrivileges TOKEN_PRIVILEGES
+ TokenOwner TOKEN_OWNER
+ TokenPrimaryGroup TOKEN_PRIMARY_GROUP
+ TokenDefaultDacl TOKEN_DEFAULT_DACL
+ TokenSource TOKEN_SOURCE
+ TokenType TOKEN_TYPE
+ TokenImpersonationLevel TOKEN_IMPERSONATION_LEVEL
+ TokenStatistics TOKEN_STATISTICS
+ *
+ * TokenInformation = Caller supplies storage for information structure.
+ * TokenInformationLength = Size of the information structure
+ * RETURNS: Status
+*/
+
+NTSTATUS
+STDCALL
+NtSetInformationToken(
+ IN HANDLE TokenHandle,
+ IN TOKEN_INFORMATION_CLASS TokenInformationClass,
+ OUT PVOID TokenInformation,
+ IN ULONG TokenInformationLength
+ );
+
+NTSTATUS
+STDCALL
+ZwSetInformationToken(
+ IN HANDLE TokenHandle,
+ IN TOKEN_INFORMATION_CLASS TokenInformationClass,
+ OUT PVOID TokenInformation,
+ IN ULONG TokenInformationLength
+ );
+
+
+/*
+ * FUNCTION: Sets an io completion
+ * ARGUMENTS:
+ * CompletionPort =
+ * CompletionKey =
+ * IoStatusBlock =
+ * NumberOfBytesToTransfer =
+ * NumberOfBytesTransferred =
+ * RETURNS: Status
+*/
+NTSTATUS
+STDCALL
+NtSetIoCompletion(
+ IN HANDLE CompletionPort,
+ IN ULONG CompletionKey,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG NumberOfBytesToTransfer,
+ OUT PULONG NumberOfBytesTransferred
+ );
+NTSTATUS
+STDCALL
+ZwSetIoCompletion(
+ IN HANDLE CompletionPort,
+ IN ULONG CompletionKey,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG NumberOfBytesToTransfer,
+ OUT PULONG NumberOfBytesTransferred
+ );
+
+/*
+ * FUNCTION: Set properties for profiling
+ * ARGUMENTS:
+ * Interval =
+ * ClockSource =
+ * RETURNS: Status
+ *
+ */
+
+NTSTATUS
+STDCALL
+NtSetIntervalProfile(
+ ULONG Interval,
+ KPROFILE_SOURCE ClockSource
+ );
+
+NTSTATUS
+STDCALL
+ZwSetIntervalProfile(
+ ULONG Interval,
+ KPROFILE_SOURCE ClockSource
+ );
+
+
+/*
+ * FUNCTION: Sets the low part of an event pair
+ * ARGUMENTS:
+ EventPair = Handle to the event pair
+ * RETURNS: Status
+*/
+
+NTSTATUS
+STDCALL
+NtSetLowEventPair(
+ HANDLE EventPair
+ );
+NTSTATUS
+STDCALL
+ZwSetLowEventPair(
+ HANDLE EventPair
+ );
+/*
+ * FUNCTION: Sets the low part of an event pair and wait for the high part
+ * ARGUMENTS:
+ EventPair = Handle to the event pair
+ * RETURNS: Status
+*/
+NTSTATUS
+STDCALL
+NtSetLowWaitHighEventPair(
+ HANDLE EventPair
+ );
+NTSTATUS
+STDCALL
+ZwSetLowWaitHighEventPair(
+ HANDLE EventPair
+ );
+
+NTSTATUS
+STDCALL
+NtSetSecurityObject(
+ IN HANDLE Handle,
+ IN SECURITY_INFORMATION SecurityInformation,
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor
+ );
+
+NTSTATUS
+STDCALL
+ZwSetSecurityObject(
+ IN HANDLE Handle,
+ IN SECURITY_INFORMATION SecurityInformation,
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor
+ );
+
+
+/*
+ * FUNCTION: Sets a system environment variable
+ * ARGUMENTS:
+ * ValueName = Name of the environment variable
+ * Value = Value of the environment variable
+ * RETURNS: Status
+*/
+NTSTATUS
+STDCALL
+NtSetSystemEnvironmentValue(
+ IN PUNICODE_STRING VariableName,
+ IN PUNICODE_STRING Value
+ );
+NTSTATUS
+STDCALL
+ZwSetSystemEnvironmentValue(
+ IN PUNICODE_STRING VariableName,
+ IN PUNICODE_STRING Value
+ );
+/*
+ * FUNCTION: Sets system parameters
+ * ARGUMENTS:
+ * SystemInformationClass = Index to a particular set of system parameters
+ * Can be one of the following values:
+ *
+ * SystemTimeAdjustmentInformation SYSTEM_TIME_ADJUSTMENT
+ *
+ * SystemInformation = Structure containing the parameters.
+ * SystemInformationLength = Size of the structure.
+ * RETURNS: Status
+*/
+NTSTATUS
+STDCALL
+NtSetSystemInformation(
+ IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
+ IN PVOID SystemInformation,
+ IN ULONG SystemInformationLength
+ );
+
+NTSTATUS
+STDCALL
+ZwSetSystemInformation(
+ IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
+ IN PVOID SystemInformation,
+ IN ULONG SystemInformationLength
+ );
+
+/*
+ * FUNCTION: Sets the system time
+ * ARGUMENTS:
+ * SystemTime = Old System time
+ * NewSystemTime = New System time
+ * RETURNS: Status
+*/
+NTSTATUS
+STDCALL
+NtSetSystemTime(
+ IN PLARGE_INTEGER SystemTime,
+ IN PLARGE_INTEGER NewSystemTime OPTIONAL
+ );
+NTSTATUS
+STDCALL
+ZwSetSystemTime(
+ IN PLARGE_INTEGER SystemTime,
+ IN PLARGE_INTEGER NewSystemTime OPTIONAL
+ );
+/*
+ * FUNCTION: Sets the characteristics of a timer
+ * ARGUMENTS:
+ * TimerHandle = Handle to the timer
+ * DueTime = Time before the timer becomes signalled for the first time.
+ * TimerApcRoutine = Completion routine can be called on time completion
+ * TimerContext = Argument to the completion routine
+ * Resume = Specifies if the timer should repeated after completing one cycle
+ * Period = Cycle of the timer
+ * REMARKS: This routine maps to the win32 SetWaitableTimer.
+ * RETURNS: Status
+*/
+NTSTATUS
+STDCALL
+NtSetTimer(
+ IN HANDLE TimerHandle,
+ IN PLARGE_INTEGER DueTime,
+ IN PTIMERAPCROUTINE TimerApcRoutine,
+ IN PVOID TimerContext,
+ IN BOOL WakeTimer,
+ IN ULONG Period OPTIONAL,
+ OUT PBOOLEAN PreviousState OPTIONAL
+ );
+NTSTATUS
+STDCALL
+ZwSetTimer(
+ IN HANDLE TimerHandle,
+ IN PLARGE_INTEGER DueTime,
+ IN PTIMERAPCROUTINE TimerApcRoutine,
+ IN PVOID TimerContext,
+ IN BOOL WakeTimer,
+ IN ULONG Period OPTIONAL,
+ OUT PBOOLEAN PreviousState OPTIONAL
+ );
+
+/*
+ * FUNCTION: Sets the frequency of the system timer
+ * ARGUMENTS:
+ * RequestedResolution =
+ * SetOrUnset =
+ * ActualResolution =
+ * RETURNS: Status
+*/
+NTSTATUS
+STDCALL
+NtSetTimerResolution(
+ IN ULONG RequestedResolution,
+ IN BOOL SetOrUnset,
+ OUT PULONG ActualResolution
+ );
+NTSTATUS
+STDCALL
+ZwSetTimerResolution(
+ IN ULONG RequestedResolution,
+ IN BOOL SetOrUnset,
+ OUT PULONG ActualResolution
+ );
+
+/*
+ * FUNCTION: Sets the value of a registry key
+ * ARGUMENTS:
+ * KeyHandle = Handle to a registry key
+ * ValueName = Name of the value entry to change
+ * TitleIndex = pointer to a structure containing the new volume information
+ * Type = Type of the registry key. Can be one of the values:
+ * REG_BINARY Unspecified binary data
+ * REG_DWORD A 32 bit value
+ * REG_DWORD_LITTLE_ENDIAN Same as REG_DWORD
+ * REG_DWORD_BIG_ENDIAN A 32 bit value whose least significant byte is at the highest address
+ * REG_EXPAND_SZ A zero terminated wide character string with unexpanded environment variables ( "%PATH%" )
+ * REG_LINK A zero terminated wide character string referring to a symbolic link.
+ * REG_MULTI_SZ A series of zero-terminated strings including a additional trailing zero
+ * REG_NONE Unspecified type
+ * REG_SZ A wide character string ( zero terminated )
+ * REG_RESOURCE_LIST ??
+ * REG_RESOURCE_REQUIREMENTS_LIST ??
+ * REG_FULL_RESOURCE_DESCRIPTOR ??
+ * Data = Contains the data for the registry key.
+ * DataSize = size of the data.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtSetValueKey(
+ IN HANDLE KeyHandle,
+ IN PUNICODE_STRING ValueName,
+ IN ULONG TitleIndex OPTIONAL,
+ IN ULONG Type,
+ IN PVOID Data,
+ IN ULONG DataSize
+ );
+NTSTATUS
+STDCALL
+ZwSetValueKey(
+ IN HANDLE KeyHandle,
+ IN PUNICODE_STRING ValueName,
+ IN ULONG TitleIndex OPTIONAL,
+ IN ULONG Type,
+ IN PVOID Data,
+ IN ULONG DataSize
+ );
+
+/*
+ * FUNCTION: Sets the volume information.
+ * ARGUMENTS:
+ * FileHandle = Handle to the file
+ * IoStatusBlock = Caller should supply storage for additional status information
+ * VolumeInformation = pointer to a structure containing the new volume information
+ * Length = size of the structure.
+ * VolumeInformationClass = specifies the particular volume information to set
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtSetVolumeInformationFile(
+ IN HANDLE FileHandle,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN PVOID FsInformation,
+ IN ULONG Length,
+ IN FS_INFORMATION_CLASS FsInformationClass
+ );
+
+NTSTATUS
+STDCALL
+ZwSetVolumeInformationFile(
+ IN HANDLE FileHandle,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN PVOID FsInformation,
+ IN ULONG Length,
+ IN FS_INFORMATION_CLASS FsInformationClass
+ );
+
+/*
+ * FUNCTION: Shuts the system down
+ * ARGUMENTS:
+ * Action = Specifies the type of shutdown, it can be one of the following values:
+ * ShutdownNoReboot, ShutdownReboot, ShutdownPowerOff
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtShutdownSystem(
+ IN SHUTDOWN_ACTION Action
+ );
+
+NTSTATUS
+STDCALL
+ZwShutdownSystem(
+ IN SHUTDOWN_ACTION Action
+ );
+
+
+/* --- PROFILING --- */
+
+/*
+ * FUNCTION: Starts profiling
+ * ARGUMENTS:
+ * ProfileHandle = Handle to the profile
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtStartProfile(
+ HANDLE ProfileHandle
+ );
+
+NTSTATUS
+STDCALL
+ZwStartProfile(
+ HANDLE ProfileHandle
+ );
+
+/*
+ * FUNCTION: Stops profiling
+ * ARGUMENTS:
+ * ProfileHandle = Handle to the profile
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtStopProfile(
+ HANDLE ProfileHandle
+ );
+
+NTSTATUS
+STDCALL
+ZwStopProfile(
+ HANDLE ProfileHandle
+ );
+
+/* --- PROCESS MANAGEMENT --- */
+
+//--NtSystemDebugControl
+/*
+ * FUNCTION: Terminates the execution of a process.
+ * ARGUMENTS:
+ * ThreadHandle = Handle to the process
+ * ExitStatus = The exit status of the process to terminate with.
+ * REMARKS
+ Native applications should kill themselves using this function.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtTerminateProcess(
+ IN HANDLE ProcessHandle ,
+ IN NTSTATUS ExitStatus
+ );
+NTSTATUS
+STDCALL
+ZwTerminateProcess(
+ IN HANDLE ProcessHandle ,
+ IN NTSTATUS ExitStatus
+ );
+
+/* --- DEVICE DRIVER CONTROL --- */
+
+/*
+ * FUNCTION: Unloads a driver.
+ * ARGUMENTS:
+ * DriverServiceName = Name of the driver to unload
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtUnloadDriver(
+ IN PUNICODE_STRING DriverServiceName
+ );
+NTSTATUS
+STDCALL
+ZwUnloadDriver(
+ IN PUNICODE_STRING DriverServiceName
+ );
+
+/* --- VIRTUAL MEMORY MANAGEMENT --- */
+
+/*
+ * FUNCTION: Writes a range of virtual memory
+ * ARGUMENTS:
+ * ProcessHandle = The handle to the process owning the address space.
+ * BaseAddress = The points to the address to write to
+ * Buffer = Pointer to the buffer to write
+ * NumberOfBytesToWrite = Offset to the upper boundary to write
+ * NumberOfBytesWritten = Total bytes written
+ * REMARKS:
+ * This function maps to the win32 WriteProcessMemory
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtWriteVirtualMemory(
+ IN HANDLE ProcessHandle,
+ IN PVOID BaseAddress,
+ IN PVOID Buffer,
+ IN ULONG NumberOfBytesToWrite,
+ OUT PULONG NumberOfBytesWritten
+ );
+
+NTSTATUS
+STDCALL
+ZwWriteVirtualMemory(
+ IN HANDLE ProcessHandle,
+ IN PVOID BaseAddress,
+ IN PVOID Buffer,
+ IN ULONG NumberOfBytesToWrite,
+ OUT PULONG NumberOfBytesWritten
+ );
+
+/*
+ * FUNCTION: Unlocks a range of virtual memory.
+ * ARGUMENTS:
+ * ProcessHandle = Handle to the process
+ * BaseAddress = Lower boundary of the range of bytes to unlock.
+ * NumberOfBytesToUnlock = Offset to the upper boundary to unlock.
+ * NumberOfBytesUnlocked (OUT) = Number of bytes actually unlocked.
+ * REMARK:
+ This procedure maps to the win32 procedure VirtualUnlock
+ * RETURNS: Status [ STATUS_SUCCESS | STATUS_PAGE_WAS_ULOCKED ]
+ */
+NTSTATUS
+STDCALL
+NtUnlockVirtualMemory(
+ IN HANDLE ProcessHandle,
+ IN PVOID BaseAddress,
+ IN ULONG NumberOfBytesToUnlock,
+ OUT PULONG NumberOfBytesUnlocked OPTIONAL
+ );
+
+NTSTATUS
+STDCALL
+ZwUnlockVirtualMemory(
+ IN HANDLE ProcessHandle,
+ IN PVOID BaseAddress,
+ IN ULONG NumberOfBytesToUnlock,
+ OUT PULONG NumberOfBytesUnlocked OPTIONAL
+ );
+/*
+ * FUNCTION: Unmaps a piece of virtual memory backed by a file.
+ * ARGUMENTS:
+ * ProcessHandle = Handle to the process
+ * BaseAddress = The address where the mapping begins
+ * REMARK:
+ This procedure maps to the win32 UnMapViewOfFile
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtUnmapViewOfSection(
+ IN HANDLE ProcessHandle,
+ IN PVOID BaseAddress
+ );
+NTSTATUS
+STDCALL
+ZwUnmapViewOfSection(
+ IN HANDLE ProcessHandle,
+ IN PVOID BaseAddress
+ );
+
+/* --- OBJECT SYNCHRONIZATION --- */
+
+/*
+ * FUNCTION: Signals an object and wait for an other one.
+ * ARGUMENTS:
+ * SignalObject = Handle to the object that should be signaled
+ * WaitObject = Handle to the object that should be waited for
+ * Alertable = True if the wait is alertable
+ * Time = The time to wait
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtSignalAndWaitForSingleObject(
+ IN HANDLE SignalObject,
+ IN HANDLE WaitObject,
+ IN BOOLEAN Alertable,
+ IN PLARGE_INTEGER Time
+ );
+
+NTSTATUS
+STDCALL
+NtSignalAndWaitForSingleObject(
+ IN HANDLE SignalObject,
+ IN HANDLE WaitObject,
+ IN BOOLEAN Alertable,
+ IN PLARGE_INTEGER Time
+ );
+
+/*
+ * FUNCTION: Waits for multiple objects to become signalled.
+ * ARGUMENTS:
+ * Count = The number of objects
+ * Object = The array of object handles
+ * WaitType = Can be one of the values UserMode or KernelMode
+ * Alertable = If true the wait is alertable.
+ * Time = The maximum wait time.
+ * REMARKS:
+ * This function maps to the win32 WaitForMultipleObjectEx.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtWaitForMultipleObjects (
+ IN ULONG Count,
+ IN HANDLE Object[],
+ IN CINT WaitType,
+ IN BOOLEAN Alertable,
+ IN PLARGE_INTEGER Time
+ );
+
+NTSTATUS
+STDCALL
+ZwWaitForMultipleObjects (
+ IN ULONG Count,
+ IN HANDLE Object[],
+ IN CINT WaitType,
+ IN BOOLEAN Alertable,
+ IN PLARGE_INTEGER Time
+ );
+
+/*
+ * FUNCTION: Waits for an object to become signalled.
+ * ARGUMENTS:
+ * Object = The object handle
+ * Alertable = If true the wait is alertable.
+ * Time = The maximum wait time.
+ * REMARKS:
+ * This function maps to the win32 WaitForSingleObjectEx.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtWaitForSingleObject (
+ IN HANDLE Object,
+ IN BOOLEAN Alertable,
+ IN PLARGE_INTEGER Time
+ );
+
+NTSTATUS
+STDCALL
+ZwWaitForSingleObject (
+ IN HANDLE Object,
+ IN BOOLEAN Alertable,
+ IN PLARGE_INTEGER Time
+ );
+
+/* --- EVENT PAIR OBJECT --- */
+
+/*
+ * FUNCTION: Waits for the high part of an eventpair to become signalled
+ * ARGUMENTS:
+ * EventPairHandle = Handle to the event pair.
+ * RETURNS: Status
+ */
+
+NTSTATUS
+STDCALL
+NtWaitHighEventPair(
+ IN HANDLE EventPairHandle
+ );
+
+NTSTATUS
+STDCALL
+ZwWaitHighEventPair(
+ IN HANDLE EventPairHandle
+ );
+
+/*
+ * FUNCTION: Waits for the low part of an eventpair to become signalled
+ * ARGUMENTS:
+ * EventPairHandle = Handle to the event pair.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtWaitLowEventPair(
+ IN HANDLE EventPairHandle
+ );
+
+NTSTATUS
+STDCALL
+ZwWaitLowEventPair(
+ IN HANDLE EventPairHandle
+ );
+
+/* --- FILE MANAGEMENT --- */
+
+/*
+ * FUNCTION: Unlocks a range of bytes in a file.
+ * ARGUMENTS:
+ * FileHandle = Handle to the file
+ * IoStatusBlock = Caller should supply storage for a structure containing
+ * the completion status and information about the requested unlock operation.
+ The information field is set to the number of bytes unlocked.
+ * ByteOffset = Offset to start the range of bytes to unlock
+ * Length = Number of bytes to unlock.
+ * Key = Special value to enable other threads to unlock a file than the
+ thread that locked the file. The key supplied must match with the one obtained
+ in a previous call to NtLockFile.
+ * REMARK:
+ This procedure maps to the win32 procedure UnlockFileEx. STATUS_PENDING is returned if the lock could
+ not be obtained immediately, the device queue is busy and the IRP is queued.
+ * RETURNS: Status [ STATUS_SUCCESS | STATUS_PENDING | STATUS_ACCESS_DENIED | STATUS_INSUFFICIENT_RESOURCES |
+ STATUS_INVALID_PARAMETER | STATUS_INVALID_DEVICE_REQUEST | STATUS_RANGE_NOT_LOCKED ]
+ */
+NTSTATUS
+STDCALL
+NtUnlockFile(
+ IN HANDLE FileHandle,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN PLARGE_INTEGER ByteOffset,
+ IN PLARGE_INTEGER Lenght,
+ OUT PULONG Key OPTIONAL
+ );
+NTSTATUS
+STDCALL
+ZwUnlockFile(
+ IN HANDLE FileHandle,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN PLARGE_INTEGER ByteOffset,
+ IN PLARGE_INTEGER Lenght,
+ OUT PULONG Key OPTIONAL
+ );
+
+/*
+ * FUNCTION: Writes data to a file
+ * ARGUMENTS:
+ * FileHandle = The handle a file ( from NtCreateFile )
+ * Event = Specifies a event that will become signalled when the write operation completes.
+ * ApcRoutine = Asynchroneous Procedure Callback [ Should not be used by device drivers ]
+ * ApcContext = Argument to the Apc Routine
+ * IoStatusBlock = Caller should supply storage for a structure containing the completion status and information about the requested write operation.
+ * Buffer = Caller should supply storage for a buffer that will contain the information to be written to file.
+ * Length = Size in bytest of the buffer
+ * ByteOffset = Points to a file offset. If a combination of Length and BytesOfSet is past the end-of-file mark the file will be enlarged.
+ * BytesOffset is ignored if the file is created with FILE_APPEND_DATA in the DesiredAccess. BytesOffset is also ignored if
+ * the file is created with CreateOptions flags FILE_SYNCHRONOUS_IO_ALERT or FILE_SYNCHRONOUS_IO_NONALERT set, in that case a offset
+ * should be created by specifying FILE_USE_FILE_POINTER_POSITION.
+ * Key = Unused
+ * REMARKS:
+ * This function maps to the win32 WriteFile.
+ * Callers to NtWriteFile should run at IRQL PASSIVE_LEVEL.
+ * RETURNS: Status [ STATUS_SUCCESS | STATUS_PENDING | STATUS_ACCESS_DENIED | STATUS_INSUFFICIENT_RESOURCES
+ STATUS_INVALID_PARAMETER | STATUS_INVALID_DEVICE_REQUEST | STATUS_FILE_LOCK_CONFLICT ]
+ */
+NTSTATUS
+STDCALL
+NtWriteFile(
+ IN HANDLE FileHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
+ IN PVOID ApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN PVOID Buffer,
+ IN ULONG Length,
+ IN PLARGE_INTEGER ByteOffset,
+ IN PULONG Key OPTIONAL
+ );
+
+NTSTATUS
+STDCALL
+ZwWriteFile(
+ IN HANDLE FileHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
+ IN PVOID ApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN PVOID Buffer,
+ IN ULONG Length,
+ IN PLARGE_INTEGER ByteOffset ,
+ IN PULONG Key OPTIONAL
+ );
+
+/*
+ * FUNCTION: Writes a file
+ * ARGUMENTS:
+ * FileHandle = The handle of the file
+ * Event =
+ * ApcRoutine = Asynchroneous Procedure Callback [ Should not be used by device drivers ]
+ * ApcContext = Argument to the Apc Routine
+ * IoStatusBlock = Caller should supply storage for a structure containing the completion status and information about the requested write operation.
+ * BufferDescription = Caller should supply storage for a buffer that will contain the information to be written to file.
+ * BufferLength = Size in bytest of the buffer
+ * ByteOffset = Points to a file offset. If a combination of Length and BytesOfSet is past the end-of-file mark the file will be enlarged.
+ * BytesOffset is ignored if the file is created with FILE_APPEND_DATA in the DesiredAccess. BytesOffset is also ignored if
+ * the file is created with CreateOptions flags FILE_SYNCHRONOUS_IO_ALERT or FILE_SYNCHRONOUS_IO_NONALERT set, in that case a offset
+ * should be created by specifying FILE_USE_FILE_POINTER_POSITION. Use FILE_WRITE_TO_END_OF_FILE to write to the EOF.
+ * Key = If a matching key [ a key provided at NtLockFile ] is provided the write operation will continue even if a byte range is locked.
+ * REMARKS:
+ * This function maps to the win32 WriteFile.
+ * Callers to NtWriteFile should run at IRQL PASSIVE_LEVEL.
+ * RETURNS: Status [ STATUS_SUCCESS | STATUS_PENDING | STATUS_ACCESS_DENIED | STATUS_INSUFFICIENT_RESOURCES
+ STATUS_INVALID_PARAMETER | STATUS_INVALID_DEVICE_REQUEST | STATUS_FILE_LOCK_CONFLICT ]
+ */
+
+NTSTATUS
+STDCALL
+NtWriteFileGather(
+ IN HANDLE FileHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
+ IN PVOID ApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN FILE_SEGMENT_ELEMENT BufferDescription[],
+ IN ULONG BufferLength,
+ IN PLARGE_INTEGER ByteOffset,
+ IN PULONG Key OPTIONAL
+ );
+
+NTSTATUS
+STDCALL
+ZwWriteFileGather(
+ IN HANDLE FileHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
+ IN PVOID ApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN FILE_SEGMENT_ELEMENT BufferDescription[],
+ IN ULONG BufferLength,
+ IN PLARGE_INTEGER ByteOffset,
+ IN PULONG Key OPTIONAL
+ );
+
+
+/* --- THREAD MANAGEMENT --- */
+
+/*
+ * FUNCTION: Increments a thread's resume count
+ * ARGUMENTS:
+ * ThreadHandle = Handle to the thread that should be resumed
+ * PreviousSuspendCount = The resulting/previous suspend count.
+ * REMARK:
+ * A thread will be suspended if its suspend count is greater than 0. This procedure maps to
+ * the win32 SuspendThread function. ( documentation about the the suspend count can be found here aswell )
+ * The suspend count is not increased if it is greater than MAXIMUM_SUSPEND_COUNT.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtSuspendThread(
+ IN HANDLE ThreadHandle,
+ IN PULONG PreviousSuspendCount
+ );
+
+NTSTATUS
+STDCALL
+ZwSuspendThread(
+ IN HANDLE ThreadHandle,
+ IN PULONG PreviousSuspendCount
+ );
+
+/*
+ * FUNCTION: Terminates the execution of a thread.
+ * ARGUMENTS:
+ * ThreadHandle = Handle to the thread
+ * ExitStatus = The exit status of the thread to terminate with.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtTerminateThread(
+ IN HANDLE ThreadHandle ,
+ IN NTSTATUS ExitStatus
+ );
+NTSTATUS
+STDCALL
+ZwTerminateThread(
+ IN HANDLE ThreadHandle ,
+ IN NTSTATUS ExitStatus
+ );
+/*
+ * FUNCTION: Tests to see if there are any pending alerts for the calling thread
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtTestAlert(
+ VOID
+ );
+NTSTATUS
+STDCALL
+ZwTestAlert(
+ VOID
+ );
+
+/*
+ * FUNCTION: Yields the callers thread.
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtYieldExecution(
+ VOID
+ );
+
+NTSTATUS
+STDCALL
+ZwYieldExecution(
+ VOID
+ );
+
+
+/*
+ * --- Local Procedure Call Facility
+ * These prototypes are unknown as yet
+ * (stack sizes by Peter-Michael Hager)
+ */
+
+/* --- REGISTRY --- */
+
+/*
+ * FUNCTION: Unloads a registry key.
+ * ARGUMENTS:
+ * KeyHandle = Handle to the registry key
+ * REMARK:
+ * This procedure maps to the win32 procedure RegUnloadKey
+ * RETURNS: Status
+ */
+NTSTATUS
+STDCALL
+NtUnloadKey(
+ HANDLE KeyHandle
+ );
+NTSTATUS
+STDCALL
+ZwUnloadKey(
+ HANDLE KeyHandle
+ );
+
+
+/* --- PLUG AND PLAY --- */
+
+NTSTATUS
+STDCALL
+NtPlugPlayControl (
+ VOID
+ );
+
+NTSTATUS
+STDCALL
+NtGetPlugPlayEvent (
+ VOID
+ );
+
+/* --- POWER MANAGEMENT --- */
+
+NTSTATUS STDCALL
+NtSetSystemPowerState(IN POWER_ACTION SystemAction,
+ IN SYSTEM_POWER_STATE MinSystemState,
+ IN ULONG Flags);
+
+/* --- DEBUG SUBSYSTEM --- */
+
+NTSTATUS STDCALL
+NtSystemDebugControl(DEBUG_CONTROL_CODE ControlCode,
+ PVOID InputBuffer,
+ ULONG InputBufferLength,
+ PVOID OutputBuffer,
+ ULONG OutputBufferLength,
+ PULONG ReturnLength);
+
+/* --- VIRTUAL DOS MACHINE (VDM) --- */
+
+NTSTATUS
+STDCALL
+NtVdmControl (ULONG ControlCode, PVOID ControlData);
+
+
+/* --- WIN32 --- */
+
+NTSTATUS STDCALL
+NtW32Call(IN ULONG RoutineIndex,
+ IN PVOID Argument,
+ IN ULONG ArgumentLength,
+ OUT PVOID* Result OPTIONAL,
+ OUT PULONG ResultLength OPTIONAL);
+
+/* --- CHANNELS --- */
+
+NTSTATUS
+STDCALL
+NtCreateChannel (
+ VOID
+ );
+
+NTSTATUS
+STDCALL
+NtListenChannel (
+ VOID
+ );
+
+NTSTATUS
+STDCALL
+NtOpenChannel (
+ VOID
+ );
+
+NTSTATUS
+STDCALL
+NtReplyWaitSendChannel (
+ VOID
+ );
+
+NTSTATUS
+STDCALL
+NtSendWaitReplyChannel (
+ VOID
+ );
+
+NTSTATUS
+STDCALL
+NtSetContextChannel (
+ VOID
+ );
+
+/* --- MISCELLANEA --- */
+
+//NTSTATUS STDCALL NtSetLdtEntries(VOID);
+NTSTATUS
+STDCALL
+NtSetLdtEntries (
+ HANDLE Thread,
+ ULONG FirstEntry,
+ PULONG Entries
+ );
+
+
+NTSTATUS
+STDCALL
+NtQueryOleDirectoryFile (
+ VOID
+ );
+
+#endif /* __DDK_ZW_H */
--- /dev/null
+#ifndef __INCLUDE_DDK_ZWTYPES_H
+#define __INCLUDE_DDK_ZWTYPES_H
+
+typedef enum _DEBUG_CONTROL_CODE
+{
+ DebugGetTraceInformation = 1,
+ DebugSetInternalBreakpoint,
+ DebugSetSpecialCalls,
+ DebugClearSpecialCalls,
+ DebugQuerySpecialCalls,
+ DebugDbgBreakPoint,
+ DebugDbgLoadSymbols
+} DEBUG_CONTROL_CODE;
+
+typedef enum _KPROFILE_SOURCE
+{
+ ProfileTime
+} KPROFILE_SOURCE;
+
+#define NtCurrentProcess() ( (HANDLE) 0xFFFFFFFF )
+#define NtCurrentThread() ( (HANDLE) 0xFFFFFFFE )
+
+#ifdef __NTOSKRNL__
+extern ULONG EXPORTED NtBuildNumber;
+#else
+extern ULONG IMPORTED NtBuildNumber;
+#endif
+
+
+// event access mask
+
+#define EVENT_READ_ACCESS 1
+#define EVENT_WRITE_ACCESS 2
+
+
+// file disposition values
+
+
+#define FILE_SUPERSEDE 0x0000
+#define FILE_OPEN 0x0001
+#define FILE_CREATE 0x0002
+#define FILE_OPEN_IF 0x0003
+#define FILE_OVERWRITE 0x0004
+#define FILE_OVERWRITE_IF 0x0005
+#define FILE_MAXIMUM_DISPOSITION 0x0005
+
+// job query / set information class
+
+typedef enum _JOBOBJECTINFOCLASS { // Q S
+ JobObjectBasicAccountingInformation = 1, // Y N
+ JobObjectBasicLimitInformation, // Y Y
+ JobObjectBasicProcessIdList, // Y N
+ JobObjectBasicUIRestrictions, // Y Y
+ JobObjectSecurityLimitInformation, // Y Y
+ JobObjectEndOfJobTimeInformation, // N Y
+ JobObjectAssociateCompletionPortInformation, // N Y
+ JobObjectBasicAndIoAccountingInformation, // Y N
+ JobObjectExtendedLimitInformation, // Y Y
+} JOBOBJECTINFOCLASS;
+
+//process query / set information class
+
+#define ProcessBasicInformation 0
+#define ProcessQuotaLimits 1
+#define ProcessIoCounters 2
+#define ProcessVmCounters 3
+#define ProcessTimes 4
+#define ProcessBasePriority 5
+#define ProcessRaisePriority 6
+#define ProcessDebugPort 7
+#define ProcessExceptionPort 8
+#define ProcessAccessToken 9
+#define ProcessLdtInformation 10
+#define ProcessLdtSize 11
+#define ProcessDefaultHardErrorMode 12
+#define ProcessIoPortHandlers 13
+#define ProcessPooledUsageAndLimits 14
+#define ProcessWorkingSetWatch 15
+#define ProcessUserModeIOPL 16
+#define ProcessEnableAlignmentFaultFixup 17
+#define ProcessPriorityClass 18
+#define ProcessWx86Information 19
+#define ProcessHandleCount 20
+#define ProcessAffinityMask 21
+#define ProcessPriorityBoost 22
+#define ProcessDeviceMap 23
+#define ProcessSessionInformation 24
+#define ProcessForegroundInformation 25
+#define ProcessWow64Information 26
+/* ReactOS private. */
+#define ProcessImageFileName 27
+#define ProcessDesktop 28
+#define MaxProcessInfoClass 29
+
+/*
+ * thread query / set information class
+ */
+#define ThreadBasicInformation 0
+#define ThreadTimes 1
+#define ThreadPriority 2
+#define ThreadBasePriority 3
+#define ThreadAffinityMask 4
+#define ThreadImpersonationToken 5
+#define ThreadDescriptorTableEntry 6
+#define ThreadEnableAlignmentFaultFixup 7
+#define ThreadEventPair 8
+#define ThreadQuerySetWin32StartAddress 9
+#define ThreadZeroTlsCell 10
+#define ThreadPerformanceCount 11
+#define ThreadAmILastThread 12
+#define ThreadIdealProcessor 13
+#define ThreadPriorityBoost 14
+#define ThreadSetTlsArrayAddress 15
+#define ThreadIsIoPending 16
+#define ThreadHideFromDebugger 17
+#define MaxThreadInfoClass 17
+
+// object handle information
+
+#define ObjectBasicInformation 0
+#define ObjectNameInformation 1
+#define ObjectTypeInformation 2
+#define ObjectAllInformation 3
+#define ObjectDataInformation 4
+
+// atom information
+
+typedef enum _ATOM_INFORMATION_CLASS
+{
+ AtomBasicInformation = 0,
+ AtomTableInformation = 1,
+} ATOM_INFORMATION_CLASS;
+
+typedef struct _ATOM_BASIC_INFORMATION
+{
+ USHORT UsageCount;
+ USHORT Flags;
+ USHORT NameLength;
+ WCHAR Name[1];
+} ATOM_BASIC_INFORMATION, *PATOM_BASIC_INFORMATION;
+
+typedef struct _ATOM_TABLE_INFORMATION
+{
+ ULONG NumberOfAtoms;
+ RTL_ATOM Atoms[1];
+} ATOM_TABLE_INFORMATION, *PATOM_TABLE_INFORMATION;
+
+
+// mutant information
+
+typedef enum _MUTANT_INFORMATION_CLASS
+{
+ MutantBasicInformation = 0
+} MUTANT_INFORMATION_CLASS;
+
+typedef struct _MUTANT_BASIC_INFORMATION
+{
+ LONG Count;
+ BOOLEAN Owned;
+ BOOLEAN Abandoned;
+} MUTANT_BASIC_INFORMATION, *PMUTANT_BASIC_INFORMATION;
+
+
+// semaphore information
+
+typedef enum _SEMAPHORE_INFORMATION_CLASS
+{
+ SemaphoreBasicInformation = 0
+} SEMAPHORE_INFORMATION_CLASS;
+
+typedef struct _SEMAPHORE_BASIC_INFORMATION
+{
+ LONG CurrentCount;
+ LONG MaximumCount;
+} SEMAPHORE_BASIC_INFORMATION, *PSEMAPHORE_BASIC_INFORMATION;
+
+
+// event information
+
+typedef enum _EVENT_INFORMATION_CLASS
+{
+ EventBasicInformation = 0
+} EVENT_INFORMATION_CLASS;
+
+typedef struct _EVENT_BASIC_INFORMATION
+{
+ EVENT_TYPE EventType;
+ LONG EventState;
+} EVENT_BASIC_INFORMATION, *PEVENT_BASIC_INFORMATION;
+
+
+// system information
+// {Nt|Zw}{Query|Set}SystemInformation
+// (GN means Gary Nebbet in "NT/W2K Native API Reference")
+
+typedef
+enum _SYSTEM_INFORMATION_CLASS
+{
+ SystemInformationClassMin = 0,
+ SystemBasicInformation = 0, /* Q */
+
+ SystemProcessorInformation = 1, /* Q */
+
+ SystemPerformanceInformation = 2, /* Q */
+
+ SystemTimeOfDayInformation = 3, /* Q */
+
+ SystemPathInformation = 4, /* Q (checked build only) */
+ SystemNotImplemented1 = 4, /* Q (GN) */
+
+ SystemProcessInformation = 5, /* Q */
+ SystemProcessesAndThreadsInformation = 5, /* Q (GN) */
+
+ SystemCallCountInfoInformation = 6, /* Q */
+ SystemCallCounts = 6, /* Q (GN) */
+
+ SystemDeviceInformation = 7, /* Q */
+// It conflicts with symbol in ntoskrnl/io/resource.c
+// SystemConfigurationInformation = 7, /* Q (GN) */
+
+ SystemProcessorPerformanceInformation = 8, /* Q */
+ SystemProcessorTimes = 8, /* Q (GN) */
+
+ SystemFlagsInformation = 9, /* QS */
+ SystemGlobalFlag = 9, /* QS (GN) */
+
+ SystemCallTimeInformation = 10,
+ SystemNotImplemented2 = 10, /* (GN) */
+
+ SystemModuleInformation = 11, /* Q */
+
+ SystemLocksInformation = 12, /* Q */
+ SystemLockInformation = 12, /* Q (GN) */
+
+ SystemStackTraceInformation = 13,
+ SystemNotImplemented3 = 13, /* Q (GN) */
+
+ SystemPagedPoolInformation = 14,
+ SystemNotImplemented4 = 14, /* Q (GN) */
+
+ SystemNonPagedPoolInformation = 15,
+ SystemNotImplemented5 = 15, /* Q (GN) */
+
+ SystemHandleInformation = 16, /* Q */
+
+ SystemObjectInformation = 17, /* Q */
+
+ SystemPageFileInformation = 18, /* Q */
+ SystemPagefileInformation = 18, /* Q (GN) */
+
+ SystemVdmInstemulInformation = 19, /* Q */
+ SystemInstructionEmulationCounts = 19, /* Q (GN) */
+
+ SystemVdmBopInformation = 20,
+ SystemInvalidInfoClass1 = 20, /* (GN) */
+
+ SystemFileCacheInformation = 21, /* QS */
+ SystemCacheInformation = 21, /* QS (GN) */
+
+ SystemPoolTagInformation = 22, /* Q (checked build only) */
+
+ SystemInterruptInformation = 23, /* Q */
+ SystemProcessorStatistics = 23, /* Q (GN) */
+
+ SystemDpcBehaviourInformation = 24, /* QS */
+ SystemDpcInformation = 24, /* QS (GN) */
+
+ SystemFullMemoryInformation = 25,
+ SystemNotImplemented6 = 25, /* (GN) */
+
+ SystemLoadImage = 26, /* S (callable) (GN) */
+
+ SystemUnloadImage = 27, /* S (callable) (GN) */
+
+ SystemTimeAdjustmentInformation = 28, /* QS */
+ SystemTimeAdjustment = 28, /* QS (GN) */
+
+ SystemSummaryMemoryInformation = 29,
+ SystemNotImplemented7 = 29, /* (GN) */
+
+ SystemNextEventIdInformation = 30,
+ SystemNotImplemented8 = 30, /* (GN) */
+
+ SystemEventIdsInformation = 31,
+ SystemNotImplemented9 = 31, /* (GN) */
+
+ SystemCrashDumpInformation = 32, /* Q */
+
+ SystemExceptionInformation = 33, /* Q */
+
+ SystemCrashDumpStateInformation = 34, /* Q */
+
+ SystemKernelDebuggerInformation = 35, /* Q */
+
+ SystemContextSwitchInformation = 36, /* Q */
+
+ SystemRegistryQuotaInformation = 37, /* QS */
+
+ SystemLoadAndCallImage = 38, /* S (GN) */
+
+ SystemPrioritySeparation = 39, /* S */
+
+ SystemPlugPlayBusInformation = 40,
+ SystemNotImplemented10 = 40, /* Q (GN) */
+
+ SystemDockInformation = 41,
+ SystemNotImplemented11 = 41, /* Q (GN) */
+
+ SystemPowerInformation = 42,
+ SystemInvalidInfoClass2 = 42, /* (GN) */
+
+ SystemProcessorSpeedInformation = 43,
+ SystemInvalidInfoClass3 = 43, /* (GN) */
+
+ SystemCurrentTimeZoneInformation = 44, /* QS */
+ SystemTimeZoneInformation = 44, /* QS (GN) */
+
+ SystemLookasideInformation = 45, /* Q */
+
+ SystemSetTimeSlipEvent = 46, /* S (GN) */
+
+ SystemCreateSession = 47, /* S (GN) */
+
+ SystemDeleteSession = 48, /* S (GN) */
+
+ SystemInvalidInfoClass4 = 49, /* (GN) */
+
+ SystemRangeStartInformation = 50, /* Q (GN) */
+
+ SystemVerifierInformation = 51, /* QS (GN) */
+
+ SystemAddVerifier = 52, /* S (GN) */
+
+ SystemSessionProcessesInformation = 53, /* Q (GN) */
+ SystemInformationClassMax
+
+} SYSTEM_INFORMATION_CLASS;
+
+// SystemBasicInformation (0)
+typedef
+struct _SYSTEM_BASIC_INFORMATION
+{
+ ULONG Reserved;
+ ULONG TimerResolution;
+ ULONG PageSize;
+ ULONG NumberOfPhysicalPages;
+ ULONG LowestPhysicalPageNumber;
+ ULONG HighestPhysicalPageNumber;
+ ULONG AllocationGranularity;
+ ULONG MinimumUserModeAddress;
+ ULONG MaximumUserModeAddress;
+ KAFFINITY ActiveProcessorsAffinityMask;
+ CCHAR NumberOfProcessors;
+} SYSTEM_BASIC_INFORMATION, *PSYSTEM_BASIC_INFORMATION;
+
+// SystemProcessorInformation (1)
+typedef
+struct _SYSTEM_PROCESSOR_INFORMATION
+{
+ USHORT ProcessorArchitecture;
+ USHORT ProcessorLevel;
+ USHORT ProcessorRevision;
+ USHORT Reserved;
+ ULONG ProcessorFeatureBits;
+} SYSTEM_PROCESSOR_INFORMATION, *PSYSTEM_PROCESSOR_INFORMATION;
+
+// SystemPerformanceInfo (2)
+typedef
+struct _SYSTEM_PERFORMANCE_INFORMATION
+{
+ LARGE_INTEGER IdleProcessorTime;
+ LARGE_INTEGER IoReadTransferCount;
+ LARGE_INTEGER IoWriteTransferCount;
+ LARGE_INTEGER IoOtherTransferCount;
+ ULONG IoReadOperationCount;
+ ULONG IoWriteOperationCount;
+ ULONG IoOtherOperationCount;
+ ULONG AvailablePages;
+ ULONG CommitedPages;
+ ULONG CommitLimit;
+ ULONG PeakCommitment;
+ ULONG PageFaultCount;
+ ULONG CopyOnWriteCount;
+ ULONG TransitionCount;
+ ULONG CacheTransitionCount;
+ ULONG DemandZeroCount;
+ ULONG PageReadCount;
+ ULONG PageReadIoCount;
+ ULONG CacheReadCount;
+ ULONG CacheIoCount;
+ ULONG DirtyPagesWriteCount;
+ ULONG DirtyWriteIoCount;
+ ULONG MappedPagesWriteCount;
+ ULONG MappedWriteIoCount;
+ ULONG PagedPoolPages;
+ ULONG NonPagedPoolPages;
+ ULONG Unknown6;
+ ULONG Unknown7;
+ ULONG Unknown8;
+ ULONG Unknown9;
+ ULONG MmTotalSystemFreePtes;
+ ULONG MmSystemCodepage;
+ ULONG MmTotalSystemDriverPages;
+ ULONG MmTotalSystemCodePages;
+ ULONG Unknown10;
+ ULONG Unknown11;
+ ULONG Unknown12;
+ ULONG MmSystemCachePage;
+ ULONG MmPagedPoolPage;
+ ULONG MmSystemDriverPage;
+ ULONG CcFastReadNoWait;
+ ULONG CcFastReadWait;
+ ULONG CcFastReadResourceMiss;
+ ULONG CcFastReadNotPossible;
+ ULONG CcFastMdlReadNoWait;
+ ULONG CcFastMdlReadWait;
+ ULONG CcFastMdlReadResourceMiss;
+ ULONG CcFastMdlReadNotPossible;
+ ULONG CcMapDataNoWait;
+ ULONG CcMapDataWait;
+ ULONG CcMapDataNoWaitMiss;
+ ULONG CcMapDataWaitMiss;
+ ULONG CcPinMappedDataCount;
+ ULONG CcPinReadNoWait;
+ ULONG CcPinReadWait;
+ ULONG CcPinReadNoWaitMiss;
+ ULONG CcPinReadWaitMiss;
+ ULONG CcCopyReadNoWait;
+ ULONG CcCopyReadWait;
+ ULONG CcCopyReadNoWaitMiss;
+ ULONG CcCopyReadWaitMiss;
+ ULONG CcMdlReadNoWait;
+ ULONG CcMdlReadWait;
+ ULONG CcMdlReadNoWaitMiss;
+ ULONG CcMdlReadWaitMiss;
+ ULONG CcReadaheadIos;
+ ULONG CcLazyWriteIos;
+ ULONG CcLazyWritePages;
+ ULONG CcDataFlushes;
+ ULONG CcDataPages;
+ ULONG ContextSwitches;
+ ULONG Unknown13;
+ ULONG Unknown14;
+ ULONG SystemCalls;
+
+} SYSTEM_PERFORMANCE_INFO, *PSYSTEM_PERFORMANCE_INFO;
+
+// SystemTimeOfDayInformation (3)
+typedef
+struct _SYSTEM_TIMEOFDAY_INFORMATION
+{
+ LARGE_INTEGER BootTime;
+ LARGE_INTEGER CurrentTime;
+ LARGE_INTEGER TimeZoneBias;
+ ULONG TimeZoneId;
+ ULONG Reserved;
+} SYSTEM_TIMEOFDAY_INFORMATION, *PSYSTEM_TIMEOFDAY_INFORMATION;
+
+// SystemPathInformation (4)
+// IT DOES NOT WORK
+typedef
+struct _SYSTEM_PATH_INFORMATION
+{
+ PVOID Dummy;
+
+} SYSTEM_PATH_INFORMATION, * PSYSTEM_PATH_INFORMATION;
+
+// SystemProcessInformation (5)
+typedef
+struct _SYSTEM_THREAD_INFORMATION
+{
+ TIME KernelTime;
+ TIME UserTime;
+ TIME CreateTime;
+ ULONG TickCount;
+ ULONG StartEIP;
+ CLIENT_ID ClientId;
+ ULONG DynamicPriority;
+ ULONG BasePriority;
+ ULONG nSwitches;
+ DWORD State;
+ KWAIT_REASON WaitReason;
+
+} SYSTEM_THREAD_INFORMATION, *PSYSTEM_THREAD_INFORMATION;
+
+typedef
+struct SYSTEM_PROCESS_INFORMATION
+{
+ ULONG RelativeOffset;
+ ULONG ThreadCount;
+ ULONG Unused1 [6];
+ TIME CreateTime;
+ TIME UserTime;
+ TIME KernelTime;
+ UNICODE_STRING Name;
+ ULONG BasePriority;
+ ULONG ProcessId;
+ ULONG ParentProcessId;
+ ULONG HandleCount;
+ ULONG Unused2[2];
+ ULONG PeakVirtualSizeBytes;
+ ULONG TotalVirtualSizeBytes;
+ ULONG PageFaultCount;
+ ULONG PeakWorkingSetSizeBytes;
+ ULONG TotalWorkingSetSizeBytes;
+ ULONG PeakPagedPoolUsagePages;
+ ULONG TotalPagedPoolUsagePages;
+ ULONG PeakNonPagedPoolUsagePages;
+ ULONG TotalNonPagedPoolUsagePages;
+ ULONG TotalPageFileUsageBytes;
+ ULONG PeakPageFileUsageBytes;
+ ULONG TotalPrivateBytes;
+ SYSTEM_THREAD_INFORMATION ThreadSysInfo [1];
+
+} SYSTEM_PROCESS_INFORMATION, *PSYSTEM_PROCESS_INFORMATION;
+
+// SystemCallCountInformation (6)
+typedef
+struct _SYSTEM_SDT_INFORMATION
+{
+ ULONG BufferLength;
+ ULONG NumberOfSystemServiceTables;
+ ULONG NumberOfServices [1];
+ ULONG ServiceCounters [1];
+
+} SYSTEM_SDT_INFORMATION, *PSYSTEM_SDT_INFORMATION;
+
+// SystemDeviceInformation (7)
+typedef
+struct _SYSTEM_DEVICE_INFORMATION
+{
+ ULONG NumberOfDisks;
+ ULONG NumberOfFloppies;
+ ULONG NumberOfCdRoms;
+ ULONG NumberOfTapes;
+ ULONG NumberOfSerialPorts;
+ ULONG NumberOfParallelPorts;
+} SYSTEM_DEVICE_INFORMATION, *PSYSTEM_DEVICE_INFORMATION;
+
+// SystemProcessorPerformanceInformation (8)
+// (one per processor in the system)
+typedef
+struct _SYSTEM_PROCESSORTIME_INFO
+{
+ TIME TotalProcessorRunTime;
+ TIME TotalProcessorTime;
+ TIME TotalProcessorUserTime;
+ TIME TotalDPCTime;
+ TIME TotalInterruptTime;
+ ULONG TotalInterrupts;
+ ULONG Unused;
+
+} SYSTEM_PROCESSORTIME_INFO, *PSYSTEM_PROCESSORTIME_INFO;
+
+// SystemFlagsInformation (9)
+typedef
+struct _SYSTEM_FLAGS_INFORMATION
+{
+ ULONG Flags;
+
+} SYSTEM_FLAGS_INFORMATION, * PSYSTEM_FLAGS_INFORMATION;
+
+#define FLG_STOP_ON_EXCEPTION 0x00000001
+#define FLG_SHOW_LDR_SNAPS 0x00000002
+#define FLG_DEBUG_INITIAL_COMMAND 0x00000004
+#define FLG_STOP_ON_HANG_GUI 0x00000008
+#define FLG_HEAP_ENABLE_TAIL_CHECK 0x00000010
+#define FLG_HEAP_ENABLE_FREE_CHECK 0x00000020
+#define FLG_HEAP_VALIDATE_PARAMETERS 0x00000040
+#define FLG_HEAP_VALIDATE_ALL 0x00000080
+#define FLG_POOL_ENABLE_TAIL_CHECK 0x00000100
+#define FLG_POOL_ENABLE_FREE_CHECK 0x00000200
+#define FLG_POOL_ENABLE_TAGGING 0x00000400
+#define FLG_HEAP_ENABLE_TAGGING 0x00000800
+#define FLG_USER_STACK_TRACE_DB 0x00001000
+#define FLG_KERNEL_STACK_TRACE_DB 0x00002000
+#define FLG_MAINTAIN_OBJECT_TYPELIST 0x00004000
+#define FLG_HEAP_ENABLE_TAG_BY_DLL 0x00008000
+#define FLG_IGNORE_DEBUG_PRIV 0x00010000
+#define FLG_ENABLE_CSRDEBUG 0x00020000
+#define FLG_ENABLE_KDEBUG_SYMBOL_LOAD 0x00040000
+#define FLG_DISABLE_PAGE_KERNEL_STACKS 0x00080000
+#define FLG_HEAP_ENABLE_CALL_TRACING 0x00100000
+#define FLG_HEAP_DISABLE_COALESCING 0x00200000
+#define FLG_ENABLE_CLOSE_EXCEPTION 0x00400000
+#define FLG_ENABLE_EXCEPTION_LOGGING 0x00800000
+#define FLG_UNKNOWN_01000000 0x01000000
+#define FLG_UNKNOWN_02000000 0x02000000
+#define FLG_UNKNOWN_04000000 0x04000000
+#define FLG_ENABLE_DBGPRINT_BUFFERING 0x08000000
+#define FLG_UNKNOWN_10000000 0x10000000
+#define FLG_UNKNOWN_20000000 0x20000000
+#define FLG_UNKNOWN_40000000 0x40000000
+#define FLG_UNKNOWN_80000000 0x80000000
+
+// SystemCallTimeInformation (10)
+// UNKNOWN
+
+// SystemModuleInformation (11)
+typedef
+struct _SYSTEM_MODULE_ENTRY
+{
+ ULONG Unknown1;
+ ULONG Unknown2;
+ PVOID BaseAddress;
+ ULONG Size;
+ ULONG Flags;
+ ULONG EntryIndex;
+ USHORT NameLength; /* Length of module name not including the path, this field contains valid value only for NTOSKRNL module*/
+ USHORT PathLength; /* Length of 'directory path' part of modulename*/
+ CHAR Name [256];
+} SYSTEM_MODULE_ENTRY, * PSYSTEM_MODULE_ENTRY;
+
+typedef
+struct _SYSTEM_MODULE_INFORMATION
+{
+ ULONG Count;
+ SYSTEM_MODULE_ENTRY Module [1];
+} SYSTEM_MODULE_INFORMATION, *PSYSTEM_MODULE_INFORMATION;
+
+// SystemLocksInformation (12)
+typedef
+struct _SYSTEM_RESOURCE_LOCK_ENTRY
+{
+ ULONG ResourceAddress;
+ ULONG Always1;
+ ULONG Unknown;
+ ULONG ActiveCount;
+ ULONG ContentionCount;
+ ULONG Unused[2];
+ ULONG NumberOfSharedWaiters;
+ ULONG NumberOfExclusiveWaiters;
+
+} SYSTEM_RESOURCE_LOCK_ENTRY, *PSYSTEM_RESOURCE_LOCK_ENTRY;
+
+typedef
+struct _SYSTEM_RESOURCE_LOCK_INFO
+{
+ ULONG Count;
+ SYSTEM_RESOURCE_LOCK_ENTRY Lock [1];
+
+} SYSTEM_RESOURCE_LOCK_INFO, *PSYSTEM_RESOURCE_LOCK_INFO;
+
+// SystemInformation13 (13)
+// UNKNOWN
+
+// SystemInformation14 (14)
+// UNKNOWN
+
+// SystemInformation15 (15)
+// UNKNOWN
+
+// SystemHandleInformation (16)
+// (see ontypes.h)
+typedef
+struct _SYSTEM_HANDLE_ENTRY
+{
+ ULONG OwnerPid;
+ BYTE ObjectType;
+ BYTE HandleFlags;
+ USHORT HandleValue;
+ PVOID ObjectPointer;
+ ULONG AccessMask;
+
+} SYSTEM_HANDLE_ENTRY, *PSYSTEM_HANDLE_ENTRY;
+
+typedef
+struct _SYSTEM_HANDLE_INFORMATION
+{
+ ULONG Count;
+ SYSTEM_HANDLE_ENTRY Handle [1];
+
+} SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION;
+
+// SystemObjectInformation (17)
+typedef
+struct _SYSTEM_OBJECT_TYPE_INFORMATION
+{
+ ULONG NextEntryOffset;
+ ULONG ObjectCount;
+ ULONG HandleCount;
+ ULONG TypeNumber;
+ ULONG InvalidAttributes;
+ GENERIC_MAPPING GenericMapping;
+ ACCESS_MASK ValidAccessMask;
+ POOL_TYPE PoolType;
+ UCHAR Unknown;
+ UNICODE_STRING Name;
+
+} SYSTEM_OBJECT_TYPE_INFORMATION, *PSYSTEM_OBJECT_TYPE_INFORMATION;
+
+typedef
+struct _SYSTEM_OBJECT_INFORMATION
+{
+ ULONG NextEntryOffset;
+ PVOID Object;
+ ULONG CreatorProcessId;
+ USHORT Unknown;
+ USHORT Flags;
+ ULONG PointerCount;
+ ULONG HandleCount;
+ ULONG PagedPoolUsage;
+ ULONG NonPagedPoolUsage;
+ ULONG ExclusiveProcessId;
+ PSECURITY_DESCRIPTOR SecurityDescriptor;
+ UNICODE_STRING Name;
+
+} SYSTEM_OBJECT_INFORMATION, *PSYSTEM_OBJECT_INFORMATION;
+
+// SystemPageFileInformation (18)
+typedef
+struct _SYSTEM_PAGEFILE_INFORMATION
+{
+ ULONG RelativeOffset;
+ ULONG CurrentSizePages;
+ ULONG TotalUsedPages;
+ ULONG PeakUsedPages;
+ UNICODE_STRING PagefileFileName;
+
+} SYSTEM_PAGEFILE_INFORMATION, *PSYSTEM_PAGEFILE_INFORMATION;
+
+// SystemInstructionEmulationInfo (19)
+typedef
+struct _SYSTEM_VDM_INFORMATION
+{
+ ULONG VdmSegmentNotPresentCount;
+ ULONG VdmINSWCount;
+ ULONG VdmESPREFIXCount;
+ ULONG VdmCSPREFIXCount;
+ ULONG VdmSSPREFIXCount;
+ ULONG VdmDSPREFIXCount;
+ ULONG VdmFSPREFIXCount;
+ ULONG VdmGSPREFIXCount;
+ ULONG VdmOPER32PREFIXCount;
+ ULONG VdmADDR32PREFIXCount;
+ ULONG VdmINSBCount;
+ ULONG VdmINSWV86Count;
+ ULONG VdmOUTSBCount;
+ ULONG VdmOUTSWCount;
+ ULONG VdmPUSHFCount;
+ ULONG VdmPOPFCount;
+ ULONG VdmINTNNCount;
+ ULONG VdmINTOCount;
+ ULONG VdmIRETCount;
+ ULONG VdmINBIMMCount;
+ ULONG VdmINWIMMCount;
+ ULONG VdmOUTBIMMCount;
+ ULONG VdmOUTWIMMCount;
+ ULONG VdmINBCount;
+ ULONG VdmINWCount;
+ ULONG VdmOUTBCount;
+ ULONG VdmOUTWCount;
+ ULONG VdmLOCKPREFIXCount;
+ ULONG VdmREPNEPREFIXCount;
+ ULONG VdmREPPREFIXCount;
+ ULONG VdmHLTCount;
+ ULONG VdmCLICount;
+ ULONG VdmSTICount;
+ ULONG VdmBopCount;
+
+} SYSTEM_VDM_INFORMATION, *PSYSTEM_VDM_INFORMATION;
+
+// SystemInformation20 (20)
+// UNKNOWN
+
+// SystemCacheInformation (21)
+typedef
+struct _SYSTEM_CACHE_INFORMATION
+{
+ ULONG CurrentSize;
+ ULONG PeakSize;
+ ULONG PageFaultCount;
+ ULONG MinimumWorkingSet;
+ ULONG MaximumWorkingSet;
+ ULONG Unused[4];
+
+} SYSTEM_CACHE_INFORMATION;
+
+// SystemPoolTagInformation (22)
+// found by Klaus P. Gerlicher
+// (implemented only in checked builds)
+typedef
+struct _POOL_TAG_STATS
+{
+ ULONG AllocationCount;
+ ULONG FreeCount;
+ ULONG SizeBytes;
+
+} POOL_TAG_STATS;
+
+typedef
+struct _SYSTEM_POOL_TAG_ENTRY
+{
+ ULONG Tag;
+ POOL_TAG_STATS Paged;
+ POOL_TAG_STATS NonPaged;
+
+} SYSTEM_POOL_TAG_ENTRY, * PSYSTEM_POOL_TAG_ENTRY;
+
+typedef
+struct _SYSTEM_POOL_TAG_INFO
+{
+ ULONG Count;
+ SYSTEM_POOL_TAG_ENTRY PoolEntry [1];
+
+} SYSTEM_POOL_TAG_INFO, *PSYSTEM_POOL_TAG_INFO;
+
+// SystemProcessorScheduleInfo (23)
+typedef
+struct _SYSTEM_PROCESSOR_SCHEDULE_INFO
+{
+ ULONG nContextSwitches;
+ ULONG nDPCQueued;
+ ULONG nDPCRate;
+ ULONG TimerResolution;
+ ULONG nDPCBypasses;
+ ULONG nAPCBypasses;
+
+} SYSTEM_PROCESSOR_SCHEDULE_INFO, *PSYSTEM_PROCESSOR_SCHEDULE_INFO;
+
+// SystemDpcInformation (24)
+typedef
+struct _SYSTEM_DPC_INFORMATION
+{
+ ULONG Unused;
+ ULONG KiMaximumDpcQueueDepth;
+ ULONG KiMinimumDpcRate;
+ ULONG KiAdjustDpcThreshold;
+ ULONG KiIdealDpcRate;
+
+} SYSTEM_DPC_INFORMATION, *PSYSTEM_DPC_INFORMATION;
+
+// SystemInformation25 (25)
+// UNKNOWN
+
+// SystemLoadImage (26)
+typedef struct _SYSTEM_LOAD_IMAGE
+{
+ UNICODE_STRING ModuleName;
+ PVOID ModuleBase;
+ PVOID SectionPointer;
+ PVOID EntryPoint;
+ PVOID ExportDirectory;
+} SYSTEM_LOAD_IMAGE, *PSYSTEM_LOAD_IMAGE;
+
+// SystemUnloadImage (27)
+typedef struct _SYSTEM_UNLOAD_IMAGE
+{
+ PVOID ModuleBase;
+} SYSTEM_UNLOAD_IMAGE, *PSYSTEM_UNLOAD_IMAGE;
+
+// SystemTimeAdjustmentInformation (28)
+typedef
+struct _SYSTEM_QUERY_TIME_ADJUSTMENT
+{
+ ULONG TimeAdjustment;
+ ULONG MaximumIncrement;
+ BOOLEAN TimeSynchronization;
+
+} SYSTEM_QUERY_TIME_ADJUSTMENT, *PSYSTEM_QUERY_TIME_ADJUSTMENT;
+
+typedef
+struct _SYSTEM_SET_TIME_ADJUSTMENT
+{
+ ULONG TimeAdjustment;
+ BOOLEAN TimeSynchronization;
+
+} SYSTEM_TIME_ADJUSTMENT_INFO, *PSYSTEM_TIME_ADJUSTMENT_INFO;
+
+// SystemProcessorFaultCountInfo (33)
+typedef
+struct _SYSTEM_PROCESSOR_FAULT_INFO
+{
+ ULONG nAlignmentFixup;
+ ULONG nExceptionDispatches;
+ ULONG nFloatingEmulation;
+ ULONG Unknown;
+
+} SYSTEM_PROCESSOR_FAULT_INFO, *PSYSTEM_PROCESSOR_FAULT_INFO;
+
+// SystemCrashDumpStateInfo (34)
+//
+
+// SystemDebuggerInformation (35)
+typedef
+struct _SYSTEM_DEBUGGER_INFO
+{
+ BOOLEAN KdDebuggerEnabled;
+ BOOLEAN KdDebuggerPresent;
+
+} SYSTEM_DEBUGGER_INFO, *PSYSTEM_DEBUGGER_INFO;
+
+// SystemInformation36 (36)
+// UNKNOWN
+
+// SystemQuotaInformation (37)
+typedef
+struct _SYSTEM_QUOTA_INFORMATION
+{
+ ULONG CmpGlobalQuota;
+ ULONG CmpGlobalQuotaUsed;
+ ULONG MmSizeofPagedPoolInBytes;
+
+} SYSTEM_QUOTA_INFORMATION, *PSYSTEM_QUOTA_INFORMATION;
+
+// SystemLoadAndCallImage(38)
+typedef struct _SYSTEM_LOAD_AND_CALL_IMAGE
+{
+ UNICODE_STRING ModuleName;
+} SYSTEM_LOAD_AND_CALL_IMAGE, *PSYSTEM_LOAD_AND_CALL_IMAGE;
+
+// SystemTimeZoneInformation (44)
+typedef
+struct _SYSTEM_TIME_ZONE_INFORMATION
+{
+ LONG Bias;
+ WCHAR StandardName [32];
+ TIME StandardDate;
+ LONG StandardBias;
+ WCHAR DaylightName [32];
+ TIME DaylightDate;
+ LONG DaylightBias;
+
+} SYSTEM_TIME_ZONE_INFORMATION, * PSYSTEM_TIME_ZONE_INFORMATION;
+
+// SystemLookasideInformation (45)
+typedef
+struct _SYSTEM_LOOKASIDE_INFORMATION
+{
+ USHORT Depth;
+ USHORT MaximumDepth;
+ ULONG TotalAllocates;
+ ULONG AllocatesMisses;
+ ULONG TotalFrees;
+ ULONG FreeMisses;
+ POOL_TYPE Type;
+ ULONG Tag;
+ ULONG Size;
+
+} SYSTEM_LOOKASIDE_INFORMATION, * PSYSTEM_LOOKASIDE_INFORMATION;
+
+// SystemSetTimeSlipEvent (46)
+typedef
+struct _SYSTEM_SET_TIME_SLIP_EVENT
+{
+ HANDLE TimeSlipEvent; /* IN */
+
+} SYSTEM_SET_TIME_SLIP_EVENT, * PSYSTEM_SET_TIME_SLIP_EVENT;
+
+// SystemCreateSession (47)
+// (available only on TSE/NT5+)
+typedef
+struct _SYSTEM_CREATE_SESSION
+{
+ ULONG SessionId; /* OUT */
+
+} SYSTEM_CREATE_SESSION, * PSYSTEM_CREATE_SESSION;
+
+// SystemDeleteSession (48)
+// (available only on TSE/NT5+)
+typedef
+struct _SYSTEM_DELETE_SESSION
+{
+ ULONG SessionId; /* IN */
+
+} SYSTEM_DELETE_SESSION, * PSYSTEM_DELETE_SESSION;
+
+// (49)
+// UNKNOWN
+
+// SystemRangeStartInformation (50)
+typedef
+struct _SYSTEM_RANGE_START_INFORMATION
+{
+ PVOID SystemRangeStart;
+
+} SYSTEM_RANGE_START_INFORMATION, * PSYSTEM_RANGE_START_INFORMATION;
+
+// SystemVerifierInformation (51)
+// UNKNOWN
+
+// SystemAddVerifier (52)
+// UNKNOWN
+
+// SystemSessionProcessesInformation (53)
+// (available only on TSE/NT5+)
+typedef
+struct _SYSTEM_SESSION_PROCESSES_INFORMATION
+{
+ ULONG SessionId;
+ ULONG BufferSize;
+ PVOID Buffer; /* same format as in SystemProcessInformation */
+
+} SYSTEM_SESSION_PROCESSES_INFORMATION, * PSYSTEM_SESSION_PROCESSES_INFORMATION;
+
+// memory information
+
+typedef enum _MEMORY_INFORMATION_CLASS {
+ MemoryBasicInformation,
+ MemoryWorkingSetList,
+ MemorySectionName //,
+ //MemoryBasicVlmInformation //???
+} MEMORY_INFORMATION_CLASS;
+
+typedef struct _MEMORY_BASIC_INFORMATION { // Information Class 0
+ PVOID BaseAddress;
+ PVOID AllocationBase;
+ ULONG AllocationProtect;
+ ULONG RegionSize;
+ ULONG State;
+ ULONG Protect;
+ ULONG Type;
+} MEMORY_BASIC_INFORMATION, *PMEMORY_BASIC_INFORMATION;
+
+typedef struct _MEMORY_WORKING_SET_LIST { // Information Class 1
+ ULONG NumberOfPages;
+ ULONG WorkingSetList[1];
+} MEMORY_WORKING_SET_LIST, *PMEMORY_WORKING_SET_LIST;
+
+// Information Class 2
+#define _MEMORY_SECTION_NAME_STATIC(__bufsize__) \
+ { \
+ UNICODE_STRING SectionFileName; \
+ WCHAR NameBuffer[(__bufsize__)]; \
+}
+
+#define MEMORY_SECTION_NAME_STATIC(__bufsize__) \
+ struct _MEMORY_SECTION_NAME_STATIC((__bufsize__)
+
+typedef struct _MEMORY_SECTION_NAME_STATIC(ANYSIZE_ARRAY)
+ MEMORY_SECTION_NAME, *PMEMORY_SECTION_NAME;
+
+// shutdown action
+
+typedef enum SHUTDOWN_ACTION_TAG {
+ ShutdownNoReboot,
+ ShutdownReboot,
+ ShutdownPowerOff
+} SHUTDOWN_ACTION;
+
+// wait type
+
+#define WaitAll 0
+#define WaitAny 1
+
+// number of wait objects
+
+#define THREAD_WAIT_OBJECTS 3
+//#define MAXIMUM_WAIT_OBJECTS 64
+
+// key restore flags
+
+#define REG_WHOLE_HIVE_VOLATILE 1
+#define REG_REFRESH_HIVE 2
+
+// object type access rights
+
+#define OBJECT_TYPE_CREATE 0x0001
+#define OBJECT_TYPE_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | 0x1)
+
+// directory access rights
+
+#define DIRECTORY_QUERY 0x0001
+#define DIRECTORY_TRAVERSE 0x0002
+#define DIRECTORY_CREATE_OBJECT 0x0004
+#define DIRECTORY_CREATE_SUBDIRECTORY 0x0008
+
+#define DIRECTORY_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | 0xF)
+
+// symbolic link access rights
+
+#define SYMBOLIC_LINK_QUERY 0x0001
+#define SYMBOLIC_LINK_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | 0x1)
+
+// Information class 0
+typedef struct _PROCESS_BASIC_INFORMATION
+{
+ NTSTATUS ExitStatus;
+ PPEB PebBaseAddress;
+ KAFFINITY AffinityMask;
+ KPRIORITY BasePriority;
+ ULONG UniqueProcessId;
+ ULONG InheritedFromUniqueProcessId;
+} PROCESS_BASIC_INFORMATION, *PPROCESS_BASIC_INFORMATION;
+
+// Information class 1
+typedef struct _QUOTA_LIMITS
+{
+ ULONG PagedPoolLimit;
+ ULONG NonPagedPoolLimit;
+ ULONG MinimumWorkingSetSize;
+ ULONG MaximumWorkingSetSize;
+ ULONG PagefileLimit;
+ TIME TimeLimit;
+} QUOTA_LIMITS, *PQUOTA_LIMITS;
+
+// Information class 2
+typedef struct _IO_COUNTERS
+{
+ ULONG ReadOperationCount;
+ ULONG WriteOperationCount;
+ ULONG OtherOperationCount;
+ LARGE_INTEGER ReadTransferCount;
+ LARGE_INTEGER WriteTransferCount;
+ LARGE_INTEGER OtherTransferCount;
+} IO_COUNTERS, *PIO_COUNTERS;
+
+// Information class 3
+typedef struct _VM_COUNTERS_
+{
+ ULONG PeakVirtualSize;
+ ULONG VirtualSize;
+ ULONG PageFaultCount;
+ ULONG PeakWorkingSetSize;
+ ULONG WorkingSetSize;
+ ULONG QuotaPeakPagedPoolUsage;
+ ULONG QuotaPagedPoolUsage;
+ ULONG QuotaPeakNonPagedPoolUsage;
+ ULONG QuotaNonPagedPoolUsage;
+ ULONG PagefileUsage;
+ ULONG PeakPagefileUsage;
+} VM_COUNTERS, *PVM_COUNTERS;
+
+// Information class 4
+typedef struct _KERNEL_USER_TIMES
+{
+ TIME CreateTime;
+ TIME ExitTime;
+ TIME KernelTime;
+ TIME UserTime;
+} KERNEL_USER_TIMES, *PKERNEL_USER_TIMES;
+
+// Information class 9
+typedef struct _PROCESS_ACCESS_TOKEN
+{
+ HANDLE Token;
+ HANDLE Thread;
+} PROCESS_ACCESS_TOKEN, *PPROCESS_ACCESS_TOKEN;
+
+// Information class 14
+typedef struct _POOLED_USAGE_AND_LIMITS_
+{
+ ULONG PeakPagedPoolUsage;
+ ULONG PagedPoolUsage;
+ ULONG PagedPoolLimit;
+ ULONG PeakNonPagedPoolUsage;
+ ULONG NonPagedPoolUsage;
+ ULONG NonPagedPoolLimit;
+ ULONG PeakPagefileUsage;
+ ULONG PagefileUsage;
+ ULONG PagefileLimit;
+} POOLED_USAGE_AND_LIMITS, *PPOOLED_USAGE_AND_LIMITS;
+
+// Information class 15
+typedef struct _PROCESS_WS_WATCH_INFORMATION
+{
+ PVOID FaultingPc;
+ PVOID FaultingVa;
+} PROCESS_WS_WATCH_INFORMATION, *PPROCESS_WS_WATCH_INFORMATION;
+
+// Information class 18
+typedef struct _PROCESS_PRIORITY_CLASS
+{
+ BOOLEAN Foreground;
+ UCHAR PriorityClass;
+} PROCESS_PRIORITY_CLASS, *PPROCESS_PRIORITY_CLASS;
+
+// Information class 23
+typedef struct _PROCESS_DEVICEMAP_INFORMATION
+{
+ union {
+ struct {
+ HANDLE DirectoryHandle;
+ } Set;
+ struct {
+ ULONG DriveMap;
+ UCHAR DriveType[32];
+ } Query;
+ };
+} PROCESS_DEVICEMAP_INFORMATION, *pPROCESS_DEVICEMAP_INFORMATION;
+
+// Information class 24
+typedef struct _PROCESS_SESSION_INFORMATION
+{
+ ULONG SessionId;
+} PROCESS_SESSION_INFORMATION, *PPROCESS_SESSION_INFORMATION;
+
+// thread information
+
+// incompatible with MS NT
+
+typedef struct _THREAD_BASIC_INFORMATION
+{
+ NTSTATUS ExitStatus;
+ PVOID TebBaseAddress; // PNT_TIB (GN)
+ CLIENT_ID ClientId;
+ KAFFINITY AffinityMask;
+ KPRIORITY Priority;
+ KPRIORITY BasePriority;
+} THREAD_BASIC_INFORMATION, *PTHREAD_BASIC_INFORMATION;
+
+// object information
+
+typedef struct _OBJECT_NAME_INFORMATION
+{
+ UNICODE_STRING Name;
+} OBJECT_NAME_INFORMATION, *POBJECT_NAME_INFORMATION;
+
+
+
+typedef struct _OBJECT_DATA_INFORMATION
+{
+ BOOLEAN bInheritHandle;
+ BOOLEAN bProtectFromClose;
+} OBJECT_DATA_INFORMATION, *POBJECT_DATA_INFORMATION;
+
+
+typedef struct _OBJECT_TYPE_INFORMATION
+{
+ UNICODE_STRING Name;
+ UNICODE_STRING Type;
+ ULONG TotalHandles;
+ ULONG ReferenceCount;
+} OBJECT_TYPE_INFORMATION, *POBJECT_TYPE_INFORMATION;
+
+// file information
+
+typedef struct _FILE_BASIC_INFORMATION
+{
+ TIME CreationTime;
+ TIME LastAccessTime;
+ TIME LastWriteTime;
+ TIME ChangeTime;
+ ULONG FileAttributes;
+} FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION;
+
+typedef struct _FILE_STANDARD_INFORMATION
+{
+ LARGE_INTEGER AllocationSize;
+ LARGE_INTEGER EndOfFile;
+ ULONG NumberOfLinks;
+ BOOLEAN DeletePending;
+ BOOLEAN Directory;
+} FILE_STANDARD_INFORMATION, *PFILE_STANDARD_INFORMATION;
+
+typedef struct _FILE_POSITION_INFORMATION
+{
+ LARGE_INTEGER CurrentByteOffset;
+} FILE_POSITION_INFORMATION, *PFILE_POSITION_INFORMATION;
+
+typedef struct _FILE_ALIGNMENT_INFORMATION
+{
+ ULONG AlignmentRequirement;
+} FILE_ALIGNMENT_INFORMATION, *PFILE_ALIGNMENT_INFORMATION;
+
+typedef struct _FILE_DISPOSITION_INFORMATION
+{
+ BOOLEAN DoDeleteFile;
+} FILE_DISPOSITION_INFORMATION, *PFILE_DISPOSITION_INFORMATION;
+
+typedef struct _FILE_END_OF_FILE_INFORMATION
+{
+ LARGE_INTEGER EndOfFile;
+} FILE_END_OF_FILE_INFORMATION, *PFILE_END_OF_FILE_INFORMATION;
+
+typedef struct _FILE_NETWORK_OPEN_INFORMATION
+{
+ TIME CreationTime;
+ TIME LastAccessTime;
+ TIME LastWriteTime;
+ TIME ChangeTime;
+ LARGE_INTEGER AllocationSize;
+ LARGE_INTEGER EndOfFile;
+ ULONG FileAttributes;
+} FILE_NETWORK_OPEN_INFORMATION, *PFILE_NETWORK_OPEN_INFORMATION;
+
+typedef struct _FILE_FULL_EA_INFORMATION
+{
+ ULONG NextEntryOffset;
+ UCHAR Flags;
+ UCHAR EaNameLength;
+ USHORT EaValueLength;
+ CHAR EaName[0];
+} FILE_FULL_EA_INFORMATION, *PFILE_FULL_EA_INFORMATION;
+
+
+typedef struct _FILE_EA_INFORMATION {
+ ULONG EaSize;
+} FILE_EA_INFORMATION, *PFILE_EA_INFORMATION;
+
+
+typedef struct _FILE_GET_EA_INFORMATION {
+ ULONG NextEntryOffset;
+ UCHAR EaNameLength;
+ CHAR EaName[0];
+} FILE_GET_EA_INFORMATION, *PFILE_GET_EA_INFORMATION;
+
+typedef struct _FILE_STREAM_INFORMATION {
+ ULONG NextEntryOffset;
+ ULONG StreamNameLength;
+ LARGE_INTEGER StreamSize;
+ LARGE_INTEGER StreamAllocationSize;
+ WCHAR StreamName[0];
+} FILE_STREAM_INFORMATION, *PFILE_STREAM_INFORMATION;
+
+typedef struct _FILE_ALLOCATION_INFORMATION {
+ LARGE_INTEGER AllocationSize;
+} FILE_ALLOCATION_INFORMATION, *PFILE_ALLOCATION_INFORMATION;
+
+typedef struct _FILE_NAME_INFORMATION {
+ ULONG FileNameLength;
+ WCHAR FileName[0];
+} FILE_NAME_INFORMATION, *PFILE_NAME_INFORMATION;
+
+typedef struct _FILE_NAMES_INFORMATION
+{
+ ULONG NextEntryOffset;
+ ULONG FileIndex;
+ ULONG FileNameLength;
+ WCHAR FileName[0];
+} FILE_NAMES_INFORMATION, *PFILE_NAMES_INFORMATION;
+
+
+typedef struct _FILE_RENAME_INFORMATION {
+ BOOLEAN Replace;
+ HANDLE RootDir;
+ ULONG FileNameLength;
+ WCHAR FileName[0];
+} FILE_RENAME_INFORMATION, *PFILE_RENAME_INFORMATION;
+
+
+typedef struct _FILE_INTERNAL_INFORMATION {
+ LARGE_INTEGER IndexNumber;
+} FILE_INTERNAL_INFORMATION, *PFILE_INTERNAL_INFORMATION;
+
+typedef struct _FILE_ACCESS_INFORMATION {
+ ACCESS_MASK AccessFlags;
+} FILE_ACCESS_INFORMATION, *PFILE_ACCESS_INFORMATION;
+
+
+typedef struct _FILE_MODE_INFORMATION {
+ ULONG Mode;
+} FILE_MODE_INFORMATION, *PFILE_MODE_INFORMATION;
+
+
+typedef struct _FILE_PIPE_INFORMATION {
+ ULONG ReadMode;
+ ULONG CompletionMode;
+} FILE_PIPE_INFORMATION, *PFILE_PIPE_INFORMATION;
+
+typedef struct _FILE_PIPE_LOCAL_INFORMATION {
+ ULONG NamedPipeType;
+ ULONG NamedPipeConfiguration;
+ ULONG MaximumInstances;
+ ULONG CurrentInstances;
+ ULONG InboundQuota;
+ ULONG ReadDataAvailable;
+ ULONG OutboundQuota;
+ ULONG WriteQuotaAvailable;
+ ULONG NamedPipeState;
+ ULONG NamedPipeEnd;
+} FILE_PIPE_LOCAL_INFORMATION, *PFILE_PIPE_LOCAL_INFORMATION;
+
+typedef struct _FILE_PIPE_REMOTE_INFORMATION {
+ LARGE_INTEGER CollectDataTime;
+ ULONG MaximumCollectionCount;
+} FILE_PIPE_REMOTE_INFORMATION, *PFILE_PIPE_REMOTE_INFORMATION;
+
+typedef struct _FILE_MAILSLOT_QUERY_INFORMATION {
+ ULONG MaxMessageSize;
+ ULONG Unknown; /* ?? */
+ ULONG NextSize;
+ ULONG MessageCount;
+ LARGE_INTEGER Timeout;
+} FILE_MAILSLOT_QUERY_INFORMATION, *PFILE_MAILSLOT_QUERY_INFORMATION;
+
+typedef struct _FILE_MAILSLOT_SET_INFORMATION {
+ LARGE_INTEGER Timeout;
+} FILE_MAILSLOT_SET_INFORMATION, *PFILE_MAILSLOT_SET_INFORMATION;
+
+typedef struct _FILE_COMPRESSION_INFORMATION {
+ LARGE_INTEGER CompressedFileSize;
+ USHORT CompressionFormat;
+ UCHAR CompressionUnitShift;
+ UCHAR ChunkShift;
+ UCHAR ClusterShift;
+ UCHAR Reserved[3];
+} FILE_COMPRESSION_INFORMATION, *PFILE_COMPRESSION_INFORMATION;
+
+typedef struct _FILE_ALL_INFORMATION {
+ FILE_BASIC_INFORMATION BasicInformation;
+ FILE_STANDARD_INFORMATION StandardInformation;
+ FILE_INTERNAL_INFORMATION InternalInformation;
+ FILE_EA_INFORMATION EaInformation;
+ FILE_ACCESS_INFORMATION AccessInformation;
+ FILE_POSITION_INFORMATION PositionInformation;
+ FILE_MODE_INFORMATION ModeInformation;
+ FILE_ALIGNMENT_INFORMATION AlignmentInformation;
+ FILE_NAME_INFORMATION NameInformation;
+} FILE_ALL_INFORMATION, *PFILE_ALL_INFORMATION;
+
+
+// file system information structures
+
+typedef struct _FILE_FS_DEVICE_INFORMATION {
+ DEVICE_TYPE DeviceType;
+ ULONG Characteristics;
+} FILE_FS_DEVICE_INFORMATION, *PFILE_FS_DEVICE_INFORMATION;
+
+
+typedef struct _FILE_FS_VOLUME_INFORMATION {
+ TIME VolumeCreationTime;
+ ULONG VolumeSerialNumber;
+ ULONG VolumeLabelLength;
+ BOOLEAN SupportsObjects;
+ WCHAR VolumeLabel[0];
+} FILE_FS_VOLUME_INFORMATION, *PFILE_FS_VOLUME_INFORMATION;
+
+typedef struct _FILE_FS_SIZE_INFORMATION {
+ LARGE_INTEGER TotalAllocationUnits;
+ LARGE_INTEGER AvailableAllocationUnits;
+ ULONG SectorsPerAllocationUnit;
+ ULONG BytesPerSector;
+} FILE_FS_SIZE_INFORMATION, *PFILE_FS_SIZE_INFORMATION;
+
+typedef struct _FILE_FS_ATTRIBUTE_INFORMATION {
+ ULONG FileSystemAttributes;
+ LONG MaximumComponentNameLength;
+ ULONG FileSystemNameLength;
+ WCHAR FileSystemName[0];
+} FILE_FS_ATTRIBUTE_INFORMATION, *PFILE_FS_ATTRIBUTE_INFORMATION;
+
+/*
+ FileSystemAttributes is one of the following values:
+
+ FILE_CASE_SENSITIVE_SEARCH 0x00000001
+ FILE_CASE_PRESERVED_NAMES 0x00000002
+ FILE_UNICODE_ON_DISK 0x00000004
+ FILE_PERSISTENT_ACLS 0x00000008
+ FILE_FILE_COMPRESSION 0x00000010
+ FILE_VOLUME_QUOTAS 0x00000020
+ FILE_VOLUME_IS_COMPRESSED 0x00008000
+*/
+typedef struct _FILE_FS_LABEL_INFORMATION {
+ ULONG VolumeLabelLength;
+ WCHAR VolumeLabel[0];
+} FILE_FS_LABEL_INFORMATION, *PFILE_FS_LABEL_INFORMATION;
+
+// read file scatter / write file scatter
+//FIXME I am a win32 struct aswell
+
+typedef union _FILE_SEGMENT_ELEMENT {
+ PVOID Buffer;
+ ULONG Alignment;
+}FILE_SEGMENT_ELEMENT, *PFILE_SEGMENT_ELEMENT;
+
+// directory information
+
+typedef struct _OBJDIR_INFORMATION {
+ UNICODE_STRING ObjectName;
+ UNICODE_STRING ObjectTypeName; // Directory, Device ...
+ UCHAR Data[0];
+} OBJDIR_INFORMATION, *POBJDIR_INFORMATION;
+
+
+typedef struct _FILE_DIRECTORY_INFORMATION {
+ ULONG NextEntryOffset;
+ ULONG FileIndex;
+ TIME CreationTime;
+ TIME LastAccessTime;
+ TIME LastWriteTime;
+ TIME ChangeTime;
+ LARGE_INTEGER EndOfFile;
+ LARGE_INTEGER AllocationSize;
+ ULONG FileAttributes;
+ ULONG FileNameLength;
+ WCHAR FileName[0];
+} FILE_DIRECTORY_INFORMATION, *PFILE_DIRECTORY_INFORMATION;
+
+typedef struct _FILE_FULL_DIRECTORY_INFORMATION {
+ ULONG NextEntryOffset;
+ ULONG FileIndex;
+ TIME CreationTime;
+ TIME LastAccessTime;
+ TIME LastWriteTime;
+ TIME ChangeTime;
+ LARGE_INTEGER EndOfFile;
+ LARGE_INTEGER AllocationSize;
+ ULONG FileAttributes;
+ ULONG FileNameLength;
+ ULONG EaSize;
+ WCHAR FileName[0]; // variable size
+} FILE_FULL_DIRECTORY_INFORMATION, *PFILE_FULL_DIRECTORY_INFORMATION,
+ FILE_FULL_DIR_INFORMATION, *PFILE_FULL_DIR_INFORMATION;
+
+
+typedef struct _FILE_BOTH_DIRECTORY_INFORMATION {
+ ULONG NextEntryOffset;
+ ULONG FileIndex;
+ TIME CreationTime;
+ TIME LastAccessTime;
+ TIME LastWriteTime;
+ TIME ChangeTime;
+ LARGE_INTEGER EndOfFile;
+ LARGE_INTEGER AllocationSize;
+ ULONG FileAttributes;
+ ULONG FileNameLength;
+ ULONG EaSize;
+ CHAR ShortNameLength;
+ WCHAR ShortName[12]; // 8.3 name
+ WCHAR FileName[0];
+} FILE_BOTH_DIRECTORY_INFORMATION, *PFILE_BOTH_DIRECTORY_INFORMATION,
+ FILE_BOTH_DIR_INFORMATION, *PFILE_BOTH_DIR_INFORMATION;
+
+
+/*
+ NotifyFilter / CompletionFilter:
+
+ FILE_NOTIFY_CHANGE_FILE_NAME 0x00000001
+ FILE_NOTIFY_CHANGE_DIR_NAME 0x00000002
+ FILE_NOTIFY_CHANGE_NAME 0x00000003
+ FILE_NOTIFY_CHANGE_ATTRIBUTES 0x00000004
+ FILE_NOTIFY_CHANGE_SIZE 0x00000008
+ FILE_NOTIFY_CHANGE_LAST_WRITE 0x00000010
+ FILE_NOTIFY_CHANGE_LAST_ACCESS 0x00000020
+ FILE_NOTIFY_CHANGE_CREATION 0x00000040
+ FILE_NOTIFY_CHANGE_EA 0x00000080
+ FILE_NOTIFY_CHANGE_SECURITY 0x00000100
+ FILE_NOTIFY_CHANGE_STREAM_NAME 0x00000200
+ FILE_NOTIFY_CHANGE_STREAM_SIZE 0x00000400
+ FILE_NOTIFY_CHANGE_STREAM_WRITE 0x00000800
+*/
+
+typedef struct _FILE_NOTIFY_INFORMATION {
+ ULONG Action;
+ ULONG FileNameLength;
+ WCHAR FileName[0];
+} FILE_NOTIFY_INFORMATION;
+
+
+/*
+ Action is one of the following values:
+
+ FILE_ACTION_ADDED 0x00000001
+ FILE_ACTION_REMOVED 0x00000002
+ FILE_ACTION_MODIFIED 0x00000003
+ FILE_ACTION_RENAMED_OLD_NAME 0x00000004
+ FILE_ACTION_RENAMED_NEW_NAME 0x00000005
+ FILE_ACTION_ADDED_STREAM 0x00000006
+ FILE_ACTION_REMOVED_STREAM 0x00000007
+ FILE_ACTION_MODIFIED_STREAM 0x00000008
+
+*/
+
+
+// File System Control commands ( related to defragging )
+
+#define FSCTL_READ_MFT_RECORD 0x90068 // NTFS only
+#define FSCTL_GET_VOLUME_BITMAP 0x9006F
+#define FSCTL_GET_RETRIEVAL_POINTERS 0x90073
+#define FSCTL_MOVE_FILE 0x90074
+
+typedef struct _MAPPING_PAIR
+{
+ ULONGLONG Vcn;
+ ULONGLONG Lcn;
+} MAPPING_PAIR, *PMAPPING_PAIR;
+
+typedef struct _GET_RETRIEVAL_DESCRIPTOR
+{
+ ULONG NumberOfPairs;
+ ULONGLONG StartVcn;
+ MAPPING_PAIR Pair[0]; // variable size
+} GET_RETRIEVAL_DESCRIPTOR, *PGET_RETRIEVAL_DESCRIPTOR;
+
+typedef struct _BITMAP_DESCRIPTOR
+{
+ ULONGLONG StartLcn;
+ ULONGLONG ClustersToEndOfVol;
+ BYTE Map[0]; // variable size
+} BITMAP_DESCRIPTOR, *PBITMAP_DESCRIPTOR;
+
+typedef struct _MOVEFILE_DESCRIPTOR
+{
+ HANDLE FileHandle;
+ ULONG Reserved;
+ LARGE_INTEGER StartVcn;
+ LARGE_INTEGER TargetLcn;
+ ULONG NumVcns;
+ ULONG Reserved1;
+} MOVEFILE_DESCRIPTOR, *PMOVEFILE_DESCRIPTOR;
+
+
+
+//typedef enum _TIMER_TYPE
+//{
+// NotificationTimer,
+// SynchronizationTimer
+//} TIMER_TYPE;
+
+typedef struct _TIMER_BASIC_INFORMATION
+{
+ LARGE_INTEGER TimeRemaining;
+ BOOLEAN SignalState;
+} TIMER_BASIC_INFORMATION, *PTIMER_BASIC_INFORMATION;
+
+typedef enum _TIMER_INFORMATION_CLASS
+{
+ TimerBasicInformation
+} TIMER_INFORMATION_CLASS;
+
+typedef
+struct _LPC_PORT_BASIC_INFORMATION
+{
+ DWORD Unknown0;
+ DWORD Unknown1;
+ DWORD Unknown2;
+ DWORD Unknown3;
+ DWORD Unknown4;
+ DWORD Unknown5;
+ DWORD Unknown6;
+ DWORD Unknown7;
+ DWORD Unknown8;
+ DWORD Unknown9;
+ DWORD Unknown10;
+ DWORD Unknown11;
+ DWORD Unknown12;
+ DWORD Unknown13;
+
+} LPC_PORT_BASIC_INFORMATION, * PLPC_PORT_BASIC_INFORMATION;
+
+typedef struct _SECTION_BASIC_INFORMATION
+{
+ PVOID BaseAddress;
+ ULONG Attributes;
+ LARGE_INTEGER Size;
+} SECTION_BASIC_INFORMATION, *PSECTION_BASIC_INFORMATION;
+
+typedef struct _SECTION_IMAGE_INFORMATION
+{
+ PVOID EntryPoint;
+ ULONG Unknown1;
+ ULONG StackReserve;
+ ULONG StackCommit;
+ ULONG Subsystem;
+ USHORT MinorSubsystemVersion;
+ USHORT MajorSubsystemVersion;
+ ULONG Unknown2;
+ ULONG Characteristics;
+ USHORT ImageNumber;
+ BOOLEAN Executable;
+ UCHAR Unknown3;
+ ULONG Unknown4[3];
+} SECTION_IMAGE_INFORMATION, *PSECTION_IMAGE_INFORMATION;
+
+typedef enum _SECTION_INFORMATION_CLASS
+{
+ SectionBasicInformation,
+ SectionImageInformation,
+} SECTION_INFORMATION_CLASS;
+
+#endif
--- /dev/null
+#ifndef __INCLUDE_NAPI_CORE_H
+#define __INCLUDE_NAPI_CORE_H
+
+#include "../ntoskrnl/include/internal/ke.h"
+
+#define MM_CORE_DUMP_HEADER_MAGIC (0xdeafbead)
+#define MM_CORE_DUMP_HEADER_VERSION (0x1)
+#define MM_CORE_DUMP_TYPE_MINIMAL (0x1)
+#define MM_CORE_DUMP_TYPE_FULL (0x2)
+
+typedef struct _MM_CORE_DUMP_HEADER
+{
+ ULONG Magic;
+ ULONG Version;
+ ULONG Type;
+ KTRAP_FRAME TrapFrame;
+ ULONG BugCheckCode;
+ ULONG BugCheckParameters[4];
+ PVOID FaultingStackBase;
+ ULONG FaultingStackSize;
+ ULONG PhysicalMemorySize;
+} MM_CORE_DUMP_HEADER, *PMM_CORE_DUMP_HEADER;
+
+typedef struct _MM_DUMP_POINTERS
+{
+ PVOID Context;
+ NTSTATUS (*DeviceInit)(PVOID Context);
+ NTSTATUS (*DeviceWrite)(PVOID Context, ULONG Block, PMDL Mdl);
+ NTSTATUS (*DeviceFinish)(PVOID Context);
+} MM_DUMP_POINTERS, *PMM_DUMP_POINTERS;
+
+#define FSCTL_GET_DUMP_BLOCK_MAP (('R' << 24) | 0xF1)
+#define IOCTL_GET_DUMP_POINTERS (('R' << 24) | 0xF2)
+
+#endif /* __INCLUDE_NAPI_CORE_H */
--- /dev/null
+#ifndef __INCLUDE_NAPI_DBG_H
+#define __INCLUDE_NAPI_DBG_H
+
+#include <napi/lpc.h>
+
+#define DBG_EVENT_EXCEPTION (1)
+#define DBG_EVENT_CREATE_THREAD (2)
+#define DBG_EVENT_CREATE_PROCESS (3)
+#define DBG_EVENT_EXIT_THREAD (4)
+#define DBG_EVENT_EXIT_PROCESS (5)
+#define DBG_EVENT_LOAD_DLL (6)
+#define DBG_EVENT_UNLOAD_DLL (7)
+
+typedef struct _LPC_DBG_MESSAGE
+{
+ LPC_MESSAGE_HEADER Header;
+ ULONG Type;
+ ULONG Status;
+ union
+ {
+ struct
+ {
+ EXCEPTION_RECORD ExceptionRecord;
+ ULONG FirstChance;
+ } Exception;
+ struct
+ {
+ ULONG Reserved;
+ PVOID StartAddress;
+ } CreateThread;
+ struct
+ {
+ ULONG Reserved;
+ HANDLE FileHandle;
+ PVOID Base;
+ ULONG PointerToSymbolTable;
+ ULONG NumberOfSymbols;
+ ULONG Reserved2;
+ PVOID EntryPoint;
+ } CreateProcess;
+ struct
+ {
+ ULONG ExitCode;
+ } ExitThread;
+ struct
+ {
+ ULONG ExitCode;
+ } ExitProcess;
+ struct
+ {
+ HANDLE FileHandle;
+ PVOID Base;
+ ULONG PointerToSymbolTable;
+ ULONG NumberOfSymbols;
+ } LoadDll;
+ struct
+ {
+ PVOID Base;
+ } UnloadDll;
+ } Data;
+} LPC_DBG_MESSAGE, *PLPC_DBG_MESSAGE;
+
+#endif /* __INCLUDE_NAPI_DBG_H */
--- /dev/null
+#ifndef _ASM_SEGMENT_H
+#define _ASM_SEGMENT_H
+
+#define KERNEL_CS (0x8)
+#define KERNEL_DS (0x10)
+#define USER_CS (0x18 + 0x3)
+#define USER_DS (0x20 + 0x3)
+#define RESERVED_FOR_TSS (0x28)
+#define PCR_SELECTOR (0x30)
+#define TEB_SELECTOR (0x38 + 0x3)
+
+//#define USER_CS (0x8+0x3)
+//#define USER_DS (0x10+0x3)
+//#define ZERO_DS 0x18
+//#define KERNEL_CS 0x20
+//#define KERNEL_DS 0x28
+
+#ifndef __ASSEMBLY__
+
+/*
+ * Uh, these should become the main single-value transfer routines..
+ * They automatically use the right size if we just have the right
+ * pointer type..
+ */
+#define put_user(x,ptr) __put_user((unsigned long)(x),(ptr),sizeof(*(ptr)))
+#define get_user(ptr) ((__typeof__(*(ptr)))__get_user((ptr),sizeof(*(ptr))))
+
+/*
+ * This is a silly but good way to make sure that
+ * the __put_user function is indeed always optimized,
+ * and that we use the correct sizes..
+ */
+extern int bad_user_access_length(void);
+
+/*
+ * dummy pointer type structure.. gcc won't try to do something strange
+ * this way..
+ */
+struct __segment_dummy { unsigned long a[100]; };
+#define __sd(x) ((struct __segment_dummy *) (x))
+#define __const_sd(x) ((const struct __segment_dummy *) (x))
+
+static inline void __put_user(unsigned long x, void * y, int size)
+{
+ switch (size) {
+ case 1:
+ __asm__ ("movb %b1,%%fs:%0" \
+ :"=m" (*__sd(y)) \
+ :"iq" ((unsigned char) x), "m" (*__sd(y)));
+ break;
+ case 2:
+ __asm__ ("movw %w1,%%fs:%0" \
+ :"=m" (*__sd(y)) \
+ :"ir" ((unsigned short) x), "m" (*__sd(y)));
+ break;
+ case 4:
+ __asm__ ("movl %1,%%fs:%0" \
+ :"=m" (*__sd(y)) \
+ :"ir" (x), "m" (*__sd(y)));
+ break;
+ default:
+ bad_user_access_length();
+ }
+}
+
+static inline unsigned long __get_user(const void * y, int size)
+{
+ unsigned long result;
+
+ switch (size) {
+ case 1:
+ __asm__ ("movb %%fs:%1,%b0" \
+ :"=q" (result) \
+ :"m" (*__const_sd(y)));
+ return (unsigned char) result;
+ case 2:
+ __asm__ ("movw %%fs:%1,%w0" \
+ :"=r" (result) \
+ :"m" (*__const_sd(y)));
+ return (unsigned short) result;
+ case 4:
+ __asm__ ("movl %%fs:%1,%0" \
+ :"=r" (result) \
+ :"m" (*__const_sd(y)));
+ return result;
+ default:
+ return bad_user_access_length();
+ }
+}
+
+static inline void __generic_memcpy_tofs(void * to, const void * from, unsigned long n)
+{
+ __asm__ volatile
+ (" cld \
+ push %%es \
+ push %%fs \
+ cmpl $3,%0 \
+ pop %%es \
+ jbe 1f \
+ movl %%edi,%%ecx \
+ negl %%ecx \
+ andl $3,%%ecx \
+ subl %%ecx,%0 \
+ rep; movsb \
+ movl %0,%%ecx \
+ shrl $2,%%ecx \
+ rep; movsl \
+ andl $3,%0 \
+ 1: movl %0,%%ecx \
+ rep; movsb \
+ pop %%es" \
+ :"=abd" (n) \
+ :"0" (n),"D" ((long) to),"S" ((long) from) \
+ :"cx","di","si");
+}
+
+static inline void __constant_memcpy_tofs(void * to, const void * from, unsigned long n)
+{
+ switch (n) {
+ case 0:
+ return;
+ case 1:
+ __put_user(*(const char *) from, (char *) to, 1);
+ return;
+ case 2:
+ __put_user(*(const short *) from, (short *) to, 2);
+ return;
+ case 3:
+ __put_user(*(const short *) from, (short *) to, 2);
+ __put_user(*(2+(const char *) from), 2+(char *) to, 1);
+ return;
+ case 4:
+ __put_user(*(const int *) from, (int *) to, 4);
+ return;
+ case 8:
+ __put_user(*(const int *) from, (int *) to, 4);
+ __put_user(*(1+(const int *) from), 1+(int *) to, 4);
+ return;
+ case 12:
+ __put_user(*(const int *) from, (int *) to, 4);
+ __put_user(*(1+(const int *) from), 1+(int *) to, 4);
+ __put_user(*(2+(const int *) from), 2+(int *) to, 4);
+ return;
+ case 16:
+ __put_user(*(const int *) from, (int *) to, 4);
+ __put_user(*(1+(const int *) from), 1+(int *) to, 4);
+ __put_user(*(2+(const int *) from), 2+(int *) to, 4);
+ __put_user(*(3+(const int *) from), 3+(int *) to, 4);
+ return;
+ }
+#define COMMON(x) \
+__asm__("cld\n\t" \
+ "push %%es\n\t" \
+ "push %%fs\n\t" \
+ "pop %%es\n\t" \
+ "rep ; movsl\n\t" \
+ x \
+ "pop %%es" \
+ : /* no outputs */ \
+ :"c" (n/4),"D" ((long) to),"S" ((long) from) \
+ :"cx","di","si")
+
+ switch (n % 4) {
+ case 0:
+ COMMON("");
+ return;
+ case 1:
+ COMMON("movsb\n\t");
+ return;
+ case 2:
+ COMMON("movsw\n\t");
+ return;
+ case 3:
+ COMMON("movsw\n\tmovsb\n\t");
+ return;
+ }
+#undef COMMON
+}
+
+static inline void __generic_memcpy_fromfs(void * to, const void * from, unsigned long n)
+{
+ __asm__ volatile
+ (" cld \
+ cmpl $3,%0 \
+ jbe 1f \
+ movl %%edi,%%ecx \
+ negl %%ecx \
+ andl $3,%%ecx \
+ subl %%ecx,%0 \
+ fs; rep; movsb \
+ movl %0,%%ecx \
+ shrl $2,%%ecx \
+ fs; rep; movsl \
+ andl $3,%0 \
+ 1: movl %0,%%ecx \
+ fs; rep; movsb"
+ :"=abd" (n)
+ :"0" (n),"D" ((long) to),"S" ((long) from)
+ :"cx","di","si", "memory");
+}
+
+static inline void __constant_memcpy_fromfs(void * to, const void * from, unsigned long n)
+{
+ switch (n) {
+ case 0:
+ return;
+ case 1:
+ *(char *)to = __get_user((const char *) from, 1);
+ return;
+ case 2:
+ *(short *)to = __get_user((const short *) from, 2);
+ return;
+ case 3:
+ *(short *) to = __get_user((const short *) from, 2);
+ *((char *) to + 2) = __get_user(2+(const char *) from, 1);
+ return;
+ case 4:
+ *(int *) to = __get_user((const int *) from, 4);
+ return;
+ case 8:
+ *(int *) to = __get_user((const int *) from, 4);
+ *(1+(int *) to) = __get_user(1+(const int *) from, 4);
+ return;
+ case 12:
+ *(int *) to = __get_user((const int *) from, 4);
+ *(1+(int *) to) = __get_user(1+(const int *) from, 4);
+ *(2+(int *) to) = __get_user(2+(const int *) from, 4);
+ return;
+ case 16:
+ *(int *) to = __get_user((const int *) from, 4);
+ *(1+(int *) to) = __get_user(1+(const int *) from, 4);
+ *(2+(int *) to) = __get_user(2+(const int *) from, 4);
+ *(3+(int *) to) = __get_user(3+(const int *) from, 4);
+ return;
+ }
+#define COMMON(x) \
+__asm__("cld\n\t" \
+ "rep ; fs ; movsl\n\t" \
+ x \
+ : /* no outputs */ \
+ :"c" (n/4),"D" ((long) to),"S" ((long) from) \
+ :"cx","di","si","memory")
+
+ switch (n % 4) {
+ case 0:
+ COMMON("");
+ return;
+ case 1:
+ COMMON("fs ; movsb");
+ return;
+ case 2:
+ COMMON("fs ; movsw");
+ return;
+ case 3:
+ COMMON("fs ; movsw\n\tfs ; movsb");
+ return;
+ }
+#undef COMMON
+}
+
+#define memcpy_fromfs(to, from, n) \
+(__builtin_constant_p(n) ? \
+ __constant_memcpy_fromfs((to),(from),(n)) : \
+ __generic_memcpy_fromfs((to),(from),(n)))
+
+#define memcpy_tofs(to, from, n) \
+(__builtin_constant_p(n) ? \
+ __constant_memcpy_tofs((to),(from),(n)) : \
+ __generic_memcpy_tofs((to),(from),(n)))
+
+/*
+ * These are deprecated..
+ *
+ * Use "put_user()" and "get_user()" with the proper pointer types instead.
+ */
+
+#define get_fs_byte(addr) __get_user((const unsigned char *)(addr),1)
+#define get_fs_word(addr) __get_user((const unsigned short *)(addr),2)
+#define get_fs_long(addr) __get_user((const unsigned int *)(addr),4)
+
+#define put_fs_byte(x,addr) __put_user((x),(unsigned char *)(addr),1)
+#define put_fs_word(x,addr) __put_user((x),(unsigned short *)(addr),2)
+#define put_fs_long(x,addr) __put_user((x),(unsigned int *)(addr),4)
+
+#ifdef WE_REALLY_WANT_TO_USE_A_BROKEN_INTERFACE
+
+static inline unsigned short get_user_word(const short *addr)
+{
+ return __get_user(addr, 2);
+}
+
+static inline unsigned char get_user_byte(const char * addr)
+{
+ return __get_user(addr,1);
+}
+
+static inline unsigned long get_user_long(const int *addr)
+{
+ return __get_user(addr, 4);
+}
+
+static inline void put_user_byte(char val,char *addr)
+{
+ __put_user(val, addr, 1);
+}
+
+static inline void put_user_word(short val,short * addr)
+{
+ __put_user(val, addr, 2);
+}
+
+static inline void put_user_long(unsigned long val,int * addr)
+{
+ __put_user(val, addr, 4);
+}
+
+#endif
+
+/*
+ * Someone who knows GNU asm better than I should double check the following.
+ * It seems to work, but I don't know if I'm doing something subtly wrong.
+ * --- TYT, 11/24/91
+ * [ nothing wrong here, Linus: I just changed the ax to be any reg ]
+ */
+
+static inline unsigned long get_fs(void)
+{
+ unsigned long _v;
+ __asm__("mov %%fs,%w0":"=r" (_v):"0" (0));
+ return _v;
+}
+
+static inline unsigned long get_ds(void)
+{
+ unsigned long _v;
+ __asm__("mov %%ds,%w0":"=r" (_v):"0" (0));
+ return _v;
+}
+
+static inline void set_fs(unsigned long val)
+{
+ __asm__ __volatile__("mov %w0,%%fs": /* no output */ :"r" (val));
+}
+
+static inline void set_ds(unsigned long val)
+{
+ __asm__ __volatile__("mov %w0,%%ds": /* no output */ :"r" (val));
+}
+
+
+#endif /* __ASSEMBLY__ */
+
+#endif /* _ASM_SEGMENT_H */
--- /dev/null
+#ifndef __INCLUDE_NAPI_LPC_H
+#define __INCLUDE_NAPI_LPC_H
+
+#include <ntos/security.h>
+
+#define MAX_MESSAGE_DATA (0x130)
+
+typedef enum
+{
+ UNUSED_MSG_TYPE = 0x0, /* ReactOS */
+ LPC_NEW_MESSAGE = 0x0, /* NT */
+ LPC_REQUEST = 0x1,
+ LPC_REPLY = 0x2,
+ LPC_DATAGRAM = 0x3,
+ LPC_LOST_REPLY = 0x4,
+ LPC_PORT_CLOSED = 0x5,
+ LPC_CLIENT_DIED = 0x6,
+ LPC_EXCEPTION = 0x7,
+ LPC_DEBUG_EVENT = 0x8,
+ LPC_ERROR_EVENT = 0x9,
+ LPC_CONNECTION_REQUEST = 0xa,
+ LPC_CONNECTION_REFUSED = 0xb
+
+} LPC_TYPE, *PLPC_TYPE;
+
+typedef struct _LPC_SECTION_WRITE
+{
+ ULONG Length;
+ HANDLE SectionHandle;
+ ULONG SectionOffset;
+ ULONG ViewSize;
+ PVOID ViewBase;
+ PVOID TargetViewBase;
+} LPC_SECTION_WRITE, *PLPC_SECTION_WRITE;
+
+typedef struct _LPC_SECTION_READ
+{
+ ULONG Length;
+ ULONG ViewSize;
+ PVOID ViewBase;
+} LPC_SECTION_READ, *PLPC_SECTION_READ;
+
+typedef struct _LPC_MESSAGE_HEADER
+{
+ USHORT DataSize;
+ USHORT MessageSize;
+// LPC_TYPE MessageType;
+ USHORT MessageType;
+ USHORT VirtualRangesOffset;
+ CLIENT_ID Cid;
+ ULONG MessageId;
+ ULONG SharedSectionSize;
+} LPC_MESSAGE_HEADER, *PLPC_MESSAGE_HEADER;
+
+typedef struct _LPC_TERMINATION_MESSAGE
+{
+ LPC_MESSAGE_HEADER Header;
+ TIME CreationTime;
+} LPC_TERMINATION_MESSAGE, *PLPC_TERMINATION_MESSAGE;
+
+typedef struct _LPC_DEBUG_MESSAGE
+{
+ LPC_MESSAGE_HEADER Header;
+ ULONG EventCode;
+ ULONG Status;
+ union {
+ struct {
+ EXCEPTION_RECORD ExceptionRecord;
+ ULONG FirstChance;
+ } Exception;
+ struct {
+ ULONG Reserved;
+ PVOID StartAddress;
+ } CreateThread;
+ struct {
+ ULONG Reserved;
+ HANDLE FileHandle;
+ PVOID Base;
+ ULONG PointerToSymbolTable;
+ ULONG NumberOfSymbols;
+ ULONG Reserved2;
+ PVOID EntryPoint;
+ } CreateProcess;
+ struct {
+ ULONG ExitCode;
+ } ExitThread;
+ struct {
+ ULONG ExitCode;
+ } ExitProcess;
+ struct {
+ HANDLE FileHandle;
+ PVOID Base;
+ ULONG PointerToSymbolTable;
+ ULONG NumberOfSymbols;
+ } LoadDll;
+ struct {
+ PVOID Base;
+ } UnloadDll;
+#ifdef ANONYMOUSUNIONS
+ };
+#else
+ } u;
+#endif
+} LPC_DEBUG_MESSAGE, * PLPC_DEBUG_MESSAGE;
+
+typedef LPC_MESSAGE_HEADER LPC_MESSAGE, *PLPC_MESSAGE;
+
+typedef struct _LPC_MAX_MESSAGE
+{
+ LPC_MESSAGE_HEADER Header;
+ BYTE Data[MAX_MESSAGE_DATA];
+} LPC_MAX_MESSAGE, *PLPC_MAX_MESSAGE;
+
+#define PORT_MESSAGE_TYPE(m) (LPC_TYPE)((m).Header.MessageType)
+
+#ifndef __USE_NT_LPC__
+NTSTATUS STDCALL NtAcceptConnectPort (PHANDLE PortHandle,
+ HANDLE NamedPortHandle,
+ PLPC_MESSAGE ServerReply,
+ BOOLEAN AcceptIt,
+ PLPC_SECTION_WRITE WriteMap,
+ PLPC_SECTION_READ ReadMap);
+#else
+NTSTATUS STDCALL NtAcceptConnectPort (PHANDLE PortHandle,
+ ULONG PortIdentifier,
+ PLPC_MESSAGE ServerReply,
+ BOOLEAN AcceptIt,
+ PLPC_SECTION_WRITE WriteMap,
+ PLPC_SECTION_READ ReadMap);
+#endif /* ndef __USE_NT_LPC__ */
+
+NTSTATUS STDCALL NtCompleteConnectPort (HANDLE PortHandle);
+
+NTSTATUS STDCALL NtConnectPort(PHANDLE PortHandle,
+ PUNICODE_STRING PortName,
+ PSECURITY_QUALITY_OF_SERVICE SecurityQos,
+ PLPC_SECTION_WRITE SectionInfo,
+ PLPC_SECTION_READ MapInfo,
+ PULONG MaxMessageSize,
+ PVOID ConnectInfo,
+ PULONG ConnectInfoLength);
+
+NTSTATUS STDCALL NtReplyWaitReplyPort (HANDLE PortHandle,
+ PLPC_MESSAGE ReplyMessage);
+
+NTSTATUS STDCALL NtCreatePort(PHANDLE PortHandle,
+ POBJECT_ATTRIBUTES ObjectAttributes,
+ ULONG MaxConnectInfoLength,
+ ULONG MaxDataLength,
+ ULONG NPMessageQueueSize OPTIONAL);
+
+NTSTATUS STDCALL NtCreateWaitablePort(PHANDLE PortHandle,
+ POBJECT_ATTRIBUTES ObjectAttributes,
+ ULONG MaxConnectInfoLength,
+ ULONG MaxDataLength,
+ ULONG NPMessageQueueSize OPTIONAL);
+
+NTSTATUS STDCALL NtImpersonateClientOfPort (HANDLE PortHandle,
+ PLPC_MESSAGE ClientMessage);
+
+NTSTATUS STDCALL NtListenPort (HANDLE PortHandle,
+ PLPC_MESSAGE LpcMessage);
+
+NTSTATUS STDCALL NtQueryInformationPort (HANDLE PortHandle,
+ CINT PortInformationClass,
+ PVOID PortInformation,
+ ULONG PortInformationLength,
+ PULONG ReturnLength);
+NTSTATUS STDCALL NtReplyPort (HANDLE PortHandle,
+ PLPC_MESSAGE LpcReply);
+NTSTATUS STDCALL NtReplyWaitReceivePort (HANDLE PortHandle,
+ PULONG PortId,
+ PLPC_MESSAGE MessageReply,
+ PLPC_MESSAGE MessageRequest);
+NTSTATUS STDCALL NtRequestPort (HANDLE PortHandle,
+ PLPC_MESSAGE LpcMessage);
+
+NTSTATUS STDCALL NtRequestWaitReplyPort (HANDLE PortHandle,
+ PLPC_MESSAGE LpcReply,
+ PLPC_MESSAGE LpcRequest);
+
+NTSTATUS STDCALL NtReadRequestData (HANDLE PortHandle,
+ PLPC_MESSAGE Message,
+ ULONG Index,
+ PVOID Buffer,
+ ULONG BufferLength,
+ PULONG ReturnLength);
+
+NTSTATUS STDCALL NtWriteRequestData (HANDLE PortHandle,
+ PLPC_MESSAGE Message,
+ ULONG Index,
+ PVOID Buffer,
+ ULONG BufferLength,
+ PULONG ReturnLength);
+
+
+#endif /* __INCLUDE_NAPI_LPC_H */
--- /dev/null
+#ifndef __INCLUDE_NAPI_NPIPE_H
+#define __INCLUDE_NAPI_NPIPE_H
+
+#include <ddk/ntddk.h>
+
+/*
+ * FUNCTION: ZwCreateNamedPipeFile creates named pipe
+ * ARGUMENTS:
+ * NamedPipeFileHandle (OUT) = Caller supplied storage for the
+ * resulting handle
+ * DesiredAccess = Specifies the type of access that the caller
+ * requires to the file boject
+ * ObjectAttributes = Points to a structure that specifies the
+ * object attributes.
+ * IoStatusBlock = Points to a variable that receives the final
+ * completion status and information
+ * ShareAccess = Specifies the limitations on sharing of the file.
+ * This parameter can be zero or any compatible
+ * combination of the following flags
+ * FILE_SHARE_READ
+ * FILE_SHARE_WRITE
+ * CreateDisposition = Specifies what to do depending on whether
+ * the file already exists. This must be one of
+ * the following values
+ * FILE_OPEN
+ * FILE_CREATE
+ * FILE_OPEN_IF
+ * CreateOptions = Specifies the options to be applied when
+ * creating or opening the file, as a compatible
+ * combination of the following flags
+ * FILE_WRITE_THROUGH
+ * FILE_SYNCHRONOUS_IO_ALERT
+ * FILE_SYNCHRONOUS_IO_NONALERT
+ * TypeMessage = Specifies whether the data written to the pipe is
+ * interpreted as a sequence of messages or as a
+ * stream of bytes
+ * ReadModeMessage = Specifies whether the data read from the pipe
+ * is interpreted as a sequence of messages or as
+ * a stream of bytes
+ * NonBlocking = Specifies whether non-blocking mode is enabled
+ * MaxInstances = Specifies the maximum number of instancs that can
+ * be created for this pipe
+ * InBufferSize = Specifies the number of bytes to reserve for the
+ * input buffer
+ * OutBufferSize = Specifies the number of bytes to reserve for the
+ * output buffer
+ * DefaultTimeout = Optionally points to a variable that specifies
+ * the default timeout value in units of
+ * 100-nanoseconds.
+ * REMARKS: This funciton maps to the win32 function CreateNamedPipe
+ * RETURNS:
+ * Status
+ */
+
+NTSTATUS STDCALL NtCreateNamedPipeFile(OUT PHANDLE NamedPipeFileHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG ShareAccess,
+ IN ULONG CreateDisposition,
+ IN ULONG CreateOptions,
+ IN BOOLEAN WriteModeMessage,
+ IN BOOLEAN ReadModeMessage,
+ IN BOOLEAN NonBlocking,
+ IN ULONG MaxInstances,
+ IN ULONG InBufferSize,
+ IN ULONG OutBufferSize,
+ IN PLARGE_INTEGER DefaultTimeOut);
+NTSTATUS STDCALL ZwCreateNamedPipeFile(OUT PHANDLE NamedPipeFileHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG ShareAccess,
+ IN ULONG CreateDisposition,
+ IN ULONG CreateOptions,
+ IN BOOLEAN WriteModeMessage,
+ IN BOOLEAN ReadModeMessage,
+ IN BOOLEAN NonBlocking,
+ IN ULONG MaxInstances,
+ IN ULONG InBufferSize,
+ IN ULONG OutBufferSize,
+ IN PLARGE_INTEGER DefaultTimeOut);
+
+#define FSCTL_PIPE_ASSIGN_EVENT \
+ CTL_CODE(FILE_DEVICE_NAMED_PIPE, 0, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+#define FSCTL_PIPE_DISCONNECT \
+ CTL_CODE(FILE_DEVICE_NAMED_PIPE, 1, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+#define FSCTL_PIPE_LISTEN \
+ CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+#define FSCTL_PIPE_PEEK \
+ CTL_CODE(FILE_DEVICE_NAMED_PIPE, 3, METHOD_BUFFERED, FILE_READ_DATA)
+
+#define FSCTL_PIPE_QUERY_EVENT \
+ CTL_CODE(FILE_DEVICE_NAMED_PIPE, 4, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+#define FSCTL_PIPE_TRANSCEIVE \
+ CTL_CODE(FILE_DEVICE_NAMED_PIPE, 5, METHOD_NEITHER, FILE_READ_DATA | FILE_WRITE_DATA)
+
+#define FSCTL_PIPE_WAIT \
+ CTL_CODE(FILE_DEVICE_NAMED_PIPE, 6, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+#define FSCTL_PIPE_IMPERSONATE \
+ CTL_CODE(FILE_DEVICE_NAMED_PIPE, 7, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+#define FSCTL_PIPE_SET_CLIENT_PROCESS \
+ CTL_CODE(FILE_DEVICE_NAMED_PIPE, 8, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+#define FSCTL_PIPE_QUERY_CLIENT_PROCESS \
+ CTL_CODE(FILE_DEVICE_NAMED_PIPE, 9, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+#define FSCTL_PIPE_GET_STATE \
+ CTL_CODE(FILE_DEVICE_NAMED_PIPE, 10, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+#define FSCTL_PIPE_SET_STATE \
+ CTL_CODE(FILE_DEVICE_NAMED_PIPE, 11, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+#define FSCTL_PIPE_INTERNAL_READ \
+ CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2045, METHOD_BUFFERED, FILE_READ_DATA)
+
+#define FSCTL_PIPE_INTERNAL_WRITE \
+ CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2046, METHOD_BUFFERED, FILE_WRITE_DATA)
+
+#define FSCTL_PIPE_INTERNAL_TRANSCEIVE \
+ CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2047, METHOD_NEITHER, FILE_READ_DATA | FILE_WRITE_DATA)
+
+#define FSCTL_PIPE_INTERNAL_READ_OVFLOW \
+ CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2048, METHOD_BUFFERED, FILE_READ_DATA)
+
+
+typedef struct _NPFS_WAIT_PIPE
+{
+ LARGE_INTEGER Timeout;
+} NPFS_WAIT_PIPE, *PNPFS_WAIT_PIPE;
+
+typedef struct _NPFS_LISTEN
+{
+} NPFS_LISTEN, *PNPFS_LISTEN;
+
+typedef struct _NPFS_SET_STATE
+{
+ BOOLEAN WriteModeMessage;
+ BOOLEAN ReadModeMessage;
+ BOOLEAN NonBlocking;
+ ULONG InBufferSize;
+ ULONG OutBufferSize;
+ LARGE_INTEGER Timeout;
+} NPFS_SET_STATE, *PNPFS_SET_STATE;
+
+typedef struct _NPFS_GET_STATE
+{
+ BOOLEAN WriteModeMessage;
+ BOOLEAN ReadModeMessage;
+ BOOLEAN NonBlocking;
+ ULONG InBufferSize;
+ ULONG OutBufferSize;
+ LARGE_INTEGER Timeout;
+} NPFS_GET_STATE, *PNPFS_GET_STATE;
+
+typedef struct _FILE_PIPE_PEEK_BUFFER
+{
+ ULONG NamedPipeState;
+ ULONG ReadDataAvailable;
+ ULONG NumberOfMessages;
+ ULONG MessageLength;
+ CHAR Data[1];
+} FILE_PIPE_PEEK_BUFFER, *PFILE_PIPE_PEEK_BUFFER;
+
+#define FILE_PIPE_BYTE_STREAM_TYPE 0x00000000
+#define FILE_PIPE_MESSAGE_TYPE 0x00000001
+
+#define FILE_PIPE_BYTE_STREAM_MODE 0x00000000
+#define FILE_PIPE_MESSAGE_MODE 0x00000001
+
+#define FILE_PIPE_QUEUE_OPERATION 0x00000000
+#define FILE_PIPE_COMPLETE_OPERATION 0x00000001
+
+#define FILE_PIPE_INBOUND 0x00000000
+#define FILE_PIPE_OUTBOUND 0x00000001
+#define FILE_PIPE_FULL_DUPLEX 0x00000002
+
+#define FILE_PIPE_DISCONNECTED_STATE 0x00000001
+#define FILE_PIPE_LISTENING_STATE 0x00000002
+#define FILE_PIPE_CONNECTED_STATE 0x00000003
+#define FILE_PIPE_CLOSING_STATE 0x00000004
+
+#define FILE_PIPE_CLIENT_END 0x00000000
+#define FILE_PIPE_SERVER_END 0x00000001
+
+#define FILE_PIPE_READ_DATA 0x00000000
+#define FILE_PIPE_WRITE_SPACE 0x00000001
+
+
+#endif /* __INCLUDE_NAPI_NPIPE_H */
--- /dev/null
+#ifndef __INCLUDE_NAPI_SHARED_DATA_H
+#define __INCLUDE_NAPI_SHARED_DATA_H
+
+#define PROCESSOR_FEATURES_MAX 64
+
+typedef enum _ALTERNATIVE_ARCHITECTURE_TYPE
+{
+ StandardDesign,
+ NEC98x86,
+ EndAlternatives
+} ALTERNATIVE_ARCHITECTURE_TYPE;
+
+
+typedef struct _KUSER_SHARED_DATA
+{
+ volatile ULONG TickCountLow;
+ ULONG TickCountMultiplier;
+ volatile KSYSTEM_TIME InterruptTime;
+ volatile KSYSTEM_TIME SystemTime;
+ volatile KSYSTEM_TIME TimeZoneBias;
+ USHORT ImageNumberLow;
+ USHORT ImageNumberHigh;
+ WCHAR NtSystemRoot[260];
+ ULONG DosDeviceMap;
+ ULONG CryptoExponent;
+ ULONG TimeZoneId;
+ UCHAR DosDeviceDriveType[32];
+ NT_PRODUCT_TYPE NtProductType;
+ BOOLEAN ProductTypeIsValid;
+ ULONG NtMajorVersion;
+ ULONG NtMinorVersion;
+ BOOLEAN ProcessorFeatures[PROCESSOR_FEATURES_MAX];
+
+ // NT5 / Win2k specific ??
+ ULONG Reserved1;
+ ULONG Reserved3;
+ volatile ULONG TimeSlip;
+ ALTERNATIVE_ARCHITECTURE_TYPE AlternativeArchitecture;
+ ULONG SuiteMask;
+#ifdef REMOTE_BOOT
+ ULONG SystemFlags;
+ UCHAR RemoteBootServerPath[260];
+#endif
+ BOOLEAN KdDebuggerEnabled;
+} KUSER_SHARED_DATA, *PKUSER_SHARED_DATA;
+
+/* Values for DosDeviceDriveType */
+#define DOSDEVICE_DRIVE_UNKNOWN 0
+#define DOSDEVICE_DRIVE_CALCULATE 1
+#define DOSDEVICE_DRIVE_REMOVABLE 2
+#define DOSDEVICE_DRIVE_FIXED 3
+#define DOSDEVICE_DRIVE_REMOTE 4
+#define DOSDEVICE_DRIVE_CDROM 5
+#define DOSDEVICE_DRIVE_RAMDISK 6
+
+
+#define KERNEL_SHARED_DATA (0xFFDF0000)
+#define USER_SHARED_DATA (0x7FFE0000)
+
+#if defined(__NTOSKRNL__) || defined(__NTDRIVER__) || defined(__NTHAL__)
+#define KI_USER_SHARED_DATA (0xFFDF0000)
+#define SharedUserData ((KUSER_SHARED_DATA * const)KI_USER_SHARED_DATA)
+#else
+#define SharedUserData ((KUSER_SHARED_DATA * const)USER_SHARED_DATA)
+#endif
+
+
+#endif /* __INCLUDE_NAPI_SHARED_DATA_H */
--- /dev/null
+/* TEB/PEB parameters */
+#ifndef __INCLUDE_INTERNAL_TEB
+#define __INCLUDE_INTERNAL_TEB
+
+#include <napi/types.h>
+
+typedef struct _CLIENT_ID
+{
+ HANDLE UniqueProcess;
+ HANDLE UniqueThread;
+} CLIENT_ID, *PCLIENT_ID;
+
+typedef struct _CURDIR
+{
+ UNICODE_STRING DosPath;
+ PVOID Handle;
+} CURDIR, *PCURDIR;
+
+typedef struct RTL_DRIVE_LETTER_CURDIR
+{
+ USHORT Flags;
+ USHORT Length;
+ ULONG TimeStamp;
+ UNICODE_STRING DosPath;
+} RTL_DRIVE_LETTER_CURDIR, *PRTL_DRIVE_LETTER_CURDIR;
+
+typedef struct _PEB_FREE_BLOCK
+{
+ struct _PEB_FREE_BLOCK* Next;
+ ULONG Size;
+} PEB_FREE_BLOCK, *PPEB_FREE_BLOCK;
+
+/* RTL_USER_PROCESS_PARAMETERS.Flags */
+#define PPF_NORMALIZED (1)
+
+typedef struct _RTL_USER_PROCESS_PARAMETERS
+{
+ ULONG MaximumLength; // 00h
+ ULONG Length; // 04h
+ ULONG Flags; // 08h
+ ULONG DebugFlags; // 0Ch
+ PVOID ConsoleHandle; // 10h
+ ULONG ConsoleFlags; // 14h
+ HANDLE InputHandle; // 18h
+ HANDLE OutputHandle; // 1Ch
+ HANDLE ErrorHandle; // 20h
+ CURDIR CurrentDirectory; // 24h
+ UNICODE_STRING DllPath; // 30h
+ UNICODE_STRING ImagePathName; // 38h
+ UNICODE_STRING CommandLine; // 40h
+ PWSTR Environment; // 48h
+ ULONG StartingX; // 4Ch
+ ULONG StartingY; // 50h
+ ULONG CountX; // 54h
+ ULONG CountY; // 58h
+ ULONG CountCharsX; // 5Ch
+ ULONG CountCharsY; // 60h
+ ULONG FillAttribute; // 64h
+ ULONG WindowFlags; // 68h
+ ULONG ShowWindowFlags; // 6Ch
+ UNICODE_STRING WindowTitle; // 70h
+ UNICODE_STRING DesktopInfo; // 78h
+ UNICODE_STRING ShellInfo; // 80h
+ UNICODE_STRING RuntimeInfo; // 88h
+ RTL_DRIVE_LETTER_CURDIR DLCurrentDirectory[0x20]; // 90h
+} RTL_USER_PROCESS_PARAMETERS, *PRTL_USER_PROCESS_PARAMETERS;
+
+#define PEB_BASE (0x7FFDF000)
+
+typedef struct _PEB_LDR_DATA
+{
+ ULONG Length;
+ BOOLEAN Initialized;
+ PVOID SsHandle;
+ LIST_ENTRY InLoadOrderModuleList;
+ LIST_ENTRY InMemoryOrderModuleList;
+ LIST_ENTRY InInitializationOrderModuleList;
+} PEB_LDR_DATA, *PPEB_LDR_DATA;
+
+typedef VOID STDCALL (*PPEBLOCKROUTINE)(PVOID);
+
+typedef struct _PEB
+{
+ UCHAR InheritedAddressSpace; // 00h
+ UCHAR ReadImageFileExecOptions; // 01h
+ UCHAR BeingDebugged; // 02h
+ UCHAR Spare; // 03h
+ PVOID Mutant; // 04h
+ PVOID ImageBaseAddress; // 08h
+ PPEB_LDR_DATA Ldr; // 0Ch
+ PRTL_USER_PROCESS_PARAMETERS ProcessParameters; // 10h
+ PVOID SubSystemData; // 14h
+ PVOID ProcessHeap; // 18h
+ PVOID FastPebLock; // 1Ch
+ PPEBLOCKROUTINE FastPebLockRoutine; // 20h
+ PPEBLOCKROUTINE FastPebUnlockRoutine; // 24h
+ ULONG EnvironmentUpdateCount; // 28h
+ PVOID* KernelCallbackTable; // 2Ch
+ PVOID EventLogSection; // 30h
+ PVOID EventLog; // 34h
+ PPEB_FREE_BLOCK FreeList; // 38h
+ ULONG TlsExpansionCounter; // 3Ch
+ PVOID TlsBitmap; // 40h
+ ULONG TlsBitmapBits[0x2]; // 44h
+ PVOID ReadOnlySharedMemoryBase; // 4Ch
+ PVOID ReadOnlySharedMemoryHeap; // 50h
+ PVOID* ReadOnlyStaticServerData; // 54h
+ PVOID AnsiCodePageData; // 58h
+ PVOID OemCodePageData; // 5Ch
+ PVOID UnicodeCaseTableData; // 60h
+ ULONG NumberOfProcessors; // 64h
+ ULONG NtGlobalFlag; // 68h
+ UCHAR Spare2[0x4]; // 6Ch
+ LARGE_INTEGER CriticalSectionTimeout; // 70h
+ ULONG HeapSegmentReserve; // 78h
+ ULONG HeapSegmentCommit; // 7Ch
+ ULONG HeapDeCommitTotalFreeThreshold; // 80h
+ ULONG HeapDeCommitFreeBlockThreshold; // 84h
+ ULONG NumberOfHeaps; // 88h
+ ULONG MaximumNumberOfHeaps; // 8Ch
+ PVOID** ProcessHeaps; // 90h
+ PVOID GdiSharedHandleTable; // 94h
+ PVOID ProcessStarterHelper; // 98h
+ PVOID GdiDCAttributeList; // 9Ch
+ PVOID LoaderLock; // A0h
+ ULONG OSMajorVersion; // A4h
+ ULONG OSMinorVersion; // A8h
+ ULONG OSBuildNumber; // ACh
+ ULONG OSPlatformId; // B0h
+ ULONG ImageSubSystem; // B4h
+ ULONG ImageSubSystemMajorVersion; // B8h
+ ULONG ImageSubSystemMinorVersion; // C0h
+ ULONG GdiHandleBuffer[0x22]; // C4h
+} PEB, *PPEB;
+
+
+typedef struct _NT_TIB {
+ struct _EXCEPTION_REGISTRATION_RECORD* ExceptionList; // 00h
+ PVOID StackBase; // 04h
+ PVOID StackLimit; // 08h
+ PVOID SubSystemTib; // 0Ch
+ union {
+ PVOID FiberData; // 10h
+ ULONG Version; // 10h
+ } Fib;
+ PVOID ArbitraryUserPointer; // 14h
+ struct _NT_TIB *Self; // 18h
+} NT_TIB, *PNT_TIB;
+
+typedef struct _GDI_TEB_BATCH
+{
+ ULONG Offset;
+ ULONG HDC;
+ ULONG Buffer[0x136];
+} GDI_TEB_BATCH, *PGDI_TEB_BATCH;
+
+typedef struct _TEB
+{
+ NT_TIB Tib; // 00h
+ PVOID EnvironmentPointer; // 1Ch
+ CLIENT_ID Cid; // 20h
+ PVOID ActiveRpcInfo; // 28h
+ PVOID ThreadLocalStoragePointer; // 2Ch
+ PPEB Peb; // 30h
+ ULONG LastErrorValue; // 34h
+ ULONG CountOfOwnedCriticalSections; // 38h
+ PVOID CsrClientThread; // 3Ch
+ struct _W32THREAD* Win32ThreadInfo; // 40h
+ ULONG Win32ClientInfo[0x1F]; // 44h
+ PVOID WOW32Reserved; // C0h
+ ULONG CurrentLocale; // C4h
+ ULONG FpSoftwareStatusRegister; // C8h
+ PVOID SystemReserved1[0x36]; // CCh
+ PVOID Spare1; // 1A4h
+ LONG ExceptionCode; // 1A8h
+ ULONG SpareBytes1[0x28]; // 1ACh
+ PVOID SystemReserved2[0xA]; // 1D4h
+// GDI_TEB_BATCH GdiTebBatch; // 1FCh
+ ULONG gdiRgn; // 6DCh
+ ULONG gdiPen; // 6E0h
+ ULONG gdiBrush; // 6E4h
+ CLIENT_ID RealClientId; // 6E8h
+ PVOID GdiCachedProcessHandle; // 6F0h
+ ULONG GdiClientPID; // 6F4h
+ ULONG GdiClientTID; // 6F8h
+ PVOID GdiThreadLocaleInfo; // 6FCh
+ PVOID UserReserved[5]; // 700h
+ PVOID glDispatchTable[0x118]; // 714h
+ ULONG glReserved1[0x1A]; // B74h
+ PVOID glReserved2; // BDCh
+ PVOID glSectionInfo; // BE0h
+ PVOID glSection; // BE4h
+ PVOID glTable; // BE8h
+ PVOID glCurrentRC; // BECh
+ PVOID glContext; // BF0h
+ NTSTATUS LastStatusValue; // BF4h
+ UNICODE_STRING StaticUnicodeString; // BF8h
+ WCHAR StaticUnicodeBuffer[0x105]; // C00h
+ PVOID DeallocationStack; // E0Ch
+ PVOID TlsSlots[0x40]; // E10h
+ LIST_ENTRY TlsLinks; // F10h
+ PVOID Vdm; // F18h
+ PVOID ReservedForNtRpc; // F1Ch
+ PVOID DbgSsReserved[0x2]; // F20h
+ ULONG HardErrorDisabled; // F28h
+ PVOID Instrumentation[0x10]; // F2Ch
+ PVOID WinSockData; // F6Ch
+ ULONG GdiBatchCount; // F70h
+ ULONG Spare2; // F74h
+ ULONG Spare3; // F78h
+ ULONG Spare4; // F7Ch
+ PVOID ReservedForOle; // F80h
+ ULONG WaitingOnLoaderLock; // F84h
+ PVOID WineDebugInfo; // Needed for WINE DLL's
+} TEB, *PTEB;
+
+
+#define NtCurrentPeb() (NtCurrentTeb()->Peb)
+
+static inline PTEB NtCurrentTeb(VOID)
+{
+ int x;
+
+ __asm__ __volatile__("movl %%fs:0x18, %0\n\t"
+ : "=r" (x) /* can't have two memory operands */
+ : /* no inputs */
+ );
+
+ return((PTEB)x);
+}
+
+
+
+#endif /* __INCLUDE_INTERNAL_TEB */
--- /dev/null
+#ifndef __INCLUDE_NAPI_TYPES_H
+#define __INCLUDE_NAPI_TYPES_H
+
+// these should be moved to a file like ntdef.h
+
+typedef const int CINT;
+
+typedef LONG NTSTATUS, *PNTSTATUS;
+
+typedef ULONG DEVICE_TYPE;
+
+
+
+
+
+enum
+{
+ DIRECTORY_QUERY,
+ DIRECTORY_TRAVERSE,
+ DIRECTORY_CREATE_OBJECT,
+ DIRECTORY_CREATE_SUBDIRECTORY,
+ DIRECTORY_ALL_ACCESS,
+};
+
+/*
+ * General type for status information
+ */
+//typedef LONG NTSTATUS;
+
+typedef struct _UNICODE_STRING
+{
+ USHORT Length;
+ USHORT MaximumLength;
+ PWSTR Buffer;
+} UNICODE_STRING, *PUNICODE_STRING;
+
+typedef enum _SECTION_INHERIT {
+ ViewShare = 1,
+ ViewUnmap = 2
+} SECTION_INHERIT;
+
+typedef enum _NT_PRODUCT_TYPE
+{
+ NtProductWinNt = 1,
+ NtProductLanManNt,
+ NtProductServer
+} NT_PRODUCT_TYPE, *PNT_PRODUCT_TYPE;
+
+/* File information for IRP_MJ_QUERY_INFORMATION (and SET) */
+typedef enum _FILE_INFORMATION_CLASS
+{
+ FileDirectoryInformation = 1,
+ FileFullDirectoryInformation,
+ FileBothDirectoryInformation,
+ FileBasicInformation,
+ FileStandardInformation,
+ FileInternalInformation,
+ FileEaInformation,
+ FileAccessInformation,
+ FileNameInformation,
+ FileRenameInformation,
+ FileLinkInformation,
+ FileNamesInformation,
+ FileDispositionInformation,
+ FilePositionInformation,
+ FileFullEaInformation,
+ FileModeInformation,
+ FileAlignmentInformation,
+ FileAllInformation,
+ FileAllocationInformation,
+ FileEndOfFileInformation,
+ FileAlternateNameInformation,
+ FileStreamInformation,
+ FilePipeInformation,
+ FilePipeLocalInformation,
+ FilePipeRemoteInformation,
+ FileMailslotQueryInformation,
+ FileMailslotSetInformation,
+ FileCompressionInformation,
+ FileCopyOnWriteInformation,
+ FileCompletionInformation,
+ FileMoveClusterInformation,
+ FileOleClassIdInformation,
+ FileOleStateBitsInformation,
+ FileNetworkOpenInformation,
+ FileObjectIdInformation,
+ FileOleAllInformation,
+ FileOleDirectoryInformation,
+ FileContentIndexInformation,
+ FileInheritContentIndexInformation,
+ FileOleInformation,
+ FileMaximumInformation,
+} FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
+
+typedef ULONG WAIT_TYPE;
+typedef USHORT CSHORT;
+
+
+#if 0
+typedef struct _TIME {
+ DWORD LowPart;
+ LONG HighPart;
+} TIME, *PTIME;
+#endif
+
+typedef ULARGE_INTEGER TIME, *PTIME;
+
+#endif /* __INCLUDE_NAPI_TYPES_H */
--- /dev/null
+#ifndef __INCLUDE_NAPI_WIN32_H
+#define __INCLUDE_NAPI_WIN32_H
+
+typedef struct _W32THREAD
+{
+ PVOID MessageQueue;
+ FAST_MUTEX WindowListLock;
+ LIST_ENTRY WindowListHead;
+ struct _DESKTOP_OBJECT* Desktop;
+} __attribute__((packed)) W32THREAD, *PW32THREAD;
+
+typedef struct _W32PROCESS
+{
+ FAST_MUTEX ClassListLock;
+ LIST_ENTRY ClassListHead;
+ struct _WINSTATION_OBJECT* WindowStation;
+} W32PROCESS, *PW32PROCESS;
+
+PW32THREAD STDCALL
+PsGetWin32Thread(VOID);
+PW32PROCESS STDCALL
+PsGetWin32Process(VOID);
+
+#endif /* __INCLUDE_NAPI_WIN32_H */
projects / reactos.git / commitdiff