Split out the resource functions for finer control of debug output.
[reactos.git] / reactos / lib / ntdll / ldr / utils.c
1 /* $Id: utils.c,v 1.58 2002/12/08 15:57:40 robd Exp $
2 *
3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS kernel
5 * FILE: lib/ntdll/ldr/utils.c
6 * PURPOSE: Process startup for PE executables
7 * PROGRAMMERS: Jean Michault
8 * Rex Jolliff (rex@lvcablemodem.com)
9 */
10
11 /*
12 * TODO:
13 * - Fix calling of entry points
14 * - Handle loading flags correctly
15 * - any more ??
16 */
17
18 /* INCLUDES *****************************************************************/
19
20 #include <reactos/config.h>
21 #include <ddk/ntddk.h>
22 #include <windows.h>
23 #include <string.h>
24 #include <wchar.h>
25 #include <ntdll/ldr.h>
26 #include <ntos/minmax.h>
27
28
29 #ifdef DBG_NTDLL_LDR_UTILS
30 #define NDEBUG
31 #endif
32 #include <ntdll/ntdll.h>
33
34 /* PROTOTYPES ****************************************************************/
35
36 static NTSTATUS LdrFindEntryForName(PUNICODE_STRING Name, PLDR_MODULE *Module);
37 static PVOID LdrFixupForward(PCHAR ForwardName);
38 static PVOID LdrGetExportByName(PVOID BaseAddress, PUCHAR SymbolName, USHORT Hint);
39
40
41 /* FUNCTIONS *****************************************************************/
42
43
44 #ifdef DBG
45
46 VOID
47 LdrpLoadUserModuleSymbols(PLDR_MODULE LdrModule)
48 {
49 NtSystemDebugControl(
50 DebugDbgLoadSymbols,
51 (PVOID)LdrModule,
52 0,
53 NULL,
54 0,
55 NULL);
56 }
57
58 #endif /* DBG */
59
60
61 /***************************************************************************
62 * NAME LOCAL
63 * LdrAdjustDllName
64 *
65 * DESCRIPTION
66 * Adjusts the name of a dll to a fully qualified name.
67 *
68 * ARGUMENTS
69 * FullDllName: Pointer to caller supplied storage for the fully
70 * qualified dll name.
71 * DllName: Pointer to the dll name.
72 * BaseName: TRUE: Only the file name is passed to FullDllName
73 * FALSE: The full path is preserved in FullDllName
74 *
75 * RETURN VALUE
76 * None
77 *
78 * REVISIONS
79 *
80 * NOTE
81 * A given path is not affected by the adjustment, but the file
82 * name only:
83 * ntdll --> ntdll.dll
84 * ntdll. --> ntdll
85 * ntdll.xyz --> ntdll.xyz
86 */
87
88 static VOID
89 LdrAdjustDllName (PUNICODE_STRING FullDllName,
90 PUNICODE_STRING DllName,
91 BOOLEAN BaseName)
92 {
93 WCHAR Buffer[MAX_PATH];
94 ULONG Length;
95 PWCHAR Extension;
96 PWCHAR Pointer;
97
98 Length = DllName->Length / sizeof(WCHAR);
99
100 if (BaseName == TRUE)
101 {
102 /* get the base dll name */
103 Pointer = DllName->Buffer + Length;
104 Extension = Pointer;
105
106 do
107 {
108 --Pointer;
109 }
110 while (Pointer >= DllName->Buffer && *Pointer != L'\\' && *Pointer != L'/');
111
112 Pointer++;
113 Length = Extension - Pointer;
114 memmove (Buffer, Pointer, Length * sizeof(WCHAR));
115 Buffer[Length] = L'\0';
116 }
117 else
118 {
119 /* get the full dll name */
120 memmove (Buffer, DllName->Buffer, DllName->Length);
121 Buffer[DllName->Length / sizeof(WCHAR)] = L'\0';
122 }
123
124 /* Build the DLL's absolute name */
125 Extension = wcsrchr (Buffer, L'.');
126 if ((Extension != NULL) && (*Extension == L'.'))
127 {
128 /* with extension - remove dot if it's the last character */
129 if (Buffer[Length - 1] == L'.')
130 Length--;
131 Buffer[Length] = 0;
132 }
133 else
134 {
135 /* name without extension - assume that it is .dll */
136 memmove (Buffer + Length, L".dll", 10);
137 }
138
139 RtlCreateUnicodeString(FullDllName, Buffer);
140 }
141
142 PLDR_MODULE
143 LdrAddModuleEntry(PVOID ImageBase, PIMAGE_NT_HEADERS NTHeaders,
144 PWSTR FullDosName)
145 {
146 PLDR_MODULE Module;
147 Module = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof (LDR_MODULE));
148 assert(Module);
149 Module->BaseAddress = (PVOID)ImageBase;
150 Module->EntryPoint = NTHeaders->OptionalHeader.AddressOfEntryPoint;
151 if (Module->EntryPoint != 0)
152 Module->EntryPoint += (ULONG)Module->BaseAddress;
153 Module->SizeOfImage = NTHeaders->OptionalHeader.SizeOfImage;
154 if (NtCurrentPeb()->Ldr->Initialized == TRUE)
155 {
156 /* loading while app is running */
157 Module->LoadCount = 1;
158 } else {
159 /*
160 * loading while app is initializing
161 * dll must not be unloaded
162 */
163 Module->LoadCount = -1;
164 }
165
166 Module->TlsIndex = 0;
167 Module->CheckSum = NTHeaders->OptionalHeader.CheckSum;
168 Module->TimeDateStamp = NTHeaders->FileHeader.TimeDateStamp;
169
170 RtlCreateUnicodeString (&Module->FullDllName,
171 FullDosName);
172 RtlCreateUnicodeString (&Module->BaseDllName,
173 wcsrchr(FullDosName, L'\\') + 1);
174 DPRINT ("BaseDllName %wZ\n", &Module->BaseDllName);
175
176 /* FIXME: aquire loader lock */
177 InsertTailList(&NtCurrentPeb()->Ldr->InLoadOrderModuleList,
178 &Module->InLoadOrderModuleList);
179 InsertTailList(&NtCurrentPeb()->Ldr->InInitializationOrderModuleList,
180 &Module->InInitializationOrderModuleList);
181 /* FIXME: release loader lock */
182
183 return(Module);
184 }
185
186 /***************************************************************************
187 * NAME EXPORTED
188 * LdrLoadDll
189 *
190 * DESCRIPTION
191 *
192 * ARGUMENTS
193 *
194 * RETURN VALUE
195 *
196 * REVISIONS
197 *
198 * NOTE
199 *
200 */
201
202 NTSTATUS STDCALL
203 LdrLoadDll (IN PWSTR SearchPath OPTIONAL,
204 IN ULONG LoadFlags,
205 IN PUNICODE_STRING Name,
206 OUT PVOID *BaseAddress OPTIONAL)
207 {
208 WCHAR SearchPathBuffer[MAX_PATH];
209 WCHAR FullDosName[MAX_PATH];
210 UNICODE_STRING AdjustedName;
211 UNICODE_STRING FullNtFileName;
212 OBJECT_ATTRIBUTES FileObjectAttributes;
213 char BlockBuffer [1024];
214 PIMAGE_DOS_HEADER DosHeader;
215 NTSTATUS Status;
216 PIMAGE_NT_HEADERS NTHeaders;
217 ULONG ImageSize;
218 ULONG InitialViewSize;
219 PVOID ImageBase;
220 HANDLE FileHandle;
221 HANDLE SectionHandle;
222 PDLLMAIN_FUNC Entrypoint = NULL;
223 PLDR_MODULE Module;
224
225 if (Name == NULL)
226 {
227 *BaseAddress = NtCurrentPeb()->ImageBaseAddress;
228 return STATUS_SUCCESS;
229 }
230
231 *BaseAddress = NULL;
232
233 DPRINT("LdrLoadDll(Name \"%wZ\" BaseAddress %x)\n",
234 Name, BaseAddress);
235
236 /* adjust the full dll name */
237 LdrAdjustDllName (&AdjustedName,
238 Name,
239 FALSE);
240 DPRINT("AdjustedName: %wZ\n", &AdjustedName);
241
242 /*
243 * Test if dll is already loaded.
244 */
245 if (LdrFindEntryForName(&AdjustedName, &Module) == STATUS_SUCCESS)
246 {
247 DPRINT("DLL %wZ already loaded.\n", &AdjustedName);
248 if (Module->LoadCount != -1)
249 Module->LoadCount++;
250 *BaseAddress = Module->BaseAddress;
251 return STATUS_SUCCESS;
252 }
253 DPRINT("Loading \"%wZ\"\n", Name);
254
255 if (SearchPath == NULL)
256 {
257 SearchPath = SearchPathBuffer;
258 wcscpy (SearchPathBuffer, SharedUserData->NtSystemRoot);
259 wcscat (SearchPathBuffer, L"\\system32;");
260 wcscat (SearchPathBuffer, SharedUserData->NtSystemRoot);
261 wcscat (SearchPathBuffer, L";.");
262 }
263
264 DPRINT("SearchPath %S\n", SearchPath);
265
266 if (RtlDosSearchPath_U (SearchPath,
267 AdjustedName.Buffer,
268 NULL,
269 MAX_PATH,
270 FullDosName,
271 NULL) == 0)
272 return STATUS_DLL_NOT_FOUND;
273
274 DPRINT("FullDosName %S\n", FullDosName);
275
276 RtlFreeUnicodeString (&AdjustedName);
277
278 if (!RtlDosPathNameToNtPathName_U (FullDosName,
279 &FullNtFileName,
280 NULL,
281 NULL))
282 return STATUS_DLL_NOT_FOUND;
283
284 DPRINT("FullNtFileName %wZ\n", &FullNtFileName);
285
286 InitializeObjectAttributes(&FileObjectAttributes,
287 &FullNtFileName,
288 0,
289 NULL,
290 NULL);
291
292 DPRINT("Opening dll \"%wZ\"\n", &FullNtFileName);
293
294 Status = ZwOpenFile(&FileHandle,
295 FILE_ALL_ACCESS,
296 &FileObjectAttributes,
297 NULL,
298 0,
299 0);
300 if (!NT_SUCCESS(Status))
301 {
302 DbgPrint("Dll open of %wZ failed: Status = 0x%08x\n",
303 &FullNtFileName, Status);
304 RtlFreeUnicodeString (&FullNtFileName);
305 return Status;
306 }
307 RtlFreeUnicodeString (&FullNtFileName);
308
309 Status = ZwReadFile(FileHandle,
310 0,
311 0,
312 0,
313 0,
314 BlockBuffer,
315 sizeof(BlockBuffer),
316 0,
317 0);
318 if (!NT_SUCCESS(Status))
319 {
320 DPRINT("Dll header read failed: Status = 0x%08x\n", Status);
321 ZwClose(FileHandle);
322 return Status;
323 }
324 /*
325 * Overlay DOS and NT headers structures to the
326 * buffer with DLL's header raw data.
327 */
328 DosHeader = (PIMAGE_DOS_HEADER) BlockBuffer;
329 NTHeaders = (PIMAGE_NT_HEADERS) (BlockBuffer + DosHeader->e_lfanew);
330 /*
331 * Check it is a PE image file.
332 */
333 if ((DosHeader->e_magic != IMAGE_DOS_MAGIC)
334 || (DosHeader->e_lfanew == 0L)
335 || (*(PULONG)(NTHeaders) != IMAGE_PE_MAGIC))
336 {
337 DPRINT("NTDLL format invalid\n");
338 ZwClose(FileHandle);
339
340 return STATUS_UNSUCCESSFUL;
341 }
342
343 ImageBase = (PVOID) NTHeaders->OptionalHeader.ImageBase;
344 ImageSize = NTHeaders->OptionalHeader.SizeOfImage;
345
346 DPRINT("ImageBase 0x%08x\n", ImageBase);
347
348 /*
349 * Create a section for dll.
350 */
351 Status = ZwCreateSection(&SectionHandle,
352 SECTION_ALL_ACCESS,
353 NULL,
354 NULL,
355 PAGE_READWRITE,
356 SEC_COMMIT | SEC_IMAGE,
357 FileHandle);
358 if (!NT_SUCCESS(Status))
359 {
360 DPRINT("NTDLL create section failed: Status = 0x%08x\n", Status);
361 ZwClose(FileHandle);
362 return Status;
363 }
364
365 /*
366 * Map the dll into the process.
367 */
368 InitialViewSize = 0;
369 ImageBase = 0;
370 Status = ZwMapViewOfSection(SectionHandle,
371 NtCurrentProcess(),
372 &ImageBase,
373 0,
374 InitialViewSize,
375 NULL,
376 &InitialViewSize,
377 0,
378 MEM_COMMIT,
379 PAGE_READWRITE);
380 if (!NT_SUCCESS(Status))
381 {
382 DbgPrint("NTDLL.LDR: map view of section failed (Status %x)\n", Status);
383 ZwClose(FileHandle);
384 return(Status);
385 }
386 ZwClose(FileHandle);
387
388 /* relocate dll and fixup import table */
389 if ((NTHeaders->FileHeader.Characteristics & IMAGE_FILE_DLL) ==
390 IMAGE_FILE_DLL)
391 {
392 Entrypoint =
393 (PDLLMAIN_FUNC) LdrPEStartup(ImageBase, SectionHandle, &Module,
394 FullDosName);
395 if (Entrypoint == NULL)
396 {
397 return(STATUS_UNSUCCESSFUL);
398 }
399 }
400
401 #ifdef DBG
402
403 LdrpLoadUserModuleSymbols(Module);
404
405 #endif /* DBG */
406
407 /* initialize dll */
408 if ((NTHeaders->FileHeader.Characteristics & IMAGE_FILE_DLL) ==
409 IMAGE_FILE_DLL)
410 {
411 if (Module->EntryPoint != 0)
412 {
413 Entrypoint = (PDLLMAIN_FUNC)Module->EntryPoint;
414
415 DPRINT("Calling entry point at 0x%08x\n", Entrypoint);
416 if (FALSE == Entrypoint(Module->BaseAddress,
417 DLL_PROCESS_ATTACH,
418 NULL))
419 {
420 DPRINT("NTDLL.LDR: DLL \"%wZ\" failed to initialize\n",
421 &Module->BaseDllName);
422 /* FIXME: should clean up and fail */
423 }
424 else
425 {
426 DPRINT("NTDLL.LDR: DLL \"%wZ\" initialized successfully\n",
427 &Module->BaseDllName);
428 }
429 }
430 else
431 {
432 DPRINT("NTDLL.LDR: Entrypoint is NULL for \"%wZ\"\n",
433 &Module->BaseDllName);
434 }
435 }
436
437 *BaseAddress = Module->BaseAddress;
438 return STATUS_SUCCESS;
439 }
440
441
442 /***************************************************************************
443 * NAME EXPORTED
444 * LdrFindEntryForAddress
445 *
446 * DESCRIPTION
447 *
448 * ARGUMENTS
449 *
450 * RETURN VALUE
451 *
452 * REVISIONS
453 *
454 * NOTE
455 *
456 */
457 NTSTATUS STDCALL
458 LdrFindEntryForAddress(PVOID Address,
459 PLDR_MODULE *Module)
460 {
461 PLIST_ENTRY ModuleListHead;
462 PLIST_ENTRY Entry;
463 PLDR_MODULE ModulePtr;
464
465 DPRINT("NTDLL.LdrFindEntryForAddress(Address %p)\n", Address);
466
467 if (NtCurrentPeb()->Ldr == NULL)
468 return(STATUS_NO_MORE_ENTRIES);
469
470 ModuleListHead = &NtCurrentPeb()->Ldr->InLoadOrderModuleList;
471 Entry = ModuleListHead->Flink;
472 if (Entry == ModuleListHead)
473 return(STATUS_NO_MORE_ENTRIES);
474
475 while (Entry != ModuleListHead)
476 {
477 ModulePtr = CONTAINING_RECORD(Entry, LDR_MODULE, InLoadOrderModuleList);
478
479 DPRINT("Scanning %wZ at %p\n", &ModulePtr->BaseDllName, ModulePtr->BaseAddress);
480
481 if ((Address >= ModulePtr->BaseAddress) &&
482 (Address <= (ModulePtr->BaseAddress + ModulePtr->SizeOfImage)))
483 {
484 *Module = ModulePtr;
485 return(STATUS_SUCCESS);
486 }
487
488 Entry = Entry->Flink;
489 }
490
491 DPRINT("Failed to find module entry.\n");
492
493 return(STATUS_NO_MORE_ENTRIES);
494 }
495
496
497 /***************************************************************************
498 * NAME LOCAL
499 * LdrFindEntryForName
500 *
501 * DESCRIPTION
502 *
503 * ARGUMENTS
504 *
505 * RETURN VALUE
506 *
507 * REVISIONS
508 *
509 * NOTE
510 *
511 */
512 static NTSTATUS
513 LdrFindEntryForName(PUNICODE_STRING Name,
514 PLDR_MODULE *Module)
515 {
516 PLIST_ENTRY ModuleListHead;
517 PLIST_ENTRY Entry;
518 PLDR_MODULE ModulePtr;
519
520 DPRINT("NTDLL.LdrFindEntryForName(Name %wZ)\n", Name);
521
522 if (NtCurrentPeb()->Ldr == NULL)
523 return(STATUS_NO_MORE_ENTRIES);
524
525 ModuleListHead = &NtCurrentPeb()->Ldr->InLoadOrderModuleList;
526 Entry = ModuleListHead->Flink;
527 if (Entry == ModuleListHead)
528 return(STATUS_NO_MORE_ENTRIES);
529
530 // NULL is the current process
531 if (Name == NULL)
532 {
533 *Module = CONTAINING_RECORD(Entry, LDR_MODULE, InLoadOrderModuleList);
534 return(STATUS_SUCCESS);
535 }
536
537 while (Entry != ModuleListHead)
538 {
539 ModulePtr = CONTAINING_RECORD(Entry, LDR_MODULE, InLoadOrderModuleList);
540
541 DPRINT("Scanning %wZ %wZ\n", &ModulePtr->BaseDllName, Name);
542
543 if (RtlCompareUnicodeString(&ModulePtr->BaseDllName, Name, TRUE) == 0)
544 {
545 *Module = ModulePtr;
546 return(STATUS_SUCCESS);
547 }
548
549 Entry = Entry->Flink;
550 }
551
552 DPRINT("Failed to find dll %wZ\n", Name);
553
554 return(STATUS_NO_MORE_ENTRIES);
555 }
556
557 /**********************************************************************
558 * NAME LOCAL
559 * LdrFixupForward
560 *
561 * DESCRIPTION
562 *
563 * ARGUMENTS
564 *
565 * RETURN VALUE
566 *
567 * REVISIONS
568 *
569 * NOTE
570 *
571 */
572 static PVOID
573 LdrFixupForward(PCHAR ForwardName)
574 {
575 CHAR NameBuffer[128];
576 UNICODE_STRING DllName;
577 UNICODE_STRING FunctionName;
578 NTSTATUS Status;
579 PCHAR p;
580 PVOID BaseAddress;
581
582 strcpy(NameBuffer, ForwardName);
583 p = strchr(NameBuffer, '.');
584 if (p != NULL)
585 {
586 *p = 0;
587
588 DPRINT("Dll: %s Function: %s\n", NameBuffer, p+1);
589 RtlCreateUnicodeStringFromAsciiz (&DllName,
590 NameBuffer);
591
592 Status = LdrGetDllHandle (0, 0, &DllName, &BaseAddress);
593 if (!NT_SUCCESS(Status))
594 {
595 Status = LdrLoadDll(NULL,
596 0,
597 &DllName,
598 &BaseAddress);
599 if (!NT_SUCCESS(Status))
600 {
601 DbgPrint("LdrFixupForward: failed to load %wZ\n", &DllName);
602 RtlFreeUnicodeString (&DllName);
603 return NULL;
604 }
605 }
606
607 RtlFreeUnicodeString (&DllName);
608 DPRINT("BaseAddress: %p\n", BaseAddress);
609
610 return LdrGetExportByName(BaseAddress, p+1, -1);
611 }
612
613 return NULL;
614 }
615
616
617 /**********************************************************************
618 * NAME LOCAL
619 * LdrGetExportByOrdinal
620 *
621 * DESCRIPTION
622 *
623 * ARGUMENTS
624 *
625 * RETURN VALUE
626 *
627 * REVISIONS
628 *
629 * NOTE
630 *
631 */
632 static PVOID
633 LdrGetExportByOrdinal (
634 PVOID BaseAddress,
635 ULONG Ordinal
636 )
637 {
638 PIMAGE_EXPORT_DIRECTORY ExportDir;
639 PDWORD * ExFunctions;
640 USHORT * ExOrdinals;
641
642 ExportDir = (PIMAGE_EXPORT_DIRECTORY)
643 RtlImageDirectoryEntryToData (BaseAddress,
644 TRUE,
645 IMAGE_DIRECTORY_ENTRY_EXPORT,
646 NULL);
647
648
649 ExOrdinals = (USHORT *)
650 RVA(
651 BaseAddress,
652 ExportDir->AddressOfNameOrdinals
653 );
654 ExFunctions = (PDWORD *)
655 RVA(
656 BaseAddress,
657 ExportDir->AddressOfFunctions
658 );
659 DbgPrint(
660 "LdrGetExportByOrdinal(Ordinal %d) = %x\n",
661 Ordinal,
662 ExFunctions[ExOrdinals[Ordinal - ExportDir->Base]]
663 );
664 return(ExFunctions[ExOrdinals[Ordinal - ExportDir->Base]]);
665 }
666
667
668 /**********************************************************************
669 * NAME LOCAL
670 * LdrGetExportByName
671 *
672 * DESCRIPTION
673 *
674 * ARGUMENTS
675 *
676 * RETURN VALUE
677 *
678 * REVISIONS
679 *
680 * NOTE
681 *
682 */
683 static PVOID
684 LdrGetExportByName(PVOID BaseAddress,
685 PUCHAR SymbolName,
686 WORD Hint)
687 {
688 PIMAGE_EXPORT_DIRECTORY ExportDir;
689 PDWORD * ExFunctions;
690 PDWORD * ExNames;
691 USHORT * ExOrdinals;
692 ULONG i;
693 PVOID ExName;
694 ULONG Ordinal;
695 PVOID Function;
696 ULONG minn, maxn;
697 ULONG ExportDirSize;
698
699 DPRINT("LdrGetExportByName %x %s %hu\n", BaseAddress, SymbolName, Hint);
700
701 ExportDir = (PIMAGE_EXPORT_DIRECTORY)
702 RtlImageDirectoryEntryToData(BaseAddress,
703 TRUE,
704 IMAGE_DIRECTORY_ENTRY_EXPORT,
705 &ExportDirSize);
706 if (ExportDir == NULL)
707 {
708 DbgPrint("LdrGetExportByName(): no export directory!\n");
709 return NULL;
710 }
711
712 /*
713 * Get header pointers
714 */
715 ExNames = (PDWORD *)RVA(BaseAddress,
716 ExportDir->AddressOfNames);
717 ExOrdinals = (USHORT *)RVA(BaseAddress,
718 ExportDir->AddressOfNameOrdinals);
719 ExFunctions = (PDWORD *)RVA(BaseAddress,
720 ExportDir->AddressOfFunctions);
721
722 /*
723 * Check the hint first
724 */
725 if (Hint < ExportDir->NumberOfFunctions)
726 {
727 ExName = RVA(BaseAddress, ExNames[Hint]);
728 if (strcmp(ExName, SymbolName) == 0)
729 {
730 Ordinal = ExOrdinals[Hint];
731 Function = RVA(BaseAddress, ExFunctions[Ordinal]);
732 if (((ULONG)Function >= (ULONG)ExportDir) &&
733 ((ULONG)Function < (ULONG)ExportDir + (ULONG)ExportDirSize))
734 {
735 DPRINT("Forward: %s\n", (PCHAR)Function);
736 Function = LdrFixupForward((PCHAR)Function);
737 }
738 if (Function != NULL)
739 return Function;
740 }
741 }
742
743 /*
744 * Try a binary search first
745 */
746 minn = 0;
747 maxn = ExportDir->NumberOfFunctions;
748 while (minn <= maxn)
749 {
750 ULONG mid;
751 LONG res;
752
753 mid = (minn + maxn) / 2;
754
755 ExName = RVA(BaseAddress, ExNames[mid]);
756 res = strcmp(ExName, SymbolName);
757 if (res == 0)
758 {
759 Ordinal = ExOrdinals[mid];
760 Function = RVA(BaseAddress, ExFunctions[Ordinal]);
761 if (((ULONG)Function >= (ULONG)ExportDir) &&
762 ((ULONG)Function < (ULONG)ExportDir + (ULONG)ExportDirSize))
763 {
764 DPRINT("Forward: %s\n", (PCHAR)Function);
765 Function = LdrFixupForward((PCHAR)Function);
766 }
767 if (Function != NULL)
768 return Function;
769 }
770 else if (minn == maxn)
771 {
772 DPRINT("LdrGetExportByName(): binary search failed\n");
773 break;
774 }
775 else if (res > 0)
776 {
777 maxn = mid - 1;
778 }
779 else
780 {
781 minn = mid + 1;
782 }
783 }
784
785 /*
786 * Fall back on a linear search
787 */
788 DPRINT("LdrGetExportByName(): Falling back on a linear search of export table\n");
789 for (i = 0; i < ExportDir->NumberOfFunctions; i++)
790 {
791 ExName = RVA(BaseAddress, ExNames[i]);
792 if (strcmp(ExName,SymbolName) == 0)
793 {
794 Ordinal = ExOrdinals[i];
795 Function = RVA(BaseAddress, ExFunctions[Ordinal]);
796 DPRINT("%x %x %x\n", Function, ExportDir, ExportDir + ExportDirSize);
797 if (((ULONG)Function >= (ULONG)ExportDir) &&
798 ((ULONG)Function < (ULONG)ExportDir + (ULONG)ExportDirSize))
799 {
800 DPRINT("Forward: %s\n", (PCHAR)Function);
801 Function = LdrFixupForward((PCHAR)Function);
802 }
803 return Function;
804 }
805 }
806 DbgPrint("LdrGetExportByName(): failed to find %s\n",SymbolName);
807 return NULL;
808 }
809
810
811 /**********************************************************************
812 * NAME LOCAL
813 * LdrPerformRelocations
814 *
815 * DESCRIPTION
816 * Relocate a DLL's memory image.
817 *
818 * ARGUMENTS
819 *
820 * RETURN VALUE
821 *
822 * REVISIONS
823 *
824 * NOTE
825 *
826 */
827 static NTSTATUS LdrPerformRelocations (PIMAGE_NT_HEADERS NTHeaders,
828 PVOID ImageBase)
829 {
830 USHORT NumberOfEntries;
831 PUSHORT pValue16;
832 ULONG RelocationRVA;
833 ULONG Delta32;
834 ULONG Offset;
835 PULONG pValue32;
836 PRELOCATION_DIRECTORY RelocationDir;
837 PRELOCATION_ENTRY RelocationBlock;
838 int i;
839 PIMAGE_DATA_DIRECTORY RelocationDDir;
840 ULONG OldProtect;
841 NTSTATUS Status;
842 PIMAGE_SECTION_HEADER Sections;
843 ULONG MaxExtend;
844 ULONG LastOffset;
845
846 Sections =
847 (PIMAGE_SECTION_HEADER)((PVOID)NTHeaders + sizeof(IMAGE_NT_HEADERS));
848 MaxExtend = 0;
849 for (i = 0; i < NTHeaders->FileHeader.NumberOfSections; i++)
850 {
851 if (!(Sections[i].Characteristics & IMAGE_SECTION_NOLOAD))
852 {
853 ULONG Extend;
854 Extend =
855 (ULONG)(Sections[i].VirtualAddress + Sections[i].Misc.VirtualSize);
856 MaxExtend = max(MaxExtend, Extend);
857 }
858 }
859
860 RelocationDDir =
861 &NTHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];
862 RelocationRVA = RelocationDDir->VirtualAddress;
863
864 if (RelocationRVA)
865 {
866 RelocationDir =
867 (PRELOCATION_DIRECTORY)((PCHAR)ImageBase + RelocationRVA);
868
869 while (RelocationDir->SizeOfBlock)
870 {
871 if (RelocationDir->VirtualAddress > MaxExtend)
872 {
873 RelocationRVA += RelocationDir->SizeOfBlock;
874 RelocationDir =
875 (PRELOCATION_DIRECTORY) (ImageBase + RelocationRVA);
876 continue;
877 }
878
879 Delta32 = (ULONG)(ImageBase - NTHeaders->OptionalHeader.ImageBase);
880 RelocationBlock =
881 (PRELOCATION_ENTRY) (RelocationRVA + ImageBase +
882 sizeof (RELOCATION_DIRECTORY));
883 NumberOfEntries =
884 RelocationDir->SizeOfBlock - sizeof (RELOCATION_DIRECTORY);
885 NumberOfEntries = NumberOfEntries / sizeof (RELOCATION_ENTRY);
886
887 Status = NtProtectVirtualMemory(NtCurrentProcess(),
888 ImageBase +
889 RelocationDir->VirtualAddress,
890 PAGE_SIZE,
891 PAGE_READWRITE,
892 &OldProtect);
893 if (!NT_SUCCESS(Status))
894 {
895 DPRINT1("Failed to unprotect relocation target.\n");
896 return(Status);
897 }
898
899 for (i = 0; i < NumberOfEntries; i++)
900 {
901 Offset = (RelocationBlock[i].TypeOffset & 0xfff);
902 Offset += (ULONG)(RelocationDir->VirtualAddress + ImageBase);
903
904 /*
905 * What kind of relocations should we perform
906 * for the current entry?
907 */
908 switch (RelocationBlock[i].TypeOffset >> 12)
909 {
910 case TYPE_RELOC_ABSOLUTE:
911 break;
912
913 case TYPE_RELOC_HIGH:
914 pValue16 = (PUSHORT)Offset;
915 *pValue16 += Delta32 >> 16;
916 break;
917
918 case TYPE_RELOC_LOW:
919 pValue16 = (PUSHORT)Offset;
920 *pValue16 += Delta32 & 0xffff;
921 break;
922
923 case TYPE_RELOC_HIGHLOW:
924 pValue32 = (PULONG)Offset;
925 *pValue32 += Delta32;
926 break;
927
928 case TYPE_RELOC_HIGHADJ:
929 /* FIXME: do the highadjust fixup */
930 DPRINT("TYPE_RELOC_HIGHADJ fixup not implemented, sorry\n");
931 return(STATUS_UNSUCCESSFUL);
932
933 default:
934 DPRINT("unexpected fixup type\n");
935 return STATUS_UNSUCCESSFUL;
936 }
937 }
938
939 Status = NtProtectVirtualMemory(NtCurrentProcess(),
940 ImageBase +
941 RelocationDir->VirtualAddress,
942 PAGE_SIZE,
943 OldProtect,
944 &OldProtect);
945 if (!NT_SUCCESS(Status))
946 {
947 DPRINT1("Failed to protect relocation target.\n");
948 return(Status);
949 }
950
951 RelocationRVA += RelocationDir->SizeOfBlock;
952 RelocationDir =
953 (PRELOCATION_DIRECTORY) (ImageBase + RelocationRVA);
954 }
955 }
956 return STATUS_SUCCESS;
957 }
958
959
960 /**********************************************************************
961 * NAME LOCAL
962 * LdrFixupImports
963 *
964 * DESCRIPTION
965 * Compute the entry point for every symbol the DLL imports
966 * from other modules.
967 *
968 * ARGUMENTS
969 *
970 * RETURN VALUE
971 *
972 * REVISIONS
973 *
974 * NOTE
975 *
976 */
977 static NTSTATUS LdrFixupImports(PIMAGE_NT_HEADERS NTHeaders,
978 PVOID ImageBase)
979 {
980 PIMAGE_IMPORT_MODULE_DIRECTORY ImportModuleDirectory;
981 ULONG Ordinal;
982 PVOID BaseAddress;
983 NTSTATUS Status;
984 ULONG IATSize;
985
986 DPRINT("LdrFixupImports(NTHeaders %x, ImageBase %x)\n", NTHeaders,
987 ImageBase);
988
989 /*
990 * Process each import module.
991 */
992 ImportModuleDirectory = (PIMAGE_IMPORT_MODULE_DIRECTORY)(
993 ImageBase + NTHeaders->OptionalHeader
994 .DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT]
995 .VirtualAddress);
996 DPRINT("ImportModuleDirectory %x\n", ImportModuleDirectory);
997
998 while (ImportModuleDirectory->dwRVAModuleName)
999 {
1000 PVOID * ImportAddressList;
1001 PULONG FunctionNameList;
1002 UNICODE_STRING DllName;
1003 DWORD pName;
1004 WORD pHint;
1005 PVOID IATBase;
1006 ULONG OldProtect;
1007
1008 DPRINT("ImportModule->Directory->dwRVAModuleName %s\n",
1009 (PCHAR)(ImageBase + ImportModuleDirectory->dwRVAModuleName));
1010
1011 RtlCreateUnicodeStringFromAsciiz (&DllName,
1012 (PCHAR)(ImageBase + ImportModuleDirectory->dwRVAModuleName));
1013
1014 Status = LdrGetDllHandle (0, 0, &DllName, &BaseAddress);
1015 if (!NT_SUCCESS(Status))
1016 {
1017 Status = LdrLoadDll(NULL,
1018 0,
1019 &DllName,
1020 &BaseAddress);
1021 RtlFreeUnicodeString (&DllName);
1022 if (!NT_SUCCESS(Status))
1023 {
1024 DbgPrint("LdrFixupImports:failed to load %s\n"
1025 ,(PCHAR)(ImageBase
1026 + ImportModuleDirectory->dwRVAModuleName));
1027
1028 return Status;
1029 }
1030 }
1031
1032 /*
1033 * Get the import address list.
1034 */
1035 ImportAddressList = (PVOID *)(NTHeaders->OptionalHeader.ImageBase
1036 + ImportModuleDirectory->dwRVAFunctionAddressList);
1037
1038 /*
1039 * Get the list of functions to import.
1040 */
1041 if (ImportModuleDirectory->dwRVAFunctionNameList != 0)
1042 {
1043 FunctionNameList = (PULONG) (
1044 ImageBase
1045 + ImportModuleDirectory->dwRVAFunctionNameList
1046 );
1047 }
1048 else
1049 {
1050 FunctionNameList =
1051 (PULONG)(ImageBase
1052 + ImportModuleDirectory->dwRVAFunctionAddressList);
1053 }
1054
1055 /*
1056 * Get the size of IAT.
1057 */
1058 IATSize = 0;
1059 while (FunctionNameList[IATSize] != 0L)
1060 {
1061 IATSize++;
1062 }
1063
1064 /*
1065 * Unprotect the region we are about to write into.
1066 */
1067 IATBase = (PVOID)ImportAddressList;
1068 Status = NtProtectVirtualMemory(NtCurrentProcess(),
1069 IATBase,
1070 IATSize * sizeof(PVOID*),
1071 PAGE_READWRITE,
1072 &OldProtect);
1073 if (!NT_SUCCESS(Status))
1074 {
1075 DbgPrint("LDR: Failed to unprotect IAT.\n");
1076 return(Status);
1077 }
1078
1079 /*
1080 * Walk through function list and fixup addresses.
1081 */
1082 while (*FunctionNameList != 0L)
1083 {
1084 if ((*FunctionNameList) & 0x80000000)
1085 {
1086 Ordinal = (*FunctionNameList) & 0x7fffffff;
1087 *ImportAddressList =
1088 LdrGetExportByOrdinal(BaseAddress,
1089 Ordinal);
1090 }
1091 else
1092 {
1093 pName = (DWORD) (ImageBase + *FunctionNameList + 2);
1094 pHint = *(PWORD)(ImageBase + *FunctionNameList);
1095
1096 *ImportAddressList =
1097 LdrGetExportByName(BaseAddress, (PUCHAR)pName, pHint);
1098 if ((*ImportAddressList) == NULL)
1099 {
1100 DbgPrint("Failed to import %s\n", pName);
1101 return STATUS_UNSUCCESSFUL;
1102 }
1103 }
1104 ImportAddressList++;
1105 FunctionNameList++;
1106 }
1107
1108 /*
1109 * Protect the region we are about to write into.
1110 */
1111 Status = NtProtectVirtualMemory(NtCurrentProcess(),
1112 IATBase,
1113 IATSize * sizeof(PVOID*),
1114 OldProtect,
1115 &OldProtect);
1116 if (!NT_SUCCESS(Status))
1117 {
1118 DbgPrint("LDR: Failed to protect IAT.\n");
1119 return(Status);
1120 }
1121
1122 ImportModuleDirectory++;
1123 }
1124 return STATUS_SUCCESS;
1125 }
1126
1127
1128 /**********************************************************************
1129 * NAME
1130 * LdrPEStartup
1131 *
1132 * DESCRIPTION
1133 * 1. Map the DLL's sections into memory.
1134 * 2. Relocate, if needed the DLL.
1135 * 3. Fixup any imported symbol.
1136 * 4. Compute the DLL's entry point.
1137 *
1138 * ARGUMENTS
1139 * ImageBase
1140 * Address at which the DLL's image
1141 * is loaded.
1142 *
1143 * SectionHandle
1144 * Handle of the section that contains
1145 * the DLL's image.
1146 *
1147 * RETURN VALUE
1148 * NULL on error; otherwise the entry point
1149 * to call for initializing the DLL.
1150 *
1151 * REVISIONS
1152 *
1153 * NOTE
1154 *
1155 */
1156 PEPFUNC LdrPEStartup (PVOID ImageBase,
1157 HANDLE SectionHandle,
1158 PLDR_MODULE* Module,
1159 PWSTR FullDosName)
1160 {
1161 NTSTATUS Status;
1162 PEPFUNC EntryPoint = NULL;
1163 PIMAGE_DOS_HEADER DosHeader;
1164 PIMAGE_NT_HEADERS NTHeaders;
1165
1166 DPRINT("LdrPEStartup(ImageBase %x SectionHandle %x)\n",
1167 ImageBase, (ULONG)SectionHandle);
1168
1169 /*
1170 * Overlay DOS and WNT headers structures
1171 * to the DLL's image.
1172 */
1173 DosHeader = (PIMAGE_DOS_HEADER) ImageBase;
1174 NTHeaders = (PIMAGE_NT_HEADERS) (ImageBase + DosHeader->e_lfanew);
1175
1176 /*
1177 * If the base address is different from the
1178 * one the DLL is actually loaded, perform any
1179 * relocation.
1180 */
1181 if (ImageBase != (PVOID) NTHeaders->OptionalHeader.ImageBase)
1182 {
1183 DbgPrint("LDR: Performing relocations\n");
1184 Status = LdrPerformRelocations(NTHeaders, ImageBase);
1185 if (!NT_SUCCESS(Status))
1186 {
1187 DbgPrint("LdrPerformRelocations() failed\n");
1188 return NULL;
1189 }
1190 }
1191
1192 if (Module != NULL)
1193 {
1194 *Module = LdrAddModuleEntry(ImageBase, NTHeaders, FullDosName);
1195 }
1196
1197 /*
1198 * If the DLL's imports symbols from other
1199 * modules, fixup the imported calls entry points.
1200 */
1201 if (NTHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT]
1202 .VirtualAddress != 0)
1203 {
1204 DPRINT("About to fixup imports\n");
1205 Status = LdrFixupImports(NTHeaders, ImageBase);
1206 if (!NT_SUCCESS(Status))
1207 {
1208 DbgPrint("LdrFixupImports() failed\n");
1209 return NULL;
1210 }
1211 DPRINT("Fixup done\n");
1212 }
1213
1214 /*
1215 * Compute the DLL's entry point's address.
1216 */
1217 DPRINT("ImageBase = %x\n",(ULONG)ImageBase);
1218 DPRINT("AddressOfEntryPoint = %x\n",(ULONG)NTHeaders->OptionalHeader.AddressOfEntryPoint);
1219 if (NTHeaders->OptionalHeader.AddressOfEntryPoint != 0)
1220 {
1221 EntryPoint = (PEPFUNC) (ImageBase
1222 + NTHeaders->OptionalHeader.AddressOfEntryPoint);
1223 }
1224 DPRINT("LdrPEStartup() = %x\n",EntryPoint);
1225 return EntryPoint;
1226 }
1227
1228
1229 NTSTATUS STDCALL
1230 LdrUnloadDll (IN PVOID BaseAddress)
1231 {
1232 PIMAGE_NT_HEADERS NtHeaders;
1233 PDLLMAIN_FUNC Entrypoint;
1234 PLIST_ENTRY ModuleListHead;
1235 PLIST_ENTRY Entry;
1236 PLDR_MODULE Module;
1237 NTSTATUS Status;
1238
1239 if (BaseAddress == NULL)
1240 return STATUS_SUCCESS;
1241
1242 ModuleListHead = &NtCurrentPeb()->Ldr->InLoadOrderModuleList;
1243 Entry = ModuleListHead->Flink;
1244
1245 while (Entry != ModuleListHead)
1246 {
1247 Module = CONTAINING_RECORD(Entry, LDR_MODULE, InLoadOrderModuleList);
1248 if (Module->BaseAddress == BaseAddress)
1249 {
1250 if (Module->LoadCount == -1)
1251 {
1252 /* never unload this dll */
1253 return STATUS_SUCCESS;
1254 }
1255 else if (Module->LoadCount > 1)
1256 {
1257 Module->LoadCount--;
1258 return STATUS_SUCCESS;
1259 }
1260
1261 NtHeaders = RtlImageNtHeader (Module->BaseAddress);
1262 if ((NtHeaders->FileHeader.Characteristics & IMAGE_FILE_DLL) == IMAGE_FILE_DLL)
1263 {
1264 if (Module->EntryPoint != 0)
1265 {
1266 Entrypoint = (PDLLMAIN_FUNC)Module->EntryPoint;
1267 DPRINT("Calling entry point at 0x%08x\n", Entrypoint);
1268 Entrypoint(Module->BaseAddress,
1269 DLL_PROCESS_DETACH,
1270 NULL);
1271 }
1272 else
1273 {
1274 DPRINT("NTDLL.LDR: Entrypoint is NULL for \n");
1275 }
1276 }
1277 Status = ZwUnmapViewOfSection (NtCurrentProcess (),
1278 Module->BaseAddress);
1279 ZwClose (Module->SectionHandle);
1280
1281 /* remove the module entry from the list */
1282 RtlFreeUnicodeString (&Module->FullDllName);
1283 RtlFreeUnicodeString (&Module->BaseDllName);
1284 RemoveEntryList (Entry);
1285 RtlFreeHeap (RtlGetProcessHeap (), 0, Module);
1286
1287 return Status;
1288 }
1289
1290 Entry = Entry->Flink;
1291 }
1292
1293 DPRINT("NTDLL.LDR: Dll not found\n")
1294
1295 return STATUS_UNSUCCESSFUL;
1296 }
1297
1298 #if 0 /*MOVED_TO_FILE_RES_C*/
1299
1300 NTSTATUS STDCALL
1301 LdrFindResource_U(PVOID BaseAddress,
1302 PLDR_RESOURCE_INFO ResourceInfo,
1303 ULONG Level,
1304 PIMAGE_RESOURCE_DATA_ENTRY *ResourceDataEntry)
1305 {
1306 PIMAGE_RESOURCE_DIRECTORY ResDir;
1307 PIMAGE_RESOURCE_DIRECTORY ResBase;
1308 PIMAGE_RESOURCE_DIRECTORY_ENTRY ResEntry;
1309 NTSTATUS Status = STATUS_SUCCESS;
1310 ULONG EntryCount;
1311 PWCHAR ws;
1312 ULONG i;
1313 ULONG Id;
1314
1315 DPRINT ("LdrFindResource_U()\n");
1316
1317 /* Get the pointer to the resource directory */
1318 ResDir = (PIMAGE_RESOURCE_DIRECTORY)
1319 RtlImageDirectoryEntryToData (BaseAddress,
1320 TRUE,
1321 IMAGE_DIRECTORY_ENTRY_RESOURCE,
1322 &i);
1323 if (ResDir == NULL)
1324 {
1325 return STATUS_RESOURCE_DATA_NOT_FOUND;
1326 }
1327
1328 DPRINT("ResourceDirectory: %x\n", (ULONG)ResDir);
1329
1330 ResBase = ResDir;
1331
1332 /* Let's go into resource tree */
1333 for (i = 0; i < Level; i++)
1334 {
1335 DPRINT("ResDir: %x\n", (ULONG)ResDir);
1336 Id = ((PULONG)ResourceInfo)[i];
1337 EntryCount = ResDir->NumberOfNamedEntries;
1338 ResEntry = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(ResDir + 1);
1339 DPRINT("ResEntry %x\n", (ULONG)ResEntry);
1340 if (Id & 0xFFFF0000)
1341 {
1342 /* Resource name is a unicode string */
1343 for (; EntryCount--; ResEntry++)
1344 {
1345 /* Scan entries for equal name */
1346 if (ResEntry->Name & 0x80000000)
1347 {
1348 ws = (PWCHAR)((ULONG)ResDir + (ResEntry->Name & 0x7FFFFFFF));
1349 if (!wcsncmp((PWCHAR)Id, ws + 1, *ws ) &&
1350 wcslen((PWCHAR)Id) == (int)*ws )
1351 {
1352 goto found;
1353 }
1354 }
1355 }
1356 }
1357 else
1358 {
1359 /* We use ID number instead of string */
1360 ResEntry += EntryCount;
1361 EntryCount = ResDir->NumberOfIdEntries;
1362 for (; EntryCount--; ResEntry++)
1363 {
1364 /* Scan entries for equal name */
1365 if (ResEntry->Name == Id)
1366 {
1367 DPRINT("ID entry found %x\n", Id);
1368 goto found;
1369 }
1370 }
1371 }
1372 DPRINT("Error %lu\n", i);
1373
1374 switch (i)
1375 {
1376 case 0:
1377 return STATUS_RESOURCE_TYPE_NOT_FOUND;
1378
1379 case 1:
1380 return STATUS_RESOURCE_NAME_NOT_FOUND;
1381
1382 case 2:
1383 if (ResDir->NumberOfNamedEntries || ResDir->NumberOfIdEntries)
1384 {
1385 /* Use the first available language */
1386 ResEntry = (IMAGE_RESOURCE_DIRECTORY_ENTRY*)(ResDir + 1);
1387 break;
1388 }
1389 return STATUS_RESOURCE_LANG_NOT_FOUND;
1390
1391 case 3:
1392 return STATUS_RESOURCE_DATA_NOT_FOUND;
1393
1394 default:
1395 return STATUS_INVALID_PARAMETER;
1396 }
1397 found:;
1398 ResDir = (PIMAGE_RESOURCE_DIRECTORY)((ULONG)ResBase +
1399 (ResEntry->OffsetToData & 0x7FFFFFFF));
1400 }
1401 DPRINT("ResourceDataEntry: %x\n", (ULONG)ResDir);
1402
1403 if (ResourceDataEntry)
1404 {
1405 *ResourceDataEntry = (PVOID)ResDir;
1406 }
1407
1408 return Status;
1409 }
1410
1411
1412 NTSTATUS STDCALL
1413 LdrAccessResource(IN PVOID BaseAddress,
1414 IN PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry,
1415 OUT PVOID *Resource OPTIONAL,
1416 OUT PULONG Size OPTIONAL)
1417 {
1418 PIMAGE_SECTION_HEADER Section;
1419 PIMAGE_NT_HEADERS NtHeader;
1420 ULONG SectionRva;
1421 ULONG SectionVa;
1422 ULONG DataSize;
1423 ULONG Offset = 0;
1424 ULONG Data;
1425
1426 Data = (ULONG)RtlImageDirectoryEntryToData (BaseAddress,
1427 TRUE,
1428 IMAGE_DIRECTORY_ENTRY_RESOURCE,
1429 &DataSize);
1430 if (Data == 0)
1431 return STATUS_RESOURCE_DATA_NOT_FOUND;
1432
1433 if ((ULONG)BaseAddress & 1)
1434 {
1435 /* loaded as ordinary file */
1436 NtHeader = RtlImageNtHeader((PVOID)((ULONG)BaseAddress & ~1UL));
1437 Offset = (ULONG)BaseAddress - Data + NtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress;
1438 Section = RtlImageRvaToSection (NtHeader, BaseAddress, NtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress);
1439 if (Section == NULL)
1440 {
1441 return STATUS_RESOURCE_DATA_NOT_FOUND;
1442 }
1443
1444 if (Section->Misc.VirtualSize < ResourceDataEntry->OffsetToData)
1445 {
1446 SectionRva = RtlImageRvaToSection (NtHeader, BaseAddress, ResourceDataEntry->OffsetToData)->VirtualAddress;
1447 SectionVa = RtlImageRvaToVa(NtHeader, BaseAddress, SectionRva, NULL);
1448 Offset = SectionRva - SectionVa + Data - Section->VirtualAddress;
1449 }
1450 }
1451
1452 if (Resource)
1453 {
1454 *Resource = (PVOID)(ResourceDataEntry->OffsetToData - Offset + (ULONG)BaseAddress);
1455 }
1456
1457 if (Size)
1458 {
1459 *Size = ResourceDataEntry->Size;
1460 }
1461
1462 return STATUS_SUCCESS;
1463 }
1464
1465 #endif /*MOVED_TO_FILE_RES_C*/
1466
1467 NTSTATUS STDCALL
1468 LdrDisableThreadCalloutsForDll(IN PVOID BaseAddress)
1469 {
1470 PLIST_ENTRY ModuleListHead;
1471 PLIST_ENTRY Entry;
1472 PLDR_MODULE Module;
1473 NTSTATUS Status;
1474
1475 DPRINT("LdrDisableThreadCalloutsForDll (BaseAddress %x)\n", BaseAddress);
1476
1477 Status = STATUS_DLL_NOT_FOUND;
1478 ModuleListHead = &NtCurrentPeb()->Ldr->InLoadOrderModuleList;
1479 Entry = ModuleListHead->Flink;
1480 while (Entry != ModuleListHead) {
1481 Module = CONTAINING_RECORD(Entry, LDR_MODULE, InLoadOrderModuleList);
1482
1483 DPRINT("BaseDllName %wZ BaseAddress %x\n", &Module->BaseDllName, Module->BaseAddress);
1484
1485 if (Module->BaseAddress == BaseAddress) {
1486 if (Module->TlsIndex == 0) {
1487 Module->Flags |= 0x00040000;
1488 Status = STATUS_SUCCESS;
1489 }
1490 return Status;
1491 }
1492 Entry = Entry->Flink;
1493 }
1494 return Status;
1495 }
1496
1497 #if 0 /*MOVED_TO_FILE_RES_C*/
1498
1499 NTSTATUS STDCALL
1500 LdrFindResourceDirectory_U (IN PVOID BaseAddress,
1501 WCHAR **name,
1502 DWORD level,
1503 OUT PVOID *addr)
1504 {
1505 PIMAGE_RESOURCE_DIRECTORY ResDir;
1506 PIMAGE_RESOURCE_DIRECTORY_ENTRY ResEntry;
1507 ULONG EntryCount;
1508 ULONG i;
1509 NTSTATUS Status = STATUS_SUCCESS;
1510 WCHAR *ws;
1511
1512 /* Get the pointer to the resource directory */
1513 ResDir = (PIMAGE_RESOURCE_DIRECTORY)
1514 RtlImageDirectoryEntryToData (BaseAddress,
1515 TRUE,
1516 IMAGE_DIRECTORY_ENTRY_RESOURCE,
1517 &i);
1518 if (ResDir == NULL)
1519 {
1520 return STATUS_RESOURCE_DATA_NOT_FOUND;
1521 }
1522
1523 /* Let's go into resource tree */
1524 for (i = 0; i < level; i++, name++)
1525 {
1526 EntryCount = ResDir->NumberOfNamedEntries;
1527 ResEntry = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(ResDir + 1);
1528 if ((ULONG)(*name) & 0xFFFF0000)
1529 {
1530 /* Resource name is a unicode string */
1531 for (; EntryCount--; ResEntry++)
1532 {
1533 /* Scan entries for equal name */
1534 if (ResEntry->Name & 0x80000000)
1535 {
1536 ws = (WCHAR*)((ULONG)ResDir + (ResEntry->Name & 0x7FFFFFFF));
1537 if (!wcsncmp( *name, ws + 1, *ws ) && wcslen( *name ) == (int)*ws )
1538 {
1539 goto found;
1540 }
1541 }
1542 }
1543 }
1544 else
1545 {
1546 /* We use ID number instead of string */
1547 ResEntry += EntryCount;
1548 EntryCount = ResDir->NumberOfIdEntries;
1549 for (; EntryCount--; ResEntry++)
1550 {
1551 /* Scan entries for equal name */
1552 if (ResEntry->Name == (ULONG)(*name))
1553 goto found;
1554 }
1555 }
1556
1557 switch (i)
1558 {
1559 case 0:
1560 return STATUS_RESOURCE_TYPE_NOT_FOUND;
1561
1562 case 1:
1563 return STATUS_RESOURCE_NAME_NOT_FOUND;
1564
1565 case 2:
1566 Status = STATUS_RESOURCE_LANG_NOT_FOUND;
1567 /* Just use first language entry */
1568 if (ResDir->NumberOfNamedEntries || ResDir->NumberOfIdEntries)
1569 {
1570 ResEntry = (IMAGE_RESOURCE_DIRECTORY_ENTRY*)(ResDir + 1);
1571 break;
1572 }
1573 return Status;
1574
1575 case 3:
1576 return STATUS_RESOURCE_DATA_NOT_FOUND;
1577
1578 default:
1579 return STATUS_INVALID_PARAMETER;
1580 }
1581 found:;
1582 ResDir = (PIMAGE_RESOURCE_DIRECTORY)((ULONG)ResDir + ResEntry->OffsetToData);
1583 }
1584
1585 if (addr)
1586 {
1587 *addr = (PVOID)ResDir;
1588 }
1589
1590 return Status;
1591 }
1592
1593 #endif /*MOVED_TO_FILE_RES_C*/
1594
1595 NTSTATUS
1596 STDCALL
1597 LdrGetDllHandle(IN ULONG Unknown1,
1598 IN ULONG Unknown2,
1599 IN PUNICODE_STRING DllName,
1600 OUT PVOID* BaseAddress)
1601 {
1602 UNICODE_STRING FullDllName;
1603 PLIST_ENTRY ModuleListHead;
1604 PLIST_ENTRY Entry;
1605 PLDR_MODULE Module;
1606
1607 DPRINT("LdrGetDllHandle (Unknown1 %x Unknown2 %x DllName %wZ BaseAddress %p)\n",
1608 Unknown1, Unknown2, DllName, BaseAddress);
1609
1610 /* NULL is the current executable */
1611 if (DllName == NULL) {
1612 *BaseAddress = NtCurrentPeb()->ImageBaseAddress;
1613 DPRINT("BaseAddress %x\n", *BaseAddress);
1614 return STATUS_SUCCESS;
1615 }
1616 LdrAdjustDllName(&FullDllName, DllName, TRUE);
1617
1618 DPRINT("FullDllName %wZ\n", &FullDllName);
1619
1620 ModuleListHead = &NtCurrentPeb()->Ldr->InLoadOrderModuleList;
1621 Entry = ModuleListHead->Flink;
1622 while (Entry != ModuleListHead) {
1623 Module = CONTAINING_RECORD(Entry, LDR_MODULE, InLoadOrderModuleList);
1624
1625 DPRINT("EntryPoint %x\n", Module->EntryPoint);
1626 DPRINT("Comparing %wZ and %wZ\n", &Module->BaseDllName, &FullDllName);
1627
1628 if (!RtlCompareUnicodeString(&Module->BaseDllName, &FullDllName, TRUE)) {
1629 RtlFreeUnicodeString(&FullDllName);
1630 *BaseAddress = Module->BaseAddress;
1631 DPRINT("BaseAddress %x\n", *BaseAddress);
1632 return STATUS_SUCCESS;
1633 }
1634 Entry = Entry->Flink;
1635 }
1636
1637 DPRINT("Failed to find dll %wZ\n", &FullDllName);
1638
1639 RtlFreeUnicodeString(&FullDllName);
1640 *BaseAddress = NULL;
1641 return STATUS_DLL_NOT_FOUND;
1642 }
1643
1644
1645 NTSTATUS STDCALL
1646 LdrGetProcedureAddress (IN PVOID BaseAddress,
1647 IN PANSI_STRING Name,
1648 IN ULONG Ordinal,
1649 OUT PVOID *ProcedureAddress)
1650 {
1651 PIMAGE_EXPORT_DIRECTORY ExportDir;
1652 PUSHORT OrdinalPtr;
1653 PULONG NamePtr;
1654 PULONG AddressPtr;
1655 ULONG i = 0;
1656
1657 DPRINT("LdrGetProcedureAddress (BaseAddress %x Name %Z Ordinal %lu ProcedureAddress %x)\n",
1658 BaseAddress, Name, Ordinal, ProcedureAddress);
1659
1660 /* Get the pointer to the export directory */
1661 ExportDir = (PIMAGE_EXPORT_DIRECTORY)
1662 RtlImageDirectoryEntryToData (BaseAddress,
1663 TRUE,
1664 IMAGE_DIRECTORY_ENTRY_EXPORT,
1665 &i);
1666
1667 DPRINT("ExportDir %x i %lu\n", ExportDir, i);
1668
1669 if (!ExportDir || !i || !ProcedureAddress)
1670 {
1671 return STATUS_INVALID_PARAMETER;
1672 }
1673
1674 AddressPtr = (PULONG)((ULONG)BaseAddress + (ULONG)ExportDir->AddressOfFunctions);
1675 if (Name && Name->Length)
1676 {
1677 /* by name */
1678 OrdinalPtr = (PUSHORT)((ULONG)BaseAddress + (ULONG)ExportDir->AddressOfNameOrdinals);
1679 NamePtr = (PULONG)((ULONG)BaseAddress + (ULONG)ExportDir->AddressOfNames);
1680 for( i = 0; i < ExportDir->NumberOfNames; i++, NamePtr++, OrdinalPtr++)
1681 {
1682 if (!_strnicmp(Name->Buffer, (char*)(BaseAddress + *NamePtr), Name->Length))
1683 {
1684 *ProcedureAddress = (PVOID)((ULONG)BaseAddress + (ULONG)AddressPtr[*OrdinalPtr]);
1685 return STATUS_SUCCESS;
1686 }
1687 }
1688 DbgPrint("LdrGetProcedureAddress: Can't resolve symbol '%Z'\n", Name);
1689 }
1690 else
1691 {
1692 /* by ordinal */
1693 Ordinal &= 0x0000FFFF;
1694 if (Ordinal - ExportDir->Base < ExportDir->NumberOfFunctions)
1695 {
1696 *ProcedureAddress = (PVOID)((ULONG)BaseAddress + (ULONG)AddressPtr[Ordinal - ExportDir->Base]);
1697 return STATUS_SUCCESS;
1698 }
1699 DbgPrint("LdrGetProcedureAddress: Can't resolve symbol @%d\n", Ordinal);
1700 }
1701
1702 return STATUS_PROCEDURE_NOT_FOUND;
1703 }
1704
1705
1706 NTSTATUS STDCALL
1707 LdrShutdownProcess (VOID)
1708 {
1709 PLIST_ENTRY ModuleListHead;
1710 PLIST_ENTRY Entry;
1711 PLDR_MODULE Module;
1712
1713 DPRINT("LdrShutdownProcess() called\n");
1714
1715 RtlEnterCriticalSection (NtCurrentPeb()->LoaderLock);
1716
1717 ModuleListHead = &NtCurrentPeb()->Ldr->InInitializationOrderModuleList;
1718 Entry = ModuleListHead->Blink;
1719
1720 while (Entry != ModuleListHead)
1721 {
1722 Module = CONTAINING_RECORD(Entry, LDR_MODULE, InInitializationOrderModuleList);
1723
1724 DPRINT(" Unloading %S\n",
1725 &Module->BaseDllName);
1726 // PJS: only detach from static dlls, they should FreeLibrary() any dlls that
1727 // they loaded dynamically, and when the last reference is gone, that lib will
1728 // be detached.
1729 if (Module->EntryPoint != 0 && Module->LoadCount == -1)
1730 {
1731 PDLLMAIN_FUNC Entrypoint = (PDLLMAIN_FUNC)Module->EntryPoint;
1732
1733 DPRINT("Calling entry point at 0x%08x\n", Entrypoint);
1734 Entrypoint (Module->BaseAddress,
1735 DLL_PROCESS_DETACH,
1736 NULL);
1737 }
1738
1739 Entry = Entry->Blink;
1740 }
1741
1742 RtlLeaveCriticalSection (NtCurrentPeb()->LoaderLock);
1743
1744 DPRINT("LdrShutdownProcess() done\n");
1745
1746 return STATUS_SUCCESS;
1747 }
1748
1749
1750 NTSTATUS STDCALL
1751 LdrShutdownThread (VOID)
1752 {
1753 PLIST_ENTRY ModuleListHead;
1754 PLIST_ENTRY Entry;
1755 PLDR_MODULE Module;
1756
1757 DPRINT("LdrShutdownThread() called\n");
1758
1759 RtlEnterCriticalSection (NtCurrentPeb()->LoaderLock);
1760
1761 ModuleListHead = &NtCurrentPeb()->Ldr->InInitializationOrderModuleList;
1762 Entry = ModuleListHead->Blink;
1763
1764 while (Entry != ModuleListHead)
1765 {
1766 Module = CONTAINING_RECORD(Entry, LDR_MODULE, InInitializationOrderModuleList);
1767
1768 DPRINT(" Unloading %wZ\n",
1769 &Module->BaseDllName);
1770
1771 if (Module->EntryPoint != 0)
1772 {
1773 PDLLMAIN_FUNC Entrypoint = (PDLLMAIN_FUNC)Module->EntryPoint;
1774
1775 DPRINT("Calling entry point at 0x%08x\n", Entrypoint);
1776 Entrypoint (Module->BaseAddress,
1777 DLL_THREAD_DETACH,
1778 NULL);
1779 }
1780
1781 Entry = Entry->Blink;
1782 }
1783
1784 RtlLeaveCriticalSection (NtCurrentPeb()->LoaderLock);
1785
1786 DPRINT("LdrShutdownThread() done\n");
1787
1788 return STATUS_SUCCESS;
1789 }
1790
1791
1792 /***************************************************************************
1793 * NAME EXPORTED
1794 * LdrQueryProcessModuleInformation
1795 *
1796 * DESCRIPTION
1797 *
1798 * ARGUMENTS
1799 *
1800 * RETURN VALUE
1801 *
1802 * REVISIONS
1803 *
1804 * NOTE
1805 */
1806 NTSTATUS STDCALL
1807 LdrQueryProcessModuleInformation(IN PMODULE_INFORMATION ModuleInformation OPTIONAL,
1808 IN ULONG Size OPTIONAL,
1809 OUT PULONG ReturnedSize)
1810
1811 {
1812 PLIST_ENTRY ModuleListHead;
1813 PLIST_ENTRY Entry;
1814 PLDR_MODULE Module;
1815 PMODULE_ENTRY ModulePtr = NULL;
1816 NTSTATUS Status = STATUS_SUCCESS;
1817 ULONG UsedSize = sizeof(ULONG);
1818 ANSI_STRING AnsiString;
1819 PCHAR p;
1820
1821 DPRINT("LdrQueryProcessModuleInformation() called\n");
1822
1823 RtlEnterCriticalSection (NtCurrentPeb()->LoaderLock);
1824
1825 if (ModuleInformation == NULL || Size == 0)
1826 {
1827 Status = STATUS_INFO_LENGTH_MISMATCH;
1828 }
1829 else
1830 {
1831 ModuleInformation->ModuleCount = 0;
1832 ModulePtr = &ModuleInformation->ModuleEntry[0];
1833 Status = STATUS_SUCCESS;
1834 }
1835
1836 ModuleListHead = &NtCurrentPeb()->Ldr->InLoadOrderModuleList;
1837 Entry = ModuleListHead->Flink;
1838
1839 while (Entry != ModuleListHead)
1840 {
1841 Module = CONTAINING_RECORD(Entry, LDR_MODULE, InLoadOrderModuleList);
1842
1843 DPRINT(" Module %wZ\n",
1844 &Module->FullDllName);
1845
1846 if (UsedSize > Size)
1847 {
1848 Status = STATUS_INFO_LENGTH_MISMATCH;
1849 }
1850 else if (ModuleInformation != NULL)
1851 {
1852 ModulePtr->Unknown0 = 0; // FIXME: ??
1853 ModulePtr->Unknown1 = 0; // FIXME: ??
1854 ModulePtr->BaseAddress = Module->BaseAddress;
1855 ModulePtr->SizeOfImage = Module->SizeOfImage;
1856 ModulePtr->Flags = Module->Flags;
1857 ModulePtr->Unknown2 = 0; // FIXME: load order index ??
1858 ModulePtr->Unknown3 = 0; // FIXME: ??
1859 ModulePtr->LoadCount = Module->LoadCount;
1860
1861 AnsiString.Length = 0;
1862 AnsiString.MaximumLength = 256;
1863 AnsiString.Buffer = ModulePtr->ModuleName;
1864 RtlUnicodeStringToAnsiString(&AnsiString,
1865 &Module->FullDllName,
1866 FALSE);
1867 p = strrchr(ModulePtr->ModuleName, '\\');
1868 if (p != NULL)
1869 ModulePtr->PathLength = p - ModulePtr->ModuleName + 1;
1870 else
1871 ModulePtr->PathLength = 0;
1872
1873 ModulePtr++;
1874 ModuleInformation->ModuleCount++;
1875 }
1876 UsedSize += sizeof(MODULE_ENTRY);
1877
1878 Entry = Entry->Flink;
1879 }
1880
1881 RtlLeaveCriticalSection (NtCurrentPeb()->LoaderLock);
1882
1883 if (ReturnedSize != 0)
1884 *ReturnedSize = UsedSize;
1885
1886 DPRINT("LdrQueryProcessModuleInformation() done\n");
1887
1888 return(Status);
1889 }
1890
1891 /* EOF */