ReactOS 0.4.15-dev-7670-g69b08be
ldrapi.c
Go to the documentation of this file.
1/*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS NT User Mode Library
4 * FILE: dll/ntdll/ldr/ldrapi.c
5 * PURPOSE: PE Loader Public APIs
6 * PROGRAMMERS: Alex Ionescu (alex@relsoft.net)
7 * Aleksey Bragin (aleksey@reactos.org)
8 */
9
10/* INCLUDES *****************************************************************/
11
12#include <ntdll.h>
13
14#define NDEBUG
15#include <debug.h>
16
17/* GLOBALS *******************************************************************/
18
25
26/* FUNCTIONS *****************************************************************/
27
32 IN PVOID IdPath,
33 IN ULONG IdPathLength,
34 IN PVOID OutDataEntry)
35{
38}
39
43{
46}
47
52 IN HANDLE DllHandle,
54{
57}
58
63 IN PVOID Unknown1,
64 IN PVOID Unknown2,
66{
69}
70
71VOID
75{
77}
78
82{
83 /* ReactOS does not support this */
84 return FALSE;
85}
86
90{
91 /* Generate a cookie */
92 return (((ULONG_PTR)NtCurrentTeb()->RealClientId.UniqueThread & 0xFFF) << 16) |
94}
95
96/*
97 * @implemented
98 */
100NTAPI
104{
106
107 DPRINT("LdrUnlockLoaderLock(%x %Ix)\n", Flags, Cookie);
108
109 /* Check for valid flags */
111 {
112 /* Flags are invalid, check how to fail */
114 {
115 /* The caller wants us to raise status */
117 }
118
119 /* A normal failure */
121 }
122
123 /* If we don't have a cookie, just return */
124 if (!Cookie) return STATUS_SUCCESS;
125
126 /* Validate the cookie */
127 if ((Cookie & 0xF0000000) ||
128 ((Cookie >> 16) ^ (HandleToUlong(NtCurrentTeb()->RealClientId.UniqueThread) & 0xFFF)))
129 {
130 DPRINT1("LdrUnlockLoaderLock() called with an invalid cookie!\n");
131
132 /* Invalid cookie, check how to fail */
134 {
135 /* The caller wants us to raise status */
137 }
138
139 /* A normal failure */
141 }
142
143 /* Ready to release the lock */
145 {
146 /* Do a direct leave */
148 }
149 else
150 {
151 /* Wrap this in SEH, since we're not supposed to raise */
153 {
154 /* Leave the lock */
156 }
158 {
159 /* We should use the LDR Filter instead */
161 }
162 _SEH2_END;
163 }
164
165 /* All done */
166 return Status;
167}
168
169/*
170 * @implemented
171 */
173NTAPI
178{
180 BOOLEAN InInit = LdrpInLdrInit;
181
182 DPRINT("LdrLockLoaderLock(%x %p %p)\n", Flags, Disposition, Cookie);
183
184 /* Zero out the outputs */
186 if (Cookie) *Cookie = 0;
187
188 /* Validate the flags */
191 {
192 /* Flags are invalid, check how to fail */
194 {
195 /* The caller wants us to raise status */
197 }
198
199 /* A normal failure */
201 }
202
203 /* Make sure we got a cookie */
204 if (!Cookie)
205 {
206 /* No cookie check how to fail */
208 {
209 /* The caller wants us to raise status */
211 }
212
213 /* A normal failure */
215 }
216
217 /* If the flag is set, make sure we have a valid pointer to use */
219 {
220 /* No pointer to return the data to */
222 {
223 /* The caller wants us to raise status */
225 }
226
227 /* Fail */
229 }
230
231 /* Return now if we are in the init phase */
232 if (InInit) return STATUS_SUCCESS;
233
234 /* Check what locking semantic to use */
236 {
237 /* Check if we should enter or simply try */
239 {
240 /* Do a try */
242 {
243 /* It's locked */
245 }
246 else
247 {
248 /* It worked */
251 }
252 }
253 else
254 {
255 /* Do a enter */
257
258 /* See if result was requested */
261 }
262 }
263 else
264 {
265 /* Wrap this in SEH, since we're not supposed to raise */
267 {
268 /* Check if we should enter or simply try */
270 {
271 /* Do a try */
273 {
274 /* It's locked */
276 }
277 else
278 {
279 /* It worked */
282 }
283 }
284 else
285 {
286 /* Do an enter */
288
289 /* See if result was requested */
292 }
293 }
295 {
296 /* We should use the LDR Filter instead */
298 }
299 _SEH2_END;
300 }
301
302 /* Return status */
303 return Status;
304}
305
306/*
307 * @implemented
308 */
310NTAPI
314 _In_opt_ PULONG DllCharacteristics,
315 _In_ PUNICODE_STRING DllName,
317{
319 UNICODE_STRING DllString1, DllString2;
320 BOOLEAN RedirectedDll = FALSE;
323 PUNICODE_STRING OldTldDll;
324 PTEB Teb = NtCurrentTeb();
325
326 /* Initialize the strings */
327 RtlInitEmptyUnicodeString(&DllString1, StringBuffer, sizeof(StringBuffer));
328 RtlInitEmptyUnicodeString(&DllString2, NULL, 0);
329
330 /* Check if the SxS Assemblies specify another file */
332 DllName,
334 &DllString1,
335 &DllString2,
336 &DllName,
337 NULL,
338 NULL,
339 NULL);
340
341 /* Check success */
342 if (NT_SUCCESS(Status))
343 {
344 /* Let Ldrp know */
345 RedirectedDll = TRUE;
346 }
348 {
349 /* Unrecoverable SxS failure; did we get a string? */
350 if (DllString2.Buffer) RtlFreeUnicodeString(&DllString2);
351 return Status;
352 }
353
354 /* Lock the loader lock */
356
357 /* Check if there's a TLD DLL being loaded */
358 OldTldDll = LdrpTopLevelDllBeingLoaded;
360 {
361
362 if (OldTldDll)
363 {
364 /* This is a recursive load, do something about it? */
366 {
367 /* Print out debug messages */
368 DPRINT1("[%p, %p] LDR: Recursive DLL Load\n",
371 DPRINT1("[%p, %p] Previous DLL being loaded \"%wZ\"\n",
374 OldTldDll);
375 DPRINT1("[%p, %p] DLL being requested \"%wZ\"\n",
378 DllName);
379
380 /* Was it initializing too? */
382 {
383 DPRINT1("[%p, %p] LDR: No DLL Initializer was running\n",
386 }
387 else
388 {
389 DPRINT1("[%p, %p] DLL whose initializer was currently running \"%wZ\"\n",
393 }
394 }
395 }
396
397 /* Set this one as the TLD DLL being loaded*/
399
400 /* Load the DLL */
401 Status = LdrpLoadDll(RedirectedDll,
403 DllCharacteristics,
404 DllName,
406 TRUE);
407 if (NT_SUCCESS(Status))
408 {
410 }
411 else if ((Status != STATUS_NO_SUCH_FILE) &&
415 {
418 "LDR: %s - failing because LdrpLoadDll(%wZ) returned status %x\n",
420 DllName,
421 Status);
422 }
423 }
425 {
426 /* Restore the old TLD DLL */
427 LdrpTopLevelDllBeingLoaded = OldTldDll;
428
429 /* Release the lock */
431 }
432 _SEH2_END;
433
434 /* Do we have a redirect string? */
435 if (DllString2.Buffer) RtlFreeUnicodeString(&DllString2);
436
437 /* Return */
438 return Status;
439}
440
441/*
442 * @implemented
443 */
445NTAPI
449{
450 PLIST_ENTRY ListHead, NextEntry;
451 PLDR_DATA_TABLE_ENTRY LdrEntry;
452 PIMAGE_NT_HEADERS NtHeader;
453 PPEB_LDR_DATA Ldr = NtCurrentPeb()->Ldr;
454 ULONG_PTR DllBase, DllEnd;
455
456 DPRINT("LdrFindEntryForAddress(Address %p)\n", Address);
457
458 /* Nothing to do */
459 if (!Ldr) return STATUS_NO_MORE_ENTRIES;
460
461 /* Get the current entry */
462 LdrEntry = Ldr->EntryInProgress;
463 if (LdrEntry)
464 {
465 /* Get the NT Headers */
466 NtHeader = RtlImageNtHeader(LdrEntry->DllBase);
467 if (NtHeader)
468 {
469 /* Get the Image Base */
470 DllBase = (ULONG_PTR)LdrEntry->DllBase;
471 DllEnd = DllBase + NtHeader->OptionalHeader.SizeOfImage;
472
473 /* Check if they match */
474 if (((ULONG_PTR)Address >= DllBase) &&
475 ((ULONG_PTR)Address < DllEnd))
476 {
477 /* Return it */
478 *Module = LdrEntry;
479 return STATUS_SUCCESS;
480 }
481 }
482 }
483
484 /* Loop the module list */
485 ListHead = &Ldr->InMemoryOrderModuleList;
486 NextEntry = ListHead->Flink;
487 while (NextEntry != ListHead)
488 {
489 /* Get the entry and NT Headers */
490 LdrEntry = CONTAINING_RECORD(NextEntry, LDR_DATA_TABLE_ENTRY, InMemoryOrderLinks);
491 NtHeader = RtlImageNtHeader(LdrEntry->DllBase);
492 if (NtHeader)
493 {
494 /* Get the Image Base */
495 DllBase = (ULONG_PTR)LdrEntry->DllBase;
496 DllEnd = DllBase + NtHeader->OptionalHeader.SizeOfImage;
497
498 /* Check if they match */
499 if (((ULONG_PTR)Address >= DllBase) &&
500 ((ULONG_PTR)Address < DllEnd))
501 {
502 /* Return it */
503 *Module = LdrEntry;
504 return STATUS_SUCCESS;
505 }
506
507 /* Next Entry */
508 NextEntry = NextEntry->Flink;
509 }
510 }
511
512 /* Nothing found */
515 "LDR: %s() exiting 0x%08lx\n",
519}
520
521/*
522 * @implemented
523 */
525NTAPI
529 _In_opt_ PULONG DllCharacteristics,
530 _In_ PUNICODE_STRING DllName,
531 _Out_opt_ PVOID *DllHandle)
532{
534 PLDR_DATA_TABLE_ENTRY LdrEntry;
535 UNICODE_STRING RedirectName, DllString1, RawDllName;
536 PUNICODE_STRING pRedirectName, CompareName;
537 PWCHAR p1, p2, p3;
538 BOOLEAN Locked, RedirectedDll;
540 ULONG LoadFlag, Length;
541
542 /* Initialize the strings */
543 RtlInitEmptyUnicodeString(&DllString1, NULL, 0);
544 RtlInitEmptyUnicodeString(&RawDllName, NULL, 0);
545 RedirectName = *DllName;
546 pRedirectName = &RedirectName;
547
548 /* Initialize state */
549 RedirectedDll = Locked = FALSE;
550 LdrEntry = NULL;
551 Cookie = 0;
552
553 /* Clear the handle */
554 if (DllHandle) *DllHandle = NULL;
555
556 /* Check for a valid flag combination */
558 (!DllHandle && !(Flags & LDR_GET_DLL_HANDLE_EX_PIN)))
559 {
560 DPRINT1("Flags are invalid or no DllHandle given\n");
562 goto Quickie;
563 }
564
565 /* If not initializing */
566 if (!LdrpInLdrInit)
567 {
568 /* Acquire the lock */
570 if (!NT_SUCCESS(Status)) goto Quickie;
571
572 /* Remember we own it */
573 Locked = TRUE;
574 }
575
576 /* Check if the SxS Assemblies specify another file */
578 pRedirectName,
580 NULL,
581 &DllString1,
582 &pRedirectName,
583 NULL,
584 NULL,
585 NULL);
586
587 /* Check success */
588 if (NT_SUCCESS(Status))
589 {
590 /* Let Ldrp know */
591 RedirectedDll = TRUE;
592 }
594 {
595 /* Unrecoverable SxS failure */
596 goto Quickie;
597 }
598 else
599 {
600 ASSERT(pRedirectName == &RedirectName);
601 }
602
603 /* Set default failure code */
605
606 /* Use the cache if we can */
608 {
609 /* Check if we were redirected */
610 if (RedirectedDll)
611 {
612 /* Check the flag */
614 {
615 goto DontCompare;
616 }
617
618 /* Use the right name */
620 }
621 else
622 {
623 /* Check the flag */
625 {
626 goto DontCompare;
627 }
628
629 /* Use the right name */
631 }
632
633 /* Check if the name matches */
634 if (RtlEqualUnicodeString(pRedirectName,
636 TRUE))
637 {
638 /* Skip the rest */
639 LdrEntry = LdrpGetModuleHandleCache;
640
641 /* Return success */
643 goto Quickie;
644 }
645 }
646
647DontCompare:
648 /* Find the name without the extension */
649 p1 = pRedirectName->Buffer;
650 p2 = NULL;
651 p3 = &p1[pRedirectName->Length / sizeof(WCHAR)];
652 while (p1 != p3)
653 {
654 if (*p1++ == L'.')
655 {
656 p2 = p1;
657 }
658 else if (*p1 == L'\\')
659 {
660 p2 = NULL;
661 }
662 }
663
664 /* Check if no extension was found or if we got a slash */
665 if (!(p2) || (*p2 == L'\\') || (*p2 == L'/'))
666 {
667 /* Check that we have space to add one */
668 Length = pRedirectName->Length +
671 {
672 /* No space to add the extension */
674 goto Quickie;
675 }
676
677 /* Setup the string */
678 RawDllName.MaximumLength = Length;
679 ASSERT(Length >= sizeof(UNICODE_NULL));
680 RawDllName.Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
681 0,
682 RawDllName.MaximumLength);
683 if (!RawDllName.Buffer)
684 {
686 goto Quickie;
687 }
688
689 /* Copy the string and add extension */
690 RtlCopyUnicodeString(&RawDllName, pRedirectName);
692 }
693 else
694 {
695 /* Check if there's something in the name */
696 Length = pRedirectName->Length;
697 if (Length)
698 {
699 /* Check and remove trailing period */
700 if (pRedirectName->Buffer[Length / sizeof(WCHAR) - sizeof(ANSI_NULL)] == '.')
701 {
702 /* Decrease the size */
703 pRedirectName->Length -= sizeof(WCHAR);
704 }
705 }
706
707 /* Setup the string */
708 RawDllName.MaximumLength = pRedirectName->Length + sizeof(WCHAR);
709 RawDllName.Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
710 0,
711 RawDllName.MaximumLength);
712 if (!RawDllName.Buffer)
713 {
715 goto Quickie;
716 }
717
718 /* Copy the string */
719 RtlCopyUnicodeString(&RawDllName, pRedirectName);
720 }
721
722 /* Display debug string */
723 if (ShowSnaps)
724 {
725 DPRINT1("LDR: LdrGetDllHandleEx, searching for %wZ from %ws\n",
726 &RawDllName,
727 DllPath ? ((ULONG_PTR)DllPath == 1 ? L"" : DllPath) : L"");
728 }
729
730 /* Do the lookup */
732 &RawDllName,
733 ((ULONG_PTR)DllPath == 1) ? TRUE : FALSE,
734 RedirectedDll,
735 &LdrEntry))
736 {
737 /* Update cached entry */
738 LdrpGetModuleHandleCache = LdrEntry;
739
740 /* Return success */
742 }
743 else
744 {
745 /* Make sure to NULL this */
746 LdrEntry = NULL;
747 }
748Quickie:
749 /* The success path must have a valid loader entry */
750 ASSERT((LdrEntry != NULL) == NT_SUCCESS(Status));
751
752 /* Check if we got an entry and success */
753 DPRINT("Got LdrEntry->BaseDllName %wZ\n", LdrEntry ? &LdrEntry->BaseDllName : NULL);
754 if ((LdrEntry) && (NT_SUCCESS(Status)))
755 {
756 /* Check if the DLL is locked */
757 if ((LdrEntry->LoadCount != 0xFFFF) &&
759 {
760 /* Check what to do with the load count */
762 {
763 /* Pin it */
764 LdrEntry->LoadCount = 0xFFFF;
765 LoadFlag = LDRP_UPDATE_PIN;
766 }
767 else
768 {
769 /* Increase the load count */
770 LdrEntry->LoadCount++;
771 LoadFlag = LDRP_UPDATE_REFCOUNT;
772 }
773
774 /* Update the load count now */
775 LdrpUpdateLoadCount2(LdrEntry, LoadFlag);
777 }
778
779 /* Check if the caller is requesting the handle */
780 if (DllHandle) *DllHandle = LdrEntry->DllBase;
781 }
782
783 /* Free string if needed */
784 if (DllString1.Buffer) RtlFreeUnicodeString(&DllString1);
785
786 /* Free the raw DLL Name if needed */
787 if (RawDllName.Buffer)
788 {
789 /* Free the heap-allocated buffer */
790 RtlFreeHeap(RtlGetProcessHeap(), 0, RawDllName.Buffer);
791 RawDllName.Buffer = NULL;
792 }
793
794 /* Release lock */
795 if (Locked)
796 {
798 Cookie);
799 }
800
801 /* Return */
802 return Status;
803}
804
805/*
806 * @implemented
807 */
809NTAPI
812 _In_opt_ PULONG DllCharacteristics,
813 _In_ PUNICODE_STRING DllName,
814 _Out_ PVOID *DllHandle)
815{
816 /* Call the newer API */
818 DllPath,
819 DllCharacteristics,
820 DllName,
821 DllHandle);
822}
823
824/*
825 * @implemented
826 */
828NTAPI
832 _In_opt_ _When_(Name == NULL, _In_range_(>, 0)) ULONG Ordinal,
833 _Out_ PVOID *ProcedureAddress)
834{
835 /* Call the internal routine and tell it to execute DllInit */
836 return LdrpGetProcedureAddress(BaseAddress, Name, Ordinal, ProcedureAddress, TRUE);
837}
838
839/*
840 * @implemented
841 */
843NTAPI
848 _Out_ PUSHORT ImageCharacteristics)
849{
850 FILE_STANDARD_INFORMATION FileStandardInfo;
851 PIMAGE_IMPORT_DESCRIPTOR ImportData;
852 PIMAGE_SECTION_HEADER LastSection = NULL;
854 PIMAGE_NT_HEADERS NtHeader;
855 HANDLE SectionHandle;
857 PVOID ViewBase;
858 BOOLEAN Result, NoActualCheck;
860 PVOID ImportName;
861 ULONG Size;
862 DPRINT("LdrVerifyImageMatchesChecksum() called\n");
863
864 /* If the handle has the magic KnownDll flag, skip actual checksums */
865 NoActualCheck = ((ULONG_PTR)FileHandle & 1);
866
867 /* Create the section */
868 Status = NtCreateSection(&SectionHandle,
870 NULL,
871 NULL,
874 FileHandle);
875 if (!NT_SUCCESS(Status))
876 {
877 DPRINT1 ("NtCreateSection() failed (Status 0x%x)\n", Status);
878 return Status;
879 }
880
881 /* Map the section */
882 ViewSize = 0;
883 ViewBase = NULL;
884 Status = NtMapViewOfSection(SectionHandle,
886 &ViewBase,
887 0,
888 0,
889 NULL,
890 &ViewSize,
891 ViewShare,
892 0,
894 if (!NT_SUCCESS(Status))
895 {
896 DPRINT1("NtMapViewOfSection() failed (Status 0x%x)\n", Status);
897 NtClose(SectionHandle);
898 return Status;
899 }
900
901 /* Get the file information */
904 &FileStandardInfo,
907 if (!NT_SUCCESS(Status))
908 {
909 DPRINT1("NtMapViewOfSection() failed (Status 0x%x)\n", Status);
911 NtClose(SectionHandle);
912 return Status;
913 }
914
915 /* Protect with SEH */
917 {
918 /* Check if this is the KnownDll hack */
919 if (NoActualCheck)
920 {
921 /* Don't actually do it */
922 Result = TRUE;
923 }
924 else
925 {
926 /* Verify the checksum */
928 FileStandardInfo.EndOfFile.LowPart,
929 FileStandardInfo.EndOfFile.LowPart);
930 }
931
932 /* Check if a callback was supplied */
933 if ((Result) && (Callback))
934 {
935 /* Get the NT Header */
936 NtHeader = RtlImageNtHeader(ViewBase);
937
938 /* Check if caller requested this back */
939 if (ImageCharacteristics)
940 {
941 /* Return to caller */
942 *ImageCharacteristics = NtHeader->FileHeader.Characteristics;
943 }
944
945 /* Get the Import Directory Data */
946 ImportData = RtlImageDirectoryEntryToData(ViewBase,
947 FALSE,
949 &Size);
950
951 /* Make sure there is one */
952 if (ImportData)
953 {
954 /* Loop the imports */
955 while (ImportData->Name)
956 {
957 /* Get the name */
958 ImportName = RtlImageRvaToVa(NtHeader,
959 ViewBase,
960 ImportData->Name,
961 &LastSection);
962
963 /* Notify the callback */
964 Callback(CallbackContext, ImportName);
965 ImportData++;
966 }
967 }
968 }
969 }
971 {
972 /* Fail the request returning STATUS_IMAGE_CHECKSUM_MISMATCH */
973 Result = FALSE;
974 }
975 _SEH2_END;
976
977 /* Unmap file and close handle */
979 NtClose(SectionHandle);
980
981 /* Return status */
983}
984
986NTAPI
993{
994 PLIST_ENTRY ModuleListHead, InitListHead;
995 PLIST_ENTRY Entry, InitEntry;
996 PLDR_DATA_TABLE_ENTRY Module, InitModule;
999 ULONG UsedSize = FIELD_OFFSET(RTL_PROCESS_MODULES, Modules);
1001 PCHAR p;
1002
1003 DPRINT("LdrQueryProcessModuleInformation() called\n");
1004
1005 /* Acquire loader lock */
1007
1008 _SEH2_TRY
1009 {
1010 /* Check if we were given enough space */
1011 if (Size < UsedSize)
1012 {
1014 }
1015 else
1016 {
1017 ModuleInformation->NumberOfModules = 0;
1018 ModulePtr = &ModuleInformation->Modules[0];
1020 }
1021
1022 /* Traverse the list of modules */
1023 ModuleListHead = &NtCurrentPeb()->Ldr->InLoadOrderModuleList;
1025
1026 while (Entry != ModuleListHead)
1027 {
1028 Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
1029
1030 DPRINT(" Module %wZ\n", &Module->FullDllName);
1031
1032 /* Increase the used size */
1033 UsedSize += sizeof(RTL_PROCESS_MODULE_INFORMATION);
1034
1035 if (UsedSize > Size)
1036 {
1038 }
1039 else
1040 {
1041 ModulePtr->ImageBase = Module->DllBase;
1042 ModulePtr->ImageSize = Module->SizeOfImage;
1043 ModulePtr->Flags = Module->Flags;
1044 ModulePtr->LoadCount = Module->LoadCount;
1045 ModulePtr->MappedBase = NULL;
1046 ModulePtr->InitOrderIndex = 0;
1047 ModulePtr->LoadOrderIndex = ModuleInformation->NumberOfModules;
1048
1049 /* Now get init order index by traversing init list */
1050 InitListHead = &NtCurrentPeb()->Ldr->InInitializationOrderModuleList;
1051 InitEntry = InitListHead->Flink;
1052
1053 while (InitEntry != InitListHead)
1054 {
1055 InitModule = CONTAINING_RECORD(InitEntry, LDR_DATA_TABLE_ENTRY, InInitializationOrderLinks);
1056
1057 /* Increase the index */
1058 ModulePtr->InitOrderIndex++;
1059
1060 /* Quit the loop if our module is found */
1061 if (InitModule == Module) break;
1062
1063 /* Advance to the next entry */
1064 InitEntry = InitEntry->Flink;
1065 }
1066
1067 /* Prepare ANSI string with the module's name */
1068 AnsiString.Length = 0;
1069 AnsiString.MaximumLength = sizeof(ModulePtr->FullPathName);
1070 AnsiString.Buffer = ModulePtr->FullPathName;
1072 &Module->FullDllName,
1073 FALSE);
1074
1075 /* Calculate OffsetToFileName field */
1076 p = strrchr(ModulePtr->FullPathName, '\\');
1077 if (p != NULL)
1078 ModulePtr->OffsetToFileName = p - ModulePtr->FullPathName + 1;
1079 else
1080 ModulePtr->OffsetToFileName = 0;
1081
1082 /* Advance to the next module in the output list */
1083 ModulePtr++;
1084
1085 /* Increase number of modules */
1086 if (ModuleInformation)
1087 ModuleInformation->NumberOfModules++;
1088 }
1089
1090 /* Go to the next entry in the modules list */
1091 Entry = Entry->Flink;
1092 }
1093
1094 /* Set returned size if it was provided */
1095 if (ReturnedSize)
1096 *ReturnedSize = UsedSize;
1097 }
1099 {
1100 /* Ignoring the exception */
1101 } _SEH2_END;
1102
1103 /* Release the lock */
1105
1106 DPRINT("LdrQueryProcessModuleInformation() done\n");
1107
1108 return Status;
1109}
1110
1111/*
1112 * @implemented
1113 */
1115NTAPI
1118 _In_ ULONG Size,
1120{
1121 /* Call Ex version of the API */
1122 return LdrQueryProcessModuleInformationEx(0, 0, ModuleInformation, Size, ReturnedSize);
1123}
1124
1125/*
1126 * @implemented
1127 */
1129NTAPI
1131 _Reserved_ ULONG ReservedFlag,
1134{
1135 PLIST_ENTRY ListHead, ListEntry;
1136 PLDR_DATA_TABLE_ENTRY LdrEntry;
1139 BOOLEAN Stop = FALSE;
1140
1141 /* Check parameters */
1142 if ((ReservedFlag) || !(EnumProc)) return STATUS_INVALID_PARAMETER;
1143
1144 /* Acquire the loader lock */
1146 if (!NT_SUCCESS(Status)) return Status;
1147
1148 /* Loop all the modules and call enum proc */
1149 ListHead = &NtCurrentPeb()->Ldr->InLoadOrderModuleList;
1150 ListEntry = ListHead->Flink;
1151 while (ListHead != ListEntry)
1152 {
1153 /* Get the entry */
1154 LdrEntry = CONTAINING_RECORD(ListEntry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
1155
1156 /* Call the enumeration proc inside SEH */
1157 _SEH2_TRY
1158 {
1159 EnumProc(LdrEntry, Context, &Stop);
1160 }
1162 {
1163 /* Ignoring the exception */
1164 } _SEH2_END;
1165
1166 /* Break if we were asked to stop enumeration */
1167 if (Stop)
1168 {
1169 break;
1170 }
1171
1172 /* Advance to the next module */
1173 ListEntry = ListEntry->Flink;
1174 }
1175
1176 /* Release loader lock */
1179
1180 /* Reset any successful status to STATUS_SUCCESS,
1181 * but leave failure to the caller */
1182 if (NT_SUCCESS(Status))
1184
1185 /* Return any possible failure status */
1186 return Status;
1187}
1188
1189/*
1190 * @implemented
1191 */
1193NTAPI
1196{
1197 PLDR_DATA_TABLE_ENTRY LdrEntry;
1199 BOOLEAN LockHeld;
1201 DPRINT("LdrDisableThreadCalloutsForDll (BaseAddress %p)\n", BaseAddress);
1202
1203 /* Don't do it during shutdown */
1205
1206 /* Check if we should grab the lock */
1207 LockHeld = FALSE;
1208 if (!LdrpInLdrInit)
1209 {
1210 /* Grab the lock */
1212 if (!NT_SUCCESS(Status)) return Status;
1213 LockHeld = TRUE;
1214 }
1215
1216 /* Make sure the DLL is valid and get its entry */
1219 {
1220 /* Get if it has a TLS slot */
1221 if (!LdrEntry->TlsIndex)
1222 {
1223 /* It doesn't, so you're allowed to call this */
1224 LdrEntry->Flags |= LDRP_DONT_CALL_FOR_THREADS;
1226 }
1227 }
1228
1229 /* Check if the lock was held */
1230 if (LockHeld)
1231 {
1232 /* Release it */
1234 }
1235
1236 /* Return the status */
1237 return Status;
1238}
1239
1240/*
1241 * @implemented
1242 */
1244NTAPI
1248{
1249 PLDR_DATA_TABLE_ENTRY LdrEntry;
1253
1254 /* Check for invalid flags */
1255 if (Flags & ~(LDR_ADDREF_DLL_PIN))
1256 {
1257 /* Fail with invalid parameter status if so */
1259 goto quickie;
1260 }
1261
1262 /* Acquire the loader lock if not in init phase */
1263 if (!LdrpInLdrInit)
1264 {
1265 /* Acquire the lock */
1267 if (!NT_SUCCESS(Status)) goto quickie;
1268 Locked = TRUE;
1269 }
1270
1271 /* Get this module's data table entry */
1273 {
1274 if (!LdrEntry)
1275 {
1276 /* Shouldn't happen */
1278 goto quickie;
1279 }
1280
1281 /* If this is not a pinned module */
1282 if (LdrEntry->LoadCount != 0xFFFF)
1283 {
1284 /* Update its load count */
1286 {
1287 /* Pin it by setting load count to -1 */
1288 LdrEntry->LoadCount = 0xFFFF;
1290 }
1291 else
1292 {
1293 /* Increase its load count by one */
1294 LdrEntry->LoadCount++;
1296 }
1297
1298 /* Clear load in progress */
1300 }
1301 }
1302 else
1303 {
1304 /* There was an error getting this module's handle, return invalid param status */
1306 }
1307
1308quickie:
1309 /* Check for error case */
1310 if (!NT_SUCCESS(Status))
1311 {
1312 /* Print debug information */
1313 if ((ShowSnaps) || ((Status != STATUS_NO_SUCH_FILE) &&
1316 {
1317 DPRINT1("LDR: LdrAddRefDll(%p) 0x%08lx\n", BaseAddress, Status);
1318 }
1319 }
1320
1321 /* Release the lock if needed */
1323 return Status;
1324}
1325
1326/*
1327 * @implemented
1328 */
1330NTAPI
1333{
1335 PPEB Peb = NtCurrentPeb();
1336 PLDR_DATA_TABLE_ENTRY LdrEntry, CurrentEntry;
1337 PVOID EntryPoint;
1338 PLIST_ENTRY NextEntry;
1339 LIST_ENTRY UnloadList;
1340 RTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_EXTENDED ActCtx;
1341 PVOID CorImageData;
1342 ULONG ComSectionSize;
1343
1344 /* Get the LDR Lock */
1346
1347 /* Increase the unload count */
1349
1350 /* Skip unload */
1351 if (LdrpShutdownInProgress) goto Quickie;
1352
1353 /* Make sure the DLL is valid and get its entry */
1355 {
1357 goto Quickie;
1358 }
1359
1360 /* Check the current Load Count */
1361 if (LdrEntry->LoadCount != 0xFFFF)
1362 {
1363 /* Decrease it */
1364 LdrEntry->LoadCount--;
1365
1366 /* If it's a dll */
1367 if (LdrEntry->Flags & LDRP_IMAGE_DLL)
1368 {
1369 /* Set up the Act Ctx */
1370 ActCtx.Size = sizeof(ActCtx);
1373
1374 /* Activate the ActCtx */
1376 LdrEntry->EntryPointActivationContext);
1377
1378 /* Update the load count */
1380
1381 /* Release the context */
1383 }
1384 }
1385 else
1386 {
1387 /* The DLL is locked */
1388 goto Quickie;
1389 }
1390
1391 /* Show debug message */
1392 if (ShowSnaps) DPRINT1("LDR: UNINIT LIST\n");
1393
1394 /* Check if this is our only unload and initialize the list if so */
1396
1397 /* Loop the modules to build the list */
1399 while (NextEntry != &Peb->Ldr->InInitializationOrderModuleList)
1400 {
1401 /* Get the entry */
1402 LdrEntry = CONTAINING_RECORD(NextEntry,
1404 InInitializationOrderLinks);
1405 NextEntry = NextEntry->Blink;
1406
1407 /* Remove flag */
1408 LdrEntry->Flags &= ~LDRP_UNLOAD_IN_PROGRESS;
1409
1410 /* If the load count is now 0 */
1411 if (!LdrEntry->LoadCount)
1412 {
1413 /* Show message */
1414 if (ShowSnaps)
1415 {
1416 DPRINT1("(%lu) [%ws] %ws (%lx) deinit %p\n",
1418 LdrEntry->BaseDllName.Buffer,
1419 LdrEntry->FullDllName.Buffer,
1420 (ULONG)LdrEntry->LoadCount,
1421 LdrEntry->EntryPoint);
1422 }
1423
1424 /* Call Shim Engine and notify */
1425 if (g_ShimsEnabled)
1426 {
1428 SE_DllUnloaded(LdrEntry);
1429 }
1430
1431 /* Unlink it */
1432 CurrentEntry = LdrEntry;
1434 RemoveEntryList(&CurrentEntry->InMemoryOrderLinks);
1435 RemoveEntryList(&CurrentEntry->HashLinks);
1436
1437 /* If there's more then one active unload */
1438 if (LdrpActiveUnloadCount > 1)
1439 {
1440 /* Flush the cached DLL handle and clear the list */
1442 CurrentEntry->InMemoryOrderLinks.Flink = NULL;
1443 }
1444
1445 /* Add the entry on the unload list */
1446 InsertTailList(&LdrpUnloadHead, &CurrentEntry->HashLinks);
1447 }
1448 }
1449
1450 /* Only call the entrypoints once */
1451 if (LdrpActiveUnloadCount > 1) goto Quickie;
1452
1453 /* Now loop the unload list and create our own */
1454 InitializeListHead(&UnloadList);
1455 CurrentEntry = NULL;
1456 NextEntry = LdrpUnloadHead.Flink;
1457 while (NextEntry != &LdrpUnloadHead)
1458 {
1459 /* Get the current entry */
1460 LdrEntry = CONTAINING_RECORD(NextEntry, LDR_DATA_TABLE_ENTRY, HashLinks);
1461
1462 LdrpRecordUnloadEvent(LdrEntry);
1463
1464 /* Set the entry and clear it from the list */
1465 CurrentEntry = LdrEntry;
1467 CurrentEntry->InMemoryOrderLinks.Flink = NULL;
1468
1469 /* Move it from the global to the local list */
1470 RemoveEntryList(&CurrentEntry->HashLinks);
1471 InsertTailList(&UnloadList, &CurrentEntry->HashLinks);
1472
1473 /* Get the entrypoint */
1474 EntryPoint = LdrEntry->EntryPoint;
1475
1476 /* Check if we should call it */
1477 if ((EntryPoint) && (LdrEntry->Flags & LDRP_PROCESS_ATTACH_CALLED))
1478 {
1479 /* Show message */
1480 if (ShowSnaps)
1481 {
1482 DPRINT1("LDR: Calling deinit %p\n", EntryPoint);
1483 }
1484
1485 /* Set up the Act Ctx */
1486 ActCtx.Size = sizeof(ActCtx);
1489
1490 /* Activate the ActCtx */
1492 LdrEntry->EntryPointActivationContext);
1493
1494 /* Call the entrypoint */
1495 _SEH2_TRY
1496 {
1498 LdrEntry->DllBase,
1500 NULL);
1501 }
1503 {
1504 DPRINT1("WARNING: Exception 0x%x during LdrpCallInitRoutine(DLL_PROCESS_DETACH) for %wZ\n",
1505 _SEH2_GetExceptionCode(), &LdrEntry->BaseDllName);
1506 }
1507 _SEH2_END;
1508
1509 /* Release the context */
1511 }
1512
1513 /* Remove it from the list */
1514 RemoveEntryList(&CurrentEntry->InLoadOrderLinks);
1515 CurrentEntry = NULL;
1516 NextEntry = LdrpUnloadHead.Flink;
1517 }
1518
1519 /* Now loop our local list */
1520 NextEntry = UnloadList.Flink;
1521 while (NextEntry != &UnloadList)
1522 {
1523 /* Get the entry */
1524 LdrEntry = CONTAINING_RECORD(NextEntry, LDR_DATA_TABLE_ENTRY, HashLinks);
1525 NextEntry = NextEntry->Flink;
1526 CurrentEntry = LdrEntry;
1527
1528 /* Notify Application Verifier */
1530 {
1531 AVrfDllUnloadNotification(LdrEntry);
1532 }
1533
1534 /* Show message */
1535 if (ShowSnaps)
1536 {
1537 DPRINT1("LDR: Unmapping [%ws]\n", LdrEntry->BaseDllName.Buffer);
1538 }
1539
1540 /* Check if this is a .NET executable */
1541 CorImageData = RtlImageDirectoryEntryToData(LdrEntry->DllBase,
1542 TRUE,
1544 &ComSectionSize);
1545 if (CorImageData)
1546 {
1547 /* FIXME */
1548 DPRINT1(".NET Images are not supported yet\n");
1549 }
1550
1551 /* Check if we should unmap*/
1552 if (!(CurrentEntry->Flags & LDR_COR_OWNS_UNMAP))
1553 {
1554 /* Unmap the DLL */
1556 CurrentEntry->DllBase);
1558 }
1559
1560 /* Unload the alternate resource module, if any */
1562
1563 /* FIXME: Send shutdown notification */
1564 //LdrpSendDllNotifications(CurrentEntry, 2, LdrpShutdownInProgress);
1565
1566 /* Check if a Hotpatch is active */
1567 if (LdrEntry->PatchInformation)
1568 {
1569 /* FIXME */
1570 DPRINT1("We don't support Hotpatching yet\n");
1571 }
1572
1573 /* Deallocate the Entry */
1575
1576 /* If this is the cached entry, invalidate it */
1577 if (LdrpGetModuleHandleCache == CurrentEntry)
1578 {
1580 }
1581 }
1582
1583Quickie:
1584 /* Decrease unload count */
1587
1588 /* Return to caller */
1589 return Status;
1590}
1591
1592/*
1593 * @implemented
1594 */
1595BOOLEAN
1596NTAPI
1598{
1599 /* Return the internal global */
1601}
1602
1603/*
1604 * @implemented
1605 */
1607NTAPI
1611 _In_ PUSHORT TypeOffset,
1613{
1615}
1616
1617/* FIXME: Add to ntstatus.mc */
1618#define STATUS_MUI_FILE_NOT_FOUND ((NTSTATUS)0xC00B0001L)
1619
1620/*
1621 * @implemented
1622 */
1624NTAPI
1626 _In_ PVOID Module,
1628{
1629 /* Is MUI Support enabled? */
1631
1634}
1635
1636/*
1637 * @implemented
1638 */
1639BOOLEAN
1640NTAPI
1643{
1645
1646 /* Acquire the loader lock */
1648
1649 /* Check if there's any alternate resources loaded */
1651 {
1653 }
1654
1655 /* Release the loader lock */
1657
1658 /* All done */
1659 return TRUE;
1660}
1661
1662/*
1663 * @unimplemented
1664 */
1665BOOLEAN
1666NTAPI
1668{
1670 return FALSE;
1671}
1672
1673/*
1674 * @unimplemented
1675 * See https://www.kernelmode.info/forum/viewtopic.php?t=991
1676 */
1678NTAPI
1683{
1686}
1687
1688BOOLEAN
1689NTAPI
1691{
1694 if (NT_SUCCESS(Status))
1695 {
1697 {
1700 }
1702 return TRUE;
1703 }
1704 return FALSE;
1705}
1706
1707/* EOF */
NTSTATUS NTAPI NtUnmapViewOfSection(IN HANDLE ProcessHandle, IN PVOID BaseAddress)
Definition: section.c:3848
NTSTATUS NTAPI NtCreateSection(OUT PHANDLE SectionHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN PLARGE_INTEGER MaximumSize OPTIONAL, IN ULONG SectionPageProtection OPTIONAL, IN ULONG AllocationAttributes, IN HANDLE FileHandle OPTIONAL)
Definition: section.c:3441
NTSTATUS NTAPI NtMapViewOfSection(IN HANDLE SectionHandle, IN HANDLE ProcessHandle, IN OUT PVOID *BaseAddress, IN ULONG_PTR ZeroBits, IN SIZE_T CommitSize, IN OUT PLARGE_INTEGER SectionOffset OPTIONAL, IN OUT PSIZE_T ViewSize, IN SECTION_INHERIT InheritDisposition, IN ULONG AllocationType, IN ULONG Protect)
Definition: section.c:3622
#define NtCurrentPeb()
Definition: FLS.c:22
unsigned char BOOLEAN
ULONG ReturnedSize
BOOL CALLBACK EnumProc(_In_ HWND hwnd, _In_ LPARAM lParam)
#define DECLSPEC_HOTPATCH
Definition: _mingw.h:243
#define VOID
Definition: acefi.h:82
LONG NTSTATUS
Definition: precomp.h:26
#define DPRINT1
Definition: precomp.h:8
static BOOL CompareName(LPCWSTR pszName1, LPCWSTR pszName2)
Definition: find.c:72
#define HandleToUlong(h)
Definition: basetsd.h:79
#define UNIMPLEMENTED
Definition: debug.h:115
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
Definition: bufpool.h:45
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES IN DWORD Unknown3
Definition: conport.c:37
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
NTSYSAPI NTSTATUS NTAPI RtlDosApplyFileIsolationRedirection_Ustr(IN ULONG Flags, IN PUNICODE_STRING OriginalName, IN PUNICODE_STRING Extension, IN OUT PUNICODE_STRING StaticString, IN OUT PUNICODE_STRING DynamicString, IN OUT PUNICODE_STRING *NewName, IN PULONG NewFlags, IN PSIZE_T FileNameSize, IN PSIZE_T RequiredLength)
Definition: libsupp.c:818
#define DLL_PROCESS_DETACH
Definition: compat.h:130
#define RtlImageDirectoryEntryToData
Definition: compat.h:809
#define RtlImageRvaToVa
Definition: compat.h:807
#define RtlImageNtHeader
Definition: compat.h:806
#define MAX_PATH
Definition: compat.h:34
PPEB Peb
Definition: dllmain.c:27
@ AnsiString
Definition: dnslib.h:19
@ DPFLTR_LDR_ID
Definition: dpfilter.h:113
#define __FUNCTION__
Definition: types.h:116
#define ULONG_PTR
Definition: config.h:101
#define RemoveEntryList(Entry)
Definition: env_spec_w32.h:986
#define InsertTailList(ListHead, Entry)
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ProcessId
Definition: fatprocs.h:2711
#define _SEH2_FINALLY
Definition: filesup.c:21
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
_Must_inspect_result_ _In_opt_ PFLT_INSTANCE _Out_ PHANDLE FileHandle
Definition: fltkernel.h:1231
Status
Definition: gdiplustypes.h:25
GLfloat GLfloat p
Definition: glext.h:8902
@ Unknown
Definition: i8042prt.h:114
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define FLG_HEAP_ENABLE_TAIL_CHECK
Definition: pstypes.h:60
NTSYSAPI BOOLEAN WINAPI RtlDllShutdownInProgress(void)
Definition: ldrapi.c:1597
long __cdecl _InterlockedIncrement(_Interlocked_operand_ long volatile *_Addend)
#define NtCurrentTeb
LIST_ENTRY * ModuleListHead
Definition: kdpacket.c:23
LONG LdrpLoaderLockAcquisitionCount
Definition: ldrapi.c:20
NTSTATUS NTAPI LdrGetDllHandle(_In_opt_ PWSTR DllPath, _In_opt_ PULONG DllCharacteristics, _In_ PUNICODE_STRING DllName, _Out_ PVOID *DllHandle)
Definition: ldrapi.c:810
NTSTATUS NTAPI LdrUnloadDll(_In_ PVOID BaseAddress)
Definition: ldrapi.c:1331
NTSTATUS NTAPI LdrAccessOutOfProcessResource(IN PVOID Unknown, IN PVOID Image, IN PVOID Unknown1, IN PVOID Unknown2, IN PVOID Unknown3)
Definition: ldrapi.c:61
NTSTATUS NTAPI LdrFindCreateProcessManifest(IN ULONG Flags, IN PVOID Image, IN PVOID IdPath, IN ULONG IdPathLength, IN PVOID OutDataEntry)
Definition: ldrapi.c:30
#define STATUS_MUI_FILE_NOT_FOUND
Definition: ldrapi.c:1618
NTSTATUS NTAPI LdrQueryProcessModuleInformationEx(_In_opt_ ULONG ProcessId, _Reserved_ ULONG Reserved, _Out_writes_bytes_to_(Size, *ReturnedSize) PRTL_PROCESS_MODULES ModuleInformation, _In_ ULONG Size, _Out_opt_ PULONG ReturnedSize)
Definition: ldrapi.c:987
NTSTATUS NTAPI LdrLoadAlternateResourceModule(_In_ PVOID Module, _In_ PWSTR Buffer)
Definition: ldrapi.c:1625
NTSTATUS NTAPI LdrVerifyImageMatchesChecksum(_In_ HANDLE FileHandle, _In_ PLDR_CALLBACK Callback, _In_ PVOID CallbackContext, _Out_ PUSHORT ImageCharacteristics)
Definition: ldrapi.c:844
UNICODE_STRING LdrApiDefaultExtension
Definition: ldrapi.c:22
VOID NTAPI LdrSetDllManifestProber(_In_ PLDR_MANIFEST_PROBER_ROUTINE Routine)
Definition: ldrapi.c:73
NTSTATUS NTAPI LdrDisableThreadCalloutsForDll(_In_ PVOID BaseAddress)
Definition: ldrapi.c:1194
BOOLEAN NTAPI LdrInitShimEngineDynamic(IN PVOID BaseAddress)
Definition: ldrapi.c:1690
NTSTATUS NTAPI LdrUnlockLoaderLock(_In_ ULONG Flags, _In_opt_ ULONG_PTR Cookie)
Definition: ldrapi.c:101
PLDR_MANIFEST_PROBER_ROUTINE LdrpManifestProberRoutine
Definition: ldrpe.c:18
BOOLEAN LdrpBreakOnRecursiveDllLoads
Definition: ldrapi.c:21
NTSTATUS NTAPI LdrGetDllHandleEx(_In_ ULONG Flags, _In_opt_ PWSTR DllPath, _In_opt_ PULONG DllCharacteristics, _In_ PUNICODE_STRING DllName, _Out_opt_ PVOID *DllHandle)
Definition: ldrapi.c:526
PIMAGE_BASE_RELOCATION NTAPI LdrProcessRelocationBlock(_In_ ULONG_PTR Address, _In_ ULONG Count, _In_ PUSHORT TypeOffset, _In_ LONG_PTR Delta)
Definition: ldrapi.c:1608
NTSTATUS NTAPI DECLSPEC_HOTPATCH LdrLoadDll(_In_opt_ PWSTR SearchPath, _In_opt_ PULONG DllCharacteristics, _In_ PUNICODE_STRING DllName, _Out_ PVOID *BaseAddress)
Definition: ldrapi.c:312
LIST_ENTRY LdrpUnloadHead
Definition: ldrapi.c:19
NTSTATUS NTAPI LdrCreateOutOfProcessImage(IN ULONG Flags, IN HANDLE ProcessHandle, IN HANDLE DllHandle, IN PVOID Unknown3)
Definition: ldrapi.c:50
BOOLEAN NTAPI LdrFlushAlternateResourceModules(VOID)
Definition: ldrapi.c:1667
NTSTATUS NTAPI LdrQueryProcessModuleInformation(_Out_writes_bytes_to_(Size, *ReturnedSize) PRTL_PROCESS_MODULES ModuleInformation, _In_ ULONG Size, _Out_opt_ PULONG ReturnedSize)
Definition: ldrapi.c:1116
NTSTATUS NTAPI LdrDestroyOutOfProcessImage(IN PVOID Image)
Definition: ldrapi.c:42
NTSTATUS NTAPI LdrLockLoaderLock(_In_ ULONG Flags, _Out_opt_ PULONG Disposition, _Out_opt_ PULONG_PTR Cookie)
Definition: ldrapi.c:174
BOOLEAN LdrpShowRecursiveLoads
Definition: ldrapi.c:21
ULONG AlternateResourceModuleCount
Definition: ldrapi.c:23
NTSTATUS NTAPI LdrAddRefDll(_In_ ULONG Flags, _In_ PVOID BaseAddress)
Definition: ldrapi.c:1245
BOOLEAN NTAPI LdrUnloadAlternateResourceModule(_In_ PVOID BaseAddress)
Definition: ldrapi.c:1641
FORCEINLINE ULONG_PTR LdrpMakeCookie(VOID)
Definition: ldrapi.c:89
NTSTATUS NTAPI LdrFindEntryForAddress(_In_ PVOID Address, _Out_ PLDR_DATA_TABLE_ENTRY *Module)
Definition: ldrapi.c:446
NTSTATUS NTAPI LdrGetProcedureAddress(_In_ PVOID BaseAddress, _In_opt_ _When_(Ordinal==0, _Notnull_) PANSI_STRING Name, _In_opt_ _When_(Name==NULL, _In_range_(>, 0)) ULONG Ordinal, _Out_ PVOID *ProcedureAddress)
Definition: ldrapi.c:829
NTSTATUS NTAPI LdrEnumerateLoadedModules(_Reserved_ ULONG ReservedFlag, _In_ PLDR_ENUM_CALLBACK EnumProc, _In_opt_ PVOID Context)
Definition: ldrapi.c:1130
BOOLEAN NTAPI LdrAlternateResourcesEnabled(VOID)
Definition: ldrapi.c:81
NTSTATUS NTAPI LdrSetAppCompatDllRedirectionCallback(_In_ ULONG Flags, _In_ PLDR_APP_COMPAT_DLL_REDIRECTION_CALLBACK_FUNCTION CallbackFunction, _In_opt_ PVOID CallbackData)
Definition: ldrapi.c:1679
PIMAGE_BASE_RELOCATION NTAPI LdrProcessRelocationBlockLongLong(_In_ ULONG_PTR Address, _In_ ULONG Count, _In_ PUSHORT TypeOffset, _In_ LONGLONG Delta)
BOOLEAN NTAPI LdrVerifyMappedImageMatchesChecksum(_In_ PVOID BaseAddress, _In_ SIZE_T NumberOfBytes, _In_ ULONG FileLength)
WCHAR StringBuffer[156]
Definition: ldrinit.c:41
#define LDR_LOCK_LOADER_LOCK_DISPOSITION_LOCK_NOT_ACQUIRED
Definition: ldrtypes.h:93
#define LDR_GET_DLL_HANDLE_EX_UNCHANGED_REFCOUNT
Definition: ldrtypes.h:87
#define LDRP_REDIRECTED
Definition: ldrtypes.h:58
_In_opt_ PVOID _Out_ BOOLEAN * Stop
Definition: ldrtypes.h:241
#define LDR_LOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS
Definition: ldrtypes.h:76
#define LDR_ADDREF_DLL_PIN
Definition: ldrtypes.h:71
#define LDR_COR_OWNS_UNMAP
Definition: ldrtypes.h:53
#define LDR_GET_DLL_HANDLE_EX_PIN
Definition: ldrtypes.h:88
_In_ PCWSTR _Out_ PVOID * ActCtx
Definition: ldrtypes.h:247
#define LDRP_DONT_CALL_FOR_THREADS
Definition: ldrtypes.h:48
#define LDR_LOCK_LOADER_LOCK_FLAG_TRY_ONLY
Definition: ldrtypes.h:77
#define LDR_LOCK_LOADER_LOCK_DISPOSITION_INVALID
Definition: ldrtypes.h:91
#define LDR_LOCK_LOADER_LOCK_DISPOSITION_LOCK_ACQUIRED
Definition: ldrtypes.h:92
LDR_MANIFEST_PROBER_ROUTINE * PLDR_MANIFEST_PROBER_ROUTINE
Definition: ldrtypes.h:248
#define LDRP_IMAGE_DLL
Definition: ldrtypes.h:39
#define LDR_UNLOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS
Definition: ldrtypes.h:82
#define LDRP_PROCESS_ATTACH_CALLED
Definition: ldrtypes.h:49
LDR_ENUM_CALLBACK * PLDR_ENUM_CALLBACK
Definition: ldrtypes.h:242
VOID NTAPI LdrpGetShimEngineInterface()
Definition: ldrutils.c:2717
if(dx< 0)
Definition: linetemp.h:194
#define ASSERT(a)
Definition: mode.c:44
static const char const char * DllPath
Definition: image.c:34
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
#define _Out_opt_
Definition: ms_sal.h:346
#define _Notnull_
Definition: ms_sal.h:658
#define _Out_writes_bytes_to_(size, count)
Definition: ms_sal.h:360
#define _Out_
Definition: ms_sal.h:345
#define _When_(expr, annos)
Definition: ms_sal.h:254
#define _In_
Definition: ms_sal.h:308
#define _In_opt_
Definition: ms_sal.h:309
#define _Reserved_
Definition: ms_sal.h:295
#define _In_range_(lb, ub)
Definition: ms_sal.h:571
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
_In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Reserved_ ULONG _In_opt_ PUNICODE_STRING _In_ ULONG _Out_opt_ PULONG Disposition
Definition: cmfuncs.h:56
#define DPFLTR_WARNING_LEVEL
Definition: kdtypes.h:31
_In_ HANDLE ProcessHandle
Definition: mmfuncs.h:403
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER _Inout_ PSIZE_T ViewSize
Definition: mmfuncs.h:408
#define SEC_COMMIT
Definition: mmtypes.h:100
NTSYSAPI BOOLEAN NTAPI RtlTryEnterCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
NTSYSAPI ULONG __cdecl DbgPrintEx(_In_ ULONG ComponentId, _In_ ULONG Level, _In_z_ _Printf_format_string_ PCSTR Format,...)
NTSYSAPI NTSTATUS NTAPI RtlEnterCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
NTSYSAPI NTSTATUS NTAPI RtlLeaveCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
DECLSPEC_NORETURN NTSYSAPI VOID NTAPI RtlRaiseStatus(_In_ NTSTATUS Status)
struct _RTL_PROCESS_MODULE_INFORMATION RTL_PROCESS_MODULE_INFORMATION
#define RTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_FORMAT_WHISTLER
Definition: rtltypes.h:101
_In_ PMEMORY_AREA _In_ PVOID _In_ BOOLEAN Locked
Definition: newmm.h:209
int Count
Definition: noreturn.cpp:7
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)
#define SECTION_MAP_EXECUTE
Definition: nt_native.h:1290
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToAnsiString(PANSI_STRING DestinationString, PUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString)
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
#define PAGE_EXECUTE
Definition: nt_native.h:1306
NTSYSAPI BOOLEAN NTAPI RtlEqualUnicodeString(PUNICODE_STRING String1, PUNICODE_STRING String2, BOOLEAN CaseInSensitive)
#define NtCurrentProcess()
Definition: nt_native.h:1657
NTSYSAPI NTSTATUS NTAPI NtQueryInformationFile(IN HANDLE hFile, OUT PIO_STATUS_BLOCK pIoStatusBlock, OUT PVOID FileInformationBuffer, IN ULONG FileInformationBufferLength, IN FILE_INFORMATION_CLASS FileInfoClass)
@ ViewShare
Definition: nt_native.h:1278
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3402
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
#define UNICODE_NULL
#define UNICODE_STRING_MAX_BYTES
#define ANSI_NULL
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
BOOLEAN LdrpInLdrInit
Definition: ldrinit.c:30
BOOLEAN LdrpShutdownInProgress
Definition: ldrinit.c:34
BOOLEAN NTAPI LdrpCheckForLoadedDllHandle(IN PVOID Base, OUT PLDR_DATA_TABLE_ENTRY *LdrEntry)
Definition: ldrutils.c:1621
NTSTATUS NTAPI LdrpLoadDll(IN BOOLEAN Redirected, IN PWSTR DllPath OPTIONAL, IN PULONG DllCharacteristics OPTIONAL, IN PUNICODE_STRING DllName, OUT PVOID *BaseAddress, IN BOOLEAN CallInit)
Definition: ldrutils.c:2435
PVOID g_pShimEngineModule
Definition: ldrutils.c:22
VOID NTAPI LdrpUpdateLoadCount2(IN PLDR_DATA_TABLE_ENTRY LdrEntry, IN ULONG Flags)
Definition: ldrutils.c:460
#define LDRP_UPDATE_DEREFCOUNT
Definition: ntdllp.h:16
PLDR_DATA_TABLE_ENTRY LdrpCurrentDllInitializer
Definition: ldrinit.c:43
ULONG LdrpActiveUnloadCount
Definition: ldrinit.c:84
VOID NTAPI LdrpFinalizeAndDeallocateDataTableEntry(IN PLDR_DATA_TABLE_ENTRY Entry)
Definition: ldrutils.c:1598
NTSTATUS(NTAPI * PLDR_APP_COMPAT_DLL_REDIRECTION_CALLBACK_FUNCTION)(_In_ ULONG Flags, _In_ PCWSTR DllName, _In_ PCWSTR DllPath OPTIONAL, _Inout_opt_ PULONG DllCharacteristics, _In_ PVOID CallbackData, _Outptr_ PWSTR *EffectiveDllPath)
Definition: ntdllp.h:34
PLDR_DATA_TABLE_ENTRY LdrpGetModuleHandleCache
Definition: ldrutils.c:19
NTSTATUS NTAPI LdrpGetProcedureAddress(_In_ PVOID BaseAddress, _In_opt_ _When_(Ordinal==0, _Notnull_) PANSI_STRING Name, _In_opt_ _When_(Name==NULL, _In_range_(>, 0)) ULONG Ordinal, _Out_ PVOID *ProcedureAddress, _In_ BOOLEAN ExecuteInit)
Definition: ldrutils.c:2252
BOOLEAN NTAPI LdrpCheckForLoadedDll(IN PWSTR DllPath, IN PUNICODE_STRING DllName, IN BOOLEAN Flag, IN BOOLEAN RedirectedDll, OUT PLDR_DATA_TABLE_ENTRY *LdrEntry)
Definition: ldrutils.c:1979
BOOLEAN NTAPI LdrpCallInitRoutine(IN PDLL_INIT_ROUTINE EntryPoint, IN PVOID BaseAddress, IN ULONG Reason, IN PVOID Context)
Definition: ldrutils.c:100
VOID NTAPI AVrfDllUnloadNotification(IN PLDR_DATA_TABLE_ENTRY LdrEntry)
Definition: verifier.c:328
BOOLEAN ShowSnaps
Definition: ldrinit.c:81
#define LDRP_UPDATE_PIN
Definition: ntdllp.h:17
VOID NTAPI LdrpRecordUnloadEvent(_In_ PLDR_DATA_TABLE_ENTRY LdrEntry)
Definition: trace.c:28
BOOLEAN g_ShimsEnabled
Definition: ldrutils.c:21
RTL_CRITICAL_SECTION LdrpLoaderLock
Definition: ldrinit.c:70
#define LDRP_UPDATE_REFCOUNT
Definition: ntdllp.h:15
PUNICODE_STRING LdrpTopLevelDllBeingLoaded
Definition: ldrinit.c:40
ULONG NTAPI LdrpClearLoadInProgress(VOID)
Definition: ldrutils.c:2669
PVOID g_pfnSE_DllUnloaded
Definition: ldrutils.c:24
PLDR_DATA_TABLE_ENTRY LdrpLoadedDllHandleCache
Definition: ntdllp.h:59
#define IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR
Definition: ntimage.h:489
#define STATUS_INTERNAL_ERROR
Definition: ntstatus.h:465
#define STATUS_IMAGE_CHECKSUM_MISMATCH
Definition: ntstatus.h:677
#define STATUS_DLL_NOT_FOUND
Definition: ntstatus.h:545
#define STATUS_INVALID_PARAMETER_2
Definition: ntstatus.h:476
#define STATUS_NO_MORE_ENTRIES
Definition: ntstatus.h:205
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
#define STATUS_DLL_INIT_FAILED
Definition: ntstatus.h:558
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:239
#define STATUS_INVALID_PARAMETER_1
Definition: ntstatus.h:475
#define STATUS_SXS_KEY_NOT_FOUND
Definition: ntstatus.h:1389
#define STATUS_INVALID_PARAMETER_3
Definition: ntstatus.h:477
#define STATUS_NAME_TOO_LONG
Definition: ntstatus.h:498
#define L(x)
Definition: ntvdm.h:50
#define IMAGE_DIRECTORY_ENTRY_IMPORT
Definition: pedump.c:260
long LONG
Definition: pedump.c:60
static WCHAR Address[46]
Definition: ping.c:68
#define FileStandardInformation
Definition: propsheet.cpp:61
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:159
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
_Check_return_ _CRTIMP _CONST_RETURN char *__cdecl strrchr(_In_z_ const char *_Str, _In_ int _Ch)
PRTL_ACTIVATION_CONTEXT_STACK_FRAME FASTCALL RtlActivateActivationContextUnsafeFast(IN PRTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_EXTENDED Frame, IN PVOID Context)
Definition: actctx.c:5934
PRTL_ACTIVATION_CONTEXT_STACK_FRAME FASTCALL RtlDeactivateActivationContextUnsafeFast(IN PRTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_EXTENDED Frame)
Definition: actctx.c:6011
PVOID NTAPI RtlDecodeSystemPointer(IN PVOID Pointer)
Definition: process.c:439
#define STATUS_SUCCESS
Definition: shellext.h:65
VOID WINAPI SE_DllUnloaded(PLDR_DATA_TABLE_ENTRY LdrEntry)
Definition: shimeng.c:1465
#define DPRINT
Definition: sndvol32.h:71
base of all file and directory entries
Definition: entries.h:83
HANDLE UniqueThread
Definition: compat.h:826
HANDLE UniqueProcess
Definition: compat.h:825
IMAGE_OPTIONAL_HEADER32 OptionalHeader
Definition: ntddk_ex.h:184
IMAGE_FILE_HEADER FileHeader
Definition: ntddk_ex.h:183
Definition: btrfs_drv.h:1876
PACTIVATION_CONTEXT EntryPointActivationContext
Definition: ldrtypes.h:163
USHORT LoadCount
Definition: ntddk_ex.h:208
PVOID EntryPoint
Definition: ntddk_ex.h:203
UNICODE_STRING FullDllName
Definition: btrfs_drv.h:1882
ULONG SizeOfImage
Definition: ldrtypes.h:143
LIST_ENTRY InLoadOrderLinks
Definition: ldrtypes.h:138
LIST_ENTRY InInitializationOrderLinks
Definition: ldrtypes.h:140
PVOID DllBase
Definition: btrfs_drv.h:1880
LIST_ENTRY InMemoryOrderLinks
Definition: btrfs_drv.h:1878
USHORT TlsIndex
Definition: ntddk_ex.h:209
ULONG Flags
Definition: ntddk_ex.h:207
LIST_ENTRY HashLinks
Definition: ldrtypes.h:151
UNICODE_STRING BaseDllName
Definition: ldrtypes.h:145
PVOID PatchInformation
Definition: ldrtypes.h:164
Definition: typedefs.h:120
struct _LIST_ENTRY * Blink
Definition: typedefs.h:122
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
PVOID EntryInProgress
Definition: ldrtypes.h:123
LIST_ENTRY InInitializationOrderModuleList
Definition: ldrtypes.h:122
LIST_ENTRY InMemoryOrderModuleList
Definition: btrfs_drv.h:1895
PVOID LoaderLock
Definition: ntddk_ex.h:295
PPEB_LDR_DATA Ldr
Definition: btrfs_drv.h:1912
ULONG NtGlobalFlag
Definition: ntddk_ex.h:270
Definition: compat.h:836
CLIENT_ID ClientId
Definition: compat.h:839
CLIENT_ID RealClientId
Definition: compat.h:861
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14
uint16_t * PWSTR
Definition: typedefs.h:56
uint32_t * PULONG_PTR
Definition: typedefs.h:65
uint32_t * PULONG
Definition: typedefs.h:59
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
#define NTAPI
Definition: typedefs.h:36
void * PVOID
Definition: typedefs.h:50
ULONG_PTR SIZE_T
Definition: typedefs.h:80
uint16_t * PUSHORT
Definition: typedefs.h:56
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
uint16_t * PWCHAR
Definition: typedefs.h:56
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
char * PCHAR
Definition: typedefs.h:51
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define STATUS_NO_SUCH_FILE
Definition: udferr_usr.h:137
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
#define STATUS_OBJECT_NAME_NOT_FOUND
Definition: udferr_usr.h:149
VOID(NTAPI * PLDR_CALLBACK)(PVOID CallbackContext, PCHAR Name)
Definition: umfuncs.h:217
ULONG LowPart
Definition: typedefs.h:106
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
_In_ WDFINTERRUPT _In_ PFN_WDF_INTERRUPT_SYNCHRONIZE Callback
Definition: wdfinterrupt.h:458
#define FORCEINLINE
Definition: wdftypes.h:67
#define SearchPath
Definition: winbase.h:3835
_Reserved_ PVOID Reserved
Definition: winddi.h:3974
_IRQL_requires_same_ typedef _In_ ULONG _In_ UCHAR _In_ ULONGLONG _In_ ULONGLONG _In_opt_ PEVENT_FILTER_DESCRIPTOR _Inout_opt_ PVOID CallbackContext
Definition: wmitypes.h:60
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
static ULONG Delta
Definition: xboxvideo.c:33
_In_opt_ PVOID _Out_ PLARGE_INTEGER Cookie
Definition: cmfuncs.h:14
_In_ PCALLBACK_FUNCTION CallbackFunction
Definition: exfuncs.h:1034
__wchar_t WCHAR
Definition: xmlstorage.h:180