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