sdk/include/xdk/rtlfuncs.h

   1 /******************************************************************************
   2  *                         Runtime Library Functions                          *
   3  ******************************************************************************/
   4
   5 $if (_WDMDDK_)
   6 #define FAST_FAIL_LEGACY_GS_VIOLATION           0
   7 #define FAST_FAIL_VTGUARD_CHECK_FAILURE         1
   8 #define FAST_FAIL_STACK_COOKIE_CHECK_FAILURE    2
   9 #define FAST_FAIL_CORRUPT_LIST_ENTRY            3
  10 #define FAST_FAIL_INCORRECT_STACK               4
  11 #define FAST_FAIL_INVALID_ARG                   5
  12 #define FAST_FAIL_GS_COOKIE_INIT                6
  13 #define FAST_FAIL_FATAL_APP_EXIT                7
  14 #define FAST_FAIL_RANGE_CHECK_FAILURE           8
  15 #define FAST_FAIL_UNSAFE_REGISTRY_ACCESS        9
  16 #define FAST_FAIL_GUARD_ICALL_CHECK_FAILURE     10
  17 #define FAST_FAIL_GUARD_WRITE_CHECK_FAILURE     11
  18 #define FAST_FAIL_INVALID_FIBER_SWITCH          12
  19 #define FAST_FAIL_INVALID_SET_OF_CONTEXT        13
  20 #define FAST_FAIL_INVALID_REFERENCE_COUNT       14
  21 #define FAST_FAIL_INVALID_JUMP_BUFFER           18
  22 #define FAST_FAIL_MRDATA_MODIFIED               19
  23 #define FAST_FAIL_INVALID_FAST_FAIL_CODE        0xFFFFFFFF
  24
  25 DECLSPEC_NORETURN
  26 FORCEINLINE
  27 VOID
  28 RtlFailFast(
  29   _In_ ULONG Code)
  30 {
  31   __fastfail(Code);
  32 }
  33
  34 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS) && (defined(_M_CEE_PURE) || defined(_M_CEE_SAFE))
  35 #define NO_KERNEL_LIST_ENTRY_CHECKS
  36 #endif
  37
  38 #if !defined(EXTRA_KERNEL_LIST_ENTRY_CHECKS) && defined(__REACTOS__)
  39 #define EXTRA_KERNEL_LIST_ENTRY_CHECKS
  40 #endif
  41
  42 #if !defined(MIDL_PASS) && !defined(SORTPP_PASS)
  43
  44 #define RTL_STATIC_LIST_HEAD(x) LIST_ENTRY x = { &x, &x }
  45
  46 FORCEINLINE
  47 VOID
  48 InitializeListHead(
  49   _Out_ PLIST_ENTRY ListHead)
  50 {
  51   ListHead->Flink = ListHead->Blink = ListHead;
  52 }
  53
  54 _Must_inspect_result_
  55 FORCEINLINE
  56 BOOLEAN
  57 IsListEmpty(
  58   _In_ const LIST_ENTRY * ListHead)
  59 {
  60   return (BOOLEAN)(ListHead->Flink == ListHead);
  61 }
  62
  63 FORCEINLINE
  64 BOOLEAN
  65 RemoveEntryListUnsafe(
  66   _In_ PLIST_ENTRY Entry)
  67 {
  68   PLIST_ENTRY OldFlink;
  69   PLIST_ENTRY OldBlink;
  70
  71   OldFlink = Entry->Flink;
  72   OldBlink = Entry->Blink;
  73   OldFlink->Blink = OldBlink;
  74   OldBlink->Flink = OldFlink;
  75   return (BOOLEAN)(OldFlink == OldBlink);
  76 }
  77
  78 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
  79 FORCEINLINE
  80 VOID
  81 FatalListEntryError(
  82   _In_ PVOID P1,
  83   _In_ PVOID P2,
  84   _In_ PVOID P3)
  85 {
  86   UNREFERENCED_PARAMETER(P1);
  87   UNREFERENCED_PARAMETER(P2);
  88   UNREFERENCED_PARAMETER(P3);
  89
  90   RtlFailFast(FAST_FAIL_CORRUPT_LIST_ENTRY);
  91 }
  92
  93 FORCEINLINE
  94 VOID
  95 RtlpCheckListEntry(
  96   _In_ PLIST_ENTRY Entry)
  97 {
  98   if (Entry->Flink->Blink != Entry || Entry->Blink->Flink != Entry)
  99     FatalListEntryError(Entry->Blink, Entry, Entry->Flink);
 100 }
 101 #endif
 102
 103 FORCEINLINE
 104 BOOLEAN
 105 RemoveEntryList(
 106   _In_ PLIST_ENTRY Entry)
 107 {
 108   PLIST_ENTRY OldFlink;
 109   PLIST_ENTRY OldBlink;
 110
 111   OldFlink = Entry->Flink;
 112   OldBlink = Entry->Blink;
 113 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
 114 #ifdef EXTRA_KERNEL_LIST_ENTRY_CHECKS
 115   if (OldFlink == Entry || OldBlink == Entry)
 116     FatalListEntryError(OldBlink, Entry, OldFlink);
 117 #endif
 118   if (OldFlink->Blink != Entry || OldBlink->Flink != Entry)
 119     FatalListEntryError(OldBlink, Entry, OldFlink);
 120 #endif
 121   OldFlink->Blink = OldBlink;
 122   OldBlink->Flink = OldFlink;
 123   return (BOOLEAN)(OldFlink == OldBlink);
 124 }
 125
 126 FORCEINLINE
 127 PLIST_ENTRY
 128 RemoveHeadList(
 129   _Inout_ PLIST_ENTRY ListHead)
 130 {
 131   PLIST_ENTRY Flink;
 132   PLIST_ENTRY Entry;
 133
 134 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS) && DBG
 135   RtlpCheckListEntry(ListHead);
 136 #ifdef EXTRA_KERNEL_LIST_ENTRY_CHECKS
 137   if (ListHead->Flink == ListHead || ListHead->Blink == ListHead)
 138     FatalListEntryError(ListHead->Blink, ListHead, ListHead->Flink);
 139 #endif
 140 #endif
 141   Entry = ListHead->Flink;
 142   Flink = Entry->Flink;
 143 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
 144   if (Entry->Blink != ListHead || Flink->Blink != Entry)
 145     FatalListEntryError(ListHead, Entry, Flink);
 146 #endif
 147   ListHead->Flink = Flink;
 148   Flink->Blink = ListHead;
 149   return Entry;
 150 }
 151
 152 FORCEINLINE
 153 PLIST_ENTRY
 154 RemoveTailList(
 155   _Inout_ PLIST_ENTRY ListHead)
 156 {
 157   PLIST_ENTRY Blink;
 158   PLIST_ENTRY Entry;
 159
 160 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS) && DBG
 161   RtlpCheckListEntry(ListHead);
 162 #ifdef EXTRA_KERNEL_LIST_ENTRY_CHECKS
 163   if (ListHead->Flink == ListHead || ListHead->Blink == ListHead)
 164     FatalListEntryError(ListHead->Blink, ListHead, ListHead->Flink);
 165 #endif
 166 #endif
 167   Entry = ListHead->Blink;
 168   Blink = Entry->Blink;
 169 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
 170   if (Blink->Flink != Entry || Entry->Flink != ListHead)
 171     FatalListEntryError(Blink, Entry, ListHead);
 172 #endif
 173   ListHead->Blink = Blink;
 174   Blink->Flink = ListHead;
 175   return Entry;
 176 }
 177
 178 FORCEINLINE
 179 VOID
 180 InsertTailList(
 181   _Inout_ PLIST_ENTRY ListHead,
 182   _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
 183 {
 184   PLIST_ENTRY OldBlink;
 185 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS) && DBG
 186   RtlpCheckListEntry(ListHead);
 187 #endif
 188   OldBlink = ListHead->Blink;
 189   Entry->Flink = ListHead;
 190   Entry->Blink = OldBlink;
 191 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
 192   if (OldBlink->Flink != ListHead)
 193     FatalListEntryError(OldBlink->Blink, OldBlink, ListHead);
 194 #endif
 195   OldBlink->Flink = Entry;
 196   ListHead->Blink = Entry;
 197 }
 198
 199 FORCEINLINE
 200 VOID
 201 InsertHeadList(
 202   _Inout_ PLIST_ENTRY ListHead,
 203   _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
 204 {
 205   PLIST_ENTRY OldFlink;
 206 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS) && DBG
 207   RtlpCheckListEntry(ListHead);
 208 #endif
 209   OldFlink = ListHead->Flink;
 210   Entry->Flink = OldFlink;
 211   Entry->Blink = ListHead;
 212 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
 213   if (OldFlink->Blink != ListHead)
 214     FatalListEntryError(ListHead, OldFlink, OldFlink->Flink);
 215 #endif
 216   OldFlink->Blink = Entry;
 217   ListHead->Flink = Entry;
 218 }
 219
 220 FORCEINLINE
 221 VOID
 222 AppendTailList(
 223   _Inout_ PLIST_ENTRY ListHead,
 224   _Inout_ PLIST_ENTRY ListToAppend)
 225 {
 226   PLIST_ENTRY ListEnd = ListHead->Blink;
 227
 228 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
 229   RtlpCheckListEntry(ListHead);
 230   RtlpCheckListEntry(ListToAppend);
 231 #endif
 232   ListHead->Blink->Flink = ListToAppend;
 233   ListHead->Blink = ListToAppend->Blink;
 234   ListToAppend->Blink->Flink = ListHead;
 235   ListToAppend->Blink = ListEnd;
 236 }
 237
 238 FORCEINLINE
 239 PSINGLE_LIST_ENTRY
 240 PopEntryList(
 241   _Inout_ PSINGLE_LIST_ENTRY ListHead)
 242 {
 243   PSINGLE_LIST_ENTRY FirstEntry;
 244   FirstEntry = ListHead->Next;
 245   if (FirstEntry != NULL) {
 246     ListHead->Next = FirstEntry->Next;
 247   }
 248   return FirstEntry;
 249 }
 250
 251 FORCEINLINE
 252 VOID
 253 PushEntryList(
 254   _Inout_ PSINGLE_LIST_ENTRY ListHead,
 255   _Inout_ __drv_aliasesMem PSINGLE_LIST_ENTRY Entry)
 256 {
 257   Entry->Next = ListHead->Next;
 258   ListHead->Next = Entry;
 259 }
 260
 261 #endif /* !defined(MIDL_PASS) && !defined(SORTPP_PASS) */
 262
 263 __analysis_noreturn
 264 NTSYSAPI
 265 VOID
 266 NTAPI
 267 RtlAssert(
 268   _In_ PVOID FailedAssertion,
 269   _In_ PVOID FileName,
 270   _In_ ULONG LineNumber,
 271   _In_opt_z_ PSTR Message);
 272
 273 /* VOID
 274  * RtlCopyMemory(
 275  *     IN VOID UNALIGNED *Destination,
 276  *     IN CONST VOID UNALIGNED *Source,
 277  *     IN SIZE_T Length)
 278  */
 279 #define RtlCopyMemory(Destination, Source, Length) \
 280     memcpy(Destination, Source, Length)
 281
 282 #define RtlCopyBytes RtlCopyMemory
 283
 284 #if defined(_M_AMD64)
 285 NTSYSAPI
 286 VOID
 287 NTAPI
 288 RtlCopyMemoryNonTemporal(
 289   _Out_writes_bytes_all_(Length) VOID UNALIGNED *Destination,
 290   _In_reads_bytes_(Length) const VOID UNALIGNED *Source,
 291   _In_ SIZE_T Length);
 292 #else
 293 #define RtlCopyMemoryNonTemporal RtlCopyMemory
 294 #endif
 295
 296 /* BOOLEAN
 297  * RtlEqualLuid(
 298  *     IN PLUID Luid1,
 299  *     IN PLUID Luid2)
 300  */
 301 #define RtlEqualLuid(Luid1, Luid2) \
 302     (((Luid1)->LowPart == (Luid2)->LowPart) && ((Luid1)->HighPart == (Luid2)->HighPart))
 303
 304 /* LOGICAL
 305  * RtlEqualMemory(
 306  *     IN VOID UNALIGNED *Destination,
 307  *     IN CONST VOID UNALIGNED *Source,
 308  *     IN SIZE_T Length)
 309  */
 310 #define RtlEqualMemory(Destination, Source, Length) \
 311     (!memcmp(Destination, Source, Length))
 312
 313 /* VOID
 314  * RtlFillMemory(
 315  *     IN VOID UNALIGNED *Destination,
 316  *     IN SIZE_T Length,
 317  *     IN UCHAR Fill)
 318  */
 319 #define RtlFillMemory(Destination, Length, Fill) \
 320     memset(Destination, Fill, Length)
 321
 322 #define RtlFillBytes RtlFillMemory
 323
 324 _IRQL_requires_max_(PASSIVE_LEVEL)
 325 NTSYSAPI
 326 VOID
 327 NTAPI
 328 RtlFreeUnicodeString(
 329   _Inout_ _At_(UnicodeString->Buffer, __drv_freesMem(Mem))
 330     PUNICODE_STRING UnicodeString);
 331
 332 _IRQL_requires_max_(PASSIVE_LEVEL)
 333 _Must_inspect_result_
 334 NTSYSAPI
 335 NTSTATUS
 336 NTAPI
 337 RtlGUIDFromString(
 338   _In_ PUNICODE_STRING GuidString,
 339   _Out_ GUID *Guid);
 340
 341 _IRQL_requires_max_(DISPATCH_LEVEL)
 342 _At_(DestinationString->Buffer, _Post_equal_to_(SourceString))
 343 _When_(SourceString != NULL,
 344 _At_(DestinationString->Length, _Post_equal_to_(_String_length_(SourceString) * sizeof(WCHAR)))
 345 _At_(DestinationString->MaximumLength, _Post_equal_to_(DestinationString->Length + sizeof(WCHAR))))
 346 _When_(SourceString == NULL,
 347 _At_(DestinationString->Length, _Post_equal_to_(0))
 348 _At_(DestinationString->MaximumLength, _Post_equal_to_(0)))
 349 NTSYSAPI
 350 VOID
 351 NTAPI
 352 RtlInitUnicodeString(
 353     _Out_ PUNICODE_STRING DestinationString,
 354     _In_opt_z_ __drv_aliasesMem PCWSTR SourceString);
 355
 356 /* VOID
 357  * RtlMoveMemory(
 358  *    IN VOID UNALIGNED *Destination,
 359  *    IN CONST VOID UNALIGNED *Source,
 360  *    IN SIZE_T Length)
 361  */
 362 #define RtlMoveMemory(Destination, Source, Length) \
 363     memmove(Destination, Source, Length)
 364
 365 _IRQL_requires_max_(PASSIVE_LEVEL)
 366 _Must_inspect_result_
 367 NTSYSAPI
 368 NTSTATUS
 369 NTAPI
 370 RtlStringFromGUID(
 371   _In_ REFGUID Guid,
 372   _Out_ _At_(GuidString->Buffer, __drv_allocatesMem(Mem))
 373     PUNICODE_STRING GuidString);
 374
 375 /* VOID
 376  * RtlZeroMemory(
 377  *     IN VOID UNALIGNED *Destination,
 378  *     IN SIZE_T Length)
 379  */
 380 #define RtlZeroMemory(Destination, Length) \
 381     memset(Destination, 0, Length)
 382
 383 #define RtlZeroBytes RtlZeroMemory
 384 $endif (_WDMDDK_)
 385
 386 #if (NTDDI_VERSION >= NTDDI_WIN2K)
 387
 388 $if (_WDMDDK_)
 389 _Must_inspect_result_
 390 NTSYSAPI
 391 BOOLEAN
 392 NTAPI
 393 RtlAreBitsClear(
 394   _In_ PRTL_BITMAP BitMapHeader,
 395   _In_ ULONG StartingIndex,
 396   _In_ ULONG Length);
 397
 398 _Must_inspect_result_
 399 NTSYSAPI
 400 BOOLEAN
 401 NTAPI
 402 RtlAreBitsSet(
 403   _In_ PRTL_BITMAP BitMapHeader,
 404   _In_ ULONG StartingIndex,
 405   _In_ ULONG Length);
 406
 407 _IRQL_requires_max_(PASSIVE_LEVEL)
 408 _Must_inspect_result_
 409 NTSYSAPI
 410 NTSTATUS
 411 NTAPI
 412 RtlAnsiStringToUnicodeString(
 413   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
 414   _When_(!AllocateDestinationString, _Inout_)
 415     PUNICODE_STRING DestinationString,
 416   _In_ PANSI_STRING SourceString,
 417   _In_ BOOLEAN AllocateDestinationString);
 418
 419 _IRQL_requires_max_(PASSIVE_LEVEL)
 420 NTSYSAPI
 421 ULONG
 422 NTAPI
 423 RtlxAnsiStringToUnicodeSize(
 424   _In_ PCANSI_STRING AnsiString);
 425
 426 #define RtlAnsiStringToUnicodeSize(String) (               \
 427   NLS_MB_CODE_PAGE_TAG ?                                   \
 428   RtlxAnsiStringToUnicodeSize(String) :                    \
 429   ((String)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR)   \
 430 )
 431
 432 _Success_(1)
 433 _Unchanged_(Destination->MaximumLength)
 434 _Unchanged_(Destination->Buffer)
 435 _When_(_Old_(Destination->Length) + Source->Length <= Destination->MaximumLength,
 436   _At_(Destination->Length, _Post_equal_to_(_Old_(Destination->Length) + Source->Length))
 437   _At_(return, _Out_range_(==, 0)))
 438 _When_(_Old_(Destination->Length) + Source->Length > Destination->MaximumLength,
 439   _Unchanged_(Destination->Length)
 440   _At_(return, _Out_range_(<, 0)))
 441 NTSYSAPI
 442 NTSTATUS
 443 NTAPI
 444 RtlAppendUnicodeStringToString(
 445   _Inout_ PUNICODE_STRING Destination,
 446   _In_ PCUNICODE_STRING Source);
 447
 448 _Success_(1)
 449 _Unchanged_(Destination->MaximumLength)
 450 _Unchanged_(Destination->Buffer)
 451 /* _When_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR) <= Destination->MaximumLength,
 452   _At_(Destination->Length, _Post_equal_to_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR)))
 453   _At_(return, _Out_range_(==, 0)))
 454 _When_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR) > Destination->MaximumLength,
 455   _Unchanged_(Destination->Length)
 456   _At_(return, _Out_range_(<, 0))) */
 457 NTSYSAPI
 458 NTSTATUS
 459 NTAPI
 460 RtlAppendUnicodeToString(
 461   _Inout_ PUNICODE_STRING Destination,
 462   _In_opt_z_ PCWSTR Source);
 463
 464 _IRQL_requires_max_(PASSIVE_LEVEL)
 465 _Must_inspect_result_
 466 NTSYSAPI
 467 NTSTATUS
 468 NTAPI
 469 RtlCheckRegistryKey(
 470   _In_ ULONG RelativeTo,
 471   _In_ PWSTR Path);
 472
 473 NTSYSAPI
 474 VOID
 475 NTAPI
 476 RtlClearAllBits(
 477   _In_ PRTL_BITMAP BitMapHeader);
 478
 479 NTSYSAPI
 480 VOID
 481 NTAPI
 482 RtlClearBits(
 483   _In_ PRTL_BITMAP BitMapHeader,
 484   _In_range_(0, BitMapHeader->SizeOfBitMap - NumberToClear) ULONG StartingIndex,
 485   _In_range_(0, BitMapHeader->SizeOfBitMap - StartingIndex) ULONG NumberToClear);
 486
 487 _Must_inspect_result_
 488 NTSYSAPI
 489 SIZE_T
 490 NTAPI
 491 RtlCompareMemory(
 492   _In_ const VOID *Source1,
 493   _In_ const VOID *Source2,
 494   _In_ SIZE_T Length);
 495
 496 _IRQL_requires_max_(PASSIVE_LEVEL)
 497 _Must_inspect_result_
 498 NTSYSAPI
 499 LONG
 500 NTAPI
 501 RtlCompareUnicodeString(
 502   _In_ PCUNICODE_STRING String1,
 503   _In_ PCUNICODE_STRING String2,
 504   _In_ BOOLEAN CaseInSensitive);
 505
 506 _IRQL_requires_max_(PASSIVE_LEVEL)
 507 _Must_inspect_result_
 508 NTSYSAPI
 509 LONG
 510 NTAPI
 511 RtlCompareUnicodeStrings(
 512   _In_reads_(String1Length) PCWCH String1,
 513   _In_ SIZE_T String1Length,
 514   _In_reads_(String2Length) PCWCH String2,
 515   _In_ SIZE_T String2Length,
 516   _In_ BOOLEAN CaseInSensitive);
 517
 518 _Unchanged_(DestinationString->Buffer)
 519 _Unchanged_(DestinationString->MaximumLength)
 520 _At_(DestinationString->Length,
 521   _When_(SourceString->Length > DestinationString->MaximumLength,
 522     _Post_equal_to_(DestinationString->MaximumLength))
 523   _When_(SourceString->Length <= DestinationString->MaximumLength,
 524     _Post_equal_to_(SourceString->Length)))
 525 NTSYSAPI
 526 VOID
 527 NTAPI
 528 RtlCopyUnicodeString(
 529   _Inout_ PUNICODE_STRING DestinationString,
 530   _In_opt_ PCUNICODE_STRING SourceString);
 531
 532 _IRQL_requires_max_(PASSIVE_LEVEL)
 533 NTSYSAPI
 534 NTSTATUS
 535 NTAPI
 536 RtlCreateRegistryKey(
 537   _In_ ULONG RelativeTo,
 538   _In_ PWSTR Path);
 539
 540 _IRQL_requires_max_(APC_LEVEL)
 541 NTSYSAPI
 542 NTSTATUS
 543 NTAPI
 544 RtlCreateSecurityDescriptor(
 545   _Out_ PSECURITY_DESCRIPTOR SecurityDescriptor,
 546   _In_ ULONG Revision);
 547
 548 _IRQL_requires_max_(PASSIVE_LEVEL)
 549 NTSYSAPI
 550 NTSTATUS
 551 NTAPI
 552 RtlDeleteRegistryValue(
 553   _In_ ULONG RelativeTo,
 554   _In_ PCWSTR Path,
 555   _In_z_ PCWSTR ValueName);
 556
 557 _IRQL_requires_max_(PASSIVE_LEVEL)
 558 _Must_inspect_result_
 559 NTSYSAPI
 560 BOOLEAN
 561 NTAPI
 562 RtlEqualUnicodeString(
 563   _In_ CONST UNICODE_STRING *String1,
 564   _In_ CONST UNICODE_STRING *String2,
 565   _In_ BOOLEAN CaseInSensitive);
 566
 567 #if !defined(_AMD64_) && !defined(_IA64_)
 568 NTSYSAPI
 569 LARGE_INTEGER
 570 NTAPI
 571 RtlExtendedIntegerMultiply(
 572   _In_ LARGE_INTEGER Multiplicand,
 573   _In_ LONG Multiplier);
 574
 575 NTSYSAPI
 576 LARGE_INTEGER
 577 NTAPI
 578 RtlExtendedLargeIntegerDivide(
 579   _In_ LARGE_INTEGER Dividend,
 580   _In_ ULONG Divisor,
 581   _Out_opt_ PULONG Remainder);
 582 #endif
 583
 584 #if defined(_X86_) || defined(_IA64_)
 585 NTSYSAPI
 586 LARGE_INTEGER
 587 NTAPI
 588 RtlExtendedMagicDivide(
 589     _In_ LARGE_INTEGER Dividend,
 590     _In_ LARGE_INTEGER MagicDivisor,
 591     _In_ CCHAR  ShiftCount);
 592 #endif
 593
 594 _IRQL_requires_max_(PASSIVE_LEVEL)
 595 NTSYSAPI
 596 VOID
 597 NTAPI
 598 RtlFreeAnsiString(
 599   _Inout_ _At_(AnsiString->Buffer, __drv_freesMem(Mem))
 600     PANSI_STRING AnsiString);
 601
 602 _Success_(return != -1)
 603 _Must_inspect_result_
 604 NTSYSAPI
 605 ULONG
 606 NTAPI
 607 RtlFindClearBits(
 608   _In_ PRTL_BITMAP BitMapHeader,
 609   _In_ ULONG NumberToFind,
 610   _In_ ULONG HintIndex);
 611
 612 _Success_(return != -1)
 613 NTSYSAPI
 614 ULONG
 615 NTAPI
 616 RtlFindClearBitsAndSet(
 617   _In_ PRTL_BITMAP BitMapHeader,
 618   _In_ ULONG NumberToFind,
 619   _In_ ULONG HintIndex);
 620
 621 NTSYSAPI
 622 ULONG
 623 NTAPI
 624 RtlFindFirstRunClear(
 625   _In_ PRTL_BITMAP BitMapHeader,
 626   _Out_ PULONG StartingIndex);
 627
 628 NTSYSAPI
 629 ULONG
 630 NTAPI
 631 RtlFindClearRuns(
 632   _In_ PRTL_BITMAP BitMapHeader,
 633   _Out_writes_to_(SizeOfRunArray, return) PRTL_BITMAP_RUN RunArray,
 634   _In_range_(>, 0) ULONG SizeOfRunArray,
 635   _In_ BOOLEAN LocateLongestRuns);
 636
 637 NTSYSAPI
 638 ULONG
 639 NTAPI
 640 RtlFindLastBackwardRunClear(
 641   _In_ PRTL_BITMAP BitMapHeader,
 642   _In_ ULONG FromIndex,
 643   _Out_ PULONG StartingRunIndex);
 644
 645 _Success_(return != -1)
 646 _Must_inspect_result_
 647 NTSYSAPI
 648 CCHAR
 649 NTAPI
 650 RtlFindLeastSignificantBit(
 651   _In_ ULONGLONG Set);
 652
 653 NTSYSAPI
 654 ULONG
 655 NTAPI
 656 RtlFindLongestRunClear(
 657   _In_ PRTL_BITMAP BitMapHeader,
 658   _Out_ PULONG StartingIndex);
 659
 660 _Success_(return != -1)
 661 _Must_inspect_result_
 662 NTSYSAPI
 663 CCHAR
 664 NTAPI
 665 RtlFindMostSignificantBit(
 666   _In_ ULONGLONG Set);
 667
 668 NTSYSAPI
 669 ULONG
 670 NTAPI
 671 RtlFindNextForwardRunClear(
 672   _In_ PRTL_BITMAP BitMapHeader,
 673   _In_ ULONG FromIndex,
 674   _Out_ PULONG StartingRunIndex);
 675
 676 _Success_(return != -1)
 677 _Must_inspect_result_
 678 NTSYSAPI
 679 ULONG
 680 NTAPI
 681 RtlFindSetBits(
 682   _In_ PRTL_BITMAP BitMapHeader,
 683   _In_ ULONG NumberToFind,
 684   _In_ ULONG HintIndex);
 685
 686 _Success_(return != -1)
 687 NTSYSAPI
 688 ULONG
 689 NTAPI
 690 RtlFindSetBitsAndClear(
 691   _In_ PRTL_BITMAP BitMapHeader,
 692   _In_ ULONG NumberToFind,
 693   _In_ ULONG HintIndex);
 694
 695 _IRQL_requires_max_(DISPATCH_LEVEL)
 696 NTSYSAPI
 697 VOID
 698 NTAPI
 699 RtlInitAnsiString(
 700   _Out_ PANSI_STRING DestinationString,
 701   _In_opt_z_ __drv_aliasesMem PCSZ SourceString);
 702
 703 _At_(BitMapHeader->SizeOfBitMap, _Post_equal_to_(SizeOfBitMap))
 704 _At_(BitMapHeader->Buffer, _Post_equal_to_(BitMapBuffer))
 705 NTSYSAPI
 706 VOID
 707 NTAPI
 708 RtlInitializeBitMap(
 709   _Out_ PRTL_BITMAP BitMapHeader,
 710   _In_opt_ __drv_aliasesMem PULONG BitMapBuffer,
 711   _In_opt_ ULONG SizeOfBitMap);
 712
 713 _IRQL_requires_max_(DISPATCH_LEVEL)
 714 NTSYSAPI
 715 VOID
 716 NTAPI
 717 RtlInitString(
 718   _Out_ PSTRING DestinationString,
 719   _In_opt_z_ __drv_aliasesMem PCSZ SourceString);
 720
 721 _IRQL_requires_max_(PASSIVE_LEVEL)
 722 _At_(String->MaximumLength, _Const_)
 723 NTSYSAPI
 724 NTSTATUS
 725 NTAPI
 726 RtlIntegerToUnicodeString(
 727   _In_ ULONG Value,
 728   _In_opt_ ULONG Base,
 729   _Inout_ PUNICODE_STRING String);
 730
 731 _IRQL_requires_max_(PASSIVE_LEVEL)
 732 _At_(String->MaximumLength, _Const_)
 733 NTSYSAPI
 734 NTSTATUS
 735 NTAPI
 736 RtlInt64ToUnicodeString(
 737   _In_ ULONGLONG Value,
 738   _In_opt_ ULONG Base,
 739   _Inout_ PUNICODE_STRING String);
 740
 741 #ifdef _WIN64
 742 #define RtlIntPtrToUnicodeString(Value, Base, String) \
 743     RtlInt64ToUnicodeString(Value, Base, String)
 744 #else
 745 #define RtlIntPtrToUnicodeString(Value, Base, String) \
 746     RtlIntegerToUnicodeString(Value, Base, String)
 747 #endif
 748
 749 /* BOOLEAN
 750  * RtlIsZeroLuid(
 751  *     IN PLUID L1);
 752  */
 753 #define RtlIsZeroLuid(_L1) \
 754     ((BOOLEAN) ((!(_L1)->LowPart) && (!(_L1)->HighPart)))
 755
 756 _IRQL_requires_max_(APC_LEVEL)
 757 NTSYSAPI
 758 ULONG
 759 NTAPI
 760 RtlLengthSecurityDescriptor(
 761   _In_ PSECURITY_DESCRIPTOR SecurityDescriptor);
 762
 763 NTSYSAPI
 764 ULONG
 765 NTAPI
 766 RtlNumberOfClearBits(
 767   _In_ PRTL_BITMAP BitMapHeader);
 768
 769 NTSYSAPI
 770 ULONG
 771 NTAPI
 772 RtlNumberOfSetBits(
 773   _In_ PRTL_BITMAP BitMapHeader);
 774
 775 _IRQL_requires_max_(PASSIVE_LEVEL)
 776 NTSYSAPI
 777 NTSTATUS
 778 NTAPI
 779 RtlQueryRegistryValues(
 780     _In_ ULONG RelativeTo,
 781     _In_ PCWSTR Path,
 782     _Inout_ _At_(*(*QueryTable).EntryContext, _Pre_unknown_)
 783         PRTL_QUERY_REGISTRY_TABLE QueryTable,
 784     _In_opt_ PVOID Context,
 785     _In_opt_ PVOID Environment);
 786
 787 #define SHORT_SIZE  (sizeof(USHORT))
 788 #define SHORT_MASK  (SHORT_SIZE - 1)
 789 #define LONG_SIZE (sizeof(LONG))
 790 #define LONGLONG_SIZE   (sizeof(LONGLONG))
 791 #define LONG_MASK (LONG_SIZE - 1)
 792 #define LONGLONG_MASK   (LONGLONG_SIZE - 1)
 793 #define LOWBYTE_MASK 0x00FF
 794
 795 #define FIRSTBYTE(VALUE)  ((VALUE) & LOWBYTE_MASK)
 796 #define SECONDBYTE(VALUE) (((VALUE) >> 8) & LOWBYTE_MASK)
 797 #define THIRDBYTE(VALUE)  (((VALUE) >> 16) & LOWBYTE_MASK)
 798 #define FOURTHBYTE(VALUE) (((VALUE) >> 24) & LOWBYTE_MASK)
 799
 800 NTSYSAPI
 801 VOID
 802 NTAPI
 803 RtlSetAllBits(
 804   _In_ PRTL_BITMAP BitMapHeader);
 805
 806 NTSYSAPI
 807 VOID
 808 NTAPI
 809 RtlSetBits(
 810   _In_ PRTL_BITMAP BitMapHeader,
 811   _In_range_(0, BitMapHeader->SizeOfBitMap - NumberToSet) ULONG StartingIndex,
 812   _In_range_(0, BitMapHeader->SizeOfBitMap - StartingIndex) ULONG NumberToSet);
 813
 814 _IRQL_requires_max_(APC_LEVEL)
 815 NTSYSAPI
 816 NTSTATUS
 817 NTAPI
 818 RtlSetDaclSecurityDescriptor(
 819   _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
 820   _In_ BOOLEAN DaclPresent,
 821   _In_opt_ PACL Dacl,
 822   _In_opt_ BOOLEAN DaclDefaulted);
 823
 824 #if defined(_AMD64_)
 825
 826 /* VOID
 827  * RtlStoreUlong(
 828  *     IN PULONG Address,
 829  *     IN ULONG Value);
 830  */
 831 #define RtlStoreUlong(Address,Value) \
 832     *(ULONG UNALIGNED *)(Address) = (Value)
 833
 834 /* VOID
 835  * RtlStoreUlonglong(
 836  *     IN OUT PULONGLONG Address,
 837  *     ULONGLONG Value);
 838  */
 839 #define RtlStoreUlonglong(Address,Value) \
 840     *(ULONGLONG UNALIGNED *)(Address) = (Value)
 841
 842 /* VOID
 843  * RtlStoreUshort(
 844  *     IN PUSHORT Address,
 845  *     IN USHORT Value);
 846  */
 847 #define RtlStoreUshort(Address,Value) \
 848     *(USHORT UNALIGNED *)(Address) = (Value)
 849
 850 /* VOID
 851  * RtlRetrieveUshort(
 852  *     PUSHORT DestinationAddress,
 853  *    PUSHORT SourceAddress);
 854  */
 855 #define RtlRetrieveUshort(DestAddress,SrcAddress) \
 856     *(USHORT UNALIGNED *)(DestAddress) = *(USHORT)(SrcAddress)
 857
 858 /* VOID
 859  * RtlRetrieveUlong(
 860  *    PULONG DestinationAddress,
 861  *    PULONG SourceAddress);
 862  */
 863 #define RtlRetrieveUlong(DestAddress,SrcAddress) \
 864     *(ULONG UNALIGNED *)(DestAddress) = *(PULONG)(SrcAddress)
 865
 866 #else
 867
 868 #define RtlStoreUlong(Address,Value)                      \
 869     if ((ULONG_PTR)(Address) & LONG_MASK) { \
 870         ((PUCHAR) (Address))[LONG_LEAST_SIGNIFICANT_BIT]    = (UCHAR)(FIRSTBYTE(Value)); \
 871         ((PUCHAR) (Address))[LONG_3RD_MOST_SIGNIFICANT_BIT] = (UCHAR)(SECONDBYTE(Value)); \
 872         ((PUCHAR) (Address))[LONG_2ND_MOST_SIGNIFICANT_BIT] = (UCHAR)(THIRDBYTE(Value)); \
 873         ((PUCHAR) (Address))[LONG_MOST_SIGNIFICANT_BIT]     = (UCHAR)(FOURTHBYTE(Value)); \
 874     } \
 875     else { \
 876         *((PULONG)(Address)) = (ULONG) (Value); \
 877     }
 878
 879 #define RtlStoreUlonglong(Address,Value) \
 880     if ((ULONG_PTR)(Address) & LONGLONG_MASK) { \
 881         RtlStoreUlong((ULONG_PTR)(Address), \
 882                       (ULONGLONG)(Value) & 0xFFFFFFFF); \
 883         RtlStoreUlong((ULONG_PTR)(Address)+sizeof(ULONG), \
 884                       (ULONGLONG)(Value) >> 32); \
 885     } else { \
 886         *((PULONGLONG)(Address)) = (ULONGLONG)(Value); \
 887     }
 888
 889 #define RtlStoreUshort(Address,Value) \
 890     if ((ULONG_PTR)(Address) & SHORT_MASK) { \
 891         ((PUCHAR) (Address))[SHORT_LEAST_SIGNIFICANT_BIT] = (UCHAR)(FIRSTBYTE(Value)); \
 892         ((PUCHAR) (Address))[SHORT_MOST_SIGNIFICANT_BIT ] = (UCHAR)(SECONDBYTE(Value)); \
 893     } \
 894     else { \
 895         *((PUSHORT) (Address)) = (USHORT)Value; \
 896     }
 897
 898 #define RtlRetrieveUshort(DestAddress,SrcAddress) \
 899     if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \
 900     { \
 901         ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
 902         ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
 903     } \
 904     else \
 905     { \
 906         *((PUSHORT)(DestAddress))=*((PUSHORT)(SrcAddress)); \
 907     }
 908
 909 #define RtlRetrieveUlong(DestAddress,SrcAddress) \
 910     if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \
 911     { \
 912         ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
 913         ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
 914         ((PUCHAR)(DestAddress))[2]=((PUCHAR)(SrcAddress))[2]; \
 915         ((PUCHAR)(DestAddress))[3]=((PUCHAR)(SrcAddress))[3]; \
 916     } \
 917     else \
 918     { \
 919         *((PULONG)(DestAddress))=*((PULONG)(SrcAddress)); \
 920     }
 921
 922 #endif /* defined(_AMD64_) */
 923
 924 #ifdef _WIN64
 925 /* VOID
 926  * RtlStoreUlongPtr(
 927  *     IN OUT PULONG_PTR Address,
 928  *     IN ULONG_PTR Value);
 929  */
 930 #define RtlStoreUlongPtr(Address,Value) RtlStoreUlonglong(Address,Value)
 931 #else
 932 #define RtlStoreUlongPtr(Address,Value) RtlStoreUlong(Address,Value)
 933 #endif /* _WIN64 */
 934
 935 _Success_(return!=FALSE)
 936 _Must_inspect_result_
 937 NTSYSAPI
 938 BOOLEAN
 939 NTAPI
 940 RtlTimeFieldsToTime(
 941     _In_ PTIME_FIELDS TimeFields,
 942     _Out_ PLARGE_INTEGER Time);
 943
 944 NTSYSAPI
 945 VOID
 946 NTAPI
 947 RtlTimeToTimeFields(
 948   _In_ PLARGE_INTEGER Time,
 949   _Out_ PTIME_FIELDS TimeFields);
 950
 951 NTSYSAPI
 952 USHORT
 953 FASTCALL
 954 RtlUshortByteSwap(
 955   _In_ USHORT Source);
 956
 957 NTSYSAPI
 958 ULONG
 959 FASTCALL
 960 RtlUlongByteSwap(
 961   _In_ ULONG Source);
 962
 963 NTSYSAPI
 964 ULONGLONG
 965 FASTCALL
 966 RtlUlonglongByteSwap(
 967   _In_ ULONGLONG Source);
 968
 969 _When_(AllocateDestinationString,
 970   _At_(DestinationString->MaximumLength,
 971     _Out_range_(<=, (SourceString->MaximumLength / sizeof(WCHAR)))))
 972 _When_(!AllocateDestinationString,
 973   _At_(DestinationString->Buffer, _Const_)
 974   _At_(DestinationString->MaximumLength, _Const_))
 975 _IRQL_requires_max_(PASSIVE_LEVEL)
 976 _When_(AllocateDestinationString, _Must_inspect_result_)
 977 NTSYSAPI
 978 NTSTATUS
 979 NTAPI
 980 RtlUnicodeStringToAnsiString(
 981   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
 982   _When_(!AllocateDestinationString, _Inout_)
 983     PANSI_STRING DestinationString,
 984   _In_ PCUNICODE_STRING SourceString,
 985   _In_ BOOLEAN AllocateDestinationString);
 986
 987 _IRQL_requires_max_(PASSIVE_LEVEL)
 988 _Must_inspect_result_
 989 NTSYSAPI
 990 NTSTATUS
 991 NTAPI
 992 RtlUpcaseUnicodeStringToAnsiString(
 993   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
 994   _When_(!AllocateDestinationString, _Inout_)
 995     PANSI_STRING DestinationString,
 996   _In_ PCUNICODE_STRING SourceString,
 997   _In_ BOOLEAN AllocateDestinationString);
 998
 999 _IRQL_requires_max_(PASSIVE_LEVEL)
1000 NTSYSAPI
1001 ULONG
1002 NTAPI
1003 RtlxUnicodeStringToAnsiSize(
1004   _In_ PCUNICODE_STRING UnicodeString);
1005
1006 #define RtlUnicodeStringToAnsiSize(String) (                  \
1007     NLS_MB_CODE_PAGE_TAG ?                                    \
1008     RtlxUnicodeStringToAnsiSize(String) :                     \
1009     ((String)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \
1010 )
1011
1012 _IRQL_requires_max_(PASSIVE_LEVEL)
1013 NTSYSAPI
1014 NTSTATUS
1015 NTAPI
1016 RtlUnicodeStringToInteger(
1017   _In_ PCUNICODE_STRING String,
1018   _In_opt_ ULONG Base,
1019   _Out_ PULONG Value);
1020
1021 _IRQL_requires_max_(PASSIVE_LEVEL)
1022 NTSYSAPI
1023 WCHAR
1024 NTAPI
1025 RtlUpcaseUnicodeChar(
1026   _In_ WCHAR SourceCharacter);
1027
1028 _IRQL_requires_max_(APC_LEVEL)
1029 _Must_inspect_result_
1030 NTSYSAPI
1031 BOOLEAN
1032 NTAPI
1033 RtlValidRelativeSecurityDescriptor(
1034   _In_reads_bytes_(SecurityDescriptorLength) PSECURITY_DESCRIPTOR SecurityDescriptorInput,
1035   _In_ ULONG SecurityDescriptorLength,
1036   _In_ SECURITY_INFORMATION RequiredInformation);
1037
1038 _IRQL_requires_max_(APC_LEVEL)
1039 _Must_inspect_result_
1040 NTSYSAPI
1041 BOOLEAN
1042 NTAPI
1043 RtlValidSecurityDescriptor(
1044   _In_ PSECURITY_DESCRIPTOR SecurityDescriptor);
1045
1046 _IRQL_requires_max_(PASSIVE_LEVEL)
1047 NTSYSAPI
1048 NTSTATUS
1049 NTAPI
1050 RtlGetVersion(
1051     _Out_
1052     _At_(lpVersionInformation->dwOSVersionInfoSize, _Pre_ _Valid_)
1053     _When_(lpVersionInformation->dwOSVersionInfoSize == sizeof(RTL_OSVERSIONINFOEXW),
1054         _At_((PRTL_OSVERSIONINFOEXW)lpVersionInformation, _Out_))
1055         PRTL_OSVERSIONINFOW lpVersionInformation);
1056
1057 _IRQL_requires_max_(PASSIVE_LEVEL)
1058 _Must_inspect_result_
1059 NTSYSAPI
1060 NTSTATUS
1061 NTAPI
1062 RtlVerifyVersionInfo(
1063     _In_ PRTL_OSVERSIONINFOEXW VersionInfo,
1064     _In_ ULONG TypeMask,
1065     _In_ ULONGLONG ConditionMask);
1066
1067 _IRQL_requires_max_(PASSIVE_LEVEL)
1068 NTSYSAPI
1069 NTSTATUS
1070 NTAPI
1071 RtlWriteRegistryValue(
1072   _In_ ULONG RelativeTo,
1073   _In_ PCWSTR Path,
1074   _In_z_ PCWSTR ValueName,
1075   _In_ ULONG ValueType,
1076   _In_reads_bytes_opt_(ValueLength) PVOID ValueData,
1077   _In_ ULONG ValueLength);
1078
1079 $endif (_WDMDDK_)
1080 $if (_NTDDK_)
1081
1082 #ifndef RTL_USE_AVL_TABLES
1083
1084 NTSYSAPI
1085 VOID
1086 NTAPI
1087 RtlInitializeGenericTable(
1088   _Out_ PRTL_GENERIC_TABLE Table,
1089   _In_ PRTL_GENERIC_COMPARE_ROUTINE CompareRoutine,
1090   _In_ PRTL_GENERIC_ALLOCATE_ROUTINE AllocateRoutine,
1091   _In_ PRTL_GENERIC_FREE_ROUTINE FreeRoutine,
1092   _In_opt_ PVOID TableContext);
1093
1094 NTSYSAPI
1095 PVOID
1096 NTAPI
1097 RtlInsertElementGenericTable(
1098   _In_ PRTL_GENERIC_TABLE Table,
1099   _In_reads_bytes_(BufferSize) PVOID Buffer,
1100   _In_ CLONG BufferSize,
1101   _Out_opt_ PBOOLEAN NewElement);
1102
1103 NTSYSAPI
1104 PVOID
1105 NTAPI
1106 RtlInsertElementGenericTableFull(
1107   _In_ PRTL_GENERIC_TABLE Table,
1108   _In_reads_bytes_(BufferSize) PVOID Buffer,
1109   _In_ CLONG BufferSize,
1110   _Out_opt_ PBOOLEAN NewElement,
1111   _In_ PVOID NodeOrParent,
1112   _In_ TABLE_SEARCH_RESULT SearchResult);
1113
1114 NTSYSAPI
1115 BOOLEAN
1116 NTAPI
1117 RtlDeleteElementGenericTable(
1118   _In_ PRTL_GENERIC_TABLE Table,
1119   _In_ PVOID Buffer);
1120
1121 _Must_inspect_result_
1122 NTSYSAPI
1123 PVOID
1124 NTAPI
1125 RtlLookupElementGenericTable(
1126   _In_ PRTL_GENERIC_TABLE Table,
1127   _In_ PVOID Buffer);
1128
1129 NTSYSAPI
1130 PVOID
1131 NTAPI
1132 RtlLookupElementGenericTableFull(
1133   _In_ PRTL_GENERIC_TABLE Table,
1134   _In_ PVOID Buffer,
1135   _Out_ PVOID *NodeOrParent,
1136   _Out_ TABLE_SEARCH_RESULT *SearchResult);
1137
1138 _Must_inspect_result_
1139 NTSYSAPI
1140 PVOID
1141 NTAPI
1142 RtlEnumerateGenericTable(
1143   _In_ PRTL_GENERIC_TABLE Table,
1144   _In_ BOOLEAN Restart);
1145
1146 _Must_inspect_result_
1147 NTSYSAPI
1148 PVOID
1149 NTAPI
1150 RtlEnumerateGenericTableWithoutSplaying(
1151   _In_ PRTL_GENERIC_TABLE Table,
1152   _Inout_ PVOID *RestartKey);
1153
1154 _Must_inspect_result_
1155 NTSYSAPI
1156 PVOID
1157 NTAPI
1158 RtlGetElementGenericTable(
1159   _In_ PRTL_GENERIC_TABLE Table,
1160   _In_ ULONG I);
1161
1162 NTSYSAPI
1163 ULONG
1164 NTAPI
1165 RtlNumberGenericTableElements(
1166   _In_ PRTL_GENERIC_TABLE Table);
1167
1168 _Must_inspect_result_
1169 NTSYSAPI
1170 BOOLEAN
1171 NTAPI
1172 RtlIsGenericTableEmpty(
1173   _In_ PRTL_GENERIC_TABLE Table);
1174
1175 #endif /* !RTL_USE_AVL_TABLES */
1176
1177 #define RTL_STACK_WALKING_MODE_FRAMES_TO_SKIP_SHIFT     8
1178
1179 NTSYSAPI
1180 PRTL_SPLAY_LINKS
1181 NTAPI
1182 RtlSplay(
1183   _Inout_ PRTL_SPLAY_LINKS Links);
1184
1185 NTSYSAPI
1186 PRTL_SPLAY_LINKS
1187 NTAPI
1188 RtlDelete(
1189   _In_ PRTL_SPLAY_LINKS Links);
1190
1191 NTSYSAPI
1192 VOID
1193 NTAPI
1194 RtlDeleteNoSplay(
1195   _In_ PRTL_SPLAY_LINKS Links,
1196   _Inout_ PRTL_SPLAY_LINKS *Root);
1197
1198 _Must_inspect_result_
1199 NTSYSAPI
1200 PRTL_SPLAY_LINKS
1201 NTAPI
1202 RtlSubtreeSuccessor(
1203   _In_ PRTL_SPLAY_LINKS Links);
1204
1205 _Must_inspect_result_
1206 NTSYSAPI
1207 PRTL_SPLAY_LINKS
1208 NTAPI
1209 RtlSubtreePredecessor(
1210   _In_ PRTL_SPLAY_LINKS Links);
1211
1212 _Must_inspect_result_
1213 NTSYSAPI
1214 PRTL_SPLAY_LINKS
1215 NTAPI
1216 RtlRealSuccessor(
1217   _In_ PRTL_SPLAY_LINKS Links);
1218
1219 _Must_inspect_result_
1220 NTSYSAPI
1221 PRTL_SPLAY_LINKS
1222 NTAPI
1223 RtlRealPredecessor(
1224   _In_ PRTL_SPLAY_LINKS Links);
1225
1226 _IRQL_requires_max_(PASSIVE_LEVEL)
1227 _Must_inspect_result_
1228 NTSYSAPI
1229 BOOLEAN
1230 NTAPI
1231 RtlPrefixUnicodeString(
1232   _In_ PCUNICODE_STRING String1,
1233   _In_ PCUNICODE_STRING String2,
1234   _In_ BOOLEAN CaseInSensitive);
1235
1236 _IRQL_requires_max_(PASSIVE_LEVEL)
1237 NTSYSAPI
1238 VOID
1239 NTAPI
1240 RtlUpperString(
1241   _Inout_ PSTRING DestinationString,
1242   _In_ const STRING *SourceString);
1243
1244 _IRQL_requires_max_(PASSIVE_LEVEL)
1245 _When_(AllocateDestinationString, _Must_inspect_result_)
1246 NTSYSAPI
1247 NTSTATUS
1248 NTAPI
1249 RtlUpcaseUnicodeString(
1250   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
1251   _When_(!AllocateDestinationString, _Inout_)
1252     PUNICODE_STRING DestinationString,
1253   _In_ PCUNICODE_STRING SourceString,
1254   _In_ BOOLEAN AllocateDestinationString);
1255
1256 _IRQL_requires_max_(APC_LEVEL)
1257 NTSYSAPI
1258 VOID
1259 NTAPI
1260 RtlMapGenericMask(
1261   _Inout_ PACCESS_MASK AccessMask,
1262   _In_ PGENERIC_MAPPING GenericMapping);
1263
1264 _IRQL_requires_max_(PASSIVE_LEVEL)
1265 NTSYSAPI
1266 NTSTATUS
1267 NTAPI
1268 RtlVolumeDeviceToDosName(
1269   _In_ PVOID VolumeDeviceObject,
1270   _Out_ PUNICODE_STRING DosName);
1271
1272 _IRQL_requires_max_(PASSIVE_LEVEL)
1273 _Must_inspect_result_
1274 NTSYSAPI
1275 LONG
1276 NTAPI
1277 RtlCompareString(
1278   _In_ const STRING *String1,
1279   _In_ const STRING *String2,
1280   _In_ BOOLEAN CaseInSensitive);
1281
1282 NTSYSAPI
1283 VOID
1284 NTAPI
1285 RtlCopyString(
1286   _Out_ PSTRING DestinationString,
1287   _In_opt_ const STRING *SourceString);
1288
1289 _IRQL_requires_max_(PASSIVE_LEVEL)
1290 _Must_inspect_result_
1291 NTSYSAPI
1292 BOOLEAN
1293 NTAPI
1294 RtlEqualString(
1295   _In_ const STRING *String1,
1296   _In_ const STRING *String2,
1297   _In_ BOOLEAN CaseInSensitive);
1298
1299 _IRQL_requires_max_(PASSIVE_LEVEL)
1300 NTSYSAPI
1301 NTSTATUS
1302 NTAPI
1303 RtlCharToInteger(
1304   _In_z_ PCSZ String,
1305   _In_opt_ ULONG Base,
1306   _Out_ PULONG Value);
1307
1308 _IRQL_requires_max_(PASSIVE_LEVEL)
1309 NTSYSAPI
1310 CHAR
1311 NTAPI
1312 RtlUpperChar(
1313   _In_ CHAR Character);
1314
1315 NTSYSAPI
1316 ULONG
1317 NTAPI
1318 RtlWalkFrameChain(
1319   _Out_writes_(Count - (Flags >> RTL_STACK_WALKING_MODE_FRAMES_TO_SKIP_SHIFT))
1320     PVOID *Callers,
1321   _In_ ULONG Count,
1322   _In_ ULONG Flags);
1323
1324 $endif (_NTDDK_)
1325 $if (_NTIFS_)
1326
1327 _Must_inspect_result_
1328 _Ret_maybenull_
1329 _Post_writable_byte_size_(Size)
1330 NTSYSAPI
1331 PVOID
1332 NTAPI
1333 RtlAllocateHeap(
1334   _In_ HANDLE HeapHandle,
1335   _In_opt_ ULONG Flags,
1336   _In_ SIZE_T Size);
1337
1338 _Success_(return != 0)
1339 NTSYSAPI
1340 BOOLEAN
1341 NTAPI
1342 RtlFreeHeap(
1343   _In_ PVOID HeapHandle,
1344   _In_opt_ ULONG Flags,
1345   _In_ _Post_invalid_ PVOID BaseAddress);
1346
1347 NTSYSAPI
1348 VOID
1349 NTAPI
1350 RtlCaptureContext(
1351   _Out_ PCONTEXT ContextRecord);
1352
1353 _Ret_range_(<, MAXLONG)
1354 NTSYSAPI
1355 ULONG
1356 NTAPI
1357 RtlRandom(
1358   _Inout_ PULONG Seed);
1359
1360 _IRQL_requires_max_(APC_LEVEL)
1361 _Success_(return != 0)
1362 _Must_inspect_result_
1363 NTSYSAPI
1364 BOOLEAN
1365 NTAPI
1366 RtlCreateUnicodeString(
1367   _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem))
1368     PUNICODE_STRING DestinationString,
1369   _In_z_ PCWSTR SourceString);
1370
1371 _IRQL_requires_max_(PASSIVE_LEVEL)
1372 _Must_inspect_result_
1373 NTSYSAPI
1374 BOOLEAN
1375 NTAPI
1376 RtlPrefixString(
1377   _In_ const STRING *String1,
1378   _In_ const STRING *String2,
1379   _In_ BOOLEAN CaseInsensitive);
1380
1381 _IRQL_requires_max_(APC_LEVEL)
1382 NTSYSAPI
1383 NTSTATUS
1384 NTAPI
1385 RtlAppendStringToString(
1386   _Inout_ PSTRING Destination,
1387   _In_ const STRING *Source);
1388
1389 _IRQL_requires_max_(PASSIVE_LEVEL)
1390 _Must_inspect_result_
1391 NTSYSAPI
1392 NTSTATUS
1393 NTAPI
1394 RtlOemStringToUnicodeString(
1395   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
1396   _When_(!AllocateDestinationString, _Inout_)
1397     PUNICODE_STRING DestinationString,
1398   _In_ PCOEM_STRING SourceString,
1399   _In_ BOOLEAN AllocateDestinationString);
1400
1401 _IRQL_requires_max_(PASSIVE_LEVEL)
1402 _Must_inspect_result_
1403 NTSYSAPI
1404 NTSTATUS
1405 NTAPI
1406 RtlUnicodeStringToOemString(
1407   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
1408   _When_(!AllocateDestinationString, _Inout_)
1409     POEM_STRING DestinationString,
1410   _In_ PCUNICODE_STRING SourceString,
1411   _In_ BOOLEAN AllocateDestinationString);
1412
1413 _IRQL_requires_max_(PASSIVE_LEVEL)
1414 _Must_inspect_result_
1415 NTSYSAPI
1416 NTSTATUS
1417 NTAPI
1418 RtlUpcaseUnicodeStringToOemString(
1419   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
1420   _When_(!AllocateDestinationString, _Inout_)
1421     POEM_STRING DestinationString,
1422   _In_ PCUNICODE_STRING SourceString,
1423   _In_ BOOLEAN AllocateDestinationString);
1424
1425 _IRQL_requires_max_(PASSIVE_LEVEL)
1426 _Must_inspect_result_
1427 NTSYSAPI
1428 NTSTATUS
1429 NTAPI
1430 RtlOemStringToCountedUnicodeString(
1431   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
1432   _When_(!AllocateDestinationString, _Inout_)
1433     PUNICODE_STRING DestinationString,
1434   _In_ PCOEM_STRING SourceString,
1435   _In_ BOOLEAN AllocateDestinationString);
1436
1437 _IRQL_requires_max_(PASSIVE_LEVEL)
1438 _Must_inspect_result_
1439 NTSYSAPI
1440 NTSTATUS
1441 NTAPI
1442 RtlUnicodeStringToCountedOemString(
1443   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
1444   _When_(!AllocateDestinationString, _Inout_)
1445     POEM_STRING DestinationString,
1446   _In_ PCUNICODE_STRING SourceString,
1447   _In_ BOOLEAN AllocateDestinationString);
1448
1449 _IRQL_requires_max_(PASSIVE_LEVEL)
1450 _Must_inspect_result_
1451 NTSYSAPI
1452 NTSTATUS
1453 NTAPI
1454 RtlUpcaseUnicodeStringToCountedOemString(
1455   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
1456   _When_(!AllocateDestinationString, _Inout_)
1457     POEM_STRING DestinationString,
1458   _In_ PCUNICODE_STRING SourceString,
1459   _In_ BOOLEAN AllocateDestinationString);
1460
1461 _IRQL_requires_max_(PASSIVE_LEVEL)
1462 _When_(AllocateDestinationString, _Must_inspect_result_)
1463 NTSYSAPI
1464 NTSTATUS
1465 NTAPI
1466 RtlDowncaseUnicodeString(
1467   _When_(AllocateDestinationString, _Out_ _At_(UniDest->Buffer, __drv_allocatesMem(Mem)))
1468   _When_(!AllocateDestinationString, _Inout_)
1469     PUNICODE_STRING UniDest,
1470   _In_ PCUNICODE_STRING UniSource,
1471   _In_ BOOLEAN AllocateDestinationString);
1472
1473 _IRQL_requires_max_(PASSIVE_LEVEL)
1474 NTSYSAPI
1475 VOID
1476 NTAPI
1477 RtlFreeOemString(
1478   _Inout_ _At_(OemString->Buffer, __drv_freesMem(Mem)) POEM_STRING OemString);
1479
1480 _IRQL_requires_max_(PASSIVE_LEVEL)
1481 NTSYSAPI
1482 ULONG
1483 NTAPI
1484 RtlxUnicodeStringToOemSize(
1485   _In_ PCUNICODE_STRING UnicodeString);
1486
1487 _IRQL_requires_max_(PASSIVE_LEVEL)
1488 NTSYSAPI
1489 ULONG
1490 NTAPI
1491 RtlxOemStringToUnicodeSize(
1492   _In_ PCOEM_STRING OemString);
1493
1494 _IRQL_requires_max_(PASSIVE_LEVEL)
1495 NTSYSAPI
1496 NTSTATUS
1497 NTAPI
1498 RtlMultiByteToUnicodeN(
1499   _Out_writes_bytes_to_(MaxBytesInUnicodeString, *BytesInUnicodeString) PWCH UnicodeString,
1500   _In_ ULONG MaxBytesInUnicodeString,
1501   _Out_opt_ PULONG BytesInUnicodeString,
1502   _In_reads_bytes_(BytesInMultiByteString) const CHAR *MultiByteString,
1503   _In_ ULONG BytesInMultiByteString);
1504
1505 _IRQL_requires_max_(PASSIVE_LEVEL)
1506 NTSYSAPI
1507 NTSTATUS
1508 NTAPI
1509 RtlMultiByteToUnicodeSize(
1510   _Out_ PULONG BytesInUnicodeString,
1511   _In_reads_bytes_(BytesInMultiByteString) const CHAR *MultiByteString,
1512   _In_ ULONG BytesInMultiByteString);
1513
1514 _IRQL_requires_max_(PASSIVE_LEVEL)
1515 NTSYSAPI
1516 NTSTATUS
1517 NTAPI
1518 RtlUnicodeToMultiByteSize(
1519   _Out_ PULONG BytesInMultiByteString,
1520   _In_reads_bytes_(BytesInUnicodeString) PCWCH UnicodeString,
1521   _In_ ULONG BytesInUnicodeString);
1522
1523 _IRQL_requires_max_(PASSIVE_LEVEL)
1524 NTSYSAPI
1525 NTSTATUS
1526 NTAPI
1527 RtlUnicodeToMultiByteN(
1528   _Out_writes_bytes_to_(MaxBytesInMultiByteString, *BytesInMultiByteString) PCHAR MultiByteString,
1529   _In_ ULONG MaxBytesInMultiByteString,
1530   _Out_opt_ PULONG BytesInMultiByteString,
1531   _In_reads_bytes_(BytesInUnicodeString) PCWCH UnicodeString,
1532   _In_ ULONG BytesInUnicodeString);
1533
1534 _IRQL_requires_max_(PASSIVE_LEVEL)
1535 NTSYSAPI
1536 NTSTATUS
1537 NTAPI
1538 RtlUpcaseUnicodeToMultiByteN(
1539   _Out_writes_bytes_to_(MaxBytesInMultiByteString, *BytesInMultiByteString) PCHAR MultiByteString,
1540   _In_ ULONG MaxBytesInMultiByteString,
1541   _Out_opt_ PULONG BytesInMultiByteString,
1542   _In_reads_bytes_(BytesInUnicodeString) PCWCH UnicodeString,
1543   _In_ ULONG BytesInUnicodeString);
1544
1545 _IRQL_requires_max_(PASSIVE_LEVEL)
1546 NTSYSAPI
1547 NTSTATUS
1548 NTAPI
1549 RtlOemToUnicodeN(
1550   _Out_writes_bytes_to_(MaxBytesInUnicodeString, *BytesInUnicodeString) PWSTR UnicodeString,
1551   _In_ ULONG MaxBytesInUnicodeString,
1552   _Out_opt_ PULONG BytesInUnicodeString,
1553   _In_reads_bytes_(BytesInOemString) PCCH OemString,
1554   _In_ ULONG BytesInOemString);
1555
1556 _IRQL_requires_max_(PASSIVE_LEVEL)
1557 NTSYSAPI
1558 NTSTATUS
1559 NTAPI
1560 RtlUnicodeToOemN(
1561   _Out_writes_bytes_to_(MaxBytesInOemString, *BytesInOemString) PCHAR OemString,
1562   _In_ ULONG MaxBytesInOemString,
1563   _Out_opt_ PULONG BytesInOemString,
1564   _In_reads_bytes_(BytesInUnicodeString) PCWCH UnicodeString,
1565   _In_ ULONG BytesInUnicodeString);
1566
1567 _IRQL_requires_max_(PASSIVE_LEVEL)
1568 NTSYSAPI
1569 NTSTATUS
1570 NTAPI
1571 RtlUpcaseUnicodeToOemN(
1572   _Out_writes_bytes_to_(MaxBytesInOemString, *BytesInOemString) PCHAR OemString,
1573   _In_ ULONG MaxBytesInOemString,
1574   _Out_opt_ PULONG BytesInOemString,
1575   _In_reads_bytes_(BytesInUnicodeString) PCWCH UnicodeString,
1576   _In_ ULONG BytesInUnicodeString);
1577
1578 #if (NTDDI_VERSION >= NTDDI_VISTASP1)
1579 _IRQL_requires_max_(PASSIVE_LEVEL)
1580 NTSYSAPI
1581 NTSTATUS
1582 NTAPI
1583 RtlGenerate8dot3Name(
1584   _In_ PCUNICODE_STRING Name,
1585   _In_ BOOLEAN AllowExtendedCharacters,
1586   _Inout_ PGENERATE_NAME_CONTEXT Context,
1587   _Inout_ PUNICODE_STRING Name8dot3);
1588 #else
1589 _IRQL_requires_max_(PASSIVE_LEVEL)
1590 NTSYSAPI
1591 VOID
1592 NTAPI
1593 RtlGenerate8dot3Name(
1594   _In_ PCUNICODE_STRING Name,
1595   _In_ BOOLEAN AllowExtendedCharacters,
1596   _Inout_ PGENERATE_NAME_CONTEXT Context,
1597   _Inout_ PUNICODE_STRING Name8dot3);
1598 #endif
1599
1600 _IRQL_requires_max_(PASSIVE_LEVEL)
1601 _Must_inspect_result_
1602 NTSYSAPI
1603 BOOLEAN
1604 NTAPI
1605 RtlIsNameLegalDOS8Dot3(
1606   _In_ PCUNICODE_STRING Name,
1607   _Inout_opt_ POEM_STRING OemName,
1608   _Out_opt_ PBOOLEAN NameContainsSpaces);
1609
1610 _IRQL_requires_max_(PASSIVE_LEVEL)
1611 _Must_inspect_result_
1612 NTSYSAPI
1613 BOOLEAN
1614 NTAPI
1615 RtlIsValidOemCharacter(
1616   _Inout_ PWCHAR Char);
1617
1618 _IRQL_requires_max_(PASSIVE_LEVEL)
1619 NTSYSAPI
1620 VOID
1621 NTAPI
1622 PfxInitialize(
1623   _Out_ PPREFIX_TABLE PrefixTable);
1624
1625 _IRQL_requires_max_(PASSIVE_LEVEL)
1626 NTSYSAPI
1627 BOOLEAN
1628 NTAPI
1629 PfxInsertPrefix(
1630   _In_ PPREFIX_TABLE PrefixTable,
1631   _In_ __drv_aliasesMem PSTRING Prefix,
1632   _Out_ PPREFIX_TABLE_ENTRY PrefixTableEntry);
1633
1634 _IRQL_requires_max_(PASSIVE_LEVEL)
1635 NTSYSAPI
1636 VOID
1637 NTAPI
1638 PfxRemovePrefix(
1639   _In_ PPREFIX_TABLE PrefixTable,
1640   _In_ PPREFIX_TABLE_ENTRY PrefixTableEntry);
1641
1642 _IRQL_requires_max_(PASSIVE_LEVEL)
1643 _Must_inspect_result_
1644 NTSYSAPI
1645 PPREFIX_TABLE_ENTRY
1646 NTAPI
1647 PfxFindPrefix(
1648   _In_ PPREFIX_TABLE PrefixTable,
1649   _In_ PSTRING FullName);
1650
1651 _IRQL_requires_max_(PASSIVE_LEVEL)
1652 NTSYSAPI
1653 VOID
1654 NTAPI
1655 RtlInitializeUnicodePrefix(
1656   _Out_ PUNICODE_PREFIX_TABLE PrefixTable);
1657
1658 _IRQL_requires_max_(PASSIVE_LEVEL)
1659 NTSYSAPI
1660 BOOLEAN
1661 NTAPI
1662 RtlInsertUnicodePrefix(
1663   _In_ PUNICODE_PREFIX_TABLE PrefixTable,
1664   _In_ __drv_aliasesMem PUNICODE_STRING Prefix,
1665   _Out_ PUNICODE_PREFIX_TABLE_ENTRY PrefixTableEntry);
1666
1667 _IRQL_requires_max_(PASSIVE_LEVEL)
1668 NTSYSAPI
1669 VOID
1670 NTAPI
1671 RtlRemoveUnicodePrefix(
1672   _In_ PUNICODE_PREFIX_TABLE PrefixTable,
1673   _In_ PUNICODE_PREFIX_TABLE_ENTRY PrefixTableEntry);
1674
1675 _IRQL_requires_max_(PASSIVE_LEVEL)
1676 _Must_inspect_result_
1677 NTSYSAPI
1678 PUNICODE_PREFIX_TABLE_ENTRY
1679 NTAPI
1680 RtlFindUnicodePrefix(
1681   _In_ PUNICODE_PREFIX_TABLE PrefixTable,
1682   _In_ PUNICODE_STRING FullName,
1683   _In_ ULONG CaseInsensitiveIndex);
1684
1685 _IRQL_requires_max_(PASSIVE_LEVEL)
1686 _Must_inspect_result_
1687 NTSYSAPI
1688 PUNICODE_PREFIX_TABLE_ENTRY
1689 NTAPI
1690 RtlNextUnicodePrefix(
1691   _In_ PUNICODE_PREFIX_TABLE PrefixTable,
1692   _In_ BOOLEAN Restart);
1693
1694 _Must_inspect_result_
1695 NTSYSAPI
1696 SIZE_T
1697 NTAPI
1698 RtlCompareMemoryUlong(
1699   _In_reads_bytes_(Length) PVOID Source,
1700   _In_ SIZE_T Length,
1701   _In_ ULONG Pattern);
1702
1703 _Success_(return != 0)
1704 NTSYSAPI
1705 BOOLEAN
1706 NTAPI
1707 RtlTimeToSecondsSince1980(
1708   _In_ PLARGE_INTEGER Time,
1709   _Out_ PULONG ElapsedSeconds);
1710
1711 NTSYSAPI
1712 VOID
1713 NTAPI
1714 RtlSecondsSince1980ToTime(
1715   _In_ ULONG ElapsedSeconds,
1716   _Out_ PLARGE_INTEGER Time);
1717
1718 _Success_(return != 0)
1719 _Must_inspect_result_
1720 NTSYSAPI
1721 BOOLEAN
1722 NTAPI
1723 RtlTimeToSecondsSince1970(
1724     _In_ PLARGE_INTEGER Time,
1725     _Out_ PULONG ElapsedSeconds);
1726
1727 NTSYSAPI
1728 VOID
1729 NTAPI
1730 RtlSecondsSince1970ToTime(
1731   _In_ ULONG ElapsedSeconds,
1732   _Out_ PLARGE_INTEGER Time);
1733
1734 _IRQL_requires_max_(APC_LEVEL)
1735 _Must_inspect_result_
1736 NTSYSAPI
1737 BOOLEAN
1738 NTAPI
1739 RtlValidSid(
1740   _In_ PSID Sid);
1741
1742 _Must_inspect_result_
1743 NTSYSAPI
1744 BOOLEAN
1745 NTAPI
1746 RtlEqualSid(
1747   _In_ PSID Sid1,
1748   _In_ PSID Sid2);
1749
1750 _IRQL_requires_max_(APC_LEVEL)
1751 _Must_inspect_result_
1752 NTSYSAPI
1753 BOOLEAN
1754 NTAPI
1755 RtlEqualPrefixSid(
1756   _In_ PSID Sid1,
1757   _In_ PSID Sid2);
1758
1759 _IRQL_requires_max_(APC_LEVEL)
1760 NTSYSAPI
1761 ULONG
1762 NTAPI
1763 RtlLengthRequiredSid(
1764   _In_ ULONG SubAuthorityCount);
1765
1766 NTSYSAPI
1767 PVOID
1768 NTAPI
1769 RtlFreeSid(
1770   _In_ _Post_invalid_ PSID Sid);
1771
1772 _Must_inspect_result_
1773 NTSYSAPI
1774 NTSTATUS
1775 NTAPI
1776 RtlAllocateAndInitializeSid(
1777   _In_ PSID_IDENTIFIER_AUTHORITY IdentifierAuthority,
1778   _In_ UCHAR SubAuthorityCount,
1779   _In_ ULONG SubAuthority0,
1780   _In_ ULONG SubAuthority1,
1781   _In_ ULONG SubAuthority2,
1782   _In_ ULONG SubAuthority3,
1783   _In_ ULONG SubAuthority4,
1784   _In_ ULONG SubAuthority5,
1785   _In_ ULONG SubAuthority6,
1786   _In_ ULONG SubAuthority7,
1787   _Outptr_ PSID *Sid);
1788
1789 _IRQL_requires_max_(APC_LEVEL)
1790 NTSYSAPI
1791 NTSTATUS
1792 NTAPI
1793 RtlInitializeSid(
1794   _Out_ PSID Sid,
1795   _In_ PSID_IDENTIFIER_AUTHORITY IdentifierAuthority,
1796   _In_ UCHAR SubAuthorityCount);
1797
1798 NTSYSAPI
1799 PULONG
1800 NTAPI
1801 RtlSubAuthoritySid(
1802   _In_ PSID Sid,
1803   _In_ ULONG SubAuthority);
1804
1805 _Post_satisfies_(return >= 8 && return <= SECURITY_MAX_SID_SIZE)
1806 NTSYSAPI
1807 ULONG
1808 NTAPI
1809 RtlLengthSid(
1810   _In_ PSID Sid);
1811
1812 _IRQL_requires_max_(APC_LEVEL)
1813 NTSYSAPI
1814 NTSTATUS
1815 NTAPI
1816 RtlCopySid(
1817   _In_ ULONG DestinationSidLength,
1818   _Out_writes_bytes_(DestinationSidLength) PSID DestinationSid,
1819   _In_ PSID SourceSid);
1820
1821 _IRQL_requires_max_(APC_LEVEL)
1822 NTSYSAPI
1823 NTSTATUS
1824 NTAPI
1825 RtlConvertSidToUnicodeString(
1826   _Inout_ PUNICODE_STRING UnicodeString,
1827   _In_ PSID Sid,
1828   _In_ BOOLEAN AllocateDestinationString);
1829
1830 _IRQL_requires_max_(APC_LEVEL)
1831 NTSYSAPI
1832 VOID
1833 NTAPI
1834 RtlCopyLuid(
1835   _Out_ PLUID DestinationLuid,
1836   _In_ PLUID SourceLuid);
1837
1838 _IRQL_requires_max_(APC_LEVEL)
1839 NTSYSAPI
1840 NTSTATUS
1841 NTAPI
1842 RtlCreateAcl(
1843   _Out_writes_bytes_(AclLength) PACL Acl,
1844   _In_ ULONG AclLength,
1845   _In_ ULONG AclRevision);
1846
1847 _IRQL_requires_max_(APC_LEVEL)
1848 NTSYSAPI
1849 NTSTATUS
1850 NTAPI
1851 RtlAddAce(
1852   _Inout_ PACL Acl,
1853   _In_ ULONG AceRevision,
1854   _In_ ULONG StartingAceIndex,
1855   _In_reads_bytes_(AceListLength) PVOID AceList,
1856   _In_ ULONG AceListLength);
1857
1858 _IRQL_requires_max_(APC_LEVEL)
1859 NTSYSAPI
1860 NTSTATUS
1861 NTAPI
1862 RtlDeleteAce(
1863   _Inout_ PACL Acl,
1864   _In_ ULONG AceIndex);
1865
1866 NTSYSAPI
1867 NTSTATUS
1868 NTAPI
1869 RtlGetAce(
1870   _In_ PACL Acl,
1871   _In_ ULONG AceIndex,
1872   _Outptr_ PVOID *Ace);
1873
1874 _IRQL_requires_max_(APC_LEVEL)
1875 NTSYSAPI
1876 NTSTATUS
1877 NTAPI
1878 RtlAddAccessAllowedAce(
1879   _Inout_ PACL Acl,
1880   _In_ ULONG AceRevision,
1881   _In_ ACCESS_MASK AccessMask,
1882   _In_ PSID Sid);
1883
1884 _IRQL_requires_max_(APC_LEVEL)
1885 NTSYSAPI
1886 NTSTATUS
1887 NTAPI
1888 RtlAddAccessAllowedAceEx(
1889   _Inout_ PACL Acl,
1890   _In_ ULONG AceRevision,
1891   _In_ ULONG AceFlags,
1892   _In_ ACCESS_MASK AccessMask,
1893   _In_ PSID Sid);
1894
1895 _IRQL_requires_max_(APC_LEVEL)
1896 NTSYSAPI
1897 NTSTATUS
1898 NTAPI
1899 RtlCreateSecurityDescriptorRelative(
1900   _Out_ PISECURITY_DESCRIPTOR_RELATIVE SecurityDescriptor,
1901   _In_ ULONG Revision);
1902
1903 NTSYSAPI
1904 NTSTATUS
1905 NTAPI
1906 RtlGetDaclSecurityDescriptor(
1907   _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
1908   _Out_ PBOOLEAN DaclPresent,
1909   _Out_ PACL *Dacl,
1910   _Out_ PBOOLEAN DaclDefaulted);
1911
1912 _IRQL_requires_max_(APC_LEVEL)
1913 NTSYSAPI
1914 NTSTATUS
1915 NTAPI
1916 RtlSetOwnerSecurityDescriptor(
1917   _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
1918   _In_opt_ PSID Owner,
1919   _In_opt_ BOOLEAN OwnerDefaulted);
1920
1921 _IRQL_requires_max_(APC_LEVEL)
1922 NTSYSAPI
1923 NTSTATUS
1924 NTAPI
1925 RtlGetOwnerSecurityDescriptor(
1926   _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
1927   _Out_ PSID *Owner,
1928   _Out_ PBOOLEAN OwnerDefaulted);
1929
1930 _IRQL_requires_max_(APC_LEVEL)
1931 _When_(Status < 0, _Out_range_(>, 0))
1932 _When_(Status >= 0, _Out_range_(==, 0))
1933 NTSYSAPI
1934 ULONG
1935 NTAPI
1936 RtlNtStatusToDosError(
1937   _In_ NTSTATUS Status);
1938
1939 _IRQL_requires_max_(PASSIVE_LEVEL)
1940 NTSYSAPI
1941 NTSTATUS
1942 NTAPI
1943 RtlCustomCPToUnicodeN(
1944   _In_ PCPTABLEINFO CustomCP,
1945   _Out_writes_bytes_to_(MaxBytesInUnicodeString, *BytesInUnicodeString) PWCH UnicodeString,
1946   _In_ ULONG MaxBytesInUnicodeString,
1947   _Out_opt_ PULONG BytesInUnicodeString,
1948   _In_reads_bytes_(BytesInCustomCPString) PCH CustomCPString,
1949   _In_ ULONG BytesInCustomCPString);
1950
1951 _IRQL_requires_max_(PASSIVE_LEVEL)
1952 NTSYSAPI
1953 NTSTATUS
1954 NTAPI
1955 RtlUnicodeToCustomCPN(
1956   _In_ PCPTABLEINFO CustomCP,
1957   _Out_writes_bytes_to_(MaxBytesInCustomCPString, *BytesInCustomCPString) PCH CustomCPString,
1958   _In_ ULONG MaxBytesInCustomCPString,
1959   _Out_opt_ PULONG BytesInCustomCPString,
1960   _In_reads_bytes_(BytesInUnicodeString) PWCH UnicodeString,
1961   _In_ ULONG BytesInUnicodeString);
1962
1963 _IRQL_requires_max_(PASSIVE_LEVEL)
1964 NTSYSAPI
1965 NTSTATUS
1966 NTAPI
1967 RtlUpcaseUnicodeToCustomCPN(
1968   _In_ PCPTABLEINFO CustomCP,
1969   _Out_writes_bytes_to_(MaxBytesInCustomCPString, *BytesInCustomCPString) PCH CustomCPString,
1970   _In_ ULONG MaxBytesInCustomCPString,
1971   _Out_opt_ PULONG BytesInCustomCPString,
1972   _In_reads_bytes_(BytesInUnicodeString) PWCH UnicodeString,
1973   _In_ ULONG BytesInUnicodeString);
1974
1975 _IRQL_requires_max_(PASSIVE_LEVEL)
1976 NTSYSAPI
1977 VOID
1978 NTAPI
1979 RtlInitCodePageTable(
1980   _In_ PUSHORT TableBase,
1981   _Out_ PCPTABLEINFO CodePageTable);
1982
1983 $endif (_NTIFS_)
1984
1985 #endif /* (NTDDI_VERSION >= NTDDI_WIN2K) */
1986
1987 $if (_WDMDDK_)
1988
1989 #if (NTDDI_VERSION >= NTDDI_WIN2KSP3)
1990 NTSYSAPI
1991 VOID
1992 FASTCALL
1993 RtlPrefetchMemoryNonTemporal(
1994   _In_ PVOID Source,
1995   _In_ SIZE_T Length);
1996 #endif
1997
1998 $endif (_WDMDDK_)
1999
2000 #if (NTDDI_VERSION >= NTDDI_WINXP)
2001
2002 $if (_WDMDDK_)
2003
2004 NTSYSAPI
2005 VOID
2006 NTAPI
2007 RtlClearBit(
2008   _In_ PRTL_BITMAP BitMapHeader,
2009   _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber);
2010
2011 _IRQL_requires_max_(PASSIVE_LEVEL)
2012 NTSYSAPI
2013 WCHAR
2014 NTAPI
2015 RtlDowncaseUnicodeChar(
2016   _In_ WCHAR SourceCharacter);
2017
2018 NTSYSAPI
2019 VOID
2020 NTAPI
2021 RtlSetBit(
2022   _In_ PRTL_BITMAP BitMapHeader,
2023   _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber);
2024
2025 _Must_inspect_result_
2026 NTSYSAPI
2027 BOOLEAN
2028 NTAPI
2029 RtlTestBit(
2030   _In_ PRTL_BITMAP BitMapHeader,
2031   _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber);
2032
2033 _IRQL_requires_max_(PASSIVE_LEVEL)
2034 NTSYSAPI
2035 NTSTATUS
2036 NTAPI
2037 RtlHashUnicodeString(
2038   _In_ CONST UNICODE_STRING *String,
2039   _In_ BOOLEAN CaseInSensitive,
2040   _In_ ULONG HashAlgorithm,
2041   _Out_ PULONG HashValue);
2042
2043 $endif (_WDMDDK_)
2044
2045 $if (_NTDDK_)
2046
2047 NTSYSAPI
2048 VOID
2049 NTAPI
2050 RtlInitializeGenericTableAvl(
2051   _Out_ PRTL_AVL_TABLE Table,
2052   _In_ PRTL_AVL_COMPARE_ROUTINE CompareRoutine,
2053   _In_opt_ PRTL_AVL_ALLOCATE_ROUTINE AllocateRoutine,
2054   _In_opt_ PRTL_AVL_FREE_ROUTINE FreeRoutine,
2055   _In_opt_ PVOID TableContext);
2056
2057 NTSYSAPI
2058 PVOID
2059 NTAPI
2060 RtlInsertElementGenericTableAvl(
2061   _In_ PRTL_AVL_TABLE Table,
2062   _In_reads_bytes_(BufferSize) PVOID Buffer,
2063   _In_ CLONG BufferSize,
2064   _Out_opt_ PBOOLEAN NewElement);
2065
2066 NTSYSAPI
2067 PVOID
2068 NTAPI
2069 RtlInsertElementGenericTableFullAvl(
2070   _In_ PRTL_AVL_TABLE Table,
2071   _In_reads_bytes_(BufferSize) PVOID Buffer,
2072   _In_ CLONG BufferSize,
2073   _Out_opt_ PBOOLEAN NewElement,
2074   _In_ PVOID NodeOrParent,
2075   _In_ TABLE_SEARCH_RESULT SearchResult);
2076
2077 NTSYSAPI
2078 BOOLEAN
2079 NTAPI
2080 RtlDeleteElementGenericTableAvl(
2081   _In_ PRTL_AVL_TABLE Table,
2082   _In_ PVOID Buffer);
2083
2084 _Must_inspect_result_
2085 NTSYSAPI
2086 PVOID
2087 NTAPI
2088 RtlLookupElementGenericTableAvl(
2089   _In_ PRTL_AVL_TABLE Table,
2090   _In_ PVOID Buffer);
2091
2092 NTSYSAPI
2093 PVOID
2094 NTAPI
2095 RtlLookupElementGenericTableFullAvl(
2096   _In_ PRTL_AVL_TABLE Table,
2097   _In_ PVOID Buffer,
2098   _Out_ PVOID *NodeOrParent,
2099   _Out_ TABLE_SEARCH_RESULT *SearchResult);
2100
2101 _Must_inspect_result_
2102 NTSYSAPI
2103 PVOID
2104 NTAPI
2105 RtlEnumerateGenericTableAvl(
2106   _In_ PRTL_AVL_TABLE Table,
2107   _In_ BOOLEAN Restart);
2108
2109 _Must_inspect_result_
2110 NTSYSAPI
2111 PVOID
2112 NTAPI
2113 RtlEnumerateGenericTableWithoutSplayingAvl(
2114   _In_ PRTL_AVL_TABLE Table,
2115   _Inout_ PVOID *RestartKey);
2116
2117 _Must_inspect_result_
2118 NTSYSAPI
2119 PVOID
2120 NTAPI
2121 RtlLookupFirstMatchingElementGenericTableAvl(
2122   _In_ PRTL_AVL_TABLE Table,
2123   _In_ PVOID Buffer,
2124   _Out_ PVOID *RestartKey);
2125
2126 _Must_inspect_result_
2127 NTSYSAPI
2128 PVOID
2129 NTAPI
2130 RtlEnumerateGenericTableLikeADirectory(
2131   _In_ PRTL_AVL_TABLE Table,
2132   _In_opt_ PRTL_AVL_MATCH_FUNCTION MatchFunction,
2133   _In_opt_ PVOID MatchData,
2134   _In_ ULONG NextFlag,
2135   _Inout_ PVOID *RestartKey,
2136   _Inout_ PULONG DeleteCount,
2137   _In_ PVOID Buffer);
2138
2139 _Must_inspect_result_
2140 NTSYSAPI
2141 PVOID
2142 NTAPI
2143 RtlGetElementGenericTableAvl(
2144   _In_ PRTL_AVL_TABLE Table,
2145   _In_ ULONG I);
2146
2147 NTSYSAPI
2148 ULONG
2149 NTAPI
2150 RtlNumberGenericTableElementsAvl(
2151   _In_ PRTL_AVL_TABLE Table);
2152
2153 _Must_inspect_result_
2154 NTSYSAPI
2155 BOOLEAN
2156 NTAPI
2157 RtlIsGenericTableEmptyAvl(
2158   _In_ PRTL_AVL_TABLE Table);
2159
2160 $endif (_NTDDK_)
2161 $if (_NTIFS_)
2162
2163 _Must_inspect_result_
2164 NTSYSAPI
2165 PVOID
2166 NTAPI
2167 RtlCreateHeap(
2168   _In_ ULONG Flags,
2169   _In_opt_ PVOID HeapBase,
2170   _In_opt_ SIZE_T ReserveSize,
2171   _In_opt_ SIZE_T CommitSize,
2172   _In_opt_ PVOID Lock,
2173   _In_opt_ PRTL_HEAP_PARAMETERS Parameters);
2174
2175 NTSYSAPI
2176 PVOID
2177 NTAPI
2178 RtlDestroyHeap(
2179   _In_ _Post_invalid_ PVOID HeapHandle);
2180
2181 NTSYSAPI
2182 USHORT
2183 NTAPI
2184 RtlCaptureStackBackTrace(
2185   _In_ ULONG FramesToSkip,
2186   _In_ ULONG FramesToCapture,
2187   _Out_writes_to_(FramesToCapture, return) PVOID *BackTrace,
2188   _Out_opt_ PULONG BackTraceHash);
2189
2190 _Ret_range_(<, MAXLONG)
2191 NTSYSAPI
2192 ULONG
2193 NTAPI
2194 RtlRandomEx(
2195   _Inout_ PULONG Seed);
2196
2197 _IRQL_requires_max_(DISPATCH_LEVEL)
2198 NTSYSAPI
2199 NTSTATUS
2200 NTAPI
2201 RtlInitUnicodeStringEx(
2202   _Out_ PUNICODE_STRING DestinationString,
2203   _In_opt_z_ __drv_aliasesMem PCWSTR SourceString);
2204
2205 _Must_inspect_result_
2206 NTSYSAPI
2207 NTSTATUS
2208 NTAPI
2209 RtlValidateUnicodeString(
2210   _In_ ULONG Flags,
2211   _In_ PCUNICODE_STRING String);
2212
2213 _IRQL_requires_max_(PASSIVE_LEVEL)
2214 _Must_inspect_result_
2215 NTSYSAPI
2216 NTSTATUS
2217 NTAPI
2218 RtlDuplicateUnicodeString(
2219   _In_ ULONG Flags,
2220   _In_ PCUNICODE_STRING SourceString,
2221   _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)) PUNICODE_STRING DestinationString);
2222
2223 NTSYSAPI
2224 NTSTATUS
2225 NTAPI
2226 RtlGetCompressionWorkSpaceSize(
2227   _In_ USHORT CompressionFormatAndEngine,
2228   _Out_ PULONG CompressBufferWorkSpaceSize,
2229   _Out_ PULONG CompressFragmentWorkSpaceSize);
2230
2231 NTSYSAPI
2232 NTSTATUS
2233 NTAPI
2234 RtlCompressBuffer(
2235   _In_ USHORT CompressionFormatAndEngine,
2236   _In_reads_bytes_(UncompressedBufferSize) PUCHAR UncompressedBuffer,
2237   _In_ ULONG UncompressedBufferSize,
2238   _Out_writes_bytes_to_(CompressedBufferSize, *FinalCompressedSize) PUCHAR CompressedBuffer,
2239   _In_ ULONG CompressedBufferSize,
2240   _In_ ULONG UncompressedChunkSize,
2241   _Out_ PULONG FinalCompressedSize,
2242   _In_ PVOID WorkSpace);
2243
2244 _IRQL_requires_max_(APC_LEVEL)
2245 NTSYSAPI
2246 NTSTATUS
2247 NTAPI
2248 RtlDecompressBuffer(
2249   _In_ USHORT CompressionFormat,
2250   _Out_writes_bytes_to_(UncompressedBufferSize, *FinalUncompressedSize) PUCHAR UncompressedBuffer,
2251   _In_ ULONG UncompressedBufferSize,
2252   _In_reads_bytes_(CompressedBufferSize) PUCHAR CompressedBuffer,
2253   _In_ ULONG CompressedBufferSize,
2254   _Out_ PULONG FinalUncompressedSize);
2255
2256 _IRQL_requires_max_(APC_LEVEL)
2257 NTSYSAPI
2258 NTSTATUS
2259 NTAPI
2260 RtlDecompressFragment(
2261   _In_ USHORT CompressionFormat,
2262   _Out_writes_bytes_to_(UncompressedFragmentSize, *FinalUncompressedSize) PUCHAR UncompressedFragment,
2263   _In_ ULONG UncompressedFragmentSize,
2264   _In_reads_bytes_(CompressedBufferSize) PUCHAR CompressedBuffer,
2265   _In_ ULONG CompressedBufferSize,
2266   _In_range_(<, CompressedBufferSize) ULONG FragmentOffset,
2267   _Out_ PULONG FinalUncompressedSize,
2268   _In_ PVOID WorkSpace);
2269
2270 _IRQL_requires_max_(APC_LEVEL)
2271 NTSYSAPI
2272 NTSTATUS
2273 NTAPI
2274 RtlDescribeChunk(
2275   _In_ USHORT CompressionFormat,
2276   _Inout_ PUCHAR *CompressedBuffer,
2277   _In_ PUCHAR EndOfCompressedBufferPlus1,
2278   _Out_ PUCHAR *ChunkBuffer,
2279   _Out_ PULONG ChunkSize);
2280
2281 _IRQL_requires_max_(APC_LEVEL)
2282 NTSYSAPI
2283 NTSTATUS
2284 NTAPI
2285 RtlReserveChunk(
2286   _In_ USHORT CompressionFormat,
2287   _Inout_ PUCHAR *CompressedBuffer,
2288   _In_ PUCHAR EndOfCompressedBufferPlus1,
2289   _Out_ PUCHAR *ChunkBuffer,
2290   _In_ ULONG ChunkSize);
2291
2292 _IRQL_requires_max_(APC_LEVEL)
2293 NTSYSAPI
2294 NTSTATUS
2295 NTAPI
2296 RtlDecompressChunks(
2297   _Out_writes_bytes_(UncompressedBufferSize) PUCHAR UncompressedBuffer,
2298   _In_ ULONG UncompressedBufferSize,
2299   _In_reads_bytes_(CompressedBufferSize) PUCHAR CompressedBuffer,
2300   _In_ ULONG CompressedBufferSize,
2301   _In_reads_bytes_(CompressedTailSize) PUCHAR CompressedTail,
2302   _In_ ULONG CompressedTailSize,
2303   _In_ PCOMPRESSED_DATA_INFO CompressedDataInfo);
2304
2305 _IRQL_requires_max_(APC_LEVEL)
2306 NTSYSAPI
2307 NTSTATUS
2308 NTAPI
2309 RtlCompressChunks(
2310   _In_reads_bytes_(UncompressedBufferSize) PUCHAR UncompressedBuffer,
2311   _In_ ULONG UncompressedBufferSize,
2312   _Out_writes_bytes_(CompressedBufferSize) PUCHAR CompressedBuffer,
2313   _In_range_(>=, (UncompressedBufferSize - (UncompressedBufferSize / 16))) ULONG CompressedBufferSize,
2314   _Inout_updates_bytes_(CompressedDataInfoLength) PCOMPRESSED_DATA_INFO CompressedDataInfo,
2315   _In_range_(>, sizeof(COMPRESSED_DATA_INFO)) ULONG CompressedDataInfoLength,
2316   _In_ PVOID WorkSpace);
2317
2318 _IRQL_requires_max_(APC_LEVEL)
2319 NTSYSAPI
2320 PSID_IDENTIFIER_AUTHORITY
2321 NTAPI
2322 RtlIdentifierAuthoritySid(
2323   _In_ PSID Sid);
2324
2325 NTSYSAPI
2326 PUCHAR
2327 NTAPI
2328 RtlSubAuthorityCountSid(
2329   _In_ PSID Sid);
2330
2331 _When_(Status < 0, _Out_range_(>, 0))
2332 _When_(Status >= 0, _Out_range_(==, 0))
2333 NTSYSAPI
2334 ULONG
2335 NTAPI
2336 RtlNtStatusToDosErrorNoTeb(
2337   _In_ NTSTATUS Status);
2338
2339 _IRQL_requires_max_(PASSIVE_LEVEL)
2340 NTSYSAPI
2341 NTSTATUS
2342 NTAPI
2343 RtlCreateSystemVolumeInformationFolder(
2344   _In_ PCUNICODE_STRING VolumeRootPath);
2345
2346 #if defined(_M_AMD64)
2347
2348 FORCEINLINE
2349 VOID
2350 RtlFillMemoryUlong(
2351   _Out_writes_bytes_all_(Length) PVOID Destination,
2352   _In_ SIZE_T Length,
2353   _In_ ULONG Pattern)
2354 {
2355   PULONG Address = (PULONG)Destination;
2356   if ((Length /= 4) != 0) {
2357     if (((ULONG64)Address & 4) != 0) {
2358       *Address = Pattern;
2359       if ((Length -= 1) == 0) {
2360         return;
2361       }
2362       Address += 1;
2363     }
2364     __stosq((PULONG64)(Address), Pattern | ((ULONG64)Pattern << 32), Length / 2);
2365     if ((Length & 1) != 0) Address[Length - 1] = Pattern;
2366   }
2367   return;
2368 }
2369
2370 #define RtlFillMemoryUlonglong(Destination, Length, Pattern)                \
2371     __stosq((PULONG64)(Destination), Pattern, (Length) / 8)
2372
2373 #else
2374
2375 NTSYSAPI
2376 VOID
2377 NTAPI
2378 RtlFillMemoryUlong(
2379   OUT PVOID Destination,
2380   IN SIZE_T Length,
2381   IN ULONG Pattern);
2382
2383 NTSYSAPI
2384 VOID
2385 NTAPI
2386 RtlFillMemoryUlonglong(
2387   _Out_writes_bytes_all_(Length) PVOID Destination,
2388   _In_ SIZE_T Length,
2389   _In_ ULONGLONG Pattern);
2390
2391 #endif /* defined(_M_AMD64) */
2392 $endif (_NTIFS_)
2393
2394 #endif /* (NTDDI_VERSION >= NTDDI_WINXP) */
2395
2396 $if (_NTIFS_)
2397 #if (NTDDI_VERSION >= NTDDI_WS03)
2398 _IRQL_requires_max_(DISPATCH_LEVEL)
2399 NTSYSAPI
2400 NTSTATUS
2401 NTAPI
2402 RtlInitAnsiStringEx(
2403   _Out_ PANSI_STRING DestinationString,
2404   _In_opt_z_ __drv_aliasesMem PCSZ SourceString);
2405 #endif
2406
2407 #if (NTDDI_VERSION >= NTDDI_WS03SP1)
2408
2409 _IRQL_requires_max_(APC_LEVEL)
2410 NTSYSAPI
2411 NTSTATUS
2412 NTAPI
2413 RtlGetSaclSecurityDescriptor(
2414   _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
2415   _Out_ PBOOLEAN SaclPresent,
2416   _Out_ PACL *Sacl,
2417   _Out_ PBOOLEAN SaclDefaulted);
2418
2419 _IRQL_requires_max_(APC_LEVEL)
2420 NTSYSAPI
2421 NTSTATUS
2422 NTAPI
2423 RtlSetGroupSecurityDescriptor(
2424   _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
2425   _In_opt_ PSID Group,
2426   _In_opt_ BOOLEAN GroupDefaulted);
2427
2428 _IRQL_requires_max_(APC_LEVEL)
2429 NTSYSAPI
2430 NTSTATUS
2431 NTAPI
2432 RtlGetGroupSecurityDescriptor(
2433   _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
2434   _Out_ PSID *Group,
2435   _Out_ PBOOLEAN GroupDefaulted);
2436
2437 _IRQL_requires_max_(APC_LEVEL)
2438 NTSYSAPI
2439 NTSTATUS
2440 NTAPI
2441 RtlAbsoluteToSelfRelativeSD(
2442   _In_ PSECURITY_DESCRIPTOR AbsoluteSecurityDescriptor,
2443   _Out_writes_bytes_to_opt_(*BufferLength, *BufferLength) PSECURITY_DESCRIPTOR SelfRelativeSecurityDescriptor,
2444   _Inout_ PULONG BufferLength);
2445
2446 _IRQL_requires_max_(APC_LEVEL)
2447 NTSYSAPI
2448 NTSTATUS
2449 NTAPI
2450 RtlSelfRelativeToAbsoluteSD(
2451   _In_ PSECURITY_DESCRIPTOR SelfRelativeSecurityDescriptor,
2452   _Out_writes_bytes_to_opt_(*AbsoluteSecurityDescriptorSize, *AbsoluteSecurityDescriptorSize) PSECURITY_DESCRIPTOR AbsoluteSecurityDescriptor,
2453   _Inout_ PULONG AbsoluteSecurityDescriptorSize,
2454   _Out_writes_bytes_to_opt_(*DaclSize, *DaclSize) PACL Dacl,
2455   _Inout_ PULONG DaclSize,
2456   _Out_writes_bytes_to_opt_(*SaclSize, *SaclSize) PACL Sacl,
2457   _Inout_ PULONG SaclSize,
2458   _Out_writes_bytes_to_opt_(*OwnerSize, *OwnerSize) PSID Owner,
2459   _Inout_ PULONG OwnerSize,
2460   _Out_writes_bytes_to_opt_(*PrimaryGroupSize, *PrimaryGroupSize) PSID PrimaryGroup,
2461   _Inout_ PULONG PrimaryGroupSize);
2462
2463 #endif /* (NTDDI_VERSION >= NTDDI_WS03SP1) */
2464 $endif (_NTIFS_)
2465
2466 #if (NTDDI_VERSION >= NTDDI_VISTA)
2467
2468 $if (_WDMDDK_)
2469 NTSYSAPI
2470 ULONG
2471 NTAPI
2472 RtlNumberOfSetBitsUlongPtr(
2473   _In_ ULONG_PTR Target);
2474
2475 NTSYSAPI
2476 ULONGLONG
2477 NTAPI
2478 RtlIoDecodeMemIoResource(
2479   _In_ struct _IO_RESOURCE_DESCRIPTOR *Descriptor,
2480   _Out_opt_ PULONGLONG Alignment,
2481   _Out_opt_ PULONGLONG MinimumAddress,
2482   _Out_opt_ PULONGLONG MaximumAddress);
2483
2484 NTSYSAPI
2485 NTSTATUS
2486 NTAPI
2487 RtlIoEncodeMemIoResource(
2488   _In_ struct _IO_RESOURCE_DESCRIPTOR *Descriptor,
2489   _In_ UCHAR Type,
2490   _In_ ULONGLONG Length,
2491   _In_ ULONGLONG Alignment,
2492   _In_ ULONGLONG MinimumAddress,
2493   _In_ ULONGLONG MaximumAddress);
2494
2495 NTSYSAPI
2496 ULONGLONG
2497 NTAPI
2498 RtlCmDecodeMemIoResource(
2499   _In_ struct _CM_PARTIAL_RESOURCE_DESCRIPTOR *Descriptor,
2500   _Out_opt_ PULONGLONG Start);
2501
2502 NTSYSAPI
2503 NTSTATUS
2504 NTAPI
2505 RtlFindClosestEncodableLength(
2506   _In_ ULONGLONG SourceLength,
2507   _Out_ PULONGLONG TargetLength);
2508
2509 NTSYSAPI
2510 NTSTATUS
2511 NTAPI
2512 RtlCmEncodeMemIoResource(
2513   _In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor,
2514   _In_ UCHAR Type,
2515   _In_ ULONGLONG Length,
2516   _In_ ULONGLONG Start);
2517
2518 $endif (_WDMDDK_)
2519 $if (_NTDDK_)
2520
2521 _IRQL_requires_max_(APC_LEVEL)
2522 NTSYSAPI
2523 VOID
2524 NTAPI
2525 RtlRunOnceInitialize(
2526   _Out_ PRTL_RUN_ONCE RunOnce);
2527
2528 _IRQL_requires_max_(APC_LEVEL)
2529 _Maybe_raises_SEH_exception_
2530 NTSYSAPI
2531 NTSTATUS
2532 NTAPI
2533 RtlRunOnceExecuteOnce(
2534   _Inout_ PRTL_RUN_ONCE RunOnce,
2535   _In_ __inner_callback PRTL_RUN_ONCE_INIT_FN InitFn,
2536   _Inout_opt_ PVOID Parameter,
2537   _Outptr_opt_result_maybenull_ PVOID *Context);
2538
2539 _IRQL_requires_max_(APC_LEVEL)
2540 _Must_inspect_result_
2541 NTSYSAPI
2542 NTSTATUS
2543 NTAPI
2544 RtlRunOnceBeginInitialize(
2545   _Inout_ PRTL_RUN_ONCE RunOnce,
2546   _In_ ULONG Flags,
2547   _Outptr_opt_result_maybenull_ PVOID *Context);
2548
2549 _IRQL_requires_max_(APC_LEVEL)
2550 NTSYSAPI
2551 NTSTATUS
2552 NTAPI
2553 RtlRunOnceComplete(
2554   _Inout_ PRTL_RUN_ONCE RunOnce,
2555   _In_ ULONG Flags,
2556   _In_opt_ PVOID Context);
2557
2558 NTSYSAPI
2559 BOOLEAN
2560 NTAPI
2561 RtlGetProductInfo(
2562   _In_ ULONG OSMajorVersion,
2563   _In_ ULONG OSMinorVersion,
2564   _In_ ULONG SpMajorVersion,
2565   _In_ ULONG SpMinorVersion,
2566   _Out_ PULONG ReturnedProductType);
2567
2568 $endif (_NTDDK_)
2569 $if (_NTIFS_)
2570 NTSYSAPI
2571 NTSTATUS
2572 NTAPI
2573 RtlNormalizeString(
2574   _In_ ULONG NormForm,
2575   _In_ PCWSTR SourceString,
2576   _In_ LONG SourceStringLength,
2577   _Out_writes_to_(*DestinationStringLength, *DestinationStringLength) PWSTR DestinationString,
2578   _Inout_ PLONG DestinationStringLength);
2579
2580 NTSYSAPI
2581 NTSTATUS
2582 NTAPI
2583 RtlIsNormalizedString(
2584   _In_ ULONG NormForm,
2585   _In_ PCWSTR SourceString,
2586   _In_ LONG SourceStringLength,
2587   _Out_ PBOOLEAN Normalized);
2588
2589 NTSYSAPI
2590 NTSTATUS
2591 NTAPI
2592 RtlIdnToAscii(
2593   _In_ ULONG Flags,
2594   _In_ PCWSTR SourceString,
2595   _In_ LONG SourceStringLength,
2596   _Out_writes_to_(*DestinationStringLength, *DestinationStringLength) PWSTR DestinationString,
2597   _Inout_ PLONG DestinationStringLength);
2598
2599 NTSYSAPI
2600 NTSTATUS
2601 NTAPI
2602 RtlIdnToUnicode(
2603   IN ULONG Flags,
2604   IN PCWSTR SourceString,
2605   IN LONG SourceStringLength,
2606   OUT PWSTR DestinationString,
2607   IN OUT PLONG DestinationStringLength);
2608
2609 NTSYSAPI
2610 NTSTATUS
2611 NTAPI
2612 RtlIdnToNameprepUnicode(
2613   _In_ ULONG Flags,
2614   _In_ PCWSTR SourceString,
2615   _In_ LONG SourceStringLength,
2616   _Out_writes_to_(*DestinationStringLength, *DestinationStringLength) PWSTR DestinationString,
2617   _Inout_ PLONG DestinationStringLength);
2618
2619 NTSYSAPI
2620 NTSTATUS
2621 NTAPI
2622 RtlCreateServiceSid(
2623   _In_ PUNICODE_STRING ServiceName,
2624   _Out_writes_bytes_opt_(*ServiceSidLength) PSID ServiceSid,
2625   _Inout_ PULONG ServiceSidLength);
2626
2627 NTSYSAPI
2628 LONG
2629 NTAPI
2630 RtlCompareAltitudes(
2631   _In_ PCUNICODE_STRING Altitude1,
2632   _In_ PCUNICODE_STRING Altitude2);
2633
2634 $endif (_NTIFS_)
2635
2636 #endif /* (NTDDI_VERSION >= NTDDI_VISTA) */
2637
2638 #if (NTDDI_VERSION >= NTDDI_WIN7)
2639
2640 $if (_WDMDDK_)
2641 _IRQL_requires_max_(PASSIVE_LEVEL)
2642 _Must_inspect_result_
2643 NTSYSAPI
2644 NTSTATUS
2645 NTAPI
2646 RtlUnicodeToUTF8N(
2647   _Out_writes_bytes_to_(UTF8StringMaxByteCount, *UTF8StringActualByteCount)
2648     PCHAR UTF8StringDestination,
2649   _In_ ULONG UTF8StringMaxByteCount,
2650   _Out_ PULONG UTF8StringActualByteCount,
2651   _In_reads_bytes_(UnicodeStringByteCount) PCWCH UnicodeStringSource,
2652   _In_ ULONG UnicodeStringByteCount);
2653
2654 _IRQL_requires_max_(PASSIVE_LEVEL)
2655 _Must_inspect_result_
2656 NTSYSAPI
2657 NTSTATUS
2658 NTAPI
2659 RtlUTF8ToUnicodeN(
2660   _Out_writes_bytes_to_(UnicodeStringMaxByteCount, *UnicodeStringActualByteCount)
2661     PWSTR UnicodeStringDestination,
2662   _In_ ULONG UnicodeStringMaxByteCount,
2663   _Out_ PULONG UnicodeStringActualByteCount,
2664   _In_reads_bytes_(UTF8StringByteCount) PCCH UTF8StringSource,
2665   _In_ ULONG UTF8StringByteCount);
2666
2667 NTSYSAPI
2668 ULONG64
2669 NTAPI
2670 RtlGetEnabledExtendedFeatures(
2671   IN ULONG64 FeatureMask);
2672
2673 $endif (_WDMDDK_)
2674 $if (_NTDDK_)
2675
2676 _Must_inspect_result_
2677 NTSYSAPI
2678 BOOLEAN
2679 NTAPI
2680 RtlCreateHashTable(
2681   _Inout_ _When_(NULL == *HashTable, __drv_allocatesMem(Mem))
2682     PRTL_DYNAMIC_HASH_TABLE *HashTable,
2683   _In_ ULONG Shift,
2684   _In_ _Reserved_ ULONG Flags);
2685
2686 NTSYSAPI
2687 VOID
2688 NTAPI
2689 RtlDeleteHashTable(
2690   _In_ _When_((HashTable->Flags & RTL_HASH_ALLOCATED_HEADER), __drv_freesMem(Mem) _Post_invalid_)
2691     PRTL_DYNAMIC_HASH_TABLE HashTable);
2692
2693 NTSYSAPI
2694 BOOLEAN
2695 NTAPI
2696 RtlInsertEntryHashTable(
2697   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2698   _In_ __drv_aliasesMem PRTL_DYNAMIC_HASH_TABLE_ENTRY Entry,
2699   _In_ ULONG_PTR Signature,
2700   _Inout_opt_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context);
2701
2702 NTSYSAPI
2703 BOOLEAN
2704 NTAPI
2705 RtlRemoveEntryHashTable(
2706   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2707   _In_ PRTL_DYNAMIC_HASH_TABLE_ENTRY Entry,
2708   _Inout_opt_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context);
2709
2710 _Must_inspect_result_
2711 NTSYSAPI
2712 PRTL_DYNAMIC_HASH_TABLE_ENTRY
2713 NTAPI
2714 RtlLookupEntryHashTable(
2715   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2716   _In_ ULONG_PTR Signature,
2717   _Out_opt_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context);
2718
2719 _Must_inspect_result_
2720 NTSYSAPI
2721 PRTL_DYNAMIC_HASH_TABLE_ENTRY
2722 NTAPI
2723 RtlGetNextEntryHashTable(
2724   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2725   _In_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context);
2726
2727 NTSYSAPI
2728 BOOLEAN
2729 NTAPI
2730 RtlInitEnumerationHashTable(
2731   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2732   _Out_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
2733
2734 _Must_inspect_result_
2735 NTSYSAPI
2736 PRTL_DYNAMIC_HASH_TABLE_ENTRY
2737 NTAPI
2738 RtlEnumerateEntryHashTable(
2739   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2740   _Inout_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
2741
2742 NTSYSAPI
2743 VOID
2744 NTAPI
2745 RtlEndEnumerationHashTable(
2746   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2747   _Inout_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
2748
2749 NTSYSAPI
2750 BOOLEAN
2751 NTAPI
2752 RtlInitWeakEnumerationHashTable(
2753   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2754   _Out_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
2755
2756 _Must_inspect_result_
2757 NTSYSAPI
2758 PRTL_DYNAMIC_HASH_TABLE_ENTRY
2759 NTAPI
2760 RtlWeaklyEnumerateEntryHashTable(
2761   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2762   _Inout_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
2763
2764 NTSYSAPI
2765 VOID
2766 NTAPI
2767 RtlEndWeakEnumerationHashTable(
2768   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2769   _Inout_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
2770
2771 NTSYSAPI
2772 BOOLEAN
2773 NTAPI
2774 RtlExpandHashTable(
2775   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable);
2776
2777 NTSYSAPI
2778 BOOLEAN
2779 NTAPI
2780 RtlContractHashTable(
2781   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable);
2782
2783 $endif (_NTDDK_)
2784 $if (_NTIFS_)
2785 _IRQL_requires_max_(PASSIVE_LEVEL)
2786 _Must_inspect_result_
2787 NTSYSAPI
2788 NTSTATUS
2789 NTAPI
2790 RtlUnicodeToUTF8N(
2791   _Out_writes_bytes_to_(UTF8StringMaxByteCount, *UTF8StringActualByteCount) PCHAR UTF8StringDestination,
2792   _In_ ULONG UTF8StringMaxByteCount,
2793   _Out_ PULONG UTF8StringActualByteCount,
2794   _In_reads_bytes_(UnicodeStringByteCount) PCWCH UnicodeStringSource,
2795   _In_ ULONG UnicodeStringByteCount);
2796
2797 _IRQL_requires_max_(PASSIVE_LEVEL)
2798 _Must_inspect_result_
2799 NTSYSAPI
2800 NTSTATUS
2801 NTAPI
2802 RtlUTF8ToUnicodeN(
2803   _Out_writes_bytes_to_(UnicodeStringMaxByteCount, *UnicodeStringActualByteCount) PWSTR UnicodeStringDestination,
2804   _In_ ULONG UnicodeStringMaxByteCount,
2805   _Out_ PULONG UnicodeStringActualByteCount,
2806   _In_reads_bytes_(UTF8StringByteCount) PCCH UTF8StringSource,
2807   _In_ ULONG UTF8StringByteCount);
2808
2809 _IRQL_requires_max_(APC_LEVEL)
2810 NTSYSAPI
2811 NTSTATUS
2812 NTAPI
2813 RtlReplaceSidInSd(
2814   _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
2815   _In_ PSID OldSid,
2816   _In_ PSID NewSid,
2817   _Out_ ULONG *NumChanges);
2818
2819 NTSYSAPI
2820 NTSTATUS
2821 NTAPI
2822 RtlCreateVirtualAccountSid(
2823   _In_ PCUNICODE_STRING Name,
2824   _In_ ULONG BaseSubAuthority,
2825   _Out_writes_bytes_(*SidLength) PSID Sid,
2826   _Inout_ PULONG SidLength);
2827 $endif (_NTIFS_)
2828
2829 #endif /* (NTDDI_VERSION >= NTDDI_WIN7) */
2830
2831 $if (_WDMDDK_)
2832
2833 #if !defined(MIDL_PASS)
2834 /* inline funftions */
2835 //DECLSPEC_DEPRECATED_DDK_WINXP
2836 static __inline
2837 LARGE_INTEGER
2838 NTAPI_INLINE
2839 RtlConvertLongToLargeInteger(
2840   _In_ LONG SignedInteger)
2841 {
2842   LARGE_INTEGER ret;
2843   ret.QuadPart = SignedInteger;
2844   return ret;
2845 }
2846
2847 //DECLSPEC_DEPRECATED_DDK_WINXP
2848 static __inline
2849 LARGE_INTEGER
2850 NTAPI_INLINE
2851 RtlConvertUlongToLargeInteger(
2852   _In_ ULONG UnsignedInteger)
2853 {
2854   LARGE_INTEGER ret;
2855   ret.QuadPart = UnsignedInteger;
2856   return ret;
2857 }
2858
2859 //DECLSPEC_DEPRECATED_DDK_WINXP
2860 static __inline
2861 LARGE_INTEGER
2862 NTAPI_INLINE
2863 RtlLargeIntegerShiftLeft(
2864   _In_ LARGE_INTEGER LargeInteger,
2865   _In_ CCHAR ShiftCount)
2866 {
2867   LARGE_INTEGER Result;
2868
2869   Result.QuadPart = LargeInteger.QuadPart << ShiftCount;
2870   return Result;
2871 }
2872
2873 //DECLSPEC_DEPRECATED_DDK_WINXP
2874 static __inline
2875 LARGE_INTEGER
2876 NTAPI_INLINE
2877 RtlLargeIntegerShiftRight(
2878   _In_ LARGE_INTEGER LargeInteger,
2879   _In_ CCHAR ShiftCount)
2880 {
2881   LARGE_INTEGER Result;
2882
2883   Result.QuadPart = (ULONG64)LargeInteger.QuadPart >> ShiftCount;
2884   return Result;
2885 }
2886
2887 //DECLSPEC_DEPRECATED_DDK
2888 static __inline
2889 ULONG
2890 NTAPI_INLINE
2891 RtlEnlargedUnsignedDivide(
2892   _In_ ULARGE_INTEGER Dividend,
2893   _In_ ULONG Divisor,
2894   _Out_opt_ PULONG Remainder)
2895 {
2896   if (Remainder)
2897     *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
2898   return (ULONG)(Dividend.QuadPart / Divisor);
2899 }
2900
2901 //DECLSPEC_DEPRECATED_DDK
2902 static __inline
2903 LARGE_INTEGER
2904 NTAPI_INLINE
2905 RtlLargeIntegerNegate(
2906   _In_ LARGE_INTEGER Subtrahend)
2907 {
2908   LARGE_INTEGER Difference;
2909
2910   Difference.QuadPart = -Subtrahend.QuadPart;
2911   return Difference;
2912 }
2913
2914 //DECLSPEC_DEPRECATED_DDK
2915 static __inline
2916 LARGE_INTEGER
2917 NTAPI_INLINE
2918 RtlLargeIntegerSubtract(
2919   _In_ LARGE_INTEGER Minuend,
2920   _In_ LARGE_INTEGER Subtrahend)
2921 {
2922   LARGE_INTEGER Difference;
2923
2924   Difference.QuadPart = Minuend.QuadPart - Subtrahend.QuadPart;
2925   return Difference;
2926 }
2927
2928 //DECLSPEC_DEPRECATED_DDK
2929 static __inline
2930 LARGE_INTEGER
2931 NTAPI_INLINE
2932 RtlEnlargedUnsignedMultiply(
2933   _In_ ULONG Multiplicand,
2934   _In_ ULONG Multiplier)
2935 {
2936   LARGE_INTEGER ret;
2937   ret.QuadPart = (ULONGLONG)Multiplicand * (ULONGLONG)Multiplier;
2938   return ret;
2939 }
2940
2941 //DECLSPEC_DEPRECATED_DDK
2942 static __inline
2943 LARGE_INTEGER
2944 NTAPI_INLINE
2945 RtlEnlargedIntegerMultiply(
2946   _In_ LONG Multiplicand,
2947   _In_ LONG Multiplier)
2948 {
2949   LARGE_INTEGER ret;
2950   ret.QuadPart = (LONGLONG)Multiplicand * (ULONGLONG)Multiplier;
2951   return ret;
2952 }
2953
2954 _At_(AnsiString->Buffer, _Post_equal_to_(Buffer))
2955 _At_(AnsiString->Length, _Post_equal_to_(0))
2956 _At_(AnsiString->MaximumLength, _Post_equal_to_(BufferSize))
2957 FORCEINLINE
2958 VOID
2959 RtlInitEmptyAnsiString(
2960   _Out_ PANSI_STRING AnsiString,
2961   _Pre_maybenull_ _Pre_readable_size_(BufferSize) __drv_aliasesMem PCHAR Buffer,
2962   _In_ USHORT BufferSize)
2963 {
2964   AnsiString->Length = 0;
2965   AnsiString->MaximumLength = BufferSize;
2966   AnsiString->Buffer = Buffer;
2967 }
2968
2969 _At_(UnicodeString->Buffer, _Post_equal_to_(Buffer))
2970 _At_(UnicodeString->Length, _Post_equal_to_(0))
2971 _At_(UnicodeString->MaximumLength, _Post_equal_to_(BufferSize))
2972 FORCEINLINE
2973 VOID
2974 RtlInitEmptyUnicodeString(
2975     _Out_ PUNICODE_STRING UnicodeString,
2976     _Writable_bytes_(BufferSize)
2977     _When_(BufferSize != 0, _Notnull_)
2978     __drv_aliasesMem PWSTR Buffer,
2979     _In_ USHORT BufferSize)
2980 {
2981     UnicodeString->Length = 0;
2982     UnicodeString->MaximumLength = BufferSize;
2983     UnicodeString->Buffer = Buffer;
2984 }
2985 $endif (_WDMDDK_)
2986
2987 #if defined(_AMD64_) || defined(_IA64_)
2988
2989 $if (_WDMDDK_)
2990
2991 static __inline
2992 LARGE_INTEGER
2993 NTAPI_INLINE
2994 RtlExtendedIntegerMultiply(
2995   _In_ LARGE_INTEGER Multiplicand,
2996   _In_ LONG Multiplier)
2997 {
2998   LARGE_INTEGER ret;
2999   ret.QuadPart = Multiplicand.QuadPart * Multiplier;
3000   return ret;
3001 }
3002
3003 static __inline
3004 LARGE_INTEGER
3005 NTAPI_INLINE
3006 RtlExtendedLargeIntegerDivide(
3007   _In_ LARGE_INTEGER Dividend,
3008   _In_ ULONG Divisor,
3009   _Out_opt_ PULONG Remainder)
3010 {
3011   LARGE_INTEGER ret;
3012   ret.QuadPart = (ULONG64)Dividend.QuadPart / Divisor;
3013   if (Remainder)
3014     *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
3015   return ret;
3016 }
3017
3018 $endif (_WDMDDK_)
3019
3020 $if (_NTDDK_)
3021
3022 //DECLSPEC_DEPRECATED_DDK_WINXP
3023 FORCEINLINE
3024 LARGE_INTEGER
3025 NTAPI_INLINE
3026 RtlLargeIntegerDivide(
3027   _In_ LARGE_INTEGER Dividend,
3028   _In_ LARGE_INTEGER Divisor,
3029   _Out_opt_ PLARGE_INTEGER Remainder)
3030 {
3031   LARGE_INTEGER ret;
3032   ret.QuadPart = Dividend.QuadPart / Divisor.QuadPart;
3033   if (Remainder)
3034     Remainder->QuadPart = Dividend.QuadPart % Divisor.QuadPart;
3035   return ret;
3036 }
3037
3038 #else
3039
3040 #if (NTDDI_VERSION >= NTDDI_WIN2K)
3041 NTSYSAPI
3042 LARGE_INTEGER
3043 NTAPI
3044 RtlLargeIntegerDivide(
3045   _In_ LARGE_INTEGER Dividend,
3046   _In_ LARGE_INTEGER Divisor,
3047   _Out_opt_ PLARGE_INTEGER Remainder);
3048 #endif
3049
3050 $endif (_NTDDK_)
3051
3052 #endif /* defined(_AMD64_) || defined(_IA64_) */
3053
3054 $if (_WDMDDK_)
3055
3056 #if defined(_AMD64_)
3057
3058 #define MultiplyHigh __mulh
3059 #define UnsignedMultiplyHigh __umulh
3060
3061 //DECLSPEC_DEPRECATED_DDK
3062 static __inline
3063 LARGE_INTEGER
3064 NTAPI_INLINE
3065 RtlExtendedMagicDivide(
3066   _In_ LARGE_INTEGER Dividend,
3067   _In_ LARGE_INTEGER MagicDivisor,
3068   _In_ CCHAR ShiftCount)
3069 {
3070   LARGE_INTEGER ret;
3071   ULONG64 ret64;
3072   BOOLEAN Pos;
3073   Pos = (Dividend.QuadPart >= 0);
3074   ret64 = UnsignedMultiplyHigh(Pos ? Dividend.QuadPart : -Dividend.QuadPart,
3075                                MagicDivisor.QuadPart);
3076   ret64 >>= ShiftCount;
3077   ret.QuadPart = Pos ? ret64 : -(LONG64)ret64;
3078   return ret;
3079 }
3080 #endif
3081
3082 //DECLSPEC_DEPRECATED_DDK
3083 static __inline
3084 LARGE_INTEGER
3085 NTAPI_INLINE
3086 RtlLargeIntegerAdd(
3087   _In_ LARGE_INTEGER Addend1,
3088   _In_ LARGE_INTEGER Addend2)
3089 {
3090   LARGE_INTEGER ret;
3091   ret.QuadPart = Addend1.QuadPart + Addend2.QuadPart;
3092   return ret;
3093 }
3094
3095 /* VOID
3096  * RtlLargeIntegerAnd(
3097  *     IN OUT LARGE_INTEGER Result,
3098  *     IN LARGE_INTEGER Source,
3099  *     IN LARGE_INTEGER Mask);
3100  */
3101 #define RtlLargeIntegerAnd(Result, Source, Mask) \
3102     Result.QuadPart = Source.QuadPart & Mask.QuadPart
3103
3104 //DECLSPEC_DEPRECATED_DDK
3105 static __inline
3106 LARGE_INTEGER
3107 NTAPI_INLINE
3108 RtlLargeIntegerArithmeticShift(
3109   _In_ LARGE_INTEGER LargeInteger,
3110   _In_ CCHAR ShiftCount)
3111 {
3112   LARGE_INTEGER ret;
3113   ret.QuadPart = LargeInteger.QuadPart >> ShiftCount;
3114   return ret;
3115 }
3116
3117 /* BOOLEAN
3118  * RtlLargeIntegerEqualTo(
3119  *     IN LARGE_INTEGER  Operand1,
3120  *     IN LARGE_INTEGER  Operand2);
3121  */
3122 #define RtlLargeIntegerEqualTo(X,Y) \
3123     (!(((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)))
3124
3125 FORCEINLINE
3126 PVOID
3127 RtlSecureZeroMemory(
3128   _Out_writes_bytes_all_(Size) PVOID Pointer,
3129   _In_ SIZE_T Size)
3130 {
3131   volatile char* vptr = (volatile char*)Pointer;
3132 #if defined(_M_AMD64)
3133   __stosb((PUCHAR)vptr, 0, Size);
3134 #else
3135   char * endptr = (char *)vptr + Size;
3136   while (vptr < endptr) {
3137     *vptr = 0; vptr++;
3138   }
3139 #endif
3140    return Pointer;
3141 }
3142
3143 #if defined(_M_AMD64)
3144 _Must_inspect_result_
3145 FORCEINLINE
3146 BOOLEAN
3147 RtlCheckBit(
3148   _In_ PRTL_BITMAP BitMapHeader,
3149   _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitPosition)
3150 {
3151   return BitTest64((LONG64 CONST*)BitMapHeader->Buffer, (LONG64)BitPosition);
3152 }
3153 #else
3154 #define RtlCheckBit(BMH,BP) (((((PLONG)(BMH)->Buffer)[(BP)/32]) >> ((BP)%32)) & 0x1)
3155 #endif /* defined(_M_AMD64) */
3156
3157 #define RtlLargeIntegerGreaterThan(X,Y) (                              \
3158     (((X).HighPart == (Y).HighPart) && ((X).LowPart > (Y).LowPart)) || \
3159     ((X).HighPart > (Y).HighPart)                                      \
3160 )
3161
3162 #define RtlLargeIntegerGreaterThanOrEqualTo(X,Y) (                      \
3163     (((X).HighPart == (Y).HighPart) && ((X).LowPart >= (Y).LowPart)) || \
3164     ((X).HighPart > (Y).HighPart)                                       \
3165 )
3166
3167 #define RtlLargeIntegerNotEqualTo(X,Y) (                          \
3168     (((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)) \
3169 )
3170
3171 #define RtlLargeIntegerLessThan(X,Y) (                                 \
3172     (((X).HighPart == (Y).HighPart) && ((X).LowPart < (Y).LowPart)) || \
3173     ((X).HighPart < (Y).HighPart)                                      \
3174 )
3175
3176 #define RtlLargeIntegerLessThanOrEqualTo(X,Y) (                         \
3177     (((X).HighPart == (Y).HighPart) && ((X).LowPart <= (Y).LowPart)) || \
3178     ((X).HighPart < (Y).HighPart)                                       \
3179 )
3180
3181 #define RtlLargeIntegerGreaterThanZero(X) (       \
3182     (((X).HighPart == 0) && ((X).LowPart > 0)) || \
3183     ((X).HighPart > 0 )                           \
3184 )
3185
3186 #define RtlLargeIntegerGreaterOrEqualToZero(X) ( (X).HighPart >= 0 )
3187
3188 #define RtlLargeIntegerEqualToZero(X) ( !((X).LowPart | (X).HighPart) )
3189
3190 #define RtlLargeIntegerNotEqualToZero(X) ( ((X).LowPart | (X).HighPart) )
3191
3192 #define RtlLargeIntegerLessThanZero(X) ( ((X).HighPart < 0) )
3193
3194 #define RtlLargeIntegerLessOrEqualToZero(X) ( ((X).HighPart < 0) || !((X).LowPart | (X).HighPart) )
3195
3196 #endif /* !defined(MIDL_PASS) */
3197
3198 /* Byte Swap Functions */
3199 #define RtlUshortByteSwap(_x) _byteswap_ushort((USHORT)(_x))
3200 #define RtlUlongByteSwap(_x) _byteswap_ulong((_x))
3201 #define RtlUlonglongByteSwap(_x) _byteswap_uint64((_x))
3202
3203 #if defined(_MSC_VER) && !defined(__clang__)
3204 # define __assert_annotationA(msg) __annotation(L"Debug", L"AssertFail", L ## msg)
3205 # define __assert_annotationW(msg) __annotation(L"Debug", L"AssertFail", msg)
3206 #else
3207 # define __assert_annotationA(msg) \
3208     DbgPrint("Assertion failed at %s(%d): %s\n", __FILE__, __LINE__, msg)
3209 # define __assert_annotationW(msg) \
3210     DbgPrint("Assertion failed at %s(%d): %S\n", __FILE__, __LINE__, msg)
3211 #endif
3212
3213 #ifdef _PREFAST_
3214 # define NT_ANALYSIS_ASSUME(_exp) _Analysis_assume_(_exp)
3215 #elif DBG
3216 # define NT_ANALYSIS_ASSUME(_exp) ((void)0)
3217 #else
3218 # define NT_ANALYSIS_ASSUME(_exp) __noop(_exp)
3219 #endif
3220
3221 #define NT_ASSERT_ACTION(exp) \
3222    (NT_ANALYSIS_ASSUME(exp), \
3223    ((!(exp)) ? \
3224       (__assert_annotationA(#exp), \
3225        DbgRaiseAssertionFailure(), FALSE) : TRUE))
3226
3227 #define NT_ASSERTMSG_ACTION(msg, exp) \
3228    (NT_ANALYSIS_ASSUME(exp), \
3229    ((!(exp)) ? \
3230       (__assert_annotationA(msg), \
3231        DbgRaiseAssertionFailure(), FALSE) : TRUE))
3232
3233 #define NT_ASSERTMSGW_ACTION(msg, exp) \
3234    (NT_ANALYSIS_ASSUME(exp), \
3235    ((!(exp)) ? \
3236       (__assert_annotationW(msg), \
3237        DbgRaiseAssertionFailure(), FALSE) : TRUE))
3238
3239 #if DBG
3240
3241 #define RTL_VERIFY(exp) \
3242   ((!(exp)) ? \
3243     RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, NULL ), FALSE : TRUE)
3244
3245 #define RTL_VERIFYMSG(msg, exp) \
3246   ((!(exp)) ? \
3247     RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, (PCHAR)msg ), FALSE : TRUE)
3248
3249 #define RTL_SOFT_VERIFY(exp) \
3250   ((!(exp)) ? \
3251     DbgPrint("%s(%d): Soft assertion failed\n   Expression: %s\n", __FILE__, __LINE__, #exp), FALSE : TRUE)
3252
3253 #define RTL_SOFT_VERIFYMSG(msg, exp) \
3254   ((!(exp)) ? \
3255     DbgPrint("%s(%d): Soft assertion failed\n   Expression: %s\n   Message: %s\n", __FILE__, __LINE__, #exp, (msg)), FALSE : TRUE)
3256
3257 /* The ASSERTs must be cast to void to avoid warnings about unused results. */
3258 #define ASSERT                 (void)RTL_VERIFY
3259 #define ASSERTMSG              (void)RTL_VERIFYMSG
3260 #define RTL_SOFT_ASSERT        (void)RTL_SOFT_VERIFY
3261 #define RTL_SOFT_ASSERTMSG     (void)RTL_SOFT_VERIFYMSG
3262
3263 #define NT_VERIFY              NT_ASSERT_ACTION
3264 #define NT_VERIFYMSG           NT_ASSERTMSG_ACTION
3265 #define NT_VERIFYMSGW          NT_ASSERTMSGW_ACTION
3266
3267 #define NT_ASSERT_ASSUME       (void)NT_ASSERT_ACTION
3268 #define NT_ASSERTMSG_ASSUME    (void)NT_ASSERTMSG_ACTION
3269 #define NT_ASSERTMSGW_ASSUME   (void)NT_ASSERTMSGW_ACTION
3270
3271 #define NT_ASSERT_NOASSUME     (void)NT_ASSERT_ACTION
3272 #define NT_ASSERTMSG_NOASSUME  (void)NT_ASSERTMSG_ACTION
3273 #define NT_ASSERTMSGW_NOASSUME (void)NT_ASSERTMSGW_ACTION
3274
3275 #else /* !DBG */
3276
3277 #define ASSERT(exp)                  ((void)0)
3278 #define ASSERTMSG(msg, exp)          ((void)0)
3279
3280 #define RTL_SOFT_ASSERT(exp)         ((void)0)
3281 #define RTL_SOFT_ASSERTMSG(msg, exp) ((void)0)
3282
3283 #define RTL_VERIFY(exp)              ((exp) ? TRUE : FALSE)
3284 #define RTL_VERIFYMSG(msg, exp)      ((exp) ? TRUE : FALSE)
3285
3286 #define RTL_SOFT_VERIFY(exp)         ((exp) ? TRUE : FALSE)
3287 #define RTL_SOFT_VERIFYMSG(msg, exp) ((exp) ? TRUE : FALSE)
3288
3289 #define NT_VERIFY(exp)          (NT_ANALYSIS_ASSUME(exp), ((exp) ? TRUE : FALSE))
3290 #define NT_VERIFYMSG(msg, exp)  (NT_ANALYSIS_ASSUME(exp), ((exp) ? TRUE : FALSE))
3291 #define NT_VERIFYMSGW(msg, exp) (NT_ANALYSIS_ASSUME(exp), ((exp) ? TRUE : FALSE))
3292
3293 #define NT_ASSERT_ASSUME(exp)          (NT_ANALYSIS_ASSUME(exp), (void)0)
3294 #define NT_ASSERTMSG_ASSUME(msg, exp)  (NT_ANALYSIS_ASSUME(exp), (void)0)
3295 #define NT_ASSERTMSGW_ASSUME(msg, exp) (NT_ANALYSIS_ASSUME(exp), (void)0)
3296
3297 #define NT_ASSERT_NOASSUME(exp)          ((void)0)
3298 #define NT_ASSERTMSG_NOASSUME(msg, exp)  ((void)0)
3299 #define NT_ASSERTMSGW_NOASSUME(msg, exp) ((void)0)
3300
3301 #endif /* DBG */
3302
3303 #define NT_FRE_ASSERT     (void)NT_ASSERT_ACTION
3304 #define NT_FRE_ASSERTMSG  (void)NT_ASSERTMSG_ACTION
3305 #define NT_FRE_ASSERTMSGW (void)NT_ASSERTMSGW_ACTION
3306
3307 #ifdef NT_ASSERT_ALWAYS_ASSUMES
3308 # define NT_ASSERT NT_ASSERT_ASSUME
3309 # define NT_ASSERTMSG NT_ASSERTMSG_ASSUME
3310 # define NT_ASSERTMSGW NT_ASSERTMSGW_ASSUME
3311 #else
3312 # define NT_ASSERT NT_ASSERT_NOASSUME
3313 # define NT_ASSERTMSG NT_ASSERTMSG_NOASSUME
3314 # define NT_ASSERTMSGW NT_ASSERTMSGW_NOASSUME
3315 #endif /* NT_ASSERT_ALWAYS_ASSUMES */
3316
3317 #if defined(_MSC_VER) && (defined(__REACTOS__) || defined(ASSERT_ALWAYS_NT_ASSERT)) && !defined(_BLDR_)
3318 #undef ASSERT
3319 #define ASSERT NT_ASSERT
3320 #undef ASSERTMSG
3321 #define ASSERTMSG NT_ASSERTMSG
3322 #undef ASSERTMSGW
3323 #define ASSERTMSGW NT_ASSERTMSGW
3324 #undef RTL_VERIFY
3325 #define RTL_VERIFY NT_VERIFY
3326 #endif
3327
3328 #define InitializeListHead32(ListHead) (\
3329     (ListHead)->Flink = (ListHead)->Blink = PtrToUlong((ListHead)))
3330
3331 #if !defined(_WINBASE_)
3332
3333 #if defined(_WIN64) && !defined(_NTSYSTEM_) && (defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || !defined(_NTOSP_))
3334
3335 NTKERNELAPI
3336 VOID
3337 InitializeSListHead(
3338   _Out_ PSLIST_HEADER SListHead);
3339
3340 #else /* defined(_WIN64) &&  ... */
3341
3342 /* HACK */
3343 _IRQL_requires_max_(APC_LEVEL)
3344 NTKERNELAPI
3345 DECLSPEC_NORETURN
3346 VOID
3347 NTAPI
3348 ExRaiseStatus(
3349   _In_ NTSTATUS Status);
3350
3351 FORCEINLINE
3352 VOID
3353 InitializeSListHead(
3354   _Out_ PSLIST_HEADER SListHead)
3355 {
3356 #if defined(_WIN64)
3357     if (((ULONG_PTR)SListHead & 0xf) != 0) {
3358         ExRaiseStatus(STATUS_DATATYPE_MISALIGNMENT);
3359     }
3360 #if defined(_IA64_)
3361     SListHead->Region = (ULONG_PTR)SListHead & VRN_MASK;
3362 #else
3363     SListHead->Region = 0;
3364 #endif /* _IA64_ */
3365 #endif /* _WIN64 */
3366     SListHead->Alignment = 0;
3367 }
3368
3369 #endif /* defined(_WIN64) &&  ... */
3370
3371 #ifdef _X86_
3372
3373 NTKERNELAPI
3374 PSLIST_ENTRY
3375 FASTCALL
3376 InterlockedPushEntrySList(
3377   _Inout_ PSLIST_HEADER SListHead,
3378   _Inout_ __drv_aliasesMem PSLIST_ENTRY SListEntry);
3379
3380 NTKERNELAPI
3381 PSLIST_ENTRY
3382 FASTCALL
3383 InterlockedPopEntrySList(
3384   _Inout_ PSLIST_HEADER SListHead);
3385
3386 #define InterlockedFlushSList(SListHead) \
3387     ExInterlockedFlushSList(SListHead)
3388
3389 #else /* !_X86_ */
3390
3391 #define InterlockedPushEntrySList(SListHead, SListEntry) \
3392     ExpInterlockedPushEntrySList(SListHead, SListEntry)
3393
3394 #define InterlockedPopEntrySList(SListHead) \
3395     ExpInterlockedPopEntrySList(SListHead)
3396
3397 #define InterlockedFlushSList(SListHead) \
3398     ExpInterlockedFlushSList(SListHead)
3399
3400 #endif /* _X86_ */
3401
3402 #define QueryDepthSList(SListHead) \
3403     ExQueryDepthSList(SListHead)
3404
3405 #endif /* !defined(_WINBASE_) */
3406
3407 #define RTL_CONTEXT_EX_OFFSET(ContextEx, Chunk) ((ContextEx)->Chunk.Offset)
3408 #define RTL_CONTEXT_EX_LENGTH(ContextEx, Chunk) ((ContextEx)->Chunk.Length)
3409 #define RTL_CONTEXT_EX_CHUNK(Base, Layout, Chunk)       \
3410     ((PVOID)((PCHAR)(Base) + RTL_CONTEXT_EX_OFFSET(Layout, Chunk)))
3411 #define RTL_CONTEXT_OFFSET(Context, Chunk)              \
3412     RTL_CONTEXT_EX_OFFSET((PCONTEXT_EX)(Context + 1), Chunk)
3413 #define RTL_CONTEXT_LENGTH(Context, Chunk)              \
3414     RTL_CONTEXT_EX_LENGTH((PCONTEXT_EX)(Context + 1), Chunk)
3415 #define RTL_CONTEXT_CHUNK(Context, Chunk)               \
3416     RTL_CONTEXT_EX_CHUNK((PCONTEXT_EX)(Context + 1),    \
3417                          (PCONTEXT_EX)(Context + 1),    \
3418                          Chunk)
3419
3420 BOOLEAN
3421 RTLVERLIB_DDI(RtlIsNtDdiVersionAvailable)(
3422   _In_ ULONG Version);
3423
3424 BOOLEAN
3425 RTLVERLIB_DDI(RtlIsServicePackVersionInstalled)(
3426   _In_ ULONG Version);
3427
3428 #ifndef RtlIsNtDdiVersionAvailable
3429 #define RtlIsNtDdiVersionAvailable WdmlibRtlIsNtDdiVersionAvailable
3430 #endif
3431
3432 #ifndef RtlIsServicePackVersionInstalled
3433 #define RtlIsServicePackVersionInstalled WdmlibRtlIsServicePackVersionInstalled
3434 #endif
3435
3436 #define RtlInterlockedSetBits(Flags, Flag) \
3437     InterlockedOr((PLONG)(Flags), Flag)
3438
3439 #define RtlInterlockedAndBits(Flags, Flag) \
3440     InterlockedAnd((PLONG)(Flags), Flag)
3441
3442 #define RtlInterlockedClearBits(Flags, Flag) \
3443     RtlInterlockedAndBits(Flags, ~(Flag))
3444
3445 #define RtlInterlockedXorBits(Flags, Flag) \
3446     InterlockedXor(Flags, Flag)
3447
3448 #define RtlInterlockedSetBitsDiscardReturn(Flags, Flag) \
3449     (VOID) RtlInterlockedSetBits(Flags, Flag)
3450
3451 #define RtlInterlockedAndBitsDiscardReturn(Flags, Flag) \
3452     (VOID) RtlInterlockedAndBits(Flags, Flag)
3453
3454 #define RtlInterlockedClearBitsDiscardReturn(Flags, Flag) \
3455     RtlInterlockedAndBitsDiscardReturn(Flags, ~(Flag))
3456
3457 $endif (_WDMDDK_)
3458
3459 $if (_NTDDK_)
3460
3461 #ifdef RTL_USE_AVL_TABLES
3462
3463 #define RtlInitializeGenericTable               RtlInitializeGenericTableAvl
3464 #define RtlInsertElementGenericTable            RtlInsertElementGenericTableAvl
3465 #define RtlInsertElementGenericTableFull        RtlInsertElementGenericTableFullAvl
3466 #define RtlDeleteElementGenericTable            RtlDeleteElementGenericTableAvl
3467 #define RtlLookupElementGenericTable            RtlLookupElementGenericTableAvl
3468 #define RtlLookupElementGenericTableFull        RtlLookupElementGenericTableFullAvl
3469 #define RtlEnumerateGenericTable                RtlEnumerateGenericTableAvl
3470 #define RtlEnumerateGenericTableWithoutSplaying RtlEnumerateGenericTableWithoutSplayingAvl
3471 #define RtlGetElementGenericTable               RtlGetElementGenericTableAvl
3472 #define RtlNumberGenericTableElements           RtlNumberGenericTableElementsAvl
3473 #define RtlIsGenericTableEmpty                  RtlIsGenericTableEmptyAvl
3474
3475 #endif /* RTL_USE_AVL_TABLES */
3476
3477 #define RtlInitializeSplayLinks(Links) {    \
3478   PRTL_SPLAY_LINKS _SplayLinks;            \
3479   _SplayLinks = (PRTL_SPLAY_LINKS)(Links); \
3480   _SplayLinks->Parent = _SplayLinks;   \
3481   _SplayLinks->LeftChild = NULL;       \
3482   _SplayLinks->RightChild = NULL;      \
3483 }
3484
3485 #define RtlIsLeftChild(Links) \
3486     (RtlLeftChild(RtlParent(Links)) == (PRTL_SPLAY_LINKS)(Links))
3487
3488 #define RtlIsRightChild(Links) \
3489     (RtlRightChild(RtlParent(Links)) == (PRTL_SPLAY_LINKS)(Links))
3490
3491 #define RtlRightChild(Links) \
3492     ((PRTL_SPLAY_LINKS)(Links))->RightChild
3493
3494 #define RtlIsRoot(Links) \
3495     (RtlParent(Links) == (PRTL_SPLAY_LINKS)(Links))
3496
3497 #define RtlLeftChild(Links) \
3498     ((PRTL_SPLAY_LINKS)(Links))->LeftChild
3499
3500 #define RtlParent(Links) \
3501     ((PRTL_SPLAY_LINKS)(Links))->Parent
3502
3503 #define RtlInsertAsLeftChild(ParentLinks,ChildLinks)    \
3504     {                                                   \
3505         PRTL_SPLAY_LINKS _SplayParent;                  \
3506         PRTL_SPLAY_LINKS _SplayChild;                   \
3507         _SplayParent = (PRTL_SPLAY_LINKS)(ParentLinks); \
3508         _SplayChild = (PRTL_SPLAY_LINKS)(ChildLinks);   \
3509         _SplayParent->LeftChild = _SplayChild;          \
3510         _SplayChild->Parent = _SplayParent;             \
3511     }
3512
3513 #define RtlInsertAsRightChild(ParentLinks,ChildLinks)   \
3514     {                                                   \
3515         PRTL_SPLAY_LINKS _SplayParent;                  \
3516         PRTL_SPLAY_LINKS _SplayChild;                   \
3517         _SplayParent = (PRTL_SPLAY_LINKS)(ParentLinks); \
3518         _SplayChild = (PRTL_SPLAY_LINKS)(ChildLinks);   \
3519         _SplayParent->RightChild = _SplayChild;         \
3520         _SplayChild->Parent = _SplayParent;             \
3521     }
3522
3523 #if !defined(MIDL_PASS)
3524
3525 FORCEINLINE
3526 LUID
3527 NTAPI_INLINE
3528 RtlConvertLongToLuid(
3529   _In_ LONG Val)
3530 {
3531   LUID Luid;
3532   LARGE_INTEGER Temp;
3533
3534   Temp.QuadPart = Val;
3535   Luid.LowPart = Temp.u.LowPart;
3536   Luid.HighPart = Temp.u.HighPart;
3537   return Luid;
3538 }
3539
3540 FORCEINLINE
3541 LUID
3542 NTAPI_INLINE
3543 RtlConvertUlongToLuid(
3544   _In_ ULONG Val)
3545 {
3546   LUID Luid;
3547
3548   Luid.LowPart = Val;
3549   Luid.HighPart = 0;
3550   return Luid;
3551 }
3552
3553 #endif /* !defined(MIDL_PASS) */
3554
3555 #if (defined(_M_AMD64) || defined(_M_IA64)) && !defined(_REALLY_GET_CALLERS_CALLER_)
3556 #define RtlGetCallersAddress(CallersAddress, CallersCaller) \
3557     *CallersAddress = (PVOID)_ReturnAddress(); \
3558     *CallersCaller = NULL;
3559 #else
3560 #if (NTDDI_VERSION >= NTDDI_WIN2K)
3561 NTSYSAPI
3562 VOID
3563 NTAPI
3564 RtlGetCallersAddress(
3565   _Out_ PVOID *CallersAddress,
3566   _Out_ PVOID *CallersCaller);
3567 #endif
3568 #endif
3569
3570 #if !defined(MIDL_PASS) && !defined(SORTPP_PASS)
3571
3572 #if (NTDDI_VERSION >= NTDDI_WIN7)
3573
3574 FORCEINLINE
3575 VOID
3576 NTAPI
3577 RtlInitHashTableContext(
3578   _Inout_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context)
3579 {
3580   Context->ChainHead = NULL;
3581   Context->PrevLinkage = NULL;
3582 }
3583
3584 FORCEINLINE
3585 VOID
3586 NTAPI
3587 RtlInitHashTableContextFromEnumerator(
3588   _Inout_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context,
3589   _In_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator)
3590 {
3591   Context->ChainHead = Enumerator->ChainHead;
3592   Context->PrevLinkage = Enumerator->HashEntry.Linkage.Blink;
3593 }
3594
3595 FORCEINLINE
3596 VOID
3597 NTAPI
3598 RtlReleaseHashTableContext(
3599   _Inout_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context)
3600 {
3601   UNREFERENCED_PARAMETER(Context);
3602   return;
3603 }
3604
3605 FORCEINLINE
3606 ULONG
3607 NTAPI
3608 RtlTotalBucketsHashTable(
3609   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable)
3610 {
3611   return HashTable->TableSize;
3612 }
3613
3614 FORCEINLINE
3615 ULONG
3616 NTAPI
3617 RtlNonEmptyBucketsHashTable(
3618   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable)
3619 {
3620   return HashTable->NonEmptyBuckets;
3621 }
3622
3623 FORCEINLINE
3624 ULONG
3625 NTAPI
3626 RtlEmptyBucketsHashTable(
3627   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable)
3628 {
3629   return HashTable->TableSize - HashTable->NonEmptyBuckets;
3630 }
3631
3632 FORCEINLINE
3633 ULONG
3634 NTAPI
3635 RtlTotalEntriesHashTable(
3636   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable)
3637 {
3638   return HashTable->NumEntries;
3639 }
3640
3641 FORCEINLINE
3642 ULONG
3643 NTAPI
3644 RtlActiveEnumeratorsHashTable(
3645   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable)
3646 {
3647   return HashTable->NumEnumerators;
3648 }
3649
3650 #endif /* (NTDDI_VERSION >= NTDDI_WIN7) */
3651
3652 #endif /* !defined(MIDL_PASS) && !defined(SORTPP_PASS) */
3653
3654 $endif (_NTDDK_)
3655 $if (_NTIFS_)
3656
3657 #define RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE 1
3658 #define RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING 2
3659
3660 #define RtlUnicodeStringToOemSize(STRING) (NLS_MB_OEM_CODE_PAGE_TAG ?                                \
3661                                            RtlxUnicodeStringToOemSize(STRING) :                      \
3662                                            ((STRING)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \
3663 )
3664
3665 #define RtlOemStringToUnicodeSize(STRING) (                 \
3666     NLS_MB_OEM_CODE_PAGE_TAG ?                              \
3667     RtlxOemStringToUnicodeSize(STRING) :                    \
3668     ((STRING)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR)  \
3669 )
3670
3671 #define RtlOemStringToCountedUnicodeSize(STRING) (                    \
3672     (ULONG)(RtlOemStringToUnicodeSize(STRING) - sizeof(UNICODE_NULL)) \
3673 )
3674
3675 #define RtlOffsetToPointer(B,O) ((PCHAR)(((PCHAR)(B)) + ((ULONG_PTR)(O))))
3676 #define RtlPointerToOffset(B,P) ((ULONG)(((PCHAR)(P)) - ((PCHAR)(B))))
3677 $endif (_NTIFS_)