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