#define BitScanForward _BitScanForward\r
#define BitScanReverse _BitScanReverse\r
\r
+ #define BitTest _bittest\r
+ #define BitTestAndComplement _bittestandcomplement\r
+ #define BitTestAndSet _bittestandset\r
+ #define BitTestAndReset _bittestandreset\r
+ #define InterlockedBitTestAndSet _interlockedbittestandset\r
+ #define InterlockedBitTestAndReset _interlockedbittestandreset\r
+ \r
+ \r
+ /** INTERLOCKED FUNCTIONS *****************************************************/\r
+ \r
+ #if !defined(__INTERLOCKED_DECLARED)\r
+ #define __INTERLOCKED_DECLARED\r
+ \r
+ #if defined (_X86_)\r
+ #if defined(NO_INTERLOCKED_INTRINSICS)\r
+ NTKERNELAPI\r
+ LONG\r
+ FASTCALL\r
+ InterlockedIncrement(\r
+ IN OUT LONG volatile *Addend);\r
+ \r
+ NTKERNELAPI\r
+ LONG\r
+ FASTCALL\r
+ InterlockedDecrement(\r
+ IN OUT LONG volatile *Addend);\r
+ \r
+ NTKERNELAPI\r
+ LONG\r
+ FASTCALL\r
+ InterlockedCompareExchange(\r
+ IN OUT LONG volatile *Destination,\r
+ IN LONG Exchange,\r
+ IN LONG Comparand);\r
+ \r
+ NTKERNELAPI\r
+ LONG\r
+ FASTCALL\r
+ InterlockedExchange(\r
+ IN OUT LONG volatile *Destination,\r
+ IN LONG Value);\r
+ \r
+ NTKERNELAPI\r
+ LONG\r
+ FASTCALL\r
+ InterlockedExchangeAdd(\r
+ IN OUT LONG volatile *Addend,\r
+ IN LONG Value);\r
+ \r
+ #else // !defined(NO_INTERLOCKED_INTRINSICS)\r
+ \r
+ #define InterlockedExchange _InterlockedExchange\r
+ #define InterlockedIncrement _InterlockedIncrement\r
+ #define InterlockedDecrement _InterlockedDecrement\r
+ #define InterlockedExchangeAdd _InterlockedExchangeAdd\r
+ #define InterlockedCompareExchange _InterlockedCompareExchange\r
+ #define InterlockedOr _InterlockedOr\r
+ #define InterlockedAnd _InterlockedAnd\r
+ #define InterlockedXor _InterlockedXor\r
+ \r
+ #endif // !defined(NO_INTERLOCKED_INTRINSICS)\r
+ \r
+ #endif // defined (_X86_)\r
+ \r
+ #if !defined (_WIN64)\r
+ /*\r
+ * PVOID\r
+ * InterlockedExchangePointer(\r
+ * IN OUT PVOID VOLATILE *Target,\r
+ * IN PVOID Value)\r
+ */\r
+ #define InterlockedExchangePointer(Target, Value) \\r
+ ((PVOID) InterlockedExchange((PLONG) Target, (LONG) Value))\r
+ \r
+ /*\r
+ * PVOID\r
+ * InterlockedCompareExchangePointer(\r
+ * IN OUT PVOID *Destination,\r
+ * IN PVOID Exchange,\r
+ * IN PVOID Comparand)\r
+ */\r
+ #define InterlockedCompareExchangePointer(Destination, Exchange, Comparand) \\r
+ ((PVOID) InterlockedCompareExchange((PLONG) Destination, (LONG) Exchange, (LONG) Comparand))\r
+ \r
+ #define InterlockedExchangeAddSizeT(a, b) InterlockedExchangeAdd((LONG *)a, b)\r
+ #define InterlockedIncrementSizeT(a) InterlockedIncrement((LONG *)a)\r
+ #define InterlockedDecrementSizeT(a) InterlockedDecrement((LONG *)a)\r
+ \r
+ #endif // !defined (_WIN64)\r
+ \r
+ #if defined (_M_AMD64)\r
+ \r
+ #define InterlockedExchangeAddSizeT(a, b) InterlockedExchangeAdd64((LONGLONG *)a, (LONGLONG)b)\r
+ #define InterlockedIncrementSizeT(a) InterlockedIncrement64((LONGLONG *)a)\r
+ #define InterlockedDecrementSizeT(a) InterlockedDecrement64((LONGLONG *)a)\r
+ #define InterlockedAnd _InterlockedAnd\r
+ #define InterlockedOr _InterlockedOr\r
+ #define InterlockedXor _InterlockedXor\r
+ #define InterlockedIncrement _InterlockedIncrement\r
+ #define InterlockedDecrement _InterlockedDecrement\r
+ #define InterlockedAdd _InterlockedAdd\r
+ #define InterlockedExchange _InterlockedExchange\r
+ #define InterlockedExchangeAdd _InterlockedExchangeAdd\r
+ #define InterlockedCompareExchange _InterlockedCompareExchange\r
+ #define InterlockedAnd64 _InterlockedAnd64\r
+ #define InterlockedOr64 _InterlockedOr64\r
+ #define InterlockedXor64 _InterlockedXor64\r
+ #define InterlockedIncrement64 _InterlockedIncrement64\r
+ #define InterlockedDecrement64 _InterlockedDecrement64\r
+ #define InterlockedAdd64 _InterlockedAdd64\r
+ #define InterlockedExchange64 _InterlockedExchange64\r
+ #define InterlockedExchangeAdd64 _InterlockedExchangeAdd64\r
+ #define InterlockedCompareExchange64 _InterlockedCompareExchange64\r
+ #define InterlockedCompareExchangePointer _InterlockedCompareExchangePointer\r
+ #define InterlockedExchangePointer _InterlockedExchangePointer\r
+ #define InterlockedBitTestAndSet64 _interlockedbittestandset64\r
+ #define InterlockedBitTestAndReset64 _interlockedbittestandreset64\r
+ \r
+ #endif // _M_AMD64\r
+ \r
+ #if defined(_M_AMD64) && !defined(RC_INVOKED) && !defined(MIDL_PASS)\r
+ //#if !defined(_X86AMD64_) // FIXME: what's _X86AMD64_ used for?\r
+ FORCEINLINE\r
+ LONG64\r
+ InterlockedAdd64(\r
+ IN OUT LONG64 volatile *Addend,\r
+ IN LONG64 Value)\r
+ {\r
+ return InterlockedExchangeAdd64(Addend, Value) + Value;\r
+ }\r
+ //#endif\r
++#define BitScanForward _BitScanForward\r
++#define BitScanReverse _BitScanReverse\r
++#endif\r
++\r
+#ifdef _M_AMD64\r
+#define InterlockedBitTestAndSet64 _interlockedbittestandset64\r
+#define InterlockedBitTestAndReset64 _interlockedbittestandreset64\r
#endif\r
\r
+ #endif /* !__INTERLOCKED_DECLARED */\r
\r
#if defined(_M_IX86)\r
- #define YieldProcessor() __asm__ __volatile__("pause");\r
+ #define YieldProcessor _mm_pause\r
#elif defined (_M_AMD64)\r
- #define YieldProcessor() __asm__ __volatile__("pause");\r
+ #define YieldProcessor _mm_pause\r
#elif defined(_M_PPC)\r
#define YieldProcessor() __asm__ __volatile__("nop");\r
#elif defined(_M_MIPS)\r
#define QUOTA_LIMITS_USE_DEFAULT_LIMITS 0x00000010\r
\r
\r
- IN CCHAR ShiftCount);\r
+ /******************************************************************************\r
+ * WINBASE Functions *\r
+ ******************************************************************************/\r
+ #if !defined(_WINBASE_)\r
+ \r
+ #if defined(_WIN64)\r
+ \r
+ #define InterlockedPopEntrySList(Head) \\r
+ ExpInterlockedPopEntrySList(Head)\r
+ \r
+ #define InterlockedPushEntrySList(Head, Entry) \\r
+ ExpInterlockedPushEntrySList(Head, Entry)\r
+ \r
+ #define InterlockedFlushSList(Head) \\r
+ ExpInterlockedFlushSList(Head)\r
+ \r
+ #define QueryDepthSList(Head) \\r
+ ExQueryDepthSList(Head)\r
+ \r
+ #else // !defined(_WIN64)\r
+ \r
+ NTKERNELAPI\r
+ PSLIST_ENTRY\r
+ FASTCALL\r
+ InterlockedPopEntrySList(\r
+ IN PSLIST_HEADER ListHead);\r
+ \r
+ NTKERNELAPI\r
+ PSLIST_ENTRY\r
+ FASTCALL\r
+ InterlockedPushEntrySList(\r
+ IN PSLIST_HEADER ListHead,\r
+ IN PSLIST_ENTRY ListEntry);\r
+ \r
+ #define InterlockedFlushSList(ListHead) \\r
+ ExInterlockedFlushSList(ListHead)\r
+ \r
+ #define QueryDepthSList(Head) \\r
+ ExQueryDepthSList(Head)\r
+ \r
+ #endif // !defined(_WIN64)\r
+ \r
+ #endif // !defined(_WINBASE_)\r
+ \r
+ \r
+ /******************************************************************************\r
+ * Kernel Types *\r
+ ******************************************************************************/\r
+ \r
+ typedef struct _DISPATCHER_HEADER\r
+ {\r
+ union\r
+ {\r
+ struct\r
+ {\r
+ UCHAR Type;\r
+ union\r
+ {\r
+ UCHAR Absolute;\r
+ UCHAR NpxIrql;\r
+ };\r
+ union\r
+ {\r
+ UCHAR Size;\r
+ UCHAR Hand;\r
+ };\r
+ union\r
+ {\r
+ UCHAR Inserted;\r
+ BOOLEAN DebugActive;\r
+ };\r
+ };\r
+ volatile LONG Lock;\r
+ };\r
+ LONG SignalState;\r
+ LIST_ENTRY WaitListHead;\r
+ } DISPATCHER_HEADER, *PDISPATCHER_HEADER;\r
+ \r
+ typedef ULONG_PTR KSPIN_LOCK, *PKSPIN_LOCK;\r
+ \r
+ typedef struct _KEVENT {\r
+ DISPATCHER_HEADER Header;\r
+ } KEVENT, *PKEVENT, *RESTRICTED_POINTER PRKEVENT;\r
+ \r
+ typedef struct _KSEMAPHORE {\r
+ DISPATCHER_HEADER Header;\r
+ LONG Limit;\r
+ } KSEMAPHORE, *PKSEMAPHORE, *RESTRICTED_POINTER PRKSEMAPHORE;\r
+ \r
+ /******************************************************************************\r
+ * RTL Types *\r
+ ******************************************************************************/\r
+ \r
+ #define RTL_REGISTRY_ABSOLUTE 0\r
+ #define RTL_REGISTRY_SERVICES 1\r
+ #define RTL_REGISTRY_CONTROL 2\r
+ #define RTL_REGISTRY_WINDOWS_NT 3\r
+ #define RTL_REGISTRY_DEVICEMAP 4\r
+ #define RTL_REGISTRY_USER 5\r
+ #define RTL_REGISTRY_MAXIMUM 6\r
+ #define RTL_REGISTRY_HANDLE 0x40000000\r
+ #define RTL_REGISTRY_OPTIONAL 0x80000000\r
+ \r
+ /* RTL_QUERY_REGISTRY_TABLE.Flags */\r
+ #define RTL_QUERY_REGISTRY_SUBKEY 0x00000001\r
+ #define RTL_QUERY_REGISTRY_TOPKEY 0x00000002\r
+ #define RTL_QUERY_REGISTRY_REQUIRED 0x00000004\r
+ #define RTL_QUERY_REGISTRY_NOVALUE 0x00000008\r
+ #define RTL_QUERY_REGISTRY_NOEXPAND 0x00000010\r
+ #define RTL_QUERY_REGISTRY_DIRECT 0x00000020\r
+ #define RTL_QUERY_REGISTRY_DELETE 0x00000040\r
+ \r
+ typedef struct _RTL_BITMAP {\r
+ ULONG SizeOfBitMap;\r
+ PULONG Buffer;\r
+ } RTL_BITMAP, *PRTL_BITMAP;\r
+ \r
+ typedef struct _RTL_BITMAP_RUN {\r
+ ULONG StartingIndex;\r
+ ULONG NumberOfBits;\r
+ } RTL_BITMAP_RUN, *PRTL_BITMAP_RUN;\r
+ \r
+ typedef NTSTATUS\r
+ (DDKAPI *PRTL_QUERY_REGISTRY_ROUTINE)(\r
+ IN PWSTR ValueName,\r
+ IN ULONG ValueType,\r
+ IN PVOID ValueData,\r
+ IN ULONG ValueLength,\r
+ IN PVOID Context,\r
+ IN PVOID EntryContext);\r
+ \r
+ typedef struct _RTL_QUERY_REGISTRY_TABLE {\r
+ PRTL_QUERY_REGISTRY_ROUTINE QueryRoutine;\r
+ ULONG Flags;\r
+ PCWSTR Name;\r
+ PVOID EntryContext;\r
+ ULONG DefaultType;\r
+ PVOID DefaultData;\r
+ ULONG DefaultLength;\r
+ } RTL_QUERY_REGISTRY_TABLE, *PRTL_QUERY_REGISTRY_TABLE;\r
+ \r
+ typedef struct _TIME_FIELDS {\r
+ CSHORT Year;\r
+ CSHORT Month;\r
+ CSHORT Day;\r
+ CSHORT Hour;\r
+ CSHORT Minute;\r
+ CSHORT Second;\r
+ CSHORT Milliseconds;\r
+ CSHORT Weekday;\r
+ } TIME_FIELDS, *PTIME_FIELDS;\r
+ \r
+ \r
+ /******************************************************************************\r
+ * RTL Functions *\r
+ ******************************************************************************/\r
+ \r
+ NTSYSAPI\r
+ VOID\r
+ NTAPI\r
+ RtlAssert(\r
+ IN PVOID FailedAssertion,\r
+ IN PVOID FileName,\r
+ IN ULONG LineNumber,\r
+ IN PCHAR Message);\r
+ \r
+ /* VOID\r
+ * RtlCopyMemory(\r
+ * IN VOID UNALIGNED *Destination,\r
+ * IN CONST VOID UNALIGNED *Source,\r
+ * IN SIZE_T Length)\r
+ */\r
+ #define RtlCopyMemory(Destination, Source, Length) \\r
+ memcpy(Destination, Source, Length)\r
+ \r
+ #define RtlCopyBytes RtlCopyMemory\r
+ \r
+ #if defined(_M_AMD64)\r
+ NTSYSAPI\r
+ VOID\r
+ NTAPI\r
+ RtlCopyMemoryNonTemporal(\r
+ VOID UNALIGNED *Destination,\r
+ CONST VOID UNALIGNED *Source,\r
+ SIZE_T Length);\r
+ #else\r
+ #define RtlCopyMemoryNonTemporal RtlCopyMemory\r
+ #endif\r
+ \r
+ /* BOOLEAN\r
+ * RtlEqualLuid(\r
+ * IN PLUID Luid1,\r
+ * IN PLUID Luid2)\r
+ */\r
+ #define RtlEqualLuid(Luid1, Luid2) \\r
+ (((Luid1)->LowPart == (Luid2)->LowPart) && ((Luid1)->HighPart == (Luid2)->HighPart))\r
+ \r
+ /* ULONG\r
+ * RtlEqualMemory(\r
+ * IN VOID UNALIGNED *Destination,\r
+ * IN CONST VOID UNALIGNED *Source,\r
+ * IN SIZE_T Length)\r
+ */\r
+ #define RtlEqualMemory(Destination, Source, Length) \\r
+ (!memcmp(Destination, Source, Length))\r
+ \r
+ /* VOID\r
+ * RtlFillMemory(\r
+ * IN VOID UNALIGNED *Destination,\r
+ * IN SIZE_T Length,\r
+ * IN UCHAR Fill)\r
+ */\r
+ #define RtlFillMemory(Destination, Length, Fill) \\r
+ memset(Destination, Fill, Length)\r
+ \r
+ #define RtlFillBytes RtlFillMemory\r
+ \r
+ NTSYSAPI\r
+ VOID\r
+ NTAPI\r
+ RtlFreeUnicodeString(\r
+ IN PUNICODE_STRING UnicodeString);\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlGUIDFromString(\r
+ IN PUNICODE_STRING GuidString,\r
+ OUT GUID *Guid);\r
+ \r
+ NTSYSAPI\r
+ VOID\r
+ NTAPI\r
+ RtlInitUnicodeString(\r
+ IN OUT PUNICODE_STRING DestinationString,\r
+ IN PCWSTR SourceString);\r
+ \r
+ /* VOID\r
+ * RtlMoveMemory(\r
+ * IN VOID UNALIGNED *Destination,\r
+ * IN CONST VOID UNALIGNED *Source,\r
+ * IN SIZE_T Length)\r
+ */\r
+ #define RtlMoveMemory(Destination, Source, Length) \\r
+ memmove(Destination, Source, Length)\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlStringFromGUID(\r
+ IN REFGUID Guid,\r
+ OUT PUNICODE_STRING GuidString);\r
+ \r
+ /* VOID\r
+ * RtlZeroMemory(\r
+ * IN VOID UNALIGNED *Destination,\r
+ * IN SIZE_T Length)\r
+ */\r
+ #define RtlZeroMemory(Destination, Length) \\r
+ memset(Destination, 0, Length)\r
+ \r
+ #define RtlZeroBytes RtlZeroMemory\r
+ \r
+ \r
+ #if (NTDDI_VERSION >= NTDDI_WIN2K)\r
+ NTSYSAPI\r
+ BOOLEAN\r
+ NTAPI\r
+ RtlAreBitsClear(\r
+ IN PRTL_BITMAP BitMapHeader,\r
+ IN ULONG StartingIndex,\r
+ IN ULONG Length);\r
+ \r
+ NTSYSAPI\r
+ BOOLEAN\r
+ NTAPI\r
+ RtlAreBitsSet(\r
+ IN PRTL_BITMAP BitMapHeader,\r
+ IN ULONG StartingIndex,\r
+ IN ULONG Length);\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlAnsiStringToUnicodeString(\r
+ IN OUT PUNICODE_STRING DestinationString,\r
+ IN PANSI_STRING SourceString,\r
+ IN BOOLEAN AllocateDestinationString);\r
+ \r
+ NTSYSAPI\r
+ ULONG\r
+ NTAPI\r
+ RtlxAnsiStringToUnicodeSize(\r
+ IN PCANSI_STRING AnsiString);\r
+ \r
+ #define RtlAnsiStringToUnicodeSize(String) ( \\r
+ NLS_MB_CODE_PAGE_TAG ? \\r
+ RtlxAnsiStringToUnicodeSize(String) : \\r
+ ((String)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR) \\r
+ )\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlAppendUnicodeStringToString(\r
+ IN OUT PUNICODE_STRING Destination,\r
+ IN PCUNICODE_STRING Source);\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlAppendUnicodeToString(\r
+ IN OUT PUNICODE_STRING Destination,\r
+ IN PCWSTR Source);\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlCheckRegistryKey(\r
+ IN ULONG RelativeTo,\r
+ IN PWSTR Path);\r
+ \r
+ NTSYSAPI\r
+ VOID\r
+ NTAPI\r
+ RtlClearAllBits(\r
+ IN PRTL_BITMAP BitMapHeader);\r
+ \r
+ NTSYSAPI\r
+ VOID\r
+ NTAPI\r
+ RtlClearBits(\r
+ IN PRTL_BITMAP BitMapHeader,\r
+ IN ULONG StartingIndex,\r
+ IN ULONG NumberToClear);\r
+ \r
+ NTSYSAPI\r
+ SIZE_T\r
+ NTAPI\r
+ RtlCompareMemory(\r
+ IN CONST VOID *Source1,\r
+ IN CONST VOID *Source2,\r
+ IN SIZE_T Length);\r
+ \r
+ NTSYSAPI\r
+ LONG\r
+ NTAPI\r
+ RtlCompareUnicodeString(\r
+ IN PCUNICODE_STRING String1,\r
+ IN PCUNICODE_STRING String2,\r
+ IN BOOLEAN CaseInSensitive);\r
+ \r
+ NTSYSAPI\r
+ LONG\r
+ NTAPI\r
+ RtlCompareUnicodeStrings(\r
+ IN PCWCH String1,\r
+ IN SIZE_T String1Length,\r
+ IN PCWCH String2,\r
+ IN SIZE_T String2Length,\r
+ IN BOOLEAN CaseInSensitive);\r
+ \r
+ NTSYSAPI\r
+ VOID\r
+ NTAPI\r
+ RtlCopyUnicodeString(\r
+ IN OUT PUNICODE_STRING DestinationString,\r
+ IN PCUNICODE_STRING SourceString);\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlCreateRegistryKey(\r
+ IN ULONG RelativeTo,\r
+ IN PWSTR Path);\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlCreateSecurityDescriptor(\r
+ IN OUT PSECURITY_DESCRIPTOR SecurityDescriptor,\r
+ IN ULONG Revision);\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlDeleteRegistryValue(\r
+ IN ULONG RelativeTo,\r
+ IN PCWSTR Path,\r
+ IN PCWSTR ValueName);\r
+ \r
+ NTSYSAPI\r
+ BOOLEAN\r
+ NTAPI\r
+ RtlEqualUnicodeString(\r
+ IN CONST UNICODE_STRING *String1,\r
+ IN CONST UNICODE_STRING *String2,\r
+ IN BOOLEAN CaseInSensitive);\r
+ \r
+ #if !defined(_AMD64_) && !defined(_IA64_)\r
+ NTSYSAPI\r
+ LARGE_INTEGER\r
+ NTAPI\r
+ RtlExtendedIntegerMultiply(\r
+ IN LARGE_INTEGER Multiplicand,\r
+ IN LONG Multiplier);\r
+ \r
+ NTSYSAPI\r
+ LARGE_INTEGER\r
+ NTAPI\r
+ RtlExtendedLargeIntegerDivide(\r
+ IN LARGE_INTEGER Dividend,\r
+ IN ULONG Divisor,\r
+ IN OUT PULONG Remainder);\r
+ #endif\r
+ \r
+ #if defined(_X86_) || defined(_IA64_)\r
+ NTSYSAPI\r
+ LARGE_INTEGER\r
+ NTAPI\r
+ RtlExtendedMagicDivide(\r
+ IN LARGE_INTEGER Dividend,\r
+ IN LARGE_INTEGER MagicDivisor,\r
+ IN CCHAR ShiftCount);\r
+ #endif\r
+ \r
+ NTSYSAPI\r
+ VOID\r
+ NTAPI\r
+ RtlFreeAnsiString(\r
+ IN PANSI_STRING AnsiString);\r
+ \r
+ NTSYSAPI\r
+ ULONG\r
+ NTAPI\r
+ RtlFindClearBits(\r
+ IN PRTL_BITMAP BitMapHeader,\r
+ IN ULONG NumberToFind,\r
+ IN ULONG HintIndex);\r
+ \r
+ NTSYSAPI\r
+ ULONG\r
+ NTAPI\r
+ RtlFindClearBitsAndSet(\r
+ IN PRTL_BITMAP BitMapHeader,\r
+ IN ULONG NumberToFind,\r
+ IN ULONG HintIndex);\r
+ \r
+ NTSYSAPI\r
+ ULONG\r
+ NTAPI\r
+ RtlFindFirstRunClear(\r
+ IN PRTL_BITMAP BitMapHeader,\r
+ OUT PULONG StartingIndex);\r
+ \r
+ NTSYSAPI\r
+ ULONG\r
+ NTAPI\r
+ RtlFindClearRuns(\r
+ IN PRTL_BITMAP BitMapHeader,\r
+ OUT PRTL_BITMAP_RUN RunArray,\r
+ IN ULONG SizeOfRunArray,\r
+ IN BOOLEAN LocateLongestRuns);\r
+ \r
+ NTSYSAPI\r
+ ULONG\r
+ NTAPI\r
+ RtlFindLastBackwardRunClear(\r
+ IN PRTL_BITMAP BitMapHeader,\r
+ IN ULONG FromIndex,\r
+ OUT PULONG StartingRunIndex);\r
+ \r
+ NTSYSAPI\r
+ CCHAR\r
+ NTAPI\r
+ RtlFindLeastSignificantBit(\r
+ IN ULONGLONG Set);\r
+ \r
+ NTSYSAPI\r
+ ULONG\r
+ NTAPI\r
+ RtlFindLongestRunClear(\r
+ IN PRTL_BITMAP BitMapHeader,\r
+ OUT PULONG StartingIndex);\r
+ \r
+ NTSYSAPI\r
+ CCHAR\r
+ NTAPI\r
+ RtlFindMostSignificantBit(\r
+ IN ULONGLONG Set);\r
+ \r
+ NTSYSAPI\r
+ ULONG\r
+ NTAPI\r
+ RtlFindNextForwardRunClear(\r
+ IN PRTL_BITMAP BitMapHeader,\r
+ IN ULONG FromIndex,\r
+ OUT PULONG StartingRunIndex);\r
+ \r
+ NTSYSAPI\r
+ ULONG\r
+ NTAPI\r
+ RtlFindSetBits(\r
+ IN PRTL_BITMAP BitMapHeader,\r
+ IN ULONG NumberToFind,\r
+ IN ULONG HintIndex);\r
+ \r
+ NTSYSAPI\r
+ ULONG\r
+ NTAPI\r
+ RtlFindSetBitsAndClear(\r
+ IN PRTL_BITMAP BitMapHeader,\r
+ IN ULONG NumberToFind,\r
+ IN ULONG HintIndex);\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlHashUnicodeString(\r
+ IN CONST UNICODE_STRING *String,\r
+ IN BOOLEAN CaseInSensitive,\r
+ IN ULONG HashAlgorithm,\r
+ OUT PULONG HashValue);\r
+ \r
+ NTSYSAPI\r
+ VOID\r
+ NTAPI\r
+ RtlInitAnsiString(\r
+ IN OUT PANSI_STRING DestinationString,\r
+ IN PCSZ SourceString);\r
+ \r
+ NTSYSAPI\r
+ VOID\r
+ NTAPI\r
+ RtlInitializeBitMap(\r
+ IN PRTL_BITMAP BitMapHeader,\r
+ IN PULONG BitMapBuffer,\r
+ IN ULONG SizeOfBitMap);\r
+ \r
+ NTSYSAPI\r
+ VOID\r
+ NTAPI\r
+ RtlInitString(\r
+ IN OUT PSTRING DestinationString,\r
+ IN PCSZ SourceString);\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlIntegerToUnicodeString(\r
+ IN ULONG Value,\r
+ IN ULONG Base OPTIONAL,\r
+ IN OUT PUNICODE_STRING String);\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlInt64ToUnicodeString(\r
+ IN ULONGLONG Value,\r
+ IN ULONG Base OPTIONAL,\r
+ IN OUT PUNICODE_STRING String);\r
+ \r
+ #ifdef _WIN64\r
+ #define RtlIntPtrToUnicodeString(Value, Base, String) \\r
+ RtlInt64ToUnicodeString(Value, Base, String)\r
+ #else\r
+ #define RtlIntPtrToUnicodeString(Value, Base, String) \\r
+ RtlIntegerToUnicodeString(Value, Base, String)\r
+ #endif\r
+ \r
+ /* BOOLEAN\r
+ * RtlIsZeroLuid(\r
+ * IN PLUID L1);\r
+ */\r
+ #define RtlIsZeroLuid(_L1) \\r
+ ((BOOLEAN) ((!(_L1)->LowPart) && (!(_L1)->HighPart)))\r
+ \r
+ NTSYSAPI\r
+ ULONG\r
+ NTAPI\r
+ RtlLengthSecurityDescriptor(\r
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor);\r
+ \r
+ NTSYSAPI\r
+ ULONG\r
+ NTAPI\r
+ RtlNumberOfClearBits(\r
+ IN PRTL_BITMAP BitMapHeader);\r
+ \r
+ NTSYSAPI\r
+ ULONG\r
+ NTAPI\r
+ RtlNumberOfSetBits(\r
+ IN PRTL_BITMAP BitMapHeader);\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlQueryRegistryValues(\r
+ IN ULONG RelativeTo,\r
+ IN PCWSTR Path,\r
+ IN PRTL_QUERY_REGISTRY_TABLE QueryTable,\r
+ IN PVOID Context,\r
+ IN PVOID Environment OPTIONAL);\r
+ \r
+ #define LONG_SIZE (sizeof(LONG))\r
+ #define LONG_MASK (LONG_SIZE - 1)\r
+ \r
+ /* VOID\r
+ * RtlRetrieveUlong(\r
+ * PULONG DestinationAddress,\r
+ * PULONG SourceAddress);\r
+ */\r
+ #if defined(_AMD64_)\r
+ #define RtlRetrieveUlong(DestAddress,SrcAddress) \\r
+ *(ULONG UNALIGNED *)(DestAddress) = *(PULONG)(SrcAddress)\r
+ #else\r
+ #define RtlRetrieveUlong(DestAddress,SrcAddress) \\r
+ if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \\r
+ { \\r
+ ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \\r
+ ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \\r
+ ((PUCHAR)(DestAddress))[2]=((PUCHAR)(SrcAddress))[2]; \\r
+ ((PUCHAR)(DestAddress))[3]=((PUCHAR)(SrcAddress))[3]; \\r
+ } \\r
+ else \\r
+ { \\r
+ *((PULONG)(DestAddress))=*((PULONG)(SrcAddress)); \\r
+ }\r
+ #endif\r
+ \r
+ /* VOID\r
+ * RtlRetrieveUshort(\r
+ * PUSHORT DestinationAddress,\r
+ * PUSHORT SourceAddress);\r
+ */\r
+ #if defined(_AMD64_)\r
+ #define RtlRetrieveUshort(DestAddress,SrcAddress) \\r
+ *(USHORT UNALIGNED *)(DestAddress) = *(USHORT)(SrcAddress)\r
+ #else\r
+ #define RtlRetrieveUshort(DestAddress,SrcAddress) \\r
+ if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \\r
+ { \\r
+ ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \\r
+ ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \\r
+ } \\r
+ else \\r
+ { \\r
+ *((PUSHORT)(DestAddress))=*((PUSHORT)(SrcAddress)); \\r
+ }\r
+ #endif\r
+ \r
+ NTSYSAPI\r
+ VOID\r
+ NTAPI\r
+ RtlSetAllBits(\r
+ IN PRTL_BITMAP BitMapHeader);\r
+ \r
+ NTSYSAPI\r
+ VOID\r
+ NTAPI\r
+ RtlSetBits(\r
+ IN PRTL_BITMAP BitMapHeader,\r
+ IN ULONG StartingIndex,\r
+ IN ULONG NumberToSet);\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlSetDaclSecurityDescriptor(\r
+ IN OUT PSECURITY_DESCRIPTOR SecurityDescriptor,\r
+ IN BOOLEAN DaclPresent,\r
+ IN PACL Dacl OPTIONAL,\r
+ IN BOOLEAN DaclDefaulted OPTIONAL);\r
+ \r
+ /* VOID\r
+ * RtlStoreUlong(\r
+ * IN PULONG Address,\r
+ * IN ULONG Value);\r
+ */\r
+ #if defined(_AMD64_)\r
+ #define RtlStoreUlong(Address,Value) \\r
+ *(ULONG UNALIGNED *)(Address) = (Value)\r
+ #else\r
+ #define RtlStoreUlong(Address,Value) \\r
+ if ((ULONG_PTR)(Address) & LONG_MASK) { \\r
+ ((PUCHAR) (Address))[LONG_LEAST_SIGNIFICANT_BIT] = (UCHAR)(FIRSTBYTE(Value)); \\r
+ ((PUCHAR) (Address))[LONG_3RD_MOST_SIGNIFICANT_BIT] = (UCHAR)(SECONDBYTE(Value)); \\r
+ ((PUCHAR) (Address))[LONG_2ND_MOST_SIGNIFICANT_BIT] = (UCHAR)(THIRDBYTE(Value)); \\r
+ ((PUCHAR) (Address))[LONG_MOST_SIGNIFICANT_BIT] = (UCHAR)(FOURTHBYTE(Value)); \\r
+ } \\r
+ else { \\r
+ *((PULONG)(Address)) = (ULONG) (Value); \\r
+ }\r
+ #endif\r
+ \r
+ /* VOID\r
+ * RtlStoreUlonglong(\r
+ * IN OUT PULONGLONG Address,\r
+ * ULONGLONG Value);\r
+ */\r
+ #if defined(_AMD64_)\r
+ #define RtlStoreUlonglong(Address,Value) \\r
+ *(ULONGLONG UNALIGNED *)(Address) = (Value)\r
+ #else\r
+ #define RtlStoreUlonglong(Address,Value) \\r
+ if ((ULONG_PTR)(Address) & LONGLONG_MASK) { \\r
+ RtlStoreUlong((ULONG_PTR)(Address), \\r
+ (ULONGLONG)(Value) & 0xFFFFFFFF); \\r
+ RtlStoreUlong((ULONG_PTR)(Address)+sizeof(ULONG), \\r
+ (ULONGLONG)(Value) >> 32); \\r
+ } else { \\r
+ *((PULONGLONG)(Address)) = (ULONGLONG)(Value); \\r
+ }\r
+ #endif\r
+ \r
+ /* VOID\r
+ * RtlStoreUlongPtr(\r
+ * IN OUT PULONG_PTR Address,\r
+ * IN ULONG_PTR Value);\r
+ */\r
+ #ifdef _WIN64\r
+ #define RtlStoreUlongPtr(Address,Value) \\r
+ RtlStoreUlonglong(Address,Value)\r
+ #else\r
+ #define RtlStoreUlongPtr(Address,Value) \\r
+ RtlStoreUlong(Address,Value)\r
+ #endif\r
+ \r
+ /* VOID\r
+ * RtlStoreUshort(\r
+ * IN PUSHORT Address,\r
+ * IN USHORT Value);\r
+ */\r
+ #if defined(_AMD64_)\r
+ #define RtlStoreUshort(Address,Value) \\r
+ *(USHORT UNALIGNED *)(Address) = (Value)\r
+ #else\r
+ #define RtlStoreUshort(Address,Value) \\r
+ if ((ULONG_PTR)(Address) & SHORT_MASK) { \\r
+ ((PUCHAR) (Address))[SHORT_LEAST_SIGNIFICANT_BIT] = (UCHAR)(FIRSTBYTE(Value)); \\r
+ ((PUCHAR) (Address))[SHORT_MOST_SIGNIFICANT_BIT ] = (UCHAR)(SECONDBYTE(Value)); \\r
+ } \\r
+ else { \\r
+ *((PUSHORT) (Address)) = (USHORT)Value; \\r
+ }\r
+ #endif\r
+ \r
+ NTSYSAPI\r
+ BOOLEAN\r
+ NTAPI\r
+ RtlTimeFieldsToTime(\r
+ IN PTIME_FIELDS TimeFields,\r
+ IN PLARGE_INTEGER Time);\r
+ \r
+ NTSYSAPI\r
+ VOID\r
+ NTAPI\r
+ RtlTimeToTimeFields(\r
+ IN PLARGE_INTEGER Time,\r
+ IN PTIME_FIELDS TimeFields);\r
+ \r
+ NTSYSAPI\r
+ ULONG\r
+ FASTCALL\r
+ RtlUlongByteSwap(\r
+ IN ULONG Source);\r
+ \r
+ NTSYSAPI\r
+ ULONGLONG\r
+ FASTCALL\r
+ RtlUlonglongByteSwap(\r
+ IN ULONGLONG Source);\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlUnicodeStringToAnsiString(\r
+ IN OUT PANSI_STRING DestinationString,\r
+ IN PCUNICODE_STRING SourceString,\r
+ IN BOOLEAN AllocateDestinationString);\r
+ \r
+ NTSYSAPI\r
+ ULONG\r
+ NTAPI\r
+ RtlxUnicodeStringToAnsiSize(\r
+ IN PCUNICODE_STRING UnicodeString);\r
+ \r
+ #define RtlUnicodeStringToAnsiSize(String) ( \\r
+ NLS_MB_CODE_PAGE_TAG ? \\r
+ RtlxUnicodeStringToAnsiSize(String) : \\r
+ ((String)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \\r
+ )\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlUnicodeStringToInteger(\r
+ IN PCUNICODE_STRING String,\r
+ IN ULONG Base OPTIONAL,\r
+ OUT PULONG Value);\r
+ \r
+ NTSYSAPI\r
+ WCHAR\r
+ NTAPI\r
+ RtlUpcaseUnicodeChar(\r
+ IN WCHAR SourceCharacter);\r
+ \r
+ NTSYSAPI\r
+ USHORT\r
+ FASTCALL\r
+ RtlUshortByteSwap(\r
+ IN USHORT Source);\r
+ \r
+ NTSYSAPI\r
+ BOOLEAN\r
+ NTAPI\r
+ RtlValidRelativeSecurityDescriptor(\r
+ IN PSECURITY_DESCRIPTOR SecurityDescriptorInput,\r
+ IN ULONG SecurityDescriptorLength,\r
+ IN SECURITY_INFORMATION RequiredInformation);\r
+ \r
+ NTSYSAPI\r
+ BOOLEAN\r
+ NTAPI\r
+ RtlValidSecurityDescriptor(\r
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor);\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlWriteRegistryValue(\r
+ IN ULONG RelativeTo,\r
+ IN PCWSTR Path,\r
+ IN PCWSTR ValueName,\r
+ IN ULONG ValueType,\r
+ IN PVOID ValueData,\r
+ IN ULONG ValueLength);\r
+ \r
+ #endif // (NTDDI_VERSION >= NTDDI_WIN2K)\r
+ \r
+ #if (NTDDI_VERSION >= NTDDI_WIN2KSP3)\r
+ NTSYSAPI\r
+ VOID\r
+ FASTCALL\r
+ RtlPrefetchMemoryNonTemporal(\r
+ IN PVOID Source,\r
+ IN SIZE_T Length);\r
+ #endif\r
+ \r
+ #if (NTDDI_VERSION >= NTDDI_WINXP)\r
+ NTSYSAPI\r
+ VOID\r
+ NTAPI\r
+ RtlClearBit(\r
+ PRTL_BITMAP BitMapHeader,\r
+ ULONG BitNumber);\r
+ \r
+ NTSYSAPI\r
+ WCHAR\r
+ NTAPI\r
+ RtlDowncaseUnicodeChar(\r
+ IN WCHAR SourceCharacter);\r
+ \r
+ NTSYSAPI\r
+ VOID\r
+ NTAPI\r
+ RtlSetBit(\r
+ PRTL_BITMAP BitMapHeader,\r
+ ULONG BitNumber);\r
+ \r
+ NTSYSAPI\r
+ BOOLEAN\r
+ NTAPI\r
+ RtlTestBit(\r
+ IN PRTL_BITMAP BitMapHeader,\r
+ IN ULONG BitNumber);\r
+ \r
+ #endif // (NTDDI_VERSION >= NTDDI_WINXP)\r
+ \r
+ #if (NTDDI_VERSION >= NTDDI_VISTA)\r
+ NTSYSAPI\r
+ ULONG\r
+ NTAPI\r
+ RtlNumberOfSetBitsUlongPtr(\r
+ IN ULONG_PTR Target);\r
+ \r
+ NTSYSAPI\r
+ ULONGLONG\r
+ NTAPI\r
+ RtlIoDecodeMemIoResource (\r
+ IN PIO_RESOURCE_DESCRIPTOR Descriptor,\r
+ OUT PULONGLONG Alignment OPTIONAL,\r
+ OUT PULONGLONG MinimumAddress OPTIONAL,\r
+ OUT PULONGLONG MaximumAddress OPTIONAL);\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlIoEncodeMemIoResource(\r
+ IN PIO_RESOURCE_DESCRIPTOR Descriptor,\r
+ IN UCHAR Type,\r
+ IN ULONGLONG Length,\r
+ IN ULONGLONG Alignment,\r
+ IN ULONGLONG MinimumAddress,\r
+ IN ULONGLONG MaximumAddress);\r
+ \r
+ NTSYSAPI\r
+ ULONGLONG\r
+ NTAPI\r
+ RtlCmDecodeMemIoResource(\r
+ IN PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor,\r
+ OUT PULONGLONG Start OPTIONAL);\r
+ \r
+ NTSYSAPI\r
+ NTSTATUS\r
+ NTAPI\r
+ RtlFindClosestEncodableLength(\r
+ IN ULONGLONG SourceLength,\r
+ OUT PULONGLONG TargetLength);\r
+ \r
+ #endif\r
+ \r
+ #if !defined(MIDL_PASS)\r
+ /* inline funftions */\r
+ //DECLSPEC_DEPRECATED_DDK_WINXP\r
+ static __inline\r
+ LARGE_INTEGER\r
+ NTAPI_INLINE\r
+ RtlConvertLongToLargeInteger(LONG SignedInteger)\r
+ {\r
+ LARGE_INTEGER ret;\r
+ ret.QuadPart = SignedInteger;\r
+ return ret;\r
+ }\r
+ \r
+ //DECLSPEC_DEPRECATED_DDK_WINXP\r
+ static __inline\r
+ LARGE_INTEGER\r
+ NTAPI_INLINE\r
+ RtlConvertUlongToLargeInteger(\r
+ ULONG UnsignedInteger)\r
+ {\r
+ LARGE_INTEGER ret;\r
+ ret.QuadPart = UnsignedInteger;\r
+ return ret;\r
+ }\r
+ \r
+ //DECLSPEC_DEPRECATED_DDK\r
+ static __inline\r
+ ULONG\r
+ NTAPI_INLINE\r
+ RtlEnlargedUnsignedDivide(\r
+ IN ULARGE_INTEGER Dividend,\r
+ IN ULONG Divisor,\r
+ IN OUT PULONG Remainder)\r
+ {\r
+ if (Remainder)\r
+ *Remainder = Dividend.QuadPart % Divisor;\r
+ return Dividend.QuadPart / Divisor;\r
+ }\r
+ \r
+ //DECLSPEC_DEPRECATED_DDK\r
+ static __inline\r
+ LARGE_INTEGER\r
+ NTAPI_INLINE\r
+ RtlEnlargedUnsignedMultiply(\r
+ IN ULONG Multiplicand,\r
+ IN ULONG Multiplier)\r
+ {\r
+ LARGE_INTEGER ret;\r
+ ret.QuadPart = (ULONGLONG)Multiplicand * (ULONGLONG)Multiplier;\r
+ return ret;\r
+ }\r
+ \r
+ //DECLSPEC_DEPRECATED_DDK\r
+ static __inline\r
+ LARGE_INTEGER\r
+ NTAPI_INLINE\r
+ RtlEnlargedIntegerMultiply(\r
+ IN LONG Multiplicand,\r
+ IN LONG Multiplier)\r
+ {\r
+ LARGE_INTEGER ret;\r
+ ret.QuadPart = (LONGLONG)Multiplicand * (ULONGLONG)Multiplier;\r
+ return ret;\r
+ }\r
+ \r
+ FORCEINLINE\r
+ VOID\r
+ RtlInitEmptyAnsiString(OUT PANSI_STRING AnsiString,\r
+ IN PCHAR Buffer,\r
+ IN USHORT BufferSize)\r
+ {\r
+ AnsiString->Length = 0;\r
+ AnsiString->MaximumLength = BufferSize;\r
+ AnsiString->Buffer = Buffer;\r
+ }\r
+ \r
+ FORCEINLINE\r
+ VOID\r
+ RtlInitEmptyUnicodeString(\r
+ OUT PUNICODE_STRING UnicodeString,\r
+ IN PWSTR Buffer,\r
+ IN USHORT BufferSize)\r
+ {\r
+ UnicodeString->Length = 0;\r
+ UnicodeString->MaximumLength = BufferSize;\r
+ UnicodeString->Buffer = Buffer;\r
+ }\r
+ \r
+ #if defined(_AMD64_) || defined(_IA64_)\r
+ static __inline\r
+ LARGE_INTEGER\r
+ NTAPI_INLINE\r
+ RtlExtendedIntegerMultiply(\r
+ LARGE_INTEGER Multiplicand,\r
+ LONG Multiplier)\r
+ {\r
+ LARGE_INTEGER ret;\r
+ ret.QuadPart = Multiplicand.QuadPart * Multiplier;\r
+ return ret;\r
+ }\r
+ \r
+ static __inline\r
+ LARGE_INTEGER\r
+ NTAPI_INLINE\r
+ RtlExtendedLargeIntegerDivide(\r
+ LARGE_INTEGER Dividend,\r
+ ULONG Divisor,\r
+ PULONG Remainder)\r
+ {\r
+ LARGE_INTEGER ret;\r
+ ret.QuadPart = (ULONG64)Dividend.QuadPart / Divisor;\r
+ if (Remainder)\r
+ *Remainder = (ULONG)(Dividend.QuadPart % Divisor);\r
+ return ret;\r
+ }\r
+ #endif\r
+ \r
+ #if defined(_AMD64_)\r
++\r
++#define MultiplyHigh __mulh\r
++#define UnsignedMultiplyHigh __umulh\r
++\r
+ //DECLSPEC_DEPRECATED_DDK\r
+ static __inline\r
+ LARGE_INTEGER\r
+ NTAPI_INLINE\r
+ RtlExtendedMagicDivide(\r
+ IN LARGE_INTEGER Dividend,\r
+ IN LARGE_INTEGER MagicDivisor,\r
- ret64 = UnsignedMultiplyHigh(Pos ? Dividend.QuadPart : -Dividend.QuadPart\r
++ IN CCHAR ShiftCount)\r
+ {\r
+ LARGE_INTEGER ret;\r
+ ULONG64 ret64;\r
+ BOOLEAN Pos;\r
+ Pos = (Dividend.QuadPart >= 0);\r
++ ret64 = UnsignedMultiplyHigh(Pos ? Dividend.QuadPart : -Dividend.QuadPart,\r
+ MagicDivisor.QuadPart);\r
+ ret64 >>= ShiftCount;\r
+ ret.QuadPart = Pos ? ret64 : -ret64;\r
+ return ret;\r
+ }\r
+ #endif\r
+ \r
+ //DECLSPEC_DEPRECATED_DDK\r
+ static __inline\r
+ LARGE_INTEGER\r
+ NTAPI_INLINE\r
+ RtlLargeIntegerAdd(\r
+ IN LARGE_INTEGER Addend1,\r
+ IN LARGE_INTEGER Addend2)\r
+ {\r
+ LARGE_INTEGER ret;\r
+ ret.QuadPart = Addend1.QuadPart + Addend2.QuadPart;\r
+ return ret;\r
+ }\r
+ \r
+ /* VOID\r
+ * RtlLargeIntegerAnd(\r
+ * IN OUT LARGE_INTEGER Result,\r
+ * IN LARGE_INTEGER Source,\r
+ * IN LARGE_INTEGER Mask);\r
+ */\r
+ #define RtlLargeIntegerAnd(Result, Source, Mask) \\r
+ Result.QuadPart = Source.QuadPart & Mask.QuadPart\r
+ \r
+ //DECLSPEC_DEPRECATED_DDK\r
+ static __inline\r
+ LARGE_INTEGER\r
+ NTAPI_INLINE\r
+ RtlLargeIntegerArithmeticShift(\r
+ IN LARGE_INTEGER LargeInteger,\r
+ IN CCHAR ShiftCount)\r
+ {\r
+ LARGE_INTEGER ret;\r
+ ret.QuadPart = LargeInteger.QuadPart >> ShiftCount;\r
+ return ret;\r
+ }\r
+ \r
+ /* BOOLEAN\r
+ * RtlLargeIntegerEqualTo(\r
+ * IN LARGE_INTEGER Operand1,\r
+ * IN LARGE_INTEGER Operand2);\r
+ */\r
+ #define RtlLargeIntegerEqualTo(X,Y) \\r
+ (!(((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)))\r
+ \r
+ FORCEINLINE\r
+ PVOID\r
+ RtlSecureZeroMemory(\r
+ OUT PVOID Pointer,\r
+ IN SIZE_T Size)\r
+ {\r
+ volatile char* vptr = (volatile char*)Pointer;\r
+ #if defined(_M_AMD64)\r
+ __stosb((PUCHAR)vptr, 0, Size);\r
+ #else\r
+ char * endptr = (char *)vptr + Size;\r
+ while (vptr < endptr)\r
+ {\r
+ *vptr = 0; vptr++;\r
+ }\r
+ #endif\r
+ return Pointer;\r
+ }\r
+ \r
+ #if defined(_M_AMD64)\r
+ FORCEINLINE\r
+ ULONG\r
+ RtlCheckBit(\r
+ IN PRTL_BITMAP BitMapHeader,\r
+ IN ULONG BitPosition)\r
+ {\r
+ return BitTest((LONG CONST*)BitMapHeader->Buffer, BitPosition);\r
+ }\r
+ #else\r
+ #define RtlCheckBit(BMH,BP) (((((PLONG)(BMH)->Buffer)[(BP)/32]) >> ((BP)%32)) & 0x1)\r
+ #endif // defined(_M_AMD64)\r
+ \r
+ #endif // !defined(MIDL_PASS)\r
+ \r
//\r
// Byte Swap Functions\r
//\r
static unsigned ObjectDefinitionsCount = 0;
static PCSRSS_OBJECT_DEFINITION ObjectDefinitions = NULL;
- static BOOL
+ static
+ BOOL
CsrIsConsoleHandle(HANDLE Handle)
{
- return ((ULONG_PTR)Handle & 0x10000003) == 0x3;
- return ((ULONG)Handle & 0x10000003) == 0x3;
++ return ((ULONG_PTR)Handle & 0x10000003) == 0x3;
}
- NTSTATUS FASTCALL
- CsrRegisterObjectDefinitions(PCSRSS_OBJECT_DEFINITION NewDefinitions)
+ NTSTATUS
+ FASTCALL
+ CsrRegisterObjectDefinitions(
+ PCSRSS_OBJECT_DEFINITION NewDefinitions)
{
- unsigned NewCount;
- PCSRSS_OBJECT_DEFINITION Scan;
- PCSRSS_OBJECT_DEFINITION New;
+ unsigned NewCount;
+ PCSRSS_OBJECT_DEFINITION Scan;
+ PCSRSS_OBJECT_DEFINITION New;
- NewCount = 0;
- for (Scan = NewDefinitions; 0 != Scan->Type; Scan++)
+ NewCount = 0;
+ for (Scan = NewDefinitions; 0 != Scan->Type; Scan++)
{
- NewCount++;
+ NewCount++;
}
- New = RtlAllocateHeap(CsrssApiHeap, 0,
- (ObjectDefinitionsCount + NewCount)
- * sizeof(CSRSS_OBJECT_DEFINITION));
- if (NULL == New)
+ New = RtlAllocateHeap(CsrssApiHeap,
+ 0,
+ (ObjectDefinitionsCount + NewCount)
+ * sizeof(CSRSS_OBJECT_DEFINITION));
+ if (NULL == New)
{
- DPRINT1("Unable to allocate memory\n");
- return STATUS_NO_MEMORY;
+ DPRINT1("Unable to allocate memory\n");
+ return STATUS_NO_MEMORY;
}
- if (0 != ObjectDefinitionsCount)
+
+ if (0 != ObjectDefinitionsCount)
{
- RtlCopyMemory(New, ObjectDefinitions,
- ObjectDefinitionsCount * sizeof(CSRSS_OBJECT_DEFINITION));
- RtlFreeHeap(CsrssApiHeap, 0, ObjectDefinitions);
+ RtlCopyMemory(New,
+ ObjectDefinitions,
+ ObjectDefinitionsCount * sizeof(CSRSS_OBJECT_DEFINITION));
+ RtlFreeHeap(CsrssApiHeap, 0, ObjectDefinitions);
}
- RtlCopyMemory(New + ObjectDefinitionsCount, NewDefinitions,
- NewCount * sizeof(CSRSS_OBJECT_DEFINITION));
- ObjectDefinitions = New;
- ObjectDefinitionsCount += NewCount;
- return STATUS_SUCCESS;
+ RtlCopyMemory(New + ObjectDefinitionsCount,
+ NewDefinitions,
+ NewCount * sizeof(CSRSS_OBJECT_DEFINITION));
+ ObjectDefinitions = New;
+ ObjectDefinitionsCount += NewCount;
+
+ return STATUS_SUCCESS;
}
- NTSTATUS WINAPI CsrGetObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Handle, Object_t **Object, DWORD Access )
+ NTSTATUS
+ WINAPI
+ CsrGetObject(
+ PCSRSS_PROCESS_DATA ProcessData,
+ HANDLE Handle,
+ Object_t **Object,
+ DWORD Access )
{
++<<<<<<< .working
+ ULONG_PTR h = (ULONG_PTR)Handle >> 2;
+ DPRINT("CsrGetObject, Object: %x, %x, %x\n", Object, Handle, ProcessData ? ProcessData->HandleTableSize : 0);
++=======
+ ULONG h = (ULONG)Handle >> 2;
++>>>>>>> .merge-rechts.r40086
- RtlEnterCriticalSection(&ProcessData->HandleTableLock);
- if (!CsrIsConsoleHandle(Handle) || h >= ProcessData->HandleTableSize
- || (*Object = ProcessData->HandleTable[h].Object) == NULL
- || ~ProcessData->HandleTable[h].Access & Access)
+ DPRINT("CsrGetObject, Object: %x, %x, %x\n",
+ Object, Handle, ProcessData ? ProcessData->HandleTableSize : 0);
+
+ RtlEnterCriticalSection(&ProcessData->HandleTableLock);
+ if (!CsrIsConsoleHandle(Handle) || h >= ProcessData->HandleTableSize
+ || (*Object = ProcessData->HandleTable[h].Object) == NULL
+ || ~ProcessData->HandleTable[h].Access & Access)
{
- DPRINT1("CsrGetObject returning invalid handle (%x)\n", Handle);
- RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
- return STATUS_INVALID_HANDLE;
+ DPRINT1("CsrGetObject returning invalid handle (%x)\n", Handle);
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
+ return STATUS_INVALID_HANDLE;
}
- _InterlockedIncrement(&(*Object)->ReferenceCount);
- RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
- // DbgPrint( "CsrGetObject returning\n" );
- return STATUS_SUCCESS;
+ _InterlockedIncrement(&(*Object)->ReferenceCount);
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
+ // DbgPrint( "CsrGetObject returning\n" );
+ return STATUS_SUCCESS;
}
}
- NTSTATUS WINAPI
- CsrReleaseObject(PCSRSS_PROCESS_DATA ProcessData,
- HANDLE Handle)
+ NTSTATUS
+ WINAPI
+ CsrReleaseObject(
+ PCSRSS_PROCESS_DATA ProcessData,
+ HANDLE Handle)
{
-
- RtlEnterCriticalSection(&ProcessData->HandleTableLock);
- if (h >= ProcessData->HandleTableSize
- || (Object = ProcessData->HandleTable[h].Object) == NULL)
++<<<<<<< .working
+ ULONG_PTR h = (ULONG_PTR)Handle >> 2;
+ Object_t *Object;
++=======
+ ULONG h = (ULONG)Handle >> 2;
+ Object_t *Object;
++>>>>>>> .merge-rechts.r40086
+
+ RtlEnterCriticalSection(&ProcessData->HandleTableLock);
+ if (h >= ProcessData->HandleTableSize
+ || (Object = ProcessData->HandleTable[h].Object) == NULL)
{
- RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
- return STATUS_INVALID_HANDLE;
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
+ return STATUS_INVALID_HANDLE;
}
- ProcessData->HandleTable[h].Object = NULL;
- RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
+ ProcessData->HandleTable[h].Object = NULL;
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
- return CsrReleaseObjectByPointer(Object);
+ return CsrReleaseObjectByPointer(Object);
}
- NTSTATUS WINAPI CsrInsertObject(PCSRSS_PROCESS_DATA ProcessData,
- PHANDLE Handle,
- Object_t *Object,
- DWORD Access,
- BOOL Inheritable)
+ NTSTATUS
+ WINAPI
+ CsrInsertObject(
+ PCSRSS_PROCESS_DATA ProcessData,
+ PHANDLE Handle,
+ Object_t *Object,
+ DWORD Access,
+ BOOL Inheritable)
{
- ULONG i;
- PVOID* Block;
+ ULONG i;
+ PVOID* Block;
- RtlEnterCriticalSection(&ProcessData->HandleTableLock);
+ RtlEnterCriticalSection(&ProcessData->HandleTableLock);
- for (i = 0; i < ProcessData->HandleTableSize; i++)
- {
- if (ProcessData->HandleTable[i].Object == NULL)
- {
+ for (i = 0; i < ProcessData->HandleTableSize; i++)
+ {
+ if (ProcessData->HandleTable[i].Object == NULL)
+ {
break;
++<<<<<<< .working
+ }
+ }
+ if (i >= ProcessData->HandleTableSize)
+ {
+ Block = RtlAllocateHeap(CsrssApiHeap,
+ HEAP_ZERO_MEMORY,
+ (ProcessData->HandleTableSize + 64) * sizeof(CSRSS_HANDLE));
+ if (Block == NULL)
+ {
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
+ return(STATUS_UNSUCCESSFUL);
+ }
+ RtlCopyMemory(Block,
+ ProcessData->HandleTable,
+ ProcessData->HandleTableSize * sizeof(CSRSS_HANDLE));
+ Block = _InterlockedExchangePointer((volatile void*)&ProcessData->HandleTable, Block);
+ RtlFreeHeap( CsrssApiHeap, 0, Block );
+ ProcessData->HandleTableSize += 64;
+ }
+ ProcessData->HandleTable[i].Object = Object;
+ ProcessData->HandleTable[i].Access = Access;
+ ProcessData->HandleTable[i].Inheritable = Inheritable;
+ *Handle = (HANDLE)(ULONG_PTR)((i << 2) | 0x3);
+ _InterlockedIncrement( &Object->ReferenceCount );
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
+ return(STATUS_SUCCESS);
++=======
+ }
+ }
+ if (i >= ProcessData->HandleTableSize)
+ {
+ Block = RtlAllocateHeap(CsrssApiHeap,
+ HEAP_ZERO_MEMORY,
+ (ProcessData->HandleTableSize + 64) * sizeof(CSRSS_HANDLE));
+ if (Block == NULL)
+ {
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
+ return(STATUS_UNSUCCESSFUL);
+ }
+ RtlCopyMemory(Block,
+ ProcessData->HandleTable,
+ ProcessData->HandleTableSize * sizeof(CSRSS_HANDLE));
+ Block = _InterlockedExchangePointer((volatile void*)&ProcessData->HandleTable, Block);
+ RtlFreeHeap( CsrssApiHeap, 0, Block );
+ ProcessData->HandleTableSize += 64;
+ }
+ ProcessData->HandleTable[i].Object = Object;
+ ProcessData->HandleTable[i].Access = Access;
+ ProcessData->HandleTable[i].Inheritable = Inheritable;
+ *Handle = (HANDLE)((i << 2) | 0x3);
+ _InterlockedIncrement( &Object->ReferenceCount );
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
+ return(STATUS_SUCCESS);
++>>>>>>> .merge-rechts.r40086
}
- NTSTATUS WINAPI CsrDuplicateHandleTable(PCSRSS_PROCESS_DATA SourceProcessData,
- PCSRSS_PROCESS_DATA TargetProcessData)
+ NTSTATUS
+ WINAPI
+ CsrDuplicateHandleTable(
+ PCSRSS_PROCESS_DATA SourceProcessData,
+ PCSRSS_PROCESS_DATA TargetProcessData)
{
ULONG i;
_InterlockedIncrement( &SourceProcessData->HandleTable[i].Object->ReferenceCount );
}
}
- RtlLeaveCriticalSection(&SourceProcessData->HandleTableLock);
- return(STATUS_SUCCESS);
+ RtlLeaveCriticalSection(&SourceProcessData->HandleTableLock);
+ return(STATUS_SUCCESS);
}
- NTSTATUS WINAPI CsrVerifyObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Handle )
+ NTSTATUS
+ WINAPI
+ CsrVerifyObject(
+ PCSRSS_PROCESS_DATA ProcessData,
+ HANDLE Handle)
{
++<<<<<<< .working
+ ULONG_PTR h = (ULONG_PTR)Handle >> 2;
++=======
+ ULONG h = (ULONG)Handle >> 2;
++>>>>>>> .merge-rechts.r40086
- if (h >= ProcessData->HandleTableSize
- || ProcessData->HandleTable[h].Object == NULL)
+ if (h >= ProcessData->HandleTableSize ||
+ ProcessData->HandleTable[h].Object == NULL)
{
- return STATUS_INVALID_HANDLE;
+ return STATUS_INVALID_HANDLE;
}
- return STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
/* EOF */