archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: daad8a087a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'daad8a087a'
${ noResults }
windows-xp/Source/XPSP1/NT/base/published/nturtl.w

3073 lines
79 KiB
Raw Blame History

/*++ BUILD Version: 0001 // Increment this if a change has global effects
Copyright (c) Microsoft Corporation. All rights reserved.
Module Name:
nturtl.h
Abstract:
Include file for NT runtime routines that are callable by only
user mode code in various NT subsystems.
Author:
Steve Wood (stevewo) 10-Aug-1989
Environment:
These routines are dynamically linked in the caller's executable and
are callable only from user mode. They make use of Nt system
services.
Revision History:
--*/
#ifndef _NTURTL_
#define _NTURTL_
#if _MSC_VER > 1000
#pragma once
#endif
#ifdef __cplusplus
extern "C" {
#endif
#if defined (_MSC_VER)
#if ( _MSC_VER >= 800 )
#pragma warning(disable:4514)
#if _MSC_VER >= 1200
#pragma warning(push)
#endif
#pragma warning(disable:4001)
#pragma warning(disable:4201)
#pragma warning(disable:4214)
#endif
#if (_MSC_VER >= 1020)
#pragma once
#endif
#endif
//
// CriticalSection function definitions
//
// begin_winnt
typedef struct _RTL_CRITICAL_SECTION_DEBUG {
USHORT Type;
USHORT CreatorBackTraceIndex;
struct _RTL_CRITICAL_SECTION *CriticalSection;
LIST_ENTRY ProcessLocksList;
ULONG EntryCount;
ULONG ContentionCount;
ULONG Spare[ 2 ];
} RTL_CRITICAL_SECTION_DEBUG, *PRTL_CRITICAL_SECTION_DEBUG, RTL_RESOURCE_DEBUG, *PRTL_RESOURCE_DEBUG;
#define RTL_CRITSECT_TYPE 0
#define RTL_RESOURCE_TYPE 1
typedef struct _RTL_CRITICAL_SECTION {
PRTL_CRITICAL_SECTION_DEBUG DebugInfo;
//
// The following three fields control entering and exiting the critical
// section for the resource
//
LONG LockCount;
LONG RecursionCount;
HANDLE OwningThread; // from the thread's ClientId->UniqueThread
HANDLE LockSemaphore;
ULONG_PTR SpinCount; // force size on 64-bit systems when packed
} RTL_CRITICAL_SECTION, *PRTL_CRITICAL_SECTION;
// end_winnt
//
// These are needed for the debugger and WOW64.
//
typedef struct _RTL_CRITICAL_SECTION_DEBUG32 {
USHORT Type;
USHORT CreatorBackTraceIndex;
ULONG CriticalSection;
LIST_ENTRY32 ProcessLocksList;
ULONG EntryCount;
ULONG ContentionCount;
ULONG Spare[ 2 ];
} RTL_CRITICAL_SECTION_DEBUG32, *PRTL_CRITICAL_SECTION_DEBUG32, RTL_RESOURCE_DEBUG32, *PRTL_RESOURCE_DEBUG32;
typedef struct _RTL_CRITICAL_SECTION_DEBUG64 {
USHORT Type;
USHORT CreatorBackTraceIndex;
ULONG64 CriticalSection;
LIST_ENTRY64 ProcessLocksList;
ULONG EntryCount;
ULONG ContentionCount;
ULONG Spare[ 2 ];
} RTL_CRITICAL_SECTION_DEBUG64, *PRTL_CRITICAL_SECTION_DEBUG64, RTL_RESOURCE_DEBUG64, *PRTL_RESOURCE_DEBUG64;
typedef struct _RTL_CRITICAL_SECTION32 {
ULONG DebugInfo;
LONG LockCount;
LONG RecursionCount;
ULONG OwningThread;
ULONG LockSemaphore;
ULONG SpinCount;
} RTL_CRITICAL_SECTION32, *PRTL_CRITICAL_SECTION32;
typedef struct _RTL_CRITICAL_SECTION64 {
ULONG64 DebugInfo;
LONG LockCount;
LONG RecursionCount;
ULONG64 OwningThread;
ULONG64 LockSemaphore;
ULONG64 SpinCount;
} RTL_CRITICAL_SECTION64, *PRTL_CRITICAL_SECTION64;
//
// Shared resource function definitions
//
typedef struct _RTL_RESOURCE {
//
// The following field controls entering and exiting the critical
// section for the resource
//
RTL_CRITICAL_SECTION CriticalSection;
//
// The following four fields indicate the number of both shared or
// exclusive waiters
//
HANDLE SharedSemaphore;
ULONG NumberOfWaitingShared;
HANDLE ExclusiveSemaphore;
ULONG NumberOfWaitingExclusive;
//
// The following indicates the current state of the resource
//
// <0 the resource is acquired for exclusive access with the
// absolute value indicating the number of recursive accesses
// to the resource
//
// 0 the resource is available
//
// >0 the resource is acquired for shared access with the
// value indicating the number of shared accesses to the resource
//
LONG NumberOfActive;
HANDLE ExclusiveOwnerThread;
ULONG Flags; // See RTL_RESOURCE_FLAG_ equates below.
PRTL_RESOURCE_DEBUG DebugInfo;
} RTL_RESOURCE, *PRTL_RESOURCE;
#define RTL_RESOURCE_FLAG_LONG_TERM ((ULONG) 0x00000001)
NTSYSAPI
NTSTATUS
NTAPI
RtlEnterCriticalSection(
PRTL_CRITICAL_SECTION CriticalSection
);
NTSYSAPI
NTSTATUS
NTAPI
RtlLeaveCriticalSection(
PRTL_CRITICAL_SECTION CriticalSection
);
NTSYSAPI
BOOLEAN
NTAPI
RtlTryEnterCriticalSection(
PRTL_CRITICAL_SECTION CriticalSection
);
NTSYSAPI
NTSTATUS
NTAPI
RtlInitializeCriticalSection(
PRTL_CRITICAL_SECTION CriticalSection
);
NTSYSAPI
VOID
NTAPI
RtlEnableEarlyCriticalSectionEventCreation(
VOID
);
NTSYSAPI
NTSTATUS
NTAPI
RtlInitializeCriticalSectionAndSpinCount(
PRTL_CRITICAL_SECTION CriticalSection,
ULONG SpinCount
);
NTSYSAPI
ULONG
NTAPI
RtlSetCriticalSectionSpinCount(
PRTL_CRITICAL_SECTION CriticalSection,
ULONG SpinCount
);
NTSYSAPI
NTSTATUS
NTAPI
RtlDeleteCriticalSection(
PRTL_CRITICAL_SECTION CriticalSection
);
NTSYSAPI
VOID
NTAPI
RtlInitializeResource(
PRTL_RESOURCE Resource
);
NTSYSAPI
BOOLEAN
NTAPI
RtlAcquireResourceShared(
PRTL_RESOURCE Resource,
BOOLEAN Wait
);
NTSYSAPI
BOOLEAN
NTAPI
RtlAcquireResourceExclusive(
PRTL_RESOURCE Resource,
BOOLEAN Wait
);
NTSYSAPI
VOID
NTAPI
RtlReleaseResource(
PRTL_RESOURCE Resource
);
NTSYSAPI
VOID
NTAPI
RtlConvertSharedToExclusive(
PRTL_RESOURCE Resource
);
NTSYSAPI
VOID
NTAPI
RtlConvertExclusiveToShared(
PRTL_RESOURCE Resource
);
NTSYSAPI
VOID
NTAPI
RtlDeleteResource (
PRTL_RESOURCE Resource
);
NTSYSAPI
VOID
NTAPI
RtlCheckForOrphanedCriticalSections(
IN HANDLE hThread
);
//
// Application verifier types needed by provider dlls
//
// begin_winnt
typedef VOID (* RTL_VERIFIER_DLL_LOAD_CALLBACK) (
PWSTR DllName,
PVOID DllBase,
SIZE_T DllSize,
PVOID Reserved
);
typedef VOID (* RTL_VERIFIER_DLL_UNLOAD_CALLBACK) (
PWSTR DllName,
PVOID DllBase,
SIZE_T DllSize,
PVOID Reserved
);
typedef struct _RTL_VERIFIER_THUNK_DESCRIPTOR {
PCHAR ThunkName;
PVOID ThunkOldAddress;
PVOID ThunkNewAddress;
} RTL_VERIFIER_THUNK_DESCRIPTOR, *PRTL_VERIFIER_THUNK_DESCRIPTOR;
typedef struct _RTL_VERIFIER_DLL_DESCRIPTOR {
PWCHAR DllName;
ULONG DllFlags;
PVOID DllAddress;
PRTL_VERIFIER_THUNK_DESCRIPTOR DllThunks;
} RTL_VERIFIER_DLL_DESCRIPTOR, *PRTL_VERIFIER_DLL_DESCRIPTOR;
typedef struct _RTL_VERIFIER_PROVIDER_DESCRIPTOR {
//
// Filled by verifier provider DLL
//
ULONG Length;
PRTL_VERIFIER_DLL_DESCRIPTOR ProviderDlls;
RTL_VERIFIER_DLL_LOAD_CALLBACK ProviderDllLoadCallback;
RTL_VERIFIER_DLL_UNLOAD_CALLBACK ProviderDllUnloadCallback;
//
// Filled by verifier engine
//
PWSTR VerifierImage;
ULONG VerifierFlags;
ULONG VerifierDebug;
} RTL_VERIFIER_PROVIDER_DESCRIPTOR, *PRTL_VERIFIER_PROVIDER_DESCRIPTOR;
//
// Application verifier standard flags
//
#define RTL_VRF_FLG_FULL_PAGE_HEAP 0x0001
#define RTL_VRF_FLG_LOCK_CHECKS 0x0002
#define RTL_VRF_FLG_HANDLE_CHECKS 0x0004
#define RTL_VRF_FLG_STACK_CHECKS 0x0008
#define RTL_VRF_FLG_APPCOMPAT_CHECKS 0x0010
//
// Application verifier standard stop codes
//
#define APPLICATION_VERIFIER_INTERNAL_ERROR 0x80000000
#define APPLICATION_VERIFIER_INTERNAL_WARNING 0x40000000
#define APPLICATION_VERIFIER_NO_BREAK 0x20000000
#define APPLICATION_VERIFIER_RESERVED_BIT_28 0x10000000
#define APPLICATION_VERIFIER_UNKNOWN_ERROR 0x0001
#define APPLICATION_VERIFIER_ACCESS_VIOLATION 0x0002
#define APPLICATION_VERIFIER_UNSYNCHRONIZED_ACCESS 0x0003
#define APPLICATION_VERIFIER_EXTREME_SIZE_REQUEST 0x0004
#define APPLICATION_VERIFIER_BAD_HEAP_HANDLE 0x0005
#define APPLICATION_VERIFIER_SWITCHED_HEAP_HANDLE 0x0006
#define APPLICATION_VERIFIER_DOUBLE_FREE 0x0007
#define APPLICATION_VERIFIER_CORRUPTED_HEAP_BLOCK 0x0008
#define APPLICATION_VERIFIER_DESTROY_PROCESS_HEAP 0x0009
#define APPLICATION_VERIFIER_UNEXPECTED_EXCEPTION 0x000A
#define APPLICATION_VERIFIER_STACK_OVERFLOW 0x000B
#define APPLICATION_VERIFIER_TERMINATE_THREAD_CALL 0x0100
#define APPLICATION_VERIFIER_EXIT_THREAD_OWNS_LOCK 0x0200
#define APPLICATION_VERIFIER_LOCK_IN_UNLOADED_DLL 0x0201
#define APPLICATION_VERIFIER_LOCK_IN_FREED_HEAP 0x0202
#define APPLICATION_VERIFIER_LOCK_DOUBLE_INITIALIZE 0x0203
#define APPLICATION_VERIFIER_LOCK_IN_FREED_MEMORY 0x0204
#define APPLICATION_VERIFIER_LOCK_CORRUPTED 0x0205
#define APPLICATION_VERIFIER_LOCK_INVALID_OWNER 0x0206
#define APPLICATION_VERIFIER_LOCK_INVALID_RECURSION_COUNT 0x0207
#define APPLICATION_VERIFIER_LOCK_INVALID_LOCK_COUNT 0x0208
#define APPLICATION_VERIFIER_LOCK_OVER_RELEASED 0x0209
#define APPLICATION_VERIFIER_LOCK_NOT_INITIALIZED 0x0210
#define APPLICATION_VERIFIER_INVALID_HANDLE 0x0300
#define VERIFIER_STOP(Code, Msg, P1, S1, P2, S2, P3, S3, P4, S4) { \
RtlApplicationVerifierStop ((Code), \
(Msg), \
(ULONG_PTR)(P1),(S1), \
(ULONG_PTR)(P2),(S2), \
(ULONG_PTR)(P3),(S3), \
(ULONG_PTR)(P4),(S4)); \
}
VOID
RtlApplicationVerifierStop (
ULONG_PTR Code,
PCHAR Message,
ULONG_PTR Param1, PCHAR Description1,
ULONG_PTR Param2, PCHAR Description2,
ULONG_PTR Param3, PCHAR Description3,
ULONG_PTR Param4, PCHAR Description4
);
// end_winnt
//
// VectoredExceptionHandler Stuff
//
// begin_winnt
typedef LONG (NTAPI *PVECTORED_EXCEPTION_HANDLER)(
struct _EXCEPTION_POINTERS *ExceptionInfo
);
// end_winnt
NTSYSAPI
BOOLEAN
NTAPI
RtlCallVectoredExceptionHandlers(
IN PEXCEPTION_RECORD ExceptionRecord,
IN PCONTEXT ContextRecord
);
NTSYSAPI
PVOID
NTAPI
RtlAddVectoredExceptionHandler(
IN ULONG FirstHandler,
IN PVECTORED_EXCEPTION_HANDLER VectoredHandler
);
NTSYSAPI
ULONG
NTAPI
RtlRemoveVectoredExceptionHandler(
IN PVOID VectoredHandlerHandle
);
//
// Current Directory Stuff
//
typedef struct _RTL_RELATIVE_NAME {
STRING RelativeName;
HANDLE ContainingDirectory;
} RTL_RELATIVE_NAME, *PRTL_RELATIVE_NAME;
typedef enum _RTL_PATH_TYPE {
RtlPathTypeUnknown, // 0
RtlPathTypeUncAbsolute, // 1
RtlPathTypeDriveAbsolute, // 2
RtlPathTypeDriveRelative, // 3
RtlPathTypeRooted, // 4
RtlPathTypeRelative, // 5
RtlPathTypeLocalDevice, // 6
RtlPathTypeRootLocalDevice // 7
} RTL_PATH_TYPE;
NTSYSAPI
RTL_PATH_TYPE
NTAPI
RtlDetermineDosPathNameType_U(
PCWSTR DosFileName
);
NTSYSAPI
ULONG
NTAPI
RtlIsDosDeviceName_U(
PWSTR DosFileName
);
NTSYSAPI
ULONG
NTAPI
RtlGetFullPathName_U(
PCWSTR lpFileName,
ULONG nBufferLength,
PWSTR lpBuffer,
PWSTR *lpFilePart
);
NTSYSAPI
ULONG
NTAPI
RtlGetCurrentDirectory_U(
ULONG nBufferLength,
PWSTR lpBuffer
);
NTSYSAPI
NTSTATUS
NTAPI
RtlSetCurrentDirectory_U(
IN PUNICODE_STRING PathName
);
NTSYSAPI
ULONG
NTAPI
RtlGetLongestNtPathLength( VOID );
NTSYSAPI
BOOLEAN
NTAPI
RtlDosPathNameToNtPathName_U(
PCWSTR DosFileName,
PUNICODE_STRING NtFileName,
PWSTR *FilePart OPTIONAL,
PRTL_RELATIVE_NAME RelativeName OPTIONAL
);
NTSYSAPI
ULONG
NTAPI
RtlDosSearchPath_U(
IN PCWSTR lpPath,
IN PCWSTR lpFileName,
IN PCWSTR lpExtension,
ULONG nBufferLength,
PWSTR lpBuffer,
PWSTR *lpFilePart
);
#define RTL_DOS_SEARCH_PATH_FLAG_APPLY_ISOLATION_REDIRECTION (0x00000001)
// Flags to preserve Win32 SearchPathW() semantics in the ntdll implementation:
#define RTL_DOS_SEARCH_PATH_FLAG_DISALLOW_DOT_RELATIVE_PATH_SEARCH (0x00000002)
#define RTL_DOS_SEARCH_PATH_FLAG_APPLY_DEFAULT_EXTENSION_WHEN_NOT_RELATIVE_PATH_EVEN_IF_FILE_HAS_EXTENSION (0x00000004)
NTSYSAPI
NTSTATUS
NTAPI
RtlDosSearchPath_Ustr(
IN ULONG Flags,
IN PCUNICODE_STRING Path,
IN PCUNICODE_STRING FileName,
IN PCUNICODE_STRING DefaultExtension OPTIONAL,
OUT PUNICODE_STRING StaticString OPTIONAL,
OUT PUNICODE_STRING DynamicString OPTIONAL,
OUT PCUNICODE_STRING *FullFileNameOut OPTIONAL,
OUT SIZE_T *FilePartPrefixCch OPTIONAL,
OUT SIZE_T *BytesRequired OPTIONAL
);
NTSYSAPI
BOOLEAN
NTAPI
RtlDoesFileExists_U(
PCWSTR FileName
);
// input flags
#define RTL_DOS_APPLY_FILE_REDIRECTION_USTR_FLAG_RESPECT_DOT_LOCAL (1)
// output flags
#define RTL_DOS_APPLY_FILE_REDIRECTION_USTR_OUTFLAG_DOT_LOCAL_REDIRECT (1)
#define RTL_DOS_APPLY_FILE_REDIRECTION_USTR_OUTFLAG_ACTCTX_REDIRECT (2)
NTSYSAPI
NTSTATUS
NTAPI
RtlDosApplyFileIsolationRedirection_Ustr(
IN ULONG Flags,
IN PCUNICODE_STRING FileName,
IN PCUNICODE_STRING DefaultExtension OPTIONAL,
IN PUNICODE_STRING PreAllocatedString OPTIONAL,
OUT PUNICODE_STRING DynamicallyAllocatedString OPTIONAL,
OUT PUNICODE_STRING *FullPath OPTIONAL,
OUT ULONG * OutFlags,
OUT SIZE_T *FilePartPrefixCch OPTIONAL,
OUT SIZE_T *BytesRequired OPTIONAL
);
NTSYSAPI
NTSTATUS
NTAPI
RtlComputePrivatizedDllName_U(
IN PCUNICODE_STRING DllName,
IN OUT PUNICODE_STRING NewDllNameUnderImageDir,
IN OUT PUNICODE_STRING NewDllNameUnderLocalDir
);
NTSYSAPI
NTSTATUS
NTAPI
RtlInitializeProfile (
BOOLEAN KernelToo
);
NTSYSAPI
NTSTATUS
NTAPI
RtlStartProfile (
VOID
);
NTSYSAPI
NTSTATUS
NTAPI
RtlStopProfile (
VOID
);
NTSYSAPI
NTSTATUS
NTAPI
RtlAnalyzeProfile (
VOID
);
//
// User mode only security Rtl routines
//
//
// Structure to hold information about an ACE to be created
//
#ifdef _MAC
#pragma warning( disable : 4121)
#endif
typedef struct {
UCHAR AceType;
UCHAR InheritFlags;
UCHAR AceFlags;
ACCESS_MASK Mask;
PSID *Sid;
} RTL_ACE_DATA, *PRTL_ACE_DATA;
#ifdef _MAC
#pragma warning( default : 4121 )
#endif
NTSYSAPI
NTSTATUS
NTAPI
RtlNewSecurityObject(
PSECURITY_DESCRIPTOR ParentDescriptor,
PSECURITY_DESCRIPTOR CreatorDescriptor,
PSECURITY_DESCRIPTOR * NewDescriptor,
BOOLEAN IsDirectoryObject,
HANDLE Token,
PGENERIC_MAPPING GenericMapping
);
NTSYSAPI
NTSTATUS
NTAPI
RtlNewSecurityObjectEx (
IN PSECURITY_DESCRIPTOR ParentDescriptor OPTIONAL,
IN PSECURITY_DESCRIPTOR CreatorDescriptor OPTIONAL,
OUT PSECURITY_DESCRIPTOR * NewDescriptor,
IN GUID *ObjectType OPTIONAL,
IN BOOLEAN IsDirectoryObject,
IN ULONG AutoInheritFlags,
IN HANDLE Token,
IN PGENERIC_MAPPING GenericMapping
);
NTSYSAPI
NTSTATUS
NTAPI
RtlNewSecurityObjectWithMultipleInheritance (
IN PSECURITY_DESCRIPTOR ParentDescriptor OPTIONAL,
IN PSECURITY_DESCRIPTOR CreatorDescriptor OPTIONAL,
OUT PSECURITY_DESCRIPTOR * NewDescriptor,
IN GUID **pObjectType OPTIONAL,
IN ULONG GuidCount,
IN BOOLEAN IsDirectoryObject,
IN ULONG AutoInheritFlags,
IN HANDLE Token,
IN PGENERIC_MAPPING GenericMapping
);
// Values for AutoInheritFlags
// begin_winnt
#define SEF_DACL_AUTO_INHERIT 0x01
#define SEF_SACL_AUTO_INHERIT 0x02
#define SEF_DEFAULT_DESCRIPTOR_FOR_OBJECT 0x04
#define SEF_AVOID_PRIVILEGE_CHECK 0x08
#define SEF_AVOID_OWNER_CHECK 0x10
#define SEF_DEFAULT_OWNER_FROM_PARENT 0x20
#define SEF_DEFAULT_GROUP_FROM_PARENT 0x40
// end_winnt
NTSTATUS
RtlConvertToAutoInheritSecurityObject(
IN PSECURITY_DESCRIPTOR ParentDescriptor OPTIONAL,
IN PSECURITY_DESCRIPTOR CurrentSecurityDescriptor,
OUT PSECURITY_DESCRIPTOR *NewSecurityDescriptor,
IN GUID *ObjectType OPTIONAL,
IN BOOLEAN IsDirectoryObject,
IN PGENERIC_MAPPING GenericMapping
);
NTSYSAPI
NTSTATUS
NTAPI
RtlSetSecurityObject (
SECURITY_INFORMATION SecurityInformation,
PSECURITY_DESCRIPTOR ModificationDescriptor,
PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor,
PGENERIC_MAPPING GenericMapping,
HANDLE Token
);
NTSYSAPI
NTSTATUS
NTAPI
RtlSetSecurityObjectEx (
IN SECURITY_INFORMATION SecurityInformation,
IN PSECURITY_DESCRIPTOR ModificationDescriptor,
IN OUT PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor,
IN ULONG AutoInheritFlags,
IN PGENERIC_MAPPING GenericMapping,
IN HANDLE Token OPTIONAL
);
NTSYSAPI
NTSTATUS
NTAPI
RtlQuerySecurityObject (
PSECURITY_DESCRIPTOR ObjectDescriptor,
SECURITY_INFORMATION SecurityInformation,
PSECURITY_DESCRIPTOR ResultantDescriptor,
ULONG DescriptorLength,
PULONG ReturnLength
);
NTSYSAPI
NTSTATUS
NTAPI
RtlDeleteSecurityObject (
PSECURITY_DESCRIPTOR * ObjectDescriptor
);
NTSYSAPI
NTSTATUS
NTAPI
RtlNewInstanceSecurityObject(
BOOLEAN ParentDescriptorChanged,
BOOLEAN CreatorDescriptorChanged,
PLUID OldClientTokenModifiedId,
PLUID NewClientTokenModifiedId,
PSECURITY_DESCRIPTOR ParentDescriptor,
PSECURITY_DESCRIPTOR CreatorDescriptor,
PSECURITY_DESCRIPTOR * NewDescriptor,
BOOLEAN IsDirectoryObject,
HANDLE Token,
PGENERIC_MAPPING GenericMapping
);
NTSYSAPI
NTSTATUS
NTAPI
RtlCopySecurityDescriptor(
PSECURITY_DESCRIPTOR InputSecurityDescriptor,
PSECURITY_DESCRIPTOR *OutputSecurityDescriptor
);
//
// list canonicalization
//
NTSYSAPI
NTSTATUS
NTAPI
RtlConvertUiListToApiList(
PUNICODE_STRING UiList OPTIONAL,
PUNICODE_STRING ApiList,
BOOLEAN BlankIsDelimiter
);
NTSYSAPI
NTSTATUS
NTAPI
RtlCreateAndSetSD(
IN PRTL_ACE_DATA AceData,
IN ULONG AceCount,
IN PSID OwnerSid OPTIONAL,
IN PSID GroupSid OPTIONAL,
OUT PSECURITY_DESCRIPTOR *NewDescriptor
);
NTSYSAPI
NTSTATUS
NTAPI
RtlCreateUserSecurityObject(
IN PRTL_ACE_DATA AceData,
IN ULONG AceCount,
IN PSID OwnerSid,
IN PSID GroupSid,
IN BOOLEAN IsDirectoryObject,
IN PGENERIC_MAPPING GenericMapping,
OUT PSECURITY_DESCRIPTOR *NewDescriptor
);
NTSYSAPI
NTSTATUS
NTAPI
RtlDefaultNpAcl(
OUT PACL * pAcl
);
//
// Per-Thread Curdir Support
//
typedef struct _RTL_PERTHREAD_CURDIR {
PRTL_DRIVE_LETTER_CURDIR CurrentDirectories;
PUNICODE_STRING ImageName;
PVOID Environment;
} RTL_PERTHREAD_CURDIR, *PRTL_PERTHREAD_CURDIR;
#define RtlAssociatePerThreadCurdir(BLOCK,CURRENTDIRECTORIES,IMAGENAME,ENVIRONMENT)\
(BLOCK)->CurrentDirectories = (CURRENTDIRECTORIES); \
(BLOCK)->ImageName = (IMAGENAME); \
(BLOCK)->Environment = (ENVIRONMENT); \
NtCurrentTeb()->NtTib.SubSystemTib = (PVOID)(BLOCK) \
#define RtlDisAssociatePerThreadCurdir() \
NtCurrentTeb()->NtTib.SubSystemTib = NULL;
#define RtlGetPerThreadCurdir() \
((PRTL_PERTHREAD_CURDIR)(NtCurrentTeb()->NtTib.SubSystemTib))
//
// See NTRTL.H for heap functions availble to both kernel and user mode code.
//
#define RtlProcessHeap() (NtCurrentPeb()->ProcessHeap)
NTSYSAPI
BOOLEAN
NTAPI
RtlLockHeap(
IN PVOID HeapHandle
);
NTSYSAPI
BOOLEAN
NTAPI
RtlUnlockHeap(
IN PVOID HeapHandle
);
NTSYSAPI
PVOID
NTAPI
RtlReAllocateHeap(
IN PVOID HeapHandle,
IN ULONG Flags,
IN PVOID BaseAddress,
IN SIZE_T Size
);
NTSYSAPI
BOOLEAN
NTAPI
RtlGetUserInfoHeap(
IN PVOID HeapHandle,
IN ULONG Flags,
IN PVOID BaseAddress,
OUT PVOID *UserValue OPTIONAL,
OUT PULONG UserFlags OPTIONAL
);
NTSYSAPI
BOOLEAN
NTAPI
RtlSetUserValueHeap(
IN PVOID HeapHandle,
IN ULONG Flags,
IN PVOID BaseAddress,
IN PVOID UserValue
);
NTSYSAPI
BOOLEAN
NTAPI
RtlSetUserFlagsHeap(
IN PVOID HeapHandle,
IN ULONG Flags,
IN PVOID BaseAddress,
IN ULONG UserFlagsReset,
IN ULONG UserFlagsSet
);
typedef struct _RTL_HEAP_TAG_INFO {
ULONG NumberOfAllocations;
ULONG NumberOfFrees;
SIZE_T BytesAllocated;
} RTL_HEAP_TAG_INFO, *PRTL_HEAP_TAG_INFO;
NTSYSAPI
ULONG
NTAPI
RtlCreateTagHeap(
IN PVOID HeapHandle,
IN ULONG Flags,
IN PWSTR TagPrefix OPTIONAL,
IN PWSTR TagNames
);
#define RTL_HEAP_MAKE_TAG HEAP_MAKE_TAG_FLAGS
NTSYSAPI
PWSTR
NTAPI
RtlQueryTagHeap(
IN PVOID HeapHandle,
IN ULONG Flags,
IN USHORT TagIndex,
IN BOOLEAN ResetCounters,
OUT PRTL_HEAP_TAG_INFO TagInfo OPTIONAL
);
NTSYSAPI
NTSTATUS
NTAPI
RtlExtendHeap(
IN PVOID HeapHandle,
IN ULONG Flags,
IN PVOID Base,
IN SIZE_T Size
);
NTSYSAPI
SIZE_T
NTAPI
RtlCompactHeap(
IN PVOID HeapHandle,
IN ULONG Flags
);
NTSYSAPI
BOOLEAN
NTAPI
RtlValidateHeap(
IN PVOID HeapHandle,
IN ULONG Flags,
IN PVOID BaseAddress
);
NTSYSAPI
BOOLEAN
NTAPI
RtlValidateProcessHeaps( VOID );
NTSYSAPI
ULONG
NTAPI
RtlGetProcessHeaps(
ULONG NumberOfHeaps,
PVOID *ProcessHeaps
);
typedef
NTSTATUS (NTAPI * PRTL_ENUM_HEAPS_ROUTINE)(
PVOID HeapHandle,
PVOID Parameter
);
NTSYSAPI
NTSTATUS
NTAPI
RtlEnumProcessHeaps(
PRTL_ENUM_HEAPS_ROUTINE EnumRoutine,
PVOID Parameter
);
typedef struct _RTL_HEAP_USAGE_ENTRY {
struct _RTL_HEAP_USAGE_ENTRY *Next;
PVOID Address;
SIZE_T Size;
USHORT AllocatorBackTraceIndex;
USHORT TagIndex;
} RTL_HEAP_USAGE_ENTRY, *PRTL_HEAP_USAGE_ENTRY;
typedef struct _RTL_HEAP_USAGE {
ULONG Length;
SIZE_T BytesAllocated;
SIZE_T BytesCommitted;
SIZE_T BytesReserved;
SIZE_T BytesReservedMaximum;
PRTL_HEAP_USAGE_ENTRY Entries;
PRTL_HEAP_USAGE_ENTRY AddedEntries;
PRTL_HEAP_USAGE_ENTRY RemovedEntries;
ULONG_PTR Reserved[ 8 ];
} RTL_HEAP_USAGE, *PRTL_HEAP_USAGE;
#define HEAP_USAGE_ALLOCATED_BLOCKS HEAP_REALLOC_IN_PLACE_ONLY
#define HEAP_USAGE_FREE_BUFFER HEAP_ZERO_MEMORY
NTSYSAPI
NTSTATUS
NTAPI
RtlUsageHeap(
IN PVOID HeapHandle,
IN ULONG Flags,
IN OUT PRTL_HEAP_USAGE Usage
);
typedef struct _RTL_HEAP_WALK_ENTRY {
PVOID DataAddress;
SIZE_T DataSize;
UCHAR OverheadBytes;
UCHAR SegmentIndex;
USHORT Flags;
union {
struct {
SIZE_T Settable;
USHORT TagIndex;
USHORT AllocatorBackTraceIndex;
ULONG Reserved[ 2 ];
} Block;
struct {
ULONG CommittedSize;
ULONG UnCommittedSize;
PVOID FirstEntry;
PVOID LastEntry;
} Segment;
};
} RTL_HEAP_WALK_ENTRY, *PRTL_HEAP_WALK_ENTRY;
NTSYSAPI
NTSTATUS
NTAPI
RtlWalkHeap(
IN PVOID HeapHandle,
IN OUT PRTL_HEAP_WALK_ENTRY Entry
);
typedef struct _RTL_HEAP_ENTRY {
SIZE_T Size;
USHORT Flags;
USHORT AllocatorBackTraceIndex;
union {
struct {
SIZE_T Settable;
ULONG Tag;
} s1; // All other heap entries
struct {
SIZE_T CommittedSize;
PVOID FirstBlock;
} s2; // RTL_SEGMENT
} u;
} RTL_HEAP_ENTRY, *PRTL_HEAP_ENTRY;
#define RTL_HEAP_BUSY (USHORT)0x0001
#define RTL_HEAP_SEGMENT (USHORT)0x0002
#define RTL_HEAP_SETTABLE_VALUE (USHORT)0x0010
#define RTL_HEAP_SETTABLE_FLAG1 (USHORT)0x0020
#define RTL_HEAP_SETTABLE_FLAG2 (USHORT)0x0040
#define RTL_HEAP_SETTABLE_FLAG3 (USHORT)0x0080
#define RTL_HEAP_SETTABLE_FLAGS (USHORT)0x00E0
#define RTL_HEAP_UNCOMMITTED_RANGE (USHORT)0x0100
#define RTL_HEAP_PROTECTED_ENTRY (USHORT)0x0200
typedef struct _RTL_HEAP_TAG {
ULONG NumberOfAllocations;
ULONG NumberOfFrees;
SIZE_T BytesAllocated;
USHORT TagIndex;
USHORT CreatorBackTraceIndex;
WCHAR TagName[ 24 ];
} RTL_HEAP_TAG, *PRTL_HEAP_TAG;
typedef struct _RTL_HEAP_INFORMATION {
PVOID BaseAddress;
ULONG Flags;
USHORT EntryOverhead;
USHORT CreatorBackTraceIndex;
SIZE_T BytesAllocated;
SIZE_T BytesCommitted;
ULONG NumberOfTags;
ULONG NumberOfEntries;
ULONG NumberOfPseudoTags;
ULONG PseudoTagGranularity;
ULONG Reserved[ 5 ];
PRTL_HEAP_TAG Tags;
PRTL_HEAP_ENTRY Entries;
} RTL_HEAP_INFORMATION, *PRTL_HEAP_INFORMATION;
typedef struct _RTL_PROCESS_HEAPS {
ULONG NumberOfHeaps;
RTL_HEAP_INFORMATION Heaps[ 1 ];
} RTL_PROCESS_HEAPS, *PRTL_PROCESS_HEAPS;
//
// Heap Information APIs & data definitions
//
// begin_winnt
typedef enum _HEAP_INFORMATION_CLASS {
HeapCompatibilityInformation
} HEAP_INFORMATION_CLASS;
NTSTATUS
RtlSetHeapInformation (
IN PVOID HeapHandle,
IN HEAP_INFORMATION_CLASS HeapInformationClass,
IN PVOID HeapInformation OPTIONAL,
IN SIZE_T HeapInformationLength OPTIONAL
);
NTSTATUS
RtlQueryHeapInformation (
IN PVOID HeapHandle,
IN HEAP_INFORMATION_CLASS HeapInformationClass,
OUT PVOID HeapInformation OPTIONAL,
IN SIZE_T HeapInformationLength OPTIONAL,
OUT PSIZE_T ReturnLength OPTIONAL
);
// end_winnt
//
// Debugging support
//
typedef struct _RTL_DEBUG_INFORMATION {
HANDLE SectionHandleClient;
PVOID ViewBaseClient;
PVOID ViewBaseTarget;
ULONG_PTR ViewBaseDelta;
HANDLE EventPairClient;
HANDLE EventPairTarget;
HANDLE TargetProcessId;
HANDLE TargetThreadHandle;
ULONG Flags;
SIZE_T OffsetFree;
SIZE_T CommitSize;
SIZE_T ViewSize;
PRTL_PROCESS_MODULES Modules;
PRTL_PROCESS_BACKTRACES BackTraces;
PRTL_PROCESS_HEAPS Heaps;
PRTL_PROCESS_LOCKS Locks;
PVOID SpecificHeap;
HANDLE TargetProcessHandle;
PVOID Reserved[ 6 ];
} RTL_DEBUG_INFORMATION, *PRTL_DEBUG_INFORMATION;
NTSYSAPI
PRTL_DEBUG_INFORMATION
NTAPI
RtlCreateQueryDebugBuffer(
IN ULONG MaximumCommit OPTIONAL,
IN BOOLEAN UseEventPair
);
NTSYSAPI
NTSTATUS
NTAPI
RtlDestroyQueryDebugBuffer(
IN PRTL_DEBUG_INFORMATION Buffer
);
NTSYSAPI
NTSTATUS
NTAPI
RtlQueryProcessDebugInformation(
IN HANDLE UniqueProcessId,
IN ULONG Flags,
IN OUT PRTL_DEBUG_INFORMATION Buffer
);
#define RTL_QUERY_PROCESS_MODULES 0x00000001
#define RTL_QUERY_PROCESS_BACKTRACES 0x00000002
#define RTL_QUERY_PROCESS_HEAP_SUMMARY 0x00000004
#define RTL_QUERY_PROCESS_HEAP_TAGS 0x00000008
#define RTL_QUERY_PROCESS_HEAP_ENTRIES 0x00000010
#define RTL_QUERY_PROCESS_LOCKS 0x00000020
#define RTL_QUERY_PROCESS_MODULES32 0x00000040
#define RTL_QUERY_PROCESS_NONINVASIVE 0x80000000
NTSTATUS
NTAPI
RtlQueryProcessModuleInformation(
IN HANDLE hProcess OPTIONAL,
IN ULONG Flags,
IN OUT PRTL_DEBUG_INFORMATION Buffer
);
NTSYSAPI
NTSTATUS
NTAPI
RtlQueryProcessBackTraceInformation(
IN OUT PRTL_DEBUG_INFORMATION Buffer
);
NTSYSAPI
NTSTATUS
NTAPI
RtlQueryProcessHeapInformation(
IN OUT PRTL_DEBUG_INFORMATION Buffer
);
NTSYSAPI
NTSTATUS
NTAPI
RtlQueryProcessLockInformation(
IN OUT PRTL_DEBUG_INFORMATION Buffer
);
//
// Routines for manipulating user mode handle tables. Used for Atoms
// and Local/Global memory allocations.
//
typedef struct _RTL_HANDLE_TABLE_ENTRY {
union {
ULONG Flags; // Allocated entries have low bit set
struct _RTL_HANDLE_TABLE_ENTRY *NextFree; // Free entries use this word for free list
};
} RTL_HANDLE_TABLE_ENTRY, *PRTL_HANDLE_TABLE_ENTRY;
#define RTL_HANDLE_ALLOCATED (USHORT)0x0001
typedef struct _RTL_HANDLE_TABLE {
ULONG MaximumNumberOfHandles;
ULONG SizeOfHandleTableEntry;
ULONG Reserved[ 2 ];
PRTL_HANDLE_TABLE_ENTRY FreeHandles;
PRTL_HANDLE_TABLE_ENTRY CommittedHandles;
PRTL_HANDLE_TABLE_ENTRY UnCommittedHandles;
PRTL_HANDLE_TABLE_ENTRY MaxReservedHandles;
} RTL_HANDLE_TABLE, *PRTL_HANDLE_TABLE;
NTSYSAPI
void
NTAPI
RtlInitializeHandleTable(
IN ULONG MaximumNumberOfHandles,
IN ULONG SizeOfHandleTableEntry,
OUT PRTL_HANDLE_TABLE HandleTable
);
NTSYSAPI
NTSTATUS
NTAPI
RtlDestroyHandleTable(
IN OUT PRTL_HANDLE_TABLE HandleTable
);
NTSYSAPI
PRTL_HANDLE_TABLE_ENTRY
NTAPI
RtlAllocateHandle(
IN PRTL_HANDLE_TABLE HandleTable,
OUT PULONG HandleIndex OPTIONAL
);
NTSYSAPI
BOOLEAN
NTAPI
RtlFreeHandle(
IN PRTL_HANDLE_TABLE HandleTable,
IN PRTL_HANDLE_TABLE_ENTRY Handle
);
NTSYSAPI
BOOLEAN
NTAPI
RtlIsValidHandle(
IN PRTL_HANDLE_TABLE HandleTable,
IN PRTL_HANDLE_TABLE_ENTRY Handle
);
NTSYSAPI
BOOLEAN
NTAPI
RtlIsValidIndexHandle(
IN PRTL_HANDLE_TABLE HandleTable,
IN ULONG HandleIndex,
OUT PRTL_HANDLE_TABLE_ENTRY *Handle
);
//
// Routines for thread pool.
//
#define WT_EXECUTEDEFAULT 0x00000000 // winnt
#define WT_EXECUTEINIOTHREAD 0x00000001 // winnt
#define WT_EXECUTEINUITHREAD 0x00000002 // winnt
#define WT_EXECUTEINWAITTHREAD 0x00000004 // winnt
#define WT_EXECUTEONLYONCE 0x00000008 // winnt
#define WT_EXECUTEINTIMERTHREAD 0x00000020 // winnt
#define WT_EXECUTELONGFUNCTION 0x00000010 // winnt
#define WT_EXECUTEINPERSISTENTIOTHREAD 0x00000040 // winnt
#define WT_EXECUTEINPERSISTENTTHREAD 0x00000080 // winnt
#define WT_SET_MAX_THREADPOOL_THREADS(Flags, Limit) ((Flags) |= (Limit)<<16) // winnt
typedef VOID (NTAPI * WAITORTIMERCALLBACKFUNC) (PVOID, BOOLEAN ); // winnt
typedef VOID (NTAPI * WORKERCALLBACKFUNC) (PVOID ); // winnt
typedef VOID (NTAPI * APC_CALLBACK_FUNCTION) (NTSTATUS, PVOID, PVOID); // winnt
typedef NTSTATUS (NTAPI RTLP_START_THREAD)(
PUSER_THREAD_START_ROUTINE,
PVOID,
HANDLE *);
typedef NTSTATUS (NTAPI RTLP_EXIT_THREAD)(
NTSTATUS );
typedef RTLP_START_THREAD * PRTLP_START_THREAD ;
typedef RTLP_EXIT_THREAD * PRTLP_EXIT_THREAD ;
NTSTATUS
NTAPI
RtlSetThreadPoolStartFunc(
PRTLP_START_THREAD StartFunc,
PRTLP_EXIT_THREAD ExitFunc
);
NTSYSAPI
NTSTATUS
NTAPI
RtlRegisterWait (
OUT PHANDLE WaitHandle,
IN HANDLE Handle,
IN WAITORTIMERCALLBACKFUNC Function,
IN PVOID Context,
IN ULONG Milliseconds,
IN ULONG Flags
) ;
NTSYSAPI
NTSTATUS
NTAPI
RtlDeregisterWait(
IN HANDLE WaitHandle
) ;
NTSYSAPI
NTSTATUS
NTAPI
RtlDeregisterWaitEx(
IN HANDLE WaitHandle,
IN HANDLE Event
) ;
NTSYSAPI
NTSTATUS
NTAPI
RtlQueueWorkItem(
IN WORKERCALLBACKFUNC Function,
IN PVOID Context,
IN ULONG Flags
) ;
NTSTATUS
NTAPI
RtlSetIoCompletionCallback (
IN HANDLE FileHandle,
IN APC_CALLBACK_FUNCTION CompletionProc,
IN ULONG Flags
) ;
NTSYSAPI
NTSTATUS
NTAPI
RtlCreateTimerQueue(
OUT PHANDLE TimerQueueHandle
) ;
NTSYSAPI
NTSTATUS
NTAPI
RtlCreateTimer(
IN HANDLE TimerQueueHandle,
OUT HANDLE *Handle,
IN WAITORTIMERCALLBACKFUNC Function,
IN PVOID Context,
IN ULONG DueTime,
IN ULONG Period,
IN ULONG Flags
) ;
NTSYSAPI
NTSTATUS
NTAPI
RtlUpdateTimer(
IN HANDLE TimerQueueHandle,
IN HANDLE TimerHandle,
IN ULONG DueTime,
IN ULONG Period
) ;
NTSYSAPI
NTSTATUS
NTAPI
RtlDeleteTimer(
IN HANDLE TimerQueueHandle,
IN HANDLE TimerToCancel,
IN HANDLE Event
) ;
NTSYSAPI
NTSTATUS
NTAPI
RtlDeleteTimerQueue(
IN HANDLE TimerQueueHandle
) ;
NTSYSAPI
NTSTATUS
NTAPI
RtlDeleteTimerQueueEx(
IN HANDLE TimerQueueHandle,
IN HANDLE Event
) ;
BOOLEAN
RtlDllShutdownInProgress (
VOID
);
//--------OBSOLETE FUNCTIONS: DONT USE----------//
VOID
RtlDebugPrintTimes (
VOID
);
NTSYSAPI
NTSTATUS
NTAPI
RtlCancelTimer(
IN HANDLE TimerQueueHandle,
IN HANDLE TimerToCancel
) ;
NTSYSAPI
NTSTATUS
NTAPI
RtlSetTimer(
IN HANDLE TimerQueueHandle,
OUT HANDLE *Handle,
IN WAITORTIMERCALLBACKFUNC Function,
IN PVOID Context,
IN ULONG DueTime,
IN ULONG Period,
IN ULONG Flags
) ;
//todo:delete below: dont use the below flag. will be deleted
#define WT_EXECUTEINLONGTHREAD 0x00000010 // winnt
#define WT_EXECUTEDELETEWAIT 0x00000008 // winnt
//------end OBSOLUTE FUNCTIONS: DONT USE--------//
#if (defined(RTL_DECLARE_IMALLOC) && RTL_DECLARE_IMALLOC) \
|| (defined(RTL_DECLARE_STREAMS) && RTL_DECLARE_STREAMS \
&& defined(RTL_DECLARE_MEMORY_STREAM) && RTL_DECLARE_MEMORY_STREAM)
// Introducing the struct before the typedef works better if the
// header is enclosed in a C++ namespace.
struct IMallocVtbl; typedef struct IMallocVtbl IMallocVtbl;
#if defined(interface) // it's defined in objbase.h
interface IMalloc; typedef interface IMalloc IMalloc;
#else
struct IMalloc; typedef struct IMalloc IMalloc;
#endif
#endif
#if defined(RTL_DECLARE_IMALLOC) && RTL_DECLARE_IMALLOC
//
// IMalloc over an RtlHeap
//
struct _RTL_IMALLOC;
typedef struct _RTL_IMALLOC {
ULONG ReferenceCount;
ULONG Flags;
VOID (STDMETHODCALLTYPE* FinalRelease)(struct _RTL_HEAP_IMALLOC*);
HANDLE Heap;
ULONG HeapFlags;
} RTL_IMALLOC, *PRTL_IMALLOC;
//
// Don't use NTSYSAPI directly so you can more easily
// statically link to these functions, independently
// of how you link to the rest of ntdll.
//
#if !defined(RTL_IMALLOC_API)
#define RTL_IMALLOC_API NTSYSAPI
#endif
RTL_IMALLOC_API
HRESULT
STDMETHODCALLTYPE
RtlAllocHeapIMalloc(
PRTL_HEAP_IMALLOC HeapIMalloc
);
RTL_IMALLOC_API
PVOID
STDMETHODCALLTYPE
RtlReallocIMalloc(
PRTL_IMALLOC Malloc,
PVOID BlockOfMemory,
ULONG NumberOfBytes
);
RTL_IMALLOC_API
VOID
STDMETHODCALLTYPE
RtlFreeIMalloc(
PRTL_IMALLOC Malloc,
PVOID BlockOfMemory
);
RTL_IMALLOC_API
ULONG
STDMETHODCALLTYPE
RtlGetSizeIMalloc(
PRTL_IMALLOC Malloc,
PVOID BlockOfMemory
);
RTL_IMALLOC_API
BOOL
STDMETHODCALLTYPE
RtlDidAllocIMalloc(
PRTL_IMALLOC Malloc,
PVOID BlockOfMemory
);
RTL_IMALLOC_API
VOID
STDMETHODCALLTYPE
RtlMinimizeIMalloc(
PRTL_IMALLOC Malloc
);
RTL_IMALLOC_API
PRTL_IMALLOC
STDMETHODCALLTYPE
RtlProcessIMalloc(
VOID
);
#endif // RTL_DECLARE_MALLOC
#if defined(RTL_DECLARE_STREAMS) && RTL_DECLARE_STREAMS
// Introducing the structs before the typedefs works better if the
// header is enclosed in a C++ namespace.
struct tagSTATSTG; typedef struct tagSTATSTG STATSTG;
struct IStreamVtbl; typedef struct IStreamVtbl IStreamVtbl;
#if defined(interface) // it's defined in objbase.h
interface IStream; typedef interface IStream IStream;
#else
struct IStream; typedef struct IStream IStream;
#endif
#if defined(RTL_DECLARE_FILE_STREAM) && RTL_DECLARE_FILE_STREAM
//
// IStream over an NT File handle (not yet adapted for C++)
//
struct _RTL_FILE_STREAM;
typedef struct _RTL_FILE_STREAM
{
LONG ReferenceCount;
ULONG Flags;
VOID (STDMETHODCALLTYPE* FinalRelease)(struct _RTL_FILE_STREAM*);
HANDLE FileHandle;
} RTL_FILE_STREAM, *PRTL_FILE_STREAM;
//
// Don't use NTSYSAPI directly so you can more easily
// statically link to these functions, independently
// of how you link to the rest of ntdll.
//
#if !defined(RTL_FILE_STREAM_API)
#define RTL_FILE_STREAM_API NTSYSAPI
#endif
RTL_FILE_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlInitFileStream(
PRTL_FILE_STREAM FileStream
);
RTL_FILE_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlCloseFileStream(
PRTL_FILE_STREAM FileStream
);
RTL_FILE_STREAM_API
ULONG
STDMETHODCALLTYPE
RtlAddRefFileStream(
PRTL_FILE_STREAM FileStream
);
RTL_FILE_STREAM_API
ULONG
STDMETHODCALLTYPE
RtlReleaseFileStream(
PRTL_FILE_STREAM FileStream
);
RTL_FILE_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlQueryFileStreamInterface(
IStream* Functions,
PRTL_FILE_STREAM Data,
const IID* Interface,
PVOID* Object
);
RTL_FILE_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlReadFileStream(
PRTL_FILE_STREAM FileStream,
PVOID Buffer,
ULONG BytesToRead,
ULONG* BytesRead
);
RTL_FILE_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlWriteFileStream(
PRTL_FILE_STREAM FileStream,
const VOID* Buffer,
ULONG BytesToWrite,
ULONG* BytesWritten
);
RTL_FILE_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlSeekFileStream(
PRTL_FILE_STREAM FileStream,
LARGE_INTEGER Distance,
ULONG Origin,
ULARGE_INTEGER* NewPosition
);
/* returns E_NOTIMPL */
RTL_FILE_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlSetFileStreamSize(
PRTL_FILE_STREAM FileStream,
ULARGE_INTEGER NewSize
);
/* returns E_NOTIMPL */
RTL_FILE_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlCopyFileStreamTo(
PRTL_FILE_STREAM FileStream,
IStream* AnotherStream,
ULARGE_INTEGER NumberOfBytesToCopy,
ULARGE_INTEGER* NumberOfBytesRead,
ULARGE_INTEGER* NumberOfBytesWritten
);
/* returns E_NOTIMPL */
RTL_FILE_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlCommitFileStream(
PRTL_FILE_STREAM FileStream,
ULONG Flags
);
/* returns E_NOTIMPL */
RTL_FILE_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlRevertFileStream(
PRTL_FILE_STREAM FileStream
);
/* returns E_NOTIMPL */
RTL_FILE_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlLockFileStreamRegion(
PRTL_FILE_STREAM FileStream,
ULARGE_INTEGER Offset,
ULARGE_INTEGER NumberOfBytes,
ULONG LockType
);
/* returns E_NOTIMPL */
RTL_FILE_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlUnlockFileStreamRegion(
PRTL_FILE_STREAM FileStream,
ULARGE_INTEGER Offset,
ULARGE_INTEGER NumberOfBytes,
ULONG LockType
);
/* returns E_NOTIMPL */
RTL_FILE_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlStatFileStream(
PRTL_FILE_STREAM FileStream,
STATSTG* StatusInformation,
ULONG Flags
);
/* returns E_NOTIMPL */
RTL_FILE_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlCloneFileStream(
PRTL_FILE_STREAM FileStream,
IStream** NewStream
);
#endif // RTL_DECLARE_FILE_STREAM
//
// functions for implementing a readable IStream over a block of memory
// (writable/growable in the future)
//
#if defined(RTL_DECLARE_MEMORY_STREAM) && RTL_DECLARE_MEMORY_STREAM
struct _RTL_MEMORY_STREAM_DATA;
struct _RTL_MEMORY_STREAM_WITH_VTABLE;
struct _RTL_OUT_OF_PROCESS_MEMORY_STREAM_DATA;
struct _RTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE;
//
// Don't use NTSYSAPI directly so you can more easily
// statically link to these functions, independently
// of how you link to the rest of ntdll.
//
#if !defined(RTL_MEMORY_STREAM_API)
#define RTL_MEMORY_STREAM_API NTSYSAPI
#endif
typedef struct _RTL_MEMORY_STREAM_DATA {
#define RTLP_MEMORY_STREAM_DATA_PREFIX \
LONG ReferenceCount; \
ULONG Flags; \
PUCHAR Current; \
PUCHAR Begin; \
PUCHAR End
RTLP_MEMORY_STREAM_DATA_PREFIX;
VOID (STDMETHODCALLTYPE* FinalRelease)(struct _RTL_MEMORY_STREAM_WITH_VTABLE*);
IMalloc* ReservedForMalloc;
} RTL_MEMORY_STREAM_DATA, *PRTL_MEMORY_STREAM_DATA;
typedef struct _RTL_MEMORY_STREAM_WITH_VTABLE {
const IStreamVtbl* StreamVTable;
RTL_MEMORY_STREAM_DATA Data;
} RTL_MEMORY_STREAM_WITH_VTABLE, *PRTL_MEMORY_STREAM_WITH_VTABLE;
typedef struct _RTL_OUT_OF_PROCESS_MEMORY_STREAM_DATA {
RTLP_MEMORY_STREAM_DATA_PREFIX;
VOID (STDMETHODCALLTYPE* FinalRelease)(struct _RTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE*);
HANDLE Process;
} RTL_OUT_OF_PROCESS_MEMORY_STREAM_DATA, *PRTL_OUT_OF_PROCESS_MEMORY_STREAM_DATA;
typedef struct _RTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE {
const IStreamVtbl* StreamVTable;
RTL_OUT_OF_PROCESS_MEMORY_STREAM_DATA Data;
} RTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE, *PRTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE;
//
// These macros generate function pointer types that match the IStream member functions,
// but IStream* is replaced by "T". As well, an identifier is placed within the type
// appropriately for defining a typedef or a struct member or a variable.
// They are used so that a vtable can be somewhat typesafely initialized.
// This way, if you fill out the vtable in the wrong order, you will like get a compile
// error (other than were function signatures coincide).
// Also, you don't have to cast the this pointer in your implementations of member functions.
//
// You should define a set of macros like this for any COM interface you implement in C.
//
#define RTLP_STREAM_NOTHING /* nothing */
#define PRTL_QUERYINTERFACE_STREAM2(T, Name) HRESULT (STDMETHODCALLTYPE* Name)(T* This, const IID* riid, VOID** ppvObject)
#define PRTL_ADDREF_STREAM2(T, Name) ULONG (STDMETHODCALLTYPE* Name)(T* This)
#define PRTL_RELEASE_STREAM2(T, Name) ULONG (STDMETHODCALLTYPE* Name)(T* This)
#define PRTL_READ_STREAM2(T, Name) HRESULT (STDMETHODCALLTYPE* Name)(T* This, VOID* pv, ULONG cb, ULONG* pcbRead)
#define PRTL_WRITE_STREAM2(T, Name) HRESULT (STDMETHODCALLTYPE* Name)(T* This, const VOID* pv, ULONG cb, ULONG* pcbWritten)
#define PRTL_SEEK_STREAM2(T, Name) HRESULT (STDMETHODCALLTYPE* Name)(T* This, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition)
#define PRTL_SET_STREAM_SIZE2(T, Name) HRESULT (STDMETHODCALLTYPE* Name)(T* This, ULARGE_INTEGER libNewSize)
#define PRTL_COPY_STREAM_TO2(T, Name) HRESULT (STDMETHODCALLTYPE* Name)(T* This, IStream* pstm, ULARGE_INTEGER cb, ULARGE_INTEGER* pcbRead, ULARGE_INTEGER* pcbWritten)
#define PRTL_COMMIT_STREAM2(T, Name) HRESULT (STDMETHODCALLTYPE* Name)(T* This, DWORD grfCommitFlags)
#define PRTL_REVERT_STREAM2(T, Name) HRESULT (STDMETHODCALLTYPE* Name)(T* This)
#define PRTL_LOCK_STREAM_REGION2(T, Name) HRESULT (STDMETHODCALLTYPE* Name)(T* This, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
#define PRTL_UNLOCK_STREAM_REGION2(T, Name) HRESULT (STDMETHODCALLTYPE* Name)(T* This, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
#define PRTL_STAT_STREAM2(T, Name) HRESULT (STDMETHODCALLTYPE* Name)(T* This, STATSTG* pstatstg, DWORD grfStatFlag)
#define PRTL_CLONE_STREAM2(T, Name) HRESULT (STDMETHODCALLTYPE* Name)(T* This, IStream** ppstm)
//
// These macros are like the previous set, but they do not place a name in the
// type. They are appropriate for casting function pointers.
// They are used like so:
// #define RtlOperateOnDerivedFoo (PRTL_OPERATOR_INTERFACE2(RTL_DERIVED_FOO)RtlOperateOnBaseFoo)
//
// You should define a set of macros like this for any COM interface you implement in C.
//
#define PRTL_QUERYINTERFACE_STREAM1(T) PRTL_QUERYINTERFACE_STREAM2(T, RTLP_STREAM_NOTHING)
#define PRTL_ADDREF_STREAM1(T) PRTL_ADDREF_STREAM2(T, RTLP_STREAM_NOTHING)
#define PRTL_RELEASE_STREAM1(T) PRTL_RELEASE_STREAM2(T, RTLP_STREAM_NOTHING)
#define PRTL_READ_STREAM1(T) PRTL_READ_STREAM2(T, RTLP_STREAM_NOTHING)
#define PRTL_WRITE_STREAM1(T) PRTL_WRITE_STREAM2(T, RTLP_STREAM_NOTHING)
#define PRTL_SEEK_STREAM1(T) PRTL_SEEK_STREAM2(T, RTLP_STREAM_NOTHING)
#define PRTL_SET_STREAM_SIZE1(T) PRTL_SET_STREAM_SIZE2(T, RTLP_STREAM_NOTHING)
#define PRTL_COPY_STREAM_TO1(T) PRTL_COPY_STREAM_TO2(T, RTLP_STREAM_NOTHING)
#define PRTL_COMMIT_STREAM1(T) PRTL_COMMIT_STREAM2(T, RTLP_STREAM_NOTHING)
#define PRTL_REVERT_STREAM1(T) PRTL_REVERT_STREAM2(T, RTLP_STREAM_NOTHING)
#define PRTL_LOCK_STREAM_REGION1(T) PRTL_LOCK_STREAM_REGION2(T, RTLP_STREAM_NOTHING)
#define PRTL_UNLOCK_STREAM_REGION1(T) PRTL_UNLOCK_STREAM_REGION2(T, RTLP_STREAM_NOTHING)
#define PRTL_STAT_STREAM1(T) PRTL_STAT_STREAM2(T, RTLP_STREAM_NOTHING)
#define PRTL_CLONE_STREAM1(T) PRTL_CLONE_STREAM2(T, RTLP_STREAM_NOTHING)
//
// This "template" lets you fill out a VTable
// with some type safety. Then cast the address of the vtable.
// Midl ought to provide something like this..
//
// You should define a macro like this for any COM interface you implement in C.
//
#define RTL_STREAM_VTABLE_TEMPLATE(T) \
struct \
{ \
PRTL_QUERYINTERFACE_STREAM2(T, QueryInterface); \
PRTL_ADDREF_STREAM2(T, AddRef); \
PRTL_RELEASE_STREAM2(T, Release); \
PRTL_READ_STREAM2(T, Read); \
PRTL_WRITE_STREAM2(T, Write); \
PRTL_SEEK_STREAM2(T, Seek); \
PRTL_SET_STREAM_SIZE2(T, SetSize); \
PRTL_COPY_STREAM_TO2(T, CopyTo); \
PRTL_COMMIT_STREAM2(T, Commit); \
PRTL_REVERT_STREAM2(T, Revert); \
PRTL_LOCK_STREAM_REGION2(T, LockRegion); \
PRTL_UNLOCK_STREAM_REGION2(T, UnlockRegion); \
PRTL_STAT_STREAM2(T, Stat); \
PRTL_CLONE_STREAM2(T, Clone); \
}
RTL_MEMORY_STREAM_API
VOID
STDMETHODCALLTYPE
RtlInitMemoryStream(
PRTL_MEMORY_STREAM_WITH_VTABLE MemoryStream
);
RTL_MEMORY_STREAM_API
VOID
STDMETHODCALLTYPE
RtlInitOutOfProcessMemoryStream(
PRTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE MemoryStream
);
RTL_MEMORY_STREAM_API
VOID
STDMETHODCALLTYPE
RtlFinalReleaseOutOfProcessMemoryStream(
PRTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE MemoryStream
);
RTL_MEMORY_STREAM_API
ULONG
STDMETHODCALLTYPE
RtlAddRefMemoryStream(
PRTL_MEMORY_STREAM_WITH_VTABLE MemoryStream
);
#define RtlAddRefOutOfProcessMemoryStream \
((PRTL_ADDREF_STREAM1(RTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE))RtlAddRefMemoryStream)
RTL_MEMORY_STREAM_API
ULONG
STDMETHODCALLTYPE
RtlReleaseMemoryStream(
PRTL_MEMORY_STREAM_WITH_VTABLE MemoryStream
);
#define RtlReleaseOutOfProcessMemoryStream \
((PRTL_RELEASE_STREAM1(RTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE))RtlReleaseMemoryStream)
RTL_MEMORY_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlQueryInterfaceMemoryStream(
PRTL_MEMORY_STREAM_WITH_VTABLE MemoryStream,
const IID* Interface,
PVOID* Object
);
#define RtlQueryInterfaceOutOfProcessMemoryStream \
((PRTL_QUERYINTERFACE_STREAM1(RTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE))RtlQueryInterfaceMemoryStream)
RTL_MEMORY_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlReadMemoryStream(
PRTL_MEMORY_STREAM_WITH_VTABLE MemoryStream,
PVOID Buffer,
ULONG BytesToRead,
ULONG* BytesRead
);
RTL_MEMORY_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlReadOutOfProcessMemoryStream(
PRTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE MemoryStream,
PVOID Buffer,
ULONG BytesToRead,
ULONG* BytesRead
);
// E_NOTIMPL
RTL_MEMORY_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlWriteMemoryStream(
PRTL_MEMORY_STREAM_WITH_VTABLE MemoryStream,
const VOID* Buffer,
ULONG BytesToWrite,
ULONG* BytesWritten
);
#define RtlWriteOutOfProcessMemoryStream \
((PRTL_WRITE_STREAM1(RTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE))RtlWriteMemoryStream)
RTL_MEMORY_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlSeekMemoryStream(
PRTL_MEMORY_STREAM_WITH_VTABLE MemoryStream,
LARGE_INTEGER Distance,
ULONG Origin,
ULARGE_INTEGER* NewPosition
);
#define RtlSeekOutOfProcessMemoryStream \
((PRTL_SEEK_STREAM1(RTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE))RtlSeekMemoryStream)
// E_NOTIMPL
RTL_MEMORY_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlSetMemoryStreamSize(
PRTL_MEMORY_STREAM_WITH_VTABLE MemoryStream,
ULARGE_INTEGER NewSize
);
#define RtlSetOutOfProcessMemoryStreamSize \
((PRTL_SET_STREAM_SIZE1(RTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE))RtlSetMemoryStreamSize)
RTL_MEMORY_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlCopyMemoryStreamTo(
PRTL_MEMORY_STREAM_WITH_VTABLE MemoryStream,
IStream* AnotherStream,
ULARGE_INTEGER NumberOfBytesToCopy,
ULARGE_INTEGER* NumberOfBytesRead,
ULARGE_INTEGER* NumberOfBytesWritten
);
// E_NOTIMPL
RTL_MEMORY_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlCopyOutOfProcessMemoryStreamTo(
PRTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE MemoryStream,
IStream* AnotherStream,
ULARGE_INTEGER NumberOfBytesToCopy,
ULARGE_INTEGER* NumberOfBytesRead,
ULARGE_INTEGER* NumberOfBytesWritten
);
// E_NOTIMPL
RTL_MEMORY_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlCommitMemoryStream(
PRTL_MEMORY_STREAM_WITH_VTABLE MemoryStream,
ULONG Flags
);
#define RtlCommitOutOfProcessMemoryStream \
((PRTL_COMMIT_STREAM1(RTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE))RtlCommitMemoryStream)
// E_NOTIMPL
RTL_MEMORY_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlRevertMemoryStream(
PRTL_MEMORY_STREAM_WITH_VTABLE MemoryStream
);
#define RtlRevertOutOfProcessMemoryStream \
((PRTL_REVERT_STREAM1(RTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE))RtlRevertMemoryStream)
// E_NOTIMPL
RTL_MEMORY_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlLockMemoryStreamRegion(
PRTL_MEMORY_STREAM_WITH_VTABLE MemoryStream,
ULARGE_INTEGER Offset,
ULARGE_INTEGER NumberOfBytes,
ULONG LockType
);
#define RtlLockOutOfProcessMemoryStreamRegion \
((PRTL_LOCK_STREAM_REGION1(RTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE))RtlLockMemoryStreamRegion)
// E_NOTIMPL
RTL_MEMORY_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlUnlockMemoryStreamRegion(
PRTL_MEMORY_STREAM_WITH_VTABLE MemoryStream,
ULARGE_INTEGER Offset,
ULARGE_INTEGER NumberOfBytes,
ULONG LockType
);
#define RtlUnlockOutOfProcessMemoryStreamRegion \
((PRTL_UNLOCK_STREAM_REGION1(RTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE))RtlUnlockMemoryStreamRegion)
// E_NOTIMPL
RTL_MEMORY_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlStatMemoryStream(
PRTL_MEMORY_STREAM_WITH_VTABLE MemoryStream,
STATSTG* StatusInformation,
ULONG Flags
);
#define RtlStatOutOfProcessMemoryStream \
((PRTL_STAT_STREAM1(RTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE))RtlStatMemoryStream)
// E_NOTIMPL
RTL_MEMORY_STREAM_API
HRESULT
STDMETHODCALLTYPE
RtlCloneMemoryStream(
PRTL_MEMORY_STREAM_WITH_VTABLE MemoryStream,
IStream** NewStream
);
#define RtlCloneOutOfProcessMemoryStream \
((PRTL_CLONE_STREAM1(RTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE))RtlCloneMemoryStream)
#if defined(__cplusplus) && !defined(CINTERFACE)
#if !defined(interface)
//
// we need #define interface struct
//
#include "objbase.h"
#endif
#ifdef COM_NO_WINDOWS_H
#include "objidl.h"
#else
#define COM_NO_WINDOWS_H
#include "objidl.h"
#undef COM_NO_WINDOWS_H
#endif
class DECLSPEC_NOVTABLE CRtlMemoryStream : public IStream
{
protected:
operator PRTL_MEMORY_STREAM_WITH_VTABLE()
{
return reinterpret_cast<PRTL_MEMORY_STREAM_WITH_VTABLE>(this);
}
RTL_MEMORY_STREAM_DATA Data;
public:
/* This conflicts with DECLSPEC_NOVTABLE
static VOID STDMETHODCALLTYPE FinalReleaseGlue(PRTL_MEMORY_STREAM_WITH_VTABLE This)
{
return reinterpret_cast<CRtlMemoryStream*>(This)->FinalRelease();
}
virtual VOID STDMETHODCALLTYPE FinalRelease() { }
*/
CRtlMemoryStream()
{
RtlInitMemoryStream(*this);
//Data.FinalRelease = FinalReleaseGlue;
}
ULONG STDMETHODCALLTYPE AddRef()
{
return RtlAddRefMemoryStream(*this);
}
ULONG STDMETHODCALLTYPE ReleaseRef()
{
return RtlReleaseMemoryStream(*this);
}
HRESULT STDMETHODCALLTYPE QueryInterface(
const IID& Interface,
PVOID* Object
)
{
return RtlQueryInterfaceMemoryStream(*this, &Interface, Object);
}
HRESULT STDMETHODCALLTYPE Read(
PVOID Buffer,
ULONG BytesToRead,
ULONG* BytesRead
)
{
return RtlReadMemoryStream(*this, Buffer, BytesToRead, BytesRead);
}
HRESULT STDMETHODCALLTYPE Write(
const VOID* Buffer,
ULONG BytesToWrite,
ULONG* BytesWritten
)
{
return RtlWriteMemoryStream(*this, Buffer, BytesToWrite, BytesWritten);
}
HRESULT STDMETHODCALLTYPE Seek(
LARGE_INTEGER Distance,
ULONG Origin,
ULARGE_INTEGER* NewPosition
)
{
return RtlSeekMemoryStream(*this, Distance, Origin, NewPosition);
}
HRESULT STDMETHODCALLTYPE SetSize(
ULARGE_INTEGER NewSize
)
{
return RtlSetMemoryStreamSize(*this, NewSize);
}
HRESULT STDMETHODCALLTYPE CopyTo(
IStream* AnotherStream,
ULARGE_INTEGER NumberOfBytesToCopy,
ULARGE_INTEGER* NumberOfBytesRead,
ULARGE_INTEGER* NumberOfBytesWritten
)
{
return RtlCopyMemoryStreamTo(
*this,
AnotherStream,
NumberOfBytesToCopy,
NumberOfBytesRead,
NumberOfBytesWritten);
}
HRESULT STDMETHODCALLTYPE Commit(
ULONG Flags
)
{
return RtlCommitMemoryStream(*this, Flags);
}
HRESULT STDMETHODCALLTYPE Revert()
{
return RtlRevertMemoryStream(*this);
}
HRESULT STDMETHODCALLTYPE LockRegion(
ULARGE_INTEGER Offset,
ULARGE_INTEGER NumberOfBytes,
ULONG LockType
)
{
return RtlLockMemoryStreamRegion(*this, Offset, NumberOfBytes, LockType);
}
HRESULT STDMETHODCALLTYPE UnlockRegion(
ULARGE_INTEGER Offset,
ULARGE_INTEGER NumberOfBytes,
ULONG LockType
)
{
return RtlUnlockMemoryStreamRegion(*this, Offset, NumberOfBytes, LockType);
}
HRESULT STDMETHODCALLTYPE Stat(
STATSTG* StatusInformation,
ULONG Flags
)
{
return RtlStatMemoryStream(*this, StatusInformation, Flags);
}
HRESULT STDMETHODCALLTYPE Clone(
IStream** NewStream
)
{
return RtlCloneMemoryStream(*this, NewStream);
}
private:
// can't do this outside the class because Data is not public
static void CompileTimeAssert() {
C_ASSERT(FIELD_OFFSET(RTL_MEMORY_STREAM_WITH_VTABLE, Data) == FIELD_OFFSET(CRtlMemoryStream, Data));
}
};
C_ASSERT(sizeof(RTL_MEMORY_STREAM_WITH_VTABLE) == sizeof(CRtlMemoryStream));
class DECLSPEC_NOVTABLE CRtlOutOfProcessMemoryStream : public IStream
{
protected:
operator PRTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE()
{
return reinterpret_cast<PRTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE>(this);
}
RTL_OUT_OF_PROCESS_MEMORY_STREAM_DATA Data;
public:
/* This conflicts with DECLSPEC_NOVTABLE
static VOID STDMETHODCALLTYPE FinalReleaseGlue(PRTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE This)
{
return reinterpret_cast<CRtlOutOfProcessMemoryStream*>(This)->FinalRelease();
}
virtual VOID STDMETHODCALLTYPE FinalRelease() { }
*/
CRtlOutOfProcessMemoryStream()
{
RtlInitOutOfProcessMemoryStream(*this);
//Data.FinalRelease = FinalReleaseGlue;
}
ULONG STDMETHODCALLTYPE AddRef()
{
return RtlAddRefOutOfProcessMemoryStream(*this);
}
ULONG STDMETHODCALLTYPE ReleaseRef()
{
return RtlReleaseOutOfProcessMemoryStream(*this);
}
HRESULT STDMETHODCALLTYPE QueryInterface(
const IID& Interface,
PVOID* Object
)
{
return RtlQueryInterfaceOutOfProcessMemoryStream(*this, &Interface, Object);
}
HRESULT STDMETHODCALLTYPE Read(
PVOID Buffer,
ULONG BytesToRead,
ULONG* BytesRead
)
{
return RtlReadOutOfProcessMemoryStream(*this, Buffer, BytesToRead, BytesRead);
}
HRESULT STDMETHODCALLTYPE Write(
const VOID* Buffer,
ULONG BytesToWrite,
ULONG* BytesWritten
)
{
return RtlWriteOutOfProcessMemoryStream(*this, Buffer, BytesToWrite, BytesWritten);
}
HRESULT STDMETHODCALLTYPE Seek(
LARGE_INTEGER Distance,
ULONG Origin,
ULARGE_INTEGER* NewPosition
)
{
return RtlSeekOutOfProcessMemoryStream(*this, Distance, Origin, NewPosition);
}
HRESULT STDMETHODCALLTYPE SetSize(
ULARGE_INTEGER NewSize
)
{
return RtlSetOutOfProcessMemoryStreamSize(*this, NewSize);
}
HRESULT STDMETHODCALLTYPE CopyTo(
IStream* AnotherStream,
ULARGE_INTEGER NumberOfBytesToCopy,
ULARGE_INTEGER* NumberOfBytesRead,
ULARGE_INTEGER* NumberOfBytesWritten
)
{
return RtlCopyOutOfProcessMemoryStreamTo(
*this,
AnotherStream,
NumberOfBytesToCopy,
NumberOfBytesRead,
NumberOfBytesWritten);
}
HRESULT STDMETHODCALLTYPE Commit(
ULONG Flags
)
{
return RtlCommitOutOfProcessMemoryStream(*this, Flags);
}
HRESULT STDMETHODCALLTYPE Revert()
{
return RtlRevertOutOfProcessMemoryStream(*this);
}
HRESULT STDMETHODCALLTYPE LockRegion(
ULARGE_INTEGER Offset,
ULARGE_INTEGER NumberOfBytes,
ULONG LockType
)
{
return RtlLockOutOfProcessMemoryStreamRegion(*this, Offset, NumberOfBytes, LockType);
}
HRESULT STDMETHODCALLTYPE UnlockRegion(
ULARGE_INTEGER Offset,
ULARGE_INTEGER NumberOfBytes,
ULONG LockType
)
{
return RtlUnlockOutOfProcessMemoryStreamRegion(*this, Offset, NumberOfBytes, LockType);
}
HRESULT STDMETHODCALLTYPE Stat(
STATSTG* StatusInformation,
ULONG Flags
)
{
return RtlStatOutOfProcessMemoryStream(*this, StatusInformation, Flags);
}
HRESULT STDMETHODCALLTYPE Clone(
IStream** NewStream
)
{
return RtlCloneOutOfProcessMemoryStream(*this, NewStream);
}
private:
// can't do this outside the class because Data is not public
static void CompileTimeAssert() {
C_ASSERT(FIELD_OFFSET(RTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE, Data) == FIELD_OFFSET(CRtlOutOfProcessMemoryStream, Data));
}
};
C_ASSERT(sizeof(RTL_OUT_OF_PROCESS_MEMORY_STREAM_WITH_VTABLE) == sizeof(CRtlOutOfProcessMemoryStream));
#endif // __cplusplus
#endif // RTL_DECLARE_MEMORY_STREAM
#endif // RTL_DECLARE_STREAMS
#define RTL_CLOSE_HANDLE(handle_) ((handle_) != NULL ? NtClose(handle_) : STATUS_SUCCESS)
#define RTL_UNMAP_VIEW_OF_SECTION2(process_, base_) ((base_) != NULL ? NtUnmapViewOfSection((process_), (base_)) : STATUS_SUCCESS)
#define RTL_UNMAP_VIEW_OF_SECTION1(base_) (RTL_UNMAP_VIEW_OF_SECTION2(NtCurrentProcess(), (base_)))
#if defined(__cplusplus) && !defined(CINTERFACE)
#define RTL_RELEASE(punk_) do { if ((punk_) != NULL) { (punk_)->Release(); (punk_) = NULL; } } while(0)
#else
#define RTL_RELEASE(punk_) do { if ((punk_) != NULL) { (punk_)->lpVtbl->Release(punk_); (punk_) = NULL; } } while(0)
#endif
//
// Activation context management functions
//
//
// Data structures are visible both in ntrtl and Win32 APIs, so their
// definitions are factored out into a separate header file.
//
#define ACTCTX_PROCESS_DEFAULT ((void*)NULL)
//
// If you activate this activation context handle,
// all activation context queries fail and searches
// drop back to pre-activation context behavior, like
// searching PATH for .dlls.
//
// This constant works at the Win32 and Rtl level, but
// is intended only for Shell clients, so is kept out of winnt.h
//
#define ACTCTX_EMPTY ((void*)(LONG_PTR)-3)
//
// NULL can also mean ACTCTX_SYSTEM_DEFAULT. We are between decisions
// on NULL plus a flag, magic numbers and/or static instances. I generally
// favor public magic numbers internally mapped to static instances, but
// I was pushed toward flags to start.
//
#define ACTCTX_SYSTEM_DEFAULT ((void*)(LONG_PTR)-4)
//
// Reserve a small range of values, 0 through -7.
// (Note that NtCurrentProcess() == -1, NtCurrentThread() == -2, so I avoided
// those, though this macro picks them up.)
//
// We subtract one instead of comparing against NULL seperately to avoid
// evaluating the macro parameter more than once.
//
#define IS_SPECIAL_ACTCTX(x) (((((LONG_PTR)(x)) - 1) | 7) == -1)
typedef struct _ACTIVATION_CONTEXT *PACTIVATION_CONTEXT;
typedef const struct _ACTIVATION_CONTEXT *PCACTIVATION_CONTEXT;
#define INVALID_ACTIVATION_CONTEXT ((PACTIVATION_CONTEXT) ((LONG_PTR) -1))
// begin_winnt
typedef enum _ACTIVATION_CONTEXT_INFO_CLASS {
ActivationContextBasicInformation = 1,
ActivationContextDetailedInformation = 2,
AssemblyDetailedInformationInActivationContext = 3,
FileInformationInAssemblyOfAssemblyInActivationContext = 4,
MaxActivationContextInfoClass,
//
// compatibility with old names
//
AssemblyDetailedInformationInActivationContxt = 3,
FileInformationInAssemblyOfAssemblyInActivationContxt = 4
} ACTIVATION_CONTEXT_INFO_CLASS;
#define ACTIVATIONCONTEXTINFOCLASS ACTIVATION_CONTEXT_INFO_CLASS
// end_winnt
#define RTL_QUERY_INFORMATION_ACTIVATION_CONTEXT_FLAG_USE_ACTIVE_ACTIVATION_CONTEXT (0x00000001)
#define RTL_QUERY_INFORMATION_ACTIVATION_CONTEXT_FLAG_ACTIVATION_CONTEXT_IS_MODULE (0x00000002)
#define RTL_QUERY_INFORMATION_ACTIVATION_CONTEXT_FLAG_ACTIVATION_CONTEXT_IS_ADDRESS (0x00000004)
#define RTL_QUERY_INFORMATION_ACTIVATION_CONTEXT_FLAG_NO_ADDREF (0x80000000)
// begin_winnt
typedef struct _ACTIVATION_CONTEXT_QUERY_INDEX {
ULONG ulAssemblyIndex;
ULONG ulFileIndexInAssembly;
} ACTIVATION_CONTEXT_QUERY_INDEX, * PACTIVATION_CONTEXT_QUERY_INDEX;
typedef const struct _ACTIVATION_CONTEXT_QUERY_INDEX * PCACTIVATION_CONTEXT_QUERY_INDEX;
// end_winnt
NTSYSAPI
NTSTATUS
NTAPI
RtlQueryInformationActivationContext(
IN ULONG Flags,
IN PCACTIVATION_CONTEXT ActivationContext,
IN PVOID SubInstanceIndex,
IN ACTIVATION_CONTEXT_INFO_CLASS ActivationContextInformationClass,
OUT PVOID ActivationContextInformation,
IN SIZE_T ActivationContextInformationLength,
OUT PSIZE_T ReturnLength OPTIONAL
);
NTSYSAPI
NTSTATUS
NTAPI
RtlQueryInformationActiveActivationContext(
IN ACTIVATION_CONTEXT_INFO_CLASS ActivationContextInformationClass,
OUT PVOID ActivationContextInformation,
IN SIZE_T ActivationContextInformationLength,
OUT PSIZE_T ReturnLength OPTIONAL
);
#define FIND_ACTIVATION_CONTEXT_SECTION_OUTFLAG_FOUND_IN_PROCESS_DEFAULT (0x00000001)
#define FIND_ACTIVATION_CONTEXT_SECTION_OUTFLAG_FOUND_IN_SYSTEM_DEFAULT (0x00000002)
#if !defined(RC_INVOKED) /* RC complains about long symbols in #ifs */
#if !defined(ACTIVATION_CONTEXT_BASIC_INFORMATION_DEFINED)
typedef struct _ACTIVATION_CONTEXT_BASIC_INFORMATION {
union {
struct _ACTIVATION_CONTEXT *ActivationContext;
HANDLE hActCtx; // for compatibility with windows.h/winbase.h clients
};
ULONG Flags;
} ACTIVATION_CONTEXT_BASIC_INFORMATION, *PACTIVATION_CONTEXT_BASIC_INFORMATION;
typedef const struct _ACTIVATION_CONTEXT_BASIC_INFORMATION *PCACTIVATION_CONTEXT_BASIC_INFORMATION;
#define ACTIVATION_CONTEXT_BASIC_INFORMATION_DEFINED 1
#endif // !defined(ACTIVATION_CONTEXT_BASIC_INFORMATION_DEFINED)
#endif
// begin_winnt
#define ACTIVATION_CONTEXT_PATH_TYPE_NONE (1)
#define ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE (2)
#define ACTIVATION_CONTEXT_PATH_TYPE_URL (3)
#define ACTIVATION_CONTEXT_PATH_TYPE_ASSEMBLYREF (4)
typedef struct _ASSEMBLY_FILE_DETAILED_INFORMATION {
ULONG ulFlags;
ULONG ulFilenameLength;
ULONG ulPathLength;
PCWSTR lpFileName;
PCWSTR lpFilePath;
} ASSEMBLY_FILE_DETAILED_INFORMATION, *PASSEMBLY_FILE_DETAILED_INFORMATION;
typedef const ASSEMBLY_FILE_DETAILED_INFORMATION *PCASSEMBLY_FILE_DETAILED_INFORMATION;
//
// compatibility with old names
// The new names use "file" consistently.
//
#define _ASSEMBLY_DLL_REDIRECTION_DETAILED_INFORMATION _ASSEMBLY_FILE_DETAILED_INFORMATION
#define ASSEMBLY_DLL_REDIRECTION_DETAILED_INFORMATION ASSEMBLY_FILE_DETAILED_INFORMATION
#define PASSEMBLY_DLL_REDIRECTION_DETAILED_INFORMATION PASSEMBLY_FILE_DETAILED_INFORMATION
#define PCASSEMBLY_DLL_REDIRECTION_DETAILED_INFORMATION PCASSEMBLY_FILE_DETAILED_INFORMATION
typedef struct _ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION {
ULONG ulFlags;
ULONG ulEncodedAssemblyIdentityLength; // in bytes
ULONG ulManifestPathType; // ACTIVATION_CONTEXT_PATH_TYPE_*
ULONG ulManifestPathLength; // in bytes
LARGE_INTEGER liManifestLastWriteTime; // FILETIME
ULONG ulPolicyPathType; // ACTIVATION_CONTEXT_PATH_TYPE_*
ULONG ulPolicyPathLength; // in bytes
LARGE_INTEGER liPolicyLastWriteTime; // FILETIME
ULONG ulMetadataSatelliteRosterIndex;
ULONG ulManifestVersionMajor; // 1
ULONG ulManifestVersionMinor; // 0
ULONG ulPolicyVersionMajor; // 0
ULONG ulPolicyVersionMinor; // 0
ULONG ulAssemblyDirectoryNameLength; // in bytes
PCWSTR lpAssemblyEncodedAssemblyIdentity;
PCWSTR lpAssemblyManifestPath;
PCWSTR lpAssemblyPolicyPath;
PCWSTR lpAssemblyDirectoryName;
ULONG ulFileCount;
} ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION, * PACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION;
typedef const struct _ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION * PCACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION ;
typedef struct _ACTIVATION_CONTEXT_DETAILED_INFORMATION {
ULONG dwFlags;
ULONG ulFormatVersion;
ULONG ulAssemblyCount;
ULONG ulRootManifestPathType;
ULONG ulRootManifestPathChars;
ULONG ulRootConfigurationPathType;
ULONG ulRootConfigurationPathChars;
ULONG ulAppDirPathType;
ULONG ulAppDirPathChars;
PCWSTR lpRootManifestPath;
PCWSTR lpRootConfigurationPath;
PCWSTR lpAppDirPath;
} ACTIVATION_CONTEXT_DETAILED_INFORMATION, *PACTIVATION_CONTEXT_DETAILED_INFORMATION;
typedef const struct _ACTIVATION_CONTEXT_DETAILED_INFORMATION *PCACTIVATION_CONTEXT_DETAILED_INFORMATION;
// end_winnt
typedef struct _FINDFIRSTACTIVATIONCONTEXTSECTION {
ULONG Size;
ULONG Flags;
const GUID *ExtensionGuid;
ULONG Id;
ULONG Depth;
ULONG OutFlags;
} FINDFIRSTACTIVATIONCONTEXTSECTION, *PFINDFIRSTACTIVATIONCONTEXTSECTION;
typedef const FINDFIRSTACTIVATIONCONTEXTSECTION * PCFINDFIRSTACTIVATIONCONTEXTSECTION;
#define ACTIVATION_CONTEXT_NOTIFICATION_DESTROY (1)
#define ACTIVATION_CONTEXT_NOTIFICATION_ZOMBIFY (2)
#define ACTIVATION_CONTEXT_NOTIFICATION_USED (3)
typedef
VOID (NTAPI * PACTIVATION_CONTEXT_NOTIFY_ROUTINE)(
IN ULONG NotificationType,
IN PACTIVATION_CONTEXT ActivationContext,
IN const VOID *ActivationContextData,
IN PVOID NotificationContext,
IN PVOID NotificationData,
IN OUT PBOOLEAN DisableThisNotification
);
NTSYSAPI
NTSTATUS
NTAPI
RtlInitializeSxs(
VOID
);
NTSYSAPI
NTSTATUS
NTAPI
RtlCreateActivationContext(
IN ULONG Flags,
IN PVOID ActivationContextData,
IN ULONG ExtraBytes OPTIONAL,
IN PACTIVATION_CONTEXT_NOTIFY_ROUTINE NotificationRoutine OPTIONAL,
IN PVOID NotificationContext OPTIONAL,
OUT PACTIVATION_CONTEXT *ActivationContext
);
NTSYSAPI
VOID
NTAPI
RtlAddRefActivationContext(
IN PACTIVATION_CONTEXT AppCtx
);
NTSYSAPI
VOID
NTAPI
RtlReleaseActivationContext(
IN PACTIVATION_CONTEXT AppCtx
);
NTSYSAPI
NTSTATUS
NTAPI
RtlZombifyActivationContext(
IN PACTIVATION_CONTEXT ActivationContext
);
NTSYSAPI
NTSTATUS
NTAPI
RtlGetActiveActivationContext(
OUT PACTIVATION_CONTEXT *ActivationContext
);
NTSYSAPI
BOOLEAN
NTAPI
RtlIsActivationContextActive(
IN PACTIVATION_CONTEXT ActivationContext
);
typedef struct _ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_DATA_RESOLUTION_BEGINNING {
IN VOID const * Data; // pointer to activation context data
IN ULONG AssemblyRosterIndex;
OUT PVOID ResolutionContext;
OUT UNICODE_STRING Root; // Root path - a default buffer is passed in; if
// it is not large enough, callback must allocate
// a string using the RtlAllocateStringRoutine
// function pointer.
OUT BOOLEAN KnownRoot; // default is FALSE; set to TRUE if you were able to
// resolve the storage root immediately. this is
// how to handle things like run-from-source where
// the assembly is on read-only removable media like
// a CD-ROM. If you set it to TRUE, the _SUCCESSFUL
// vs. _UNSUCCESSFUL callbacks are not made.
OUT SIZE_T RootCount; // Caller may set to ((SIZE_T) -1) and use the
// .NoMoreEntries BOOLEAN in the callback to stop enumeration
OUT BOOLEAN CancelResolution; // set to true if you want to stop the resolution
} ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_DATA_RESOLUTION_BEGINNING;
typedef struct _ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_DATA_GET_ROOT {
IN PVOID ResolutionContext;
IN SIZE_T RootIndex;
OUT BOOLEAN CancelResolution; // set to true if you want to stop the resolution with STATUS_CANCELLED
OUT BOOLEAN NoMoreEntries; // set to TRUE if you have no more roots to return.
OUT UNICODE_STRING Root; // If for some reason you want to skip this index; set .Length to zero
} ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_DATA_GET_ROOT;
typedef struct _ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_DATA_RESOLUTION_SUCCESSFUL {
IN PVOID ResolutionContext;
IN ULONG RootIndexUsed;
} ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_DATA_RESOLUTION_SUCCESSFUL;
typedef struct _ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_DATA_RESOLUTION_ENDING {
IN PVOID ResolutionContext;
} ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_DATA_RESOLUTION_ENDING;
typedef union _ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_DATA {
ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_DATA_RESOLUTION_BEGINNING ResolutionBeginning;
ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_DATA_GET_ROOT GetRoot;
ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_DATA_RESOLUTION_SUCCESSFUL ResolutionSuccessful;
ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_DATA_RESOLUTION_ENDING ResolutionEnding;
} ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_DATA, *PASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_DATA;
#define ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_REASON_RESOLUTION_BEGINNING (1)
#define ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_REASON_GET_ROOT (2)
#define ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_REASON_RESOLUTION_SUCCESSFUL (3)
#define ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_REASON_RESOLUTION_ENDING (4)
typedef
VOID (NTAPI * PASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_ROUTINE)(
IN ULONG CallbackReason,
IN OUT PASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_DATA CallbackData,
IN PVOID CallbackContext
);
NTSYSAPI
NTSTATUS
NTAPI
RtlResolveAssemblyStorageMapEntry(
IN ULONG Flags,
IN PACTIVATION_CONTEXT ActivationContext,
IN ULONG AssemblyRosterIndex,
IN PASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_ROUTINE Callback,
IN PVOID CallbackContext
);
#define RTL_GET_ASSEMBLY_STORAGE_ROOT_FLAG_ACTIVATION_CONTEXT_USE_PROCESS_DEFAULT (0x00000001)
#define RTL_GET_ASSEMBLY_STORAGE_ROOT_FLAG_ACTIVATION_CONTEXT_USE_SYSTEM_DEFAULT (0x00000002)
NTSYSAPI
NTSTATUS
NTAPI
RtlGetAssemblyStorageRoot(
IN ULONG Flags,
IN PACTIVATION_CONTEXT ActivationContext,
IN ULONG AssemblyRosterIndex,
OUT PCUNICODE_STRING *AssemblyStorageRoot,
IN PASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_ROUTINE Callback,
IN PVOID CallbackContext
);
//
// Macro to enable avoiding calling RtlFindActivationContext* APIs if
// there is no side-by-side redirection going on in the process
// at all.
//
#if NTOS_KERNEL_RUNTIME
//
// For kernel mode, this needs to be a real function with probes etc.
// since it references the process state (peb/teb).
//
NTSYSAPI
BOOLEAN
NTAPI
RtlAnyActivationContextDataAvailable(VOID);
#else
#define RtlAnyActivationContextDataAvailable() \
((NtCurrentTeb()->ActivationContextStack != NULL) || \
(NtCurrentPeb()->ActivationContextData != NULL) || \
(NtCurrentPeb()->SystemDefaultActivationContextData != NULL))
#endif // NTOS_KERNEL_RUNTIME
#define RtlIsProcessDefaultActivationContextActive() ((NtCurrentTeb()->ActivationContextStack == NULL) || RtlIsActivationContextActive(NULL))
#define ACTIVATION_CONTEXT_SECTION_KEYED_DATA_FLAG_FOUND_IN_PROCESS_DEFAULT (0x00000001)
#define ACTIVATION_CONTEXT_SECTION_KEYED_DATA_FLAG_FOUND_IN_SYSTEM_DEFAULT (0x00000002)
typedef struct _ACTIVATION_CONTEXT_SECTION_KEYED_DATA_2600 {
ULONG Size;
ULONG DataFormatVersion;
PVOID Data;
ULONG Length;
PVOID SectionGlobalData;
ULONG SectionGlobalDataLength;
PVOID SectionBase;
ULONG SectionTotalLength;
PACTIVATION_CONTEXT ActivationContext;
ULONG AssemblyRosterIndex;
ULONG Flags;
} ACTIVATION_CONTEXT_SECTION_KEYED_DATA_2600, *PACTIVATION_CONTEXT_SECTION_KEYED_DATA_2600;
typedef const ACTIVATION_CONTEXT_SECTION_KEYED_DATA_2600 *PCACTIVATION_CONTEXT_SECTION_KEYED_DATA_2600;
typedef struct _ACTIVATION_CONTEXT_SECTION_KEYED_DATA_ASSEMBLY_METADATA {
struct _ACTIVATION_CONTEXT_DATA_ASSEMBLY_INFORMATION * Information;
PVOID SectionBase;
ULONG SectionLength;
PVOID SectionGlobalDataBase;
ULONG SectionGlobalDataLength;
} ACTIVATION_CONTEXT_SECTION_KEYED_DATA_ASSEMBLY_METADATA, *PACTIVATION_CONTEXT_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
typedef const ACTIVATION_CONTEXT_SECTION_KEYED_DATA_ASSEMBLY_METADATA *PCACTIVATION_CONTEXT_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
typedef struct _ACTIVATION_CONTEXT_SECTION_KEYED_DATA {
ULONG Size;
ULONG DataFormatVersion;
PVOID Data;
ULONG Length;
PVOID SectionGlobalData;
ULONG SectionGlobalDataLength;
PVOID SectionBase;
ULONG SectionTotalLength;
PACTIVATION_CONTEXT ActivationContext;
ULONG AssemblyRosterIndex;
ULONG Flags;
// 2600 stops here
ACTIVATION_CONTEXT_SECTION_KEYED_DATA_ASSEMBLY_METADATA AssemblyMetadata;
} ACTIVATION_CONTEXT_SECTION_KEYED_DATA, *PACTIVATION_CONTEXT_SECTION_KEYED_DATA;
typedef const ACTIVATION_CONTEXT_SECTION_KEYED_DATA * PCACTIVATION_CONTEXT_SECTION_KEYED_DATA;
//
// Flags for the RtlFindActivationContextSection*() APIs
//
#define FIND_ACTIVATION_CONTEXT_SECTION_KEY_RETURN_ACTIVATION_CONTEXT (0x00000001)
#define FIND_ACTIVATION_CONTEXT_SECTION_KEY_RETURN_FLAGS (0x00000002)
#define FIND_ACTIVATION_CONTEXT_SECTION_KEY_RETURN_ASSEMBLY_METADATA (0x00000004)
NTSYSAPI
NTSTATUS
NTAPI
RtlFindActivationContextSectionString(
IN ULONG Flags,
IN const GUID *ExtensionGuid OPTIONAL,
IN ULONG SectionId,
IN PCUNICODE_STRING StringToFind,
IN OUT PACTIVATION_CONTEXT_SECTION_KEYED_DATA ReturnedData
);
NTSYSAPI
NTSTATUS
NTAPI
RtlFindActivationContextSectionGuid(
IN ULONG Flags,
IN const GUID *ExtensionGuid OPTIONAL,
IN ULONG SectionId,
IN const GUID *GuidToFind,
IN OUT PACTIVATION_CONTEXT_SECTION_KEYED_DATA ReturnedData
);
#define ACTIVATION_CONTEXT_ASSEMBLY_DATA_IS_ROOT_ASSEMBLY (0x00000001)
typedef struct _ACTIVATION_CONTEXT_ASSEMBLY_DATA {
ULONG Size;
ULONG Flags;
const WCHAR *AssemblyName;
ULONG AssemblyNameLength; // in bytes
ULONG HashAlgorithm;
ULONG PseudoKey;
} ACTIVATION_CONTEXT_ASSEMBLY_DATA, *PACTIVATION_CONTEXT_ASSEMBLY_DATA;
typedef const ACTIVATION_CONTEXT_ASSEMBLY_DATA *PCACTIVATION_CONTEXT_ASSEMBLY_DATA;
NTSYSAPI
NTSTATUS
NTAPI
RtlGetActivationContextAssemblyData(
IN PCACTIVATION_CONTEXT ActivationContext,
IN ULONG AssemblyRosterIndex, // note that valid indices are [1 .. AssemblyCount] inclusive
IN OUT PACTIVATION_CONTEXT_ASSEMBLY_DATA Data
);
NTSYSAPI
NTSTATUS
NTAPI
RtlGetActivationContextAssemblyCount(
IN PCACTIVATION_CONTEXT ActivationContext,
OUT ULONG *AssemblyCount
);
NTSYSAPI
VOID
NTAPI
RtlFreeThreadActivationContextStack(
VOID
);
NTSYSAPI
NTSTATUS
NTAPI
RtlFindFirstActivationContextSection(
IN OUT PFINDFIRSTACTIVATIONCONTEXTSECTION Context,
OUT PVOID *Section,
OUT ULONG *Length,
OUT PACTIVATION_CONTEXT *ActivationContext OPTIONAL
);
NTSYSAPI
NTSTATUS
NTAPI
RtlFindNextActivationContextSection(
IN OUT PFINDFIRSTACTIVATIONCONTEXTSECTION Context,
OUT PVOID *Section,
OUT ULONG *Length,
OUT PACTIVATION_CONTEXT *ActivationContext OPTIONAL
);
NTSYSAPI
VOID
NTAPI
RtlEndFindActivationContextSection(
IN PFINDFIRSTACTIVATIONCONTEXTSECTION Context
);
NTSYSAPI
NTSTATUS
NTAPI
RtlGetActivationContextStack(
PVOID *Stack
);
//
// RTL_ACTIVATION_CONTEXT_STACK_FRAME
//
#define RTL_ACTIVATION_CONTEXT_STACK_FRAME_FLAG_RELEASE_ON_DEACTIVATION (0x00000001)
#define RTL_ACTIVATION_CONTEXT_STACK_FRAME_FLAG_NO_DEACTIVATE (0x00000002)
#define RTL_ACTIVATION_CONTEXT_STACK_FRAME_FLAG_ON_FREE_LIST (0x00000004)
#define RTL_ACTIVATION_CONTEXT_STACK_FRAME_FLAG_HEAP_ALLOCATED (0x00000008)
#define RTL_ACTIVATION_CONTEXT_STACK_FRAME_FLAG_NOT_REALLY_ACTIVATED (0x00000010)
typedef struct _RTL_ACTIVATION_CONTEXT_STACK_FRAME {
struct _RTL_ACTIVATION_CONTEXT_STACK_FRAME *Previous;
PACTIVATION_CONTEXT ActivationContext;
ULONG Flags;
} RTL_ACTIVATION_CONTEXT_STACK_FRAME, *PRTL_ACTIVATION_CONTEXT_STACK_FRAME;
typedef const struct _RTL_ACTIVATION_CONTEXT_STACK_FRAME *PCRTL_ACTIVATION_CONTEXT_STACK_FRAME;
#define RTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_FORMAT_WHISTLER (1)
typedef struct _RTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME {
SIZE_T Size;
ULONG Format;
RTL_ACTIVATION_CONTEXT_STACK_FRAME Frame;
} RTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME, *PRTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME;
#define INVALID_ACTIVATION_CONTEXT_ACTIVATION_COOKIE ((ULONG_PTR) 0)
NTSYSAPI
NTSTATUS
NTAPI
RtlActivateActivationContext(
IN ULONG Flags,
IN PACTIVATION_CONTEXT ActivationContext,
OUT ULONG_PTR *Cookie
);
#define RTL_ACTIVATE_ACTIVATION_CONTEXT_EX_FLAG_RELEASE_ON_STACK_DEALLOCATION (0x00000001)
NTSYSAPI
NTSTATUS
NTAPI
RtlActivateActivationContextEx(
IN ULONG Flags,
IN PTEB Teb,
IN PACTIVATION_CONTEXT ActivationContext,
OUT PULONG_PTR Cookie
);
#define RTL_DEACTIVATE_ACTIVATION_CONTEXT_FLAG_FORCE_EARLY_DEACTIVATION (0x00000001)
NTSYSAPI
VOID
NTAPI
RtlDeactivateActivationContext(
IN ULONG Flags,
IN ULONG_PTR Cookie
);
NTSYSAPI
VOID
NTAPI
RtlActivateActivationContextUnsafeFast(
IN PRTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME Frame,
IN PACTIVATION_CONTEXT ActivationContext
);
NTSYSAPI
VOID
NTAPI
RtlDeactivateActivationContextUnsafeFast(
IN PRTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME Frame
);
NTSYSAPI
VOID
NTAPI
RtlPushFrame(
IN PTEB_ACTIVE_FRAME Frame
);
NTSYSAPI
VOID
NTAPI
RtlPopFrame(
IN PTEB_ACTIVE_FRAME Frame
);
NTSYSAPI
PTEB_ACTIVE_FRAME
NTAPI
RtlGetFrame(
VOID
);
NTSYSAPI
NTSTATUS
NTAPI
RtlGetNativeSystemInformation(
IN ULONG SystemInformationClass,
IN PVOID NativeSystemInformation,
IN ULONG InformationLength,
OUT PULONG ReturnLength OPTIONAL
);
#if defined (_MSC_VER) && ( _MSC_VER >= 800 )
#if _MSC_VER >= 1200
#pragma warning(pop)
#else
#pragma warning(default:4001)
#pragma warning(default:4201)
#pragma warning(default:4214)
#endif
#endif
#ifdef __cplusplus
} // extern "C"
#endif
#endif // _NTURTL_