reactos/include/xdk/rtlfuncs.h

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