diff --git a/reactos/include/ddk/ccfuncs.h b/reactos/include/ddk/ccfuncs.h new file mode 100644 index 00000000000..fc179583324 --- /dev/null +++ b/reactos/include/ddk/ccfuncs.h @@ -0,0 +1,328 @@ + +#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 */ diff --git a/reactos/include/ddk/cctypes.h b/reactos/include/ddk/cctypes.h new file mode 100644 index 00000000000..bd3f0acfd32 --- /dev/null +++ b/reactos/include/ddk/cctypes.h @@ -0,0 +1,86 @@ +#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 */ diff --git a/reactos/include/ddk/cmfuncs.h b/reactos/include/ddk/cmfuncs.h new file mode 100644 index 00000000000..fee65aacca1 --- /dev/null +++ b/reactos/include/ddk/cmfuncs.h @@ -0,0 +1,47 @@ +/* + * 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); + diff --git a/reactos/include/ddk/cmtypes.h b/reactos/include/ddk/cmtypes.h new file mode 100644 index 00000000000..a9af321f9c7 --- /dev/null +++ b/reactos/include/ddk/cmtypes.h @@ -0,0 +1,100 @@ + +/* + * 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; + diff --git a/reactos/include/ddk/dbgfuncs.h b/reactos/include/ddk/dbgfuncs.h new file mode 100644 index 00000000000..8649d255766 --- /dev/null +++ b/reactos/include/ddk/dbgfuncs.h @@ -0,0 +1,23 @@ +#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 */ diff --git a/reactos/include/ddk/defines.h b/reactos/include/ddk/defines.h new file mode 100644 index 00000000000..ea65d82d6a5 --- /dev/null +++ b/reactos/include/ddk/defines.h @@ -0,0 +1,234 @@ +#ifndef _DDK_DEFINES_H +#define _DDK_DEFINES_H + +/* GENERAL DEFINITIONS ****************************************************/ + +#ifndef __ASM__ + +#define _WIN32_WINNT 0x0400 + +#include +#include + +#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, + OBJ_VALID_ATTRIBUTES = 0x1F2, +}; + +/* + * 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 + +#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 */ diff --git a/reactos/include/ddk/exfuncs.h b/reactos/include/ddk/exfuncs.h new file mode 100644 index 00000000000..fc13a68dbe7 --- /dev/null +++ b/reactos/include/ddk/exfuncs.h @@ -0,0 +1,912 @@ +#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 */ diff --git a/reactos/include/ddk/extypes.h b/reactos/include/ddk/extypes.h new file mode 100644 index 00000000000..d12e2638953 --- /dev/null +++ b/reactos/include/ddk/extypes.h @@ -0,0 +1,238 @@ +/* $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 */ diff --git a/reactos/include/ddk/fsfuncs.h b/reactos/include/ddk/fsfuncs.h new file mode 100644 index 00000000000..72434d5bc4d --- /dev/null +++ b/reactos/include/ddk/fsfuncs.h @@ -0,0 +1,612 @@ +#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 */ diff --git a/reactos/include/ddk/fstypes.h b/reactos/include/ddk/fstypes.h new file mode 100644 index 00000000000..0bc69931523 --- /dev/null +++ b/reactos/include/ddk/fstypes.h @@ -0,0 +1,96 @@ +#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 */ diff --git a/reactos/include/ddk/halfuncs.h b/reactos/include/ddk/halfuncs.h new file mode 100644 index 00000000000..a5d303f766a --- /dev/null +++ b/reactos/include/ddk/halfuncs.h @@ -0,0 +1,309 @@ +#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 */ diff --git a/reactos/include/ddk/haltypes.h b/reactos/include/ddk/haltypes.h new file mode 100644 index 00000000000..3113899c482 --- /dev/null +++ b/reactos/include/ddk/haltypes.h @@ -0,0 +1,436 @@ +/* $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 */ diff --git a/reactos/include/ddk/i386/irql.h b/reactos/include/ddk/i386/irql.h new file mode 100644 index 00000000000..db7ef233785 --- /dev/null +++ b/reactos/include/ddk/i386/irql.h @@ -0,0 +1,7 @@ +/* + * PURPOSE: The number of device specific level levels + */ +#define NR_DEVICE_SPECIFIC_LEVELS (16) + + + diff --git a/reactos/include/ddk/i386/pagesize.h b/reactos/include/ddk/i386/pagesize.h new file mode 100644 index 00000000000..6979b12617c --- /dev/null +++ b/reactos/include/ddk/i386/pagesize.h @@ -0,0 +1,6 @@ +#ifndef __INCLUDE_DDK_I386_PAGESIZE_H +#define __INCLUDE_DDK_I386_PAGESIZE_H + +#define PAGESIZE (4096) + +#endif /* __INCLUDE_DDK_I386_PAGESIZE_H */ diff --git a/reactos/include/ddk/i386/tss.h b/reactos/include/ddk/i386/tss.h new file mode 100644 index 00000000000..361086a48c1 --- /dev/null +++ b/reactos/include/ddk/i386/tss.h @@ -0,0 +1,57 @@ +/* + * + */ + +#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 */ diff --git a/reactos/include/ddk/ioctrl.h b/reactos/include/ddk/ioctrl.h new file mode 100644 index 00000000000..867eb9a2647 --- /dev/null +++ b/reactos/include/ddk/ioctrl.h @@ -0,0 +1,23 @@ +#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 */ diff --git a/reactos/include/ddk/iodef.h b/reactos/include/ddk/iodef.h new file mode 100644 index 00000000000..4d199cd27a8 --- /dev/null +++ b/reactos/include/ddk/iodef.h @@ -0,0 +1,393 @@ +#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 diff --git a/reactos/include/ddk/iofuncs.h b/reactos/include/ddk/iofuncs.h new file mode 100644 index 00000000000..9790d2fcb91 --- /dev/null +++ b/reactos/include/ddk/iofuncs.h @@ -0,0 +1,1207 @@ +#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 */ diff --git a/reactos/include/ddk/iotypes.h b/reactos/include/ddk/iotypes.h new file mode 100644 index 00000000000..6ce2f2a052b --- /dev/null +++ b/reactos/include/ddk/iotypes.h @@ -0,0 +1,845 @@ +/* $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 +#include + +#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 */ diff --git a/reactos/include/ddk/kdfuncs.h b/reactos/include/ddk/kdfuncs.h new file mode 100644 index 00000000000..5d70fda2a0a --- /dev/null +++ b/reactos/include/ddk/kdfuncs.h @@ -0,0 +1,99 @@ +#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 */ diff --git a/reactos/include/ddk/kedef.h b/reactos/include/ddk/kedef.h new file mode 100644 index 00000000000..507f1b3fc1a --- /dev/null +++ b/reactos/include/ddk/kedef.h @@ -0,0 +1,66 @@ +#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 diff --git a/reactos/include/ddk/kefuncs.h b/reactos/include/ddk/kefuncs.h new file mode 100644 index 00000000000..b99a1be9f18 --- /dev/null +++ b/reactos/include/ddk/kefuncs.h @@ -0,0 +1,493 @@ +#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 */ diff --git a/reactos/include/ddk/ketypes.h b/reactos/include/ddk/ketypes.h new file mode 100644 index 00000000000..abb87b2ce54 --- /dev/null +++ b/reactos/include/ddk/ketypes.h @@ -0,0 +1,288 @@ +/* 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 */ diff --git a/reactos/include/ddk/ldrfuncs.h b/reactos/include/ddk/ldrfuncs.h new file mode 100644 index 00000000000..229d36e8c9c --- /dev/null +++ b/reactos/include/ddk/ldrfuncs.h @@ -0,0 +1,17 @@ +#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 */ diff --git a/reactos/include/ddk/ldrtypes.h b/reactos/include/ddk/ldrtypes.h new file mode 100644 index 00000000000..36a12994590 --- /dev/null +++ b/reactos/include/ddk/ldrtypes.h @@ -0,0 +1,17 @@ +#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 */ diff --git a/reactos/include/ddk/miniport.h b/reactos/include/ddk/miniport.h new file mode 100644 index 00000000000..d1ee3ab3e92 --- /dev/null +++ b/reactos/include/ddk/miniport.h @@ -0,0 +1,25 @@ +/* + * 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; + + diff --git a/reactos/include/ddk/mmfuncs.h b/reactos/include/ddk/mmfuncs.h new file mode 100644 index 00000000000..aef72d24d8a --- /dev/null +++ b/reactos/include/ddk/mmfuncs.h @@ -0,0 +1,553 @@ +#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 diff --git a/reactos/include/ddk/mmtypes.h b/reactos/include/ddk/mmtypes.h new file mode 100644 index 00000000000..c85850d2f63 --- /dev/null +++ b/reactos/include/ddk/mmtypes.h @@ -0,0 +1,88 @@ +/* $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 +#include + + +#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 diff --git a/reactos/include/ddk/ntdd8042.h b/reactos/include/ddk/ntdd8042.h new file mode 100644 index 00000000000..b57c487c166 --- /dev/null +++ b/reactos/include/ddk/ntdd8042.h @@ -0,0 +1,98 @@ +#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_ diff --git a/reactos/include/ddk/ntddbeep.h b/reactos/include/ddk/ntddbeep.h new file mode 100644 index 00000000000..c73e8f601e9 --- /dev/null +++ b/reactos/include/ddk/ntddbeep.h @@ -0,0 +1,15 @@ +#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_ */ diff --git a/reactos/include/ddk/ntddblue.h b/reactos/include/ddk/ntddblue.h new file mode 100644 index 00000000000..ed294276f71 --- /dev/null +++ b/reactos/include/ddk/ntddblue.h @@ -0,0 +1,64 @@ +#ifndef _NTDDBLUE_H_INCLUDED_ +#define _NTDDBLUE_H_INCLUDED_ + +#include + +#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_ */ diff --git a/reactos/include/ddk/ntddk.h b/reactos/include/ddk/ntddk.h new file mode 100644 index 00000000000..59e7fbcf549 --- /dev/null +++ b/reactos/include/ddk/ntddk.h @@ -0,0 +1,90 @@ +/* $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 +#include +#endif +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#if defined(__NTOSKRNL__) || defined(__NTDRIVER__) || defined(__NTHAL__) +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#endif /*__NTOSKRNL__ || __NTDRIVER__ || __NTHAL__ */ + +#ifdef __cplusplus +}; +#endif + +#endif /* __NTDDK_H */ + diff --git a/reactos/include/ddk/ntddkbd.h b/reactos/include/ddk/ntddkbd.h new file mode 100644 index 00000000000..527392c900c --- /dev/null +++ b/reactos/include/ddk/ntddkbd.h @@ -0,0 +1,19 @@ +#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_ diff --git a/reactos/include/ddk/ntddvid.h b/reactos/include/ddk/ntddvid.h new file mode 100644 index 00000000000..324039626df --- /dev/null +++ b/reactos/include/ddk/ntddvid.h @@ -0,0 +1,453 @@ +/* + * NTDDVID.H - Video Port and MiniPort driver interface + */ + +#include + +/* + * 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); + + diff --git a/reactos/include/ddk/ntdef.h b/reactos/include/ddk/ntdef.h new file mode 100644 index 00000000000..264adc16039 --- /dev/null +++ b/reactos/include/ddk/ntdef.h @@ -0,0 +1,13 @@ +#ifndef __INCLUDE_DDK_NTDEF_H +#define __INCLUDE_DDK_NTDEF_H + +struct _KTHREAD; +struct _ETHREAD; +struct _EPROCESS; + +#define NTKERNELAPI +#define NTSYSAPI +#define NTAPI + + +#endif diff --git a/reactos/include/ddk/ntifs.h b/reactos/include/ddk/ntifs.h new file mode 100644 index 00000000000..ca81c9b1090 --- /dev/null +++ b/reactos/include/ddk/ntifs.h @@ -0,0 +1,41 @@ +#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 + +#include + +#include +#include + +#endif /* __INCLUDE_DDK_NTIFS_H */ diff --git a/reactos/include/ddk/obfuncs.h b/reactos/include/ddk/obfuncs.h new file mode 100644 index 00000000000..9fb2d224982 --- /dev/null +++ b/reactos/include/ddk/obfuncs.h @@ -0,0 +1,180 @@ +#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 */ diff --git a/reactos/include/ddk/obtypes.h b/reactos/include/ddk/obtypes.h new file mode 100644 index 00000000000..14b470e5c63 --- /dev/null +++ b/reactos/include/ddk/obtypes.h @@ -0,0 +1,199 @@ +#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 */ diff --git a/reactos/include/ddk/pnpfuncs.h b/reactos/include/ddk/pnpfuncs.h new file mode 100644 index 00000000000..73ae2c367f7 --- /dev/null +++ b/reactos/include/ddk/pnpfuncs.h @@ -0,0 +1,176 @@ +#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 */ diff --git a/reactos/include/ddk/pnptypes.h b/reactos/include/ddk/pnptypes.h new file mode 100644 index 00000000000..61529f4b104 --- /dev/null +++ b/reactos/include/ddk/pnptypes.h @@ -0,0 +1,194 @@ +#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 */ diff --git a/reactos/include/ddk/pofuncs.h b/reactos/include/ddk/pofuncs.h new file mode 100644 index 00000000000..16ae415e82e --- /dev/null +++ b/reactos/include/ddk/pofuncs.h @@ -0,0 +1,61 @@ +#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 */ diff --git a/reactos/include/ddk/potypes.h b/reactos/include/ddk/potypes.h new file mode 100644 index 00000000000..ee720e7718c --- /dev/null +++ b/reactos/include/ddk/potypes.h @@ -0,0 +1,101 @@ +#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 */ diff --git a/reactos/include/ddk/psfuncs.h b/reactos/include/ddk/psfuncs.h new file mode 100644 index 00000000000..5d1050b8ffe --- /dev/null +++ b/reactos/include/ddk/psfuncs.h @@ -0,0 +1,98 @@ +/* $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 */ diff --git a/reactos/include/ddk/pstypes.h b/reactos/include/ddk/pstypes.h new file mode 100644 index 00000000000..9aae408fee5 --- /dev/null +++ b/reactos/include/ddk/pstypes.h @@ -0,0 +1,57 @@ +#ifndef __INCLUDE_DDK_PSTYPES_H +#define __INCLUDE_DDK_PSTYPES_H + +#include + +#include +#include + +#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 */ diff --git a/reactos/include/ddk/rtl.h b/reactos/include/ddk/rtl.h new file mode 100644 index 00000000000..e26a475b002 --- /dev/null +++ b/reactos/include/ddk/rtl.h @@ -0,0 +1,2186 @@ +/* $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 +#include + +#endif /* __NTOSKRNL__ || __NTDRIVER__ || __NTHAL__ || __NTDLL__ || __NTAPP__ */ + +#include + + + +/* + * 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 */ diff --git a/reactos/include/ddk/rtltypes.h b/reactos/include/ddk/rtltypes.h new file mode 100644 index 00000000000..19b388f26e9 --- /dev/null +++ b/reactos/include/ddk/rtltypes.h @@ -0,0 +1,214 @@ +/* $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 */ diff --git a/reactos/include/ddk/sefuncs.h b/reactos/include/ddk/sefuncs.h new file mode 100644 index 00000000000..36e841900e1 --- /dev/null +++ b/reactos/include/ddk/sefuncs.h @@ -0,0 +1,152 @@ +#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 */ diff --git a/reactos/include/ddk/service.h b/reactos/include/ddk/service.h new file mode 100644 index 00000000000..e6a684899ec --- /dev/null +++ b/reactos/include/ddk/service.h @@ -0,0 +1,60 @@ + +#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 + diff --git a/reactos/include/ddk/setypes.h b/reactos/include/ddk/setypes.h new file mode 100644 index 00000000000..0b987ff26d1 --- /dev/null +++ b/reactos/include/ddk/setypes.h @@ -0,0 +1,164 @@ +/* $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 + +/* 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 */ diff --git a/reactos/include/ddk/status.h b/reactos/include/ddk/status.h new file mode 100644 index 00000000000..580dd7cf3b8 --- /dev/null +++ b/reactos/include/ddk/status.h @@ -0,0 +1,711 @@ +#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 */ + + + + + + diff --git a/reactos/include/ddk/structs.h b/reactos/include/ddk/structs.h new file mode 100644 index 00000000000..113eff3ddba --- /dev/null +++ b/reactos/include/ddk/structs.h @@ -0,0 +1,10 @@ +/* SYSTEM STRUCTURES ******************************************************/ + +#include +#include +#include +#include +#include +#include +#include + diff --git a/reactos/include/ddk/types.h b/reactos/include/ddk/types.h new file mode 100644 index 00000000000..908a47764be --- /dev/null +++ b/reactos/include/ddk/types.h @@ -0,0 +1,32 @@ +#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 */ diff --git a/reactos/include/ddk/winddi.h b/reactos/include/ddk/winddi.h new file mode 100644 index 00000000000..c4de4c72049 --- /dev/null +++ b/reactos/include/ddk/winddi.h @@ -0,0 +1,1366 @@ +/* + * 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 +#define WIN32_LEAN_AND_MEAN +#else +#include +#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 + diff --git a/reactos/include/ddk/zw.h b/reactos/include/ddk/zw.h new file mode 100644 index 00000000000..dbc63724fba --- /dev/null +++ b/reactos/include/ddk/zw.h @@ -0,0 +1,5308 @@ + +/* $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 +#include + +//#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 */ diff --git a/reactos/include/ddk/zwtypes.h b/reactos/include/ddk/zwtypes.h new file mode 100644 index 00000000000..1095c91c948 --- /dev/null +++ b/reactos/include/ddk/zwtypes.h @@ -0,0 +1,1662 @@ +#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 diff --git a/reactos/include/napi/core.h b/reactos/include/napi/core.h new file mode 100644 index 00000000000..ca13d207a27 --- /dev/null +++ b/reactos/include/napi/core.h @@ -0,0 +1,35 @@ +#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 */ diff --git a/reactos/include/napi/dbg.h b/reactos/include/napi/dbg.h new file mode 100644 index 00000000000..e2a51a6a1d7 --- /dev/null +++ b/reactos/include/napi/dbg.h @@ -0,0 +1,63 @@ +#ifndef __INCLUDE_NAPI_DBG_H +#define __INCLUDE_NAPI_DBG_H + +#include + +#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 */ diff --git a/reactos/include/napi/i386/segment.h b/reactos/include/napi/i386/segment.h new file mode 100644 index 00000000000..6034b60403d --- /dev/null +++ b/reactos/include/napi/i386/segment.h @@ -0,0 +1,353 @@ +#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 */ diff --git a/reactos/include/napi/lpc.h b/reactos/include/napi/lpc.h new file mode 100644 index 00000000000..2ee48ceb24b --- /dev/null +++ b/reactos/include/napi/lpc.h @@ -0,0 +1,197 @@ +#ifndef __INCLUDE_NAPI_LPC_H +#define __INCLUDE_NAPI_LPC_H + +#include + +#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 */ diff --git a/reactos/include/napi/npipe.h b/reactos/include/napi/npipe.h new file mode 100644 index 00000000000..b89972fd887 --- /dev/null +++ b/reactos/include/napi/npipe.h @@ -0,0 +1,196 @@ +#ifndef __INCLUDE_NAPI_NPIPE_H +#define __INCLUDE_NAPI_NPIPE_H + +#include + +/* + * 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 */ diff --git a/reactos/include/napi/shared_data.h b/reactos/include/napi/shared_data.h new file mode 100644 index 00000000000..2387273032f --- /dev/null +++ b/reactos/include/napi/shared_data.h @@ -0,0 +1,68 @@ +#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 */ diff --git a/reactos/include/napi/teb.h b/reactos/include/napi/teb.h new file mode 100644 index 00000000000..1bbc44d24e1 --- /dev/null +++ b/reactos/include/napi/teb.h @@ -0,0 +1,234 @@ +/* TEB/PEB parameters */ +#ifndef __INCLUDE_INTERNAL_TEB +#define __INCLUDE_INTERNAL_TEB + +#include + +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 */ diff --git a/reactos/include/napi/types.h b/reactos/include/napi/types.h new file mode 100644 index 00000000000..694ae40f5ce --- /dev/null +++ b/reactos/include/napi/types.h @@ -0,0 +1,108 @@ +#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 */ diff --git a/reactos/include/napi/win32.h b/reactos/include/napi/win32.h new file mode 100644 index 00000000000..948d28e1654 --- /dev/null +++ b/reactos/include/napi/win32.h @@ -0,0 +1,24 @@ +#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 */