able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/published/nturtl.w
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

3074 lines
79 KiB
OpenEdge ABL
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*++ 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_
Reference in a new issue View git blame Copy permalink