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