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