297788e5a31a5f8c35f9c090e2f60efc92f793c2
[reactos.git] / boot / freeldr / freeldr / lib / peloader.c
1 /*
2 * PROJECT: FreeLoader
3 * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
4 * PURPOSE: Provides routines for loading PE files.
5 * (Deprecated remark) To be merged with arch/i386/loader.c in future.
6 *
7 * COPYRIGHT: Copyright 1998-2003 Brian Palmer <brianp@sginet.com>
8 * Copyright 2006-2019 Aleksey Bragin <aleksey@reactos.org>
9 *
10 * NOTES: The source code in this file is based on the work of respective
11 * authors of PE loading code in ReactOS and Brian Palmer and
12 * Alex Ionescu's arch/i386/loader.c, and my research project
13 * (creating a native EFI loader for Windows).
14 *
15 * This article was very handy during development:
16 * http://msdn.microsoft.com/msdnmag/issues/02/03/PE2/
17 */
18
19 /* INCLUDES ******************************************************************/
20
21 #include <freeldr.h>
22 #include <debug.h>
23
24 DBG_DEFAULT_CHANNEL(PELOADER);
25
26 /* PRIVATE FUNCTIONS *********************************************************/
27
28 /* DllName - physical, UnicodeString->Buffer - virtual */
29 static BOOLEAN
30 PeLdrpCompareDllName(
31 IN PCH DllName,
32 IN PUNICODE_STRING UnicodeName)
33 {
34 PWSTR Buffer;
35 SIZE_T i, Length;
36
37 /* First obvious check: for length of two names */
38 Length = strlen(DllName);
39
40 #if DBG
41 {
42 UNICODE_STRING UnicodeNamePA;
43 UnicodeNamePA.Length = UnicodeName->Length;
44 UnicodeNamePA.MaximumLength = UnicodeName->MaximumLength;
45 UnicodeNamePA.Buffer = VaToPa(UnicodeName->Buffer);
46 TRACE("PeLdrpCompareDllName: %s and %wZ, Length = %d "
47 "UN->Length %d\n", DllName, &UnicodeNamePA, Length, UnicodeName->Length);
48 }
49 #endif
50
51 if ((Length * sizeof(WCHAR)) > UnicodeName->Length)
52 return FALSE;
53
54 /* Store pointer to unicode string's buffer */
55 Buffer = VaToPa(UnicodeName->Buffer);
56
57 /* Loop character by character */
58 for (i = 0; i < Length; i++)
59 {
60 /* Compare two characters, uppercasing them */
61 if (toupper(*DllName) != toupper((CHAR)*Buffer))
62 return FALSE;
63
64 /* Move to the next character */
65 DllName++;
66 Buffer++;
67 }
68
69 /* Check, if strings either fully match, or match till the "." (w/o extension) */
70 if ((UnicodeName->Length == Length * sizeof(WCHAR)) || (*Buffer == L'.'))
71 {
72 /* Yes they do */
73 return TRUE;
74 }
75
76 /* Strings don't match, return FALSE */
77 return FALSE;
78 }
79
80 static BOOLEAN
81 PeLdrpLoadAndScanReferencedDll(
82 IN OUT PLIST_ENTRY ModuleListHead,
83 IN PCCH DirectoryPath,
84 IN PCH ImportName,
85 OUT PLDR_DATA_TABLE_ENTRY *DataTableEntry);
86
87 static BOOLEAN
88 PeLdrpBindImportName(
89 IN OUT PLIST_ENTRY ModuleListHead,
90 IN PVOID DllBase,
91 IN PVOID ImageBase,
92 IN PIMAGE_THUNK_DATA ThunkData,
93 IN PIMAGE_EXPORT_DIRECTORY ExportDirectory,
94 IN ULONG ExportSize,
95 IN BOOLEAN ProcessForwards,
96 IN PCSTR DirectoryPath)
97 {
98 ULONG Ordinal;
99 PULONG NameTable, FunctionTable;
100 PUSHORT OrdinalTable;
101 LONG High, Low, Middle, Result;
102 ULONG Hint;
103 PIMAGE_IMPORT_BY_NAME ImportData;
104 PCHAR ExportName, ForwarderName;
105 BOOLEAN Success;
106
107 //TRACE("PeLdrpBindImportName(): DllBase 0x%X, ImageBase 0x%X, ThunkData 0x%X, ExportDirectory 0x%X, ExportSize %d, ProcessForwards 0x%X\n",
108 // DllBase, ImageBase, ThunkData, ExportDirectory, ExportSize, ProcessForwards);
109
110 /* Check passed DllBase param */
111 if(DllBase == NULL)
112 {
113 WARN("DllBase == NULL!\n");
114 return FALSE;
115 }
116
117 /* Convert all non-critical pointers to PA from VA */
118 ThunkData = VaToPa(ThunkData);
119
120 /* Is the reference by ordinal? */
121 if (IMAGE_SNAP_BY_ORDINAL(ThunkData->u1.Ordinal) && !ProcessForwards)
122 {
123 /* Yes, calculate the ordinal */
124 Ordinal = (ULONG)(IMAGE_ORDINAL(ThunkData->u1.Ordinal) - (UINT32)ExportDirectory->Base);
125 //TRACE("PeLdrpBindImportName(): Ordinal %d\n", Ordinal);
126 }
127 else
128 {
129 /* It's reference by name, we have to look it up in the export directory */
130 if (!ProcessForwards)
131 {
132 /* AddressOfData in thunk entry will become a virtual address (from relative) */
133 //TRACE("PeLdrpBindImportName(): ThunkData->u1.AOD was %p\n", ThunkData->u1.AddressOfData);
134 ThunkData->u1.AddressOfData =
135 (ULONG_PTR)RVA(ImageBase, ThunkData->u1.AddressOfData);
136 //TRACE("PeLdrpBindImportName(): ThunkData->u1.AOD became %p\n", ThunkData->u1.AddressOfData);
137 }
138
139 /* Get the import name */
140 ImportData = VaToPa((PVOID)ThunkData->u1.AddressOfData);
141
142 /* Get pointers to Name and Ordinal tables (RVA -> VA) */
143 NameTable = VaToPa(RVA(DllBase, ExportDirectory->AddressOfNames));
144 OrdinalTable = VaToPa(RVA(DllBase, ExportDirectory->AddressOfNameOrdinals));
145
146 //TRACE("NameTable 0x%X, OrdinalTable 0x%X, ED->AddressOfNames 0x%X, ED->AOFO 0x%X\n",
147 // NameTable, OrdinalTable, ExportDirectory->AddressOfNames, ExportDirectory->AddressOfNameOrdinals);
148
149 /* Get the hint, convert it to a physical pointer */
150 Hint = ((PIMAGE_IMPORT_BY_NAME)VaToPa((PVOID)ThunkData->u1.AddressOfData))->Hint;
151 //TRACE("HintIndex %d\n", Hint);
152
153 /* Get the export name from the hint */
154 ExportName = VaToPa(RVA(DllBase, NameTable[Hint]));
155
156 /* If Hint is less than total number of entries in the export directory,
157 and import name == export name, then we can just get it from the OrdinalTable */
158 if ((Hint < ExportDirectory->NumberOfNames) &&
159 (strcmp(ExportName, (PCHAR)ImportData->Name) == 0))
160 {
161 Ordinal = OrdinalTable[Hint];
162 //TRACE("PeLdrpBindImportName(): Ordinal %d\n", Ordinal);
163 }
164 else
165 {
166 /* It's not the easy way, we have to lookup import name in the name table.
167 Let's use a binary search for this task. */
168
169 //TRACE("PeLdrpBindImportName() looking up the import name using binary search...\n");
170
171 /* Low boundary is set to 0, and high boundary to the maximum index */
172 Low = 0;
173 High = ExportDirectory->NumberOfNames - 1;
174
175 /* Perform a binary-search loop */
176 while (High >= Low)
177 {
178 /* Divide by 2 by shifting to the right once */
179 Middle = (Low + High) / 2;
180
181 /* Get the name from the name table */
182 ExportName = VaToPa(RVA(DllBase, NameTable[Middle]));
183
184 /* Compare the names */
185 Result = strcmp(ExportName, (PCHAR)ImportData->Name);
186
187 // TRACE("Binary search: comparing Import '__', Export '%s'\n",
188 // VaToPa(&((PIMAGE_IMPORT_BY_NAME)VaToPa(ThunkData->u1.AddressOfData))->Name[0]),
189 // (PCHAR)VaToPa(RVA(DllBase, NameTable[Middle])));
190
191 // TRACE("TE->u1.AOD %p, fulladdr %p\n",
192 // ThunkData->u1.AddressOfData,
193 // ((PIMAGE_IMPORT_BY_NAME)VaToPa(ThunkData->u1.AddressOfData))->Name );
194
195 /* Depending on result of strcmp, perform different actions */
196 if (Result > 0)
197 {
198 /* Adjust top boundary */
199 High = Middle - 1;
200 }
201 else if (Result < 0)
202 {
203 /* Adjust bottom boundary */
204 Low = Middle + 1;
205 }
206 else
207 {
208 /* Yay, found it! */
209 break;
210 }
211 }
212
213 /* If high boundary is less than low boundary, then no result found */
214 if (High < Low)
215 {
216 ERR("Did not find export '%s'!\n", (PCHAR)ImportData->Name);
217 return FALSE;
218 }
219
220 /* Everything alright, get the ordinal */
221 Ordinal = OrdinalTable[Middle];
222
223 //TRACE("PeLdrpBindImportName() found Ordinal %d\n", Ordinal);
224 }
225 }
226
227 /* Check ordinal number for validity! */
228 if (Ordinal >= ExportDirectory->NumberOfFunctions)
229 {
230 ERR("Ordinal number is invalid!\n");
231 return FALSE;
232 }
233
234 /* Get a pointer to the function table */
235 FunctionTable = (PULONG)VaToPa(RVA(DllBase, ExportDirectory->AddressOfFunctions));
236
237 /* Save a pointer to the function */
238 ThunkData->u1.Function = (ULONG_PTR)RVA(DllBase, FunctionTable[Ordinal]);
239
240 /* Is it a forwarder? (function pointer is within the export directory) */
241 ForwarderName = (PCHAR)VaToPa((PVOID)ThunkData->u1.Function);
242 if (((ULONG_PTR)ForwarderName > (ULONG_PTR)ExportDirectory) &&
243 ((ULONG_PTR)ForwarderName < ((ULONG_PTR)ExportDirectory + ExportSize)))
244 {
245 PLDR_DATA_TABLE_ENTRY DataTableEntry;
246 CHAR ForwardDllName[255];
247 PIMAGE_EXPORT_DIRECTORY RefExportDirectory;
248 ULONG RefExportSize;
249
250 TRACE("PeLdrpBindImportName(): ForwarderName %s\n", ForwarderName);
251
252 /* Save the name of the forward dll */
253 RtlCopyMemory(ForwardDllName, ForwarderName, sizeof(ForwardDllName));
254
255 /* Strip out the symbol name */
256 *strrchr(ForwardDllName,'.') = '\0';
257
258 /* Check if the target image is already loaded */
259 if (!PeLdrCheckForLoadedDll(ModuleListHead, ForwardDllName, &DataTableEntry))
260 {
261 /* Check if the forward dll name has an extension */
262 if (strchr(ForwardDllName, '.') == NULL)
263 {
264 /* Name does not have an extension, append '.dll' */
265 strcat(ForwardDllName, ".dll");
266 }
267
268 /* Now let's try to load it! */
269 Success = PeLdrpLoadAndScanReferencedDll(ModuleListHead,
270 DirectoryPath,
271 ForwardDllName,
272 &DataTableEntry);
273 if (!Success)
274 {
275 ERR("PeLdrpLoadAndScanReferencedDll() failed to load forwarder dll.\n");
276 return Success;
277 }
278 }
279
280 /* Get pointer to the export directory of loaded DLL */
281 RefExportDirectory = (PIMAGE_EXPORT_DIRECTORY)
282 RtlImageDirectoryEntryToData(VaToPa(DataTableEntry->DllBase),
283 TRUE,
284 IMAGE_DIRECTORY_ENTRY_EXPORT,
285 &RefExportSize);
286
287 /* Fail if it's NULL */
288 if (RefExportDirectory)
289 {
290 UCHAR Buffer[128];
291 IMAGE_THUNK_DATA RefThunkData;
292 PIMAGE_IMPORT_BY_NAME ImportByName;
293 PCHAR ImportName;
294
295 /* Get pointer to the import name */
296 ImportName = strrchr(ForwarderName, '.') + 1;
297
298 /* Create a IMAGE_IMPORT_BY_NAME structure, pointing to the local Buffer */
299 ImportByName = (PIMAGE_IMPORT_BY_NAME)Buffer;
300
301 /* Fill the name with the import name */
302 RtlCopyMemory(ImportByName->Name, ImportName, strlen(ImportName)+1);
303
304 /* Set Hint to 0 */
305 ImportByName->Hint = 0;
306
307 /* And finally point ThunkData's AddressOfData to that structure */
308 RefThunkData.u1.AddressOfData = (ULONG_PTR)ImportByName;
309
310 /* And recursively call ourselves */
311 Success = PeLdrpBindImportName(ModuleListHead,
312 DataTableEntry->DllBase,
313 ImageBase,
314 &RefThunkData,
315 RefExportDirectory,
316 RefExportSize,
317 TRUE,
318 DirectoryPath);
319
320 /* Fill out the ThunkData with data from RefThunkData */
321 ThunkData->u1 = RefThunkData.u1;
322
323 /* Return what we got from the recursive call */
324 return Success;
325 }
326 else
327 {
328 /* Fail if ExportDirectory is NULL */
329 return FALSE;
330 }
331 }
332
333 /* Success! */
334 return TRUE;
335 }
336
337 static BOOLEAN
338 PeLdrpLoadAndScanReferencedDll(
339 IN OUT PLIST_ENTRY ModuleListHead,
340 IN PCCH DirectoryPath,
341 IN PCH ImportName,
342 OUT PLDR_DATA_TABLE_ENTRY *DataTableEntry)
343 {
344 CHAR FullDllName[256];
345 BOOLEAN Success;
346 PVOID BasePA = NULL;
347
348 /* Prepare the full path to the file to be loaded */
349 strcpy(FullDllName, DirectoryPath);
350 strcat(FullDllName, ImportName);
351
352 TRACE("Loading referenced DLL: %s\n", FullDllName);
353
354 /* Load the image */
355 Success = PeLdrLoadImage(FullDllName, LoaderBootDriver, &BasePA);
356 if (!Success)
357 {
358 ERR("PeLdrLoadImage() failed\n");
359 return Success;
360 }
361
362 /* Allocate DTE for newly loaded DLL */
363 Success = PeLdrAllocateDataTableEntry(ModuleListHead,
364 ImportName,
365 FullDllName,
366 BasePA,
367 DataTableEntry);
368 if (!Success)
369 {
370 ERR("PeLdrAllocateDataTableEntry() failed\n");
371 return Success;
372 }
373
374 (*DataTableEntry)->Flags |= LDRP_DRIVER_DEPENDENT_DLL;
375
376 /* Scan its dependencies too */
377 TRACE("PeLdrScanImportDescriptorTable() calling ourselves for %S\n",
378 VaToPa((*DataTableEntry)->BaseDllName.Buffer));
379 Success = PeLdrScanImportDescriptorTable(ModuleListHead, DirectoryPath, *DataTableEntry);
380 if (!Success)
381 {
382 ERR("PeLdrScanImportDescriptorTable() failed\n");
383 return Success;
384 }
385
386 return TRUE;
387 }
388
389 static BOOLEAN
390 PeLdrpScanImportAddressTable(
391 IN OUT PLIST_ENTRY ModuleListHead,
392 IN PVOID DllBase,
393 IN PVOID ImageBase,
394 IN PIMAGE_THUNK_DATA ThunkData,
395 IN PCSTR DirectoryPath)
396 {
397 PIMAGE_EXPORT_DIRECTORY ExportDirectory = NULL;
398 BOOLEAN Success;
399 ULONG ExportSize;
400
401 TRACE("PeLdrpScanImportAddressTable(): DllBase 0x%X, "
402 "ImageBase 0x%X, ThunkData 0x%X\n", DllBase, ImageBase, ThunkData);
403
404 /* Obtain the export table from the DLL's base */
405 if (DllBase == NULL)
406 {
407 ERR("Error, DllBase == NULL!\n");
408 return FALSE;
409 }
410 else
411 {
412 ExportDirectory =
413 (PIMAGE_EXPORT_DIRECTORY)RtlImageDirectoryEntryToData(VaToPa(DllBase),
414 TRUE,
415 IMAGE_DIRECTORY_ENTRY_EXPORT,
416 &ExportSize);
417 }
418
419 TRACE("PeLdrpScanImportAddressTable(): ExportDirectory 0x%X\n", ExportDirectory);
420
421 /* If pointer to Export Directory is */
422 if (ExportDirectory == NULL)
423 {
424 ERR("DllBase=%p(%p)\n", DllBase, VaToPa(DllBase));
425 return FALSE;
426 }
427
428 /* Go through each entry in the thunk table and bind it */
429 while (((PIMAGE_THUNK_DATA)VaToPa(ThunkData))->u1.AddressOfData != 0)
430 {
431 /* Bind it */
432 Success = PeLdrpBindImportName(ModuleListHead,
433 DllBase,
434 ImageBase,
435 ThunkData,
436 ExportDirectory,
437 ExportSize,
438 FALSE,
439 DirectoryPath);
440
441 /* Move to the next entry */
442 ThunkData++;
443
444 /* Return error if binding was unsuccessful */
445 if (!Success)
446 return Success;
447 }
448
449 /* Return success */
450 return TRUE;
451 }
452
453
454 /* FUNCTIONS *****************************************************************/
455
456 /* Returns TRUE if DLL has already been loaded - looks in LoadOrderList in LPB */
457 BOOLEAN
458 PeLdrCheckForLoadedDll(
459 IN OUT PLIST_ENTRY ModuleListHead,
460 IN PCH DllName,
461 OUT PLDR_DATA_TABLE_ENTRY *LoadedEntry)
462 {
463 PLDR_DATA_TABLE_ENTRY DataTableEntry;
464 LIST_ENTRY *ModuleEntry;
465
466 TRACE("PeLdrCheckForLoadedDll: DllName %s\n", DllName);
467
468 /* Just go through each entry in the LoadOrderList and compare loaded module's
469 name with a given name */
470 ModuleEntry = ModuleListHead->Flink;
471 while (ModuleEntry != ModuleListHead)
472 {
473 /* Get pointer to the current DTE */
474 DataTableEntry = CONTAINING_RECORD(ModuleEntry,
475 LDR_DATA_TABLE_ENTRY,
476 InLoadOrderLinks);
477
478 TRACE("PeLdrCheckForLoadedDll: DTE %p, EP %p, base %p name '%.*ws'\n",
479 DataTableEntry, DataTableEntry->EntryPoint, DataTableEntry->DllBase,
480 DataTableEntry->BaseDllName.Length / 2, VaToPa(DataTableEntry->BaseDllName.Buffer));
481
482 /* Compare names */
483 if (PeLdrpCompareDllName(DllName, &DataTableEntry->BaseDllName))
484 {
485 /* Yes, found it, report pointer to the loaded module's DTE
486 to the caller and increase load count for it */
487 *LoadedEntry = DataTableEntry;
488 DataTableEntry->LoadCount++;
489 TRACE("PeLdrCheckForLoadedDll: LoadedEntry %X\n", DataTableEntry);
490 return TRUE;
491 }
492
493 /* Go to the next entry */
494 ModuleEntry = ModuleEntry->Flink;
495 }
496
497 /* Nothing found */
498 return FALSE;
499 }
500
501 BOOLEAN
502 PeLdrScanImportDescriptorTable(
503 IN OUT PLIST_ENTRY ModuleListHead,
504 IN PCCH DirectoryPath,
505 IN PLDR_DATA_TABLE_ENTRY ScanDTE)
506 {
507 PLDR_DATA_TABLE_ENTRY DataTableEntry;
508 PIMAGE_IMPORT_DESCRIPTOR ImportTable;
509 ULONG ImportTableSize;
510 PCH ImportName;
511 BOOLEAN Success;
512
513 /* Get a pointer to the import table of this image */
514 ImportTable = (PIMAGE_IMPORT_DESCRIPTOR)RtlImageDirectoryEntryToData(VaToPa(ScanDTE->DllBase),
515 TRUE, IMAGE_DIRECTORY_ENTRY_IMPORT, &ImportTableSize);
516
517 #if DBG
518 {
519 UNICODE_STRING BaseName;
520 BaseName.Buffer = VaToPa(ScanDTE->BaseDllName.Buffer);
521 BaseName.MaximumLength = ScanDTE->BaseDllName.MaximumLength;
522 BaseName.Length = ScanDTE->BaseDllName.Length;
523 TRACE("PeLdrScanImportDescriptorTable(): %wZ ImportTable = 0x%X\n",
524 &BaseName, ImportTable);
525 }
526 #endif
527
528 /* If image doesn't have any import directory - just return success */
529 if (ImportTable == NULL)
530 return TRUE;
531
532 /* Loop through all entries */
533 for (;(ImportTable->Name != 0) && (ImportTable->FirstThunk != 0);ImportTable++)
534 {
535 /* Get pointer to the name */
536 ImportName = (PCH)VaToPa(RVA(ScanDTE->DllBase, ImportTable->Name));
537 TRACE("PeLdrScanImportDescriptorTable(): Looking at %s\n", ImportName);
538
539 /* In case we get a reference to ourselves - just skip it */
540 if (PeLdrpCompareDllName(ImportName, &ScanDTE->BaseDllName))
541 continue;
542
543 /* Load the DLL if it is not already loaded */
544 if (!PeLdrCheckForLoadedDll(ModuleListHead, ImportName, &DataTableEntry))
545 {
546 Success = PeLdrpLoadAndScanReferencedDll(ModuleListHead,
547 DirectoryPath,
548 ImportName,
549 &DataTableEntry);
550 if (!Success)
551 {
552 ERR("PeLdrpLoadAndScanReferencedDll() failed\n");
553 return Success;
554 }
555 }
556
557 /* Scan its import address table */
558 Success = PeLdrpScanImportAddressTable(ModuleListHead,
559 DataTableEntry->DllBase,
560 ScanDTE->DllBase,
561 (PIMAGE_THUNK_DATA)RVA(ScanDTE->DllBase, ImportTable->FirstThunk),
562 DirectoryPath);
563
564 if (!Success)
565 {
566 ERR("PeLdrpScanImportAddressTable() failed: ImportName = '%s', DirectoryPath = '%s'\n",
567 ImportName, DirectoryPath);
568 return Success;
569 }
570 }
571
572 return TRUE;
573 }
574
575 BOOLEAN
576 PeLdrAllocateDataTableEntry(
577 IN OUT PLIST_ENTRY ModuleListHead,
578 IN PCCH BaseDllName,
579 IN PCCH FullDllName,
580 IN PVOID BasePA,
581 OUT PLDR_DATA_TABLE_ENTRY *NewEntry)
582 {
583 PVOID BaseVA = PaToVa(BasePA);
584 PWSTR Buffer;
585 PLDR_DATA_TABLE_ENTRY DataTableEntry;
586 PIMAGE_NT_HEADERS NtHeaders;
587 USHORT Length;
588
589 TRACE("PeLdrAllocateDataTableEntry(, '%s', '%s', %p)\n",
590 BaseDllName, FullDllName, BasePA);
591
592 /* Allocate memory for a data table entry, zero-initialize it */
593 DataTableEntry = (PLDR_DATA_TABLE_ENTRY)FrLdrHeapAlloc(sizeof(LDR_DATA_TABLE_ENTRY),
594 TAG_WLDR_DTE);
595 if (DataTableEntry == NULL)
596 return FALSE;
597 RtlZeroMemory(DataTableEntry, sizeof(LDR_DATA_TABLE_ENTRY));
598
599 /* Get NT headers from the image */
600 NtHeaders = RtlImageNtHeader(BasePA);
601
602 /* Initialize corresponding fields of DTE based on NT headers value */
603 DataTableEntry->DllBase = BaseVA;
604 DataTableEntry->SizeOfImage = NtHeaders->OptionalHeader.SizeOfImage;
605 DataTableEntry->EntryPoint = RVA(BaseVA, NtHeaders->OptionalHeader.AddressOfEntryPoint);
606 DataTableEntry->SectionPointer = 0;
607 DataTableEntry->CheckSum = NtHeaders->OptionalHeader.CheckSum;
608
609 /* Initialize BaseDllName field (UNICODE_STRING) from the Ansi BaseDllName
610 by simple conversion - copying each character */
611 Length = (USHORT)(strlen(BaseDllName) * sizeof(WCHAR));
612 Buffer = (PWSTR)FrLdrHeapAlloc(Length, TAG_WLDR_NAME);
613 if (Buffer == NULL)
614 {
615 FrLdrHeapFree(DataTableEntry, TAG_WLDR_DTE);
616 return FALSE;
617 }
618 RtlZeroMemory(Buffer, Length);
619
620 DataTableEntry->BaseDllName.Length = Length;
621 DataTableEntry->BaseDllName.MaximumLength = Length;
622 DataTableEntry->BaseDllName.Buffer = PaToVa(Buffer);
623 while (*BaseDllName != 0)
624 {
625 *Buffer++ = *BaseDllName++;
626 }
627
628 /* Initialize FullDllName field (UNICODE_STRING) from the Ansi FullDllName
629 using the same method */
630 Length = (USHORT)(strlen(FullDllName) * sizeof(WCHAR));
631 Buffer = (PWSTR)FrLdrHeapAlloc(Length, TAG_WLDR_NAME);
632 if (Buffer == NULL)
633 {
634 FrLdrHeapFree(DataTableEntry, TAG_WLDR_DTE);
635 return FALSE;
636 }
637 RtlZeroMemory(Buffer, Length);
638
639 DataTableEntry->FullDllName.Length = Length;
640 DataTableEntry->FullDllName.MaximumLength = Length;
641 DataTableEntry->FullDllName.Buffer = PaToVa(Buffer);
642 while (*FullDllName != 0)
643 {
644 *Buffer++ = *FullDllName++;
645 }
646
647 /* Initialize what's left - LoadCount which is 1, and set Flags so that
648 we know this entry is processed */
649 DataTableEntry->Flags = LDRP_ENTRY_PROCESSED;
650 DataTableEntry->LoadCount = 1;
651
652 /* Insert this DTE to a list in the LPB */
653 InsertTailList(ModuleListHead, &DataTableEntry->InLoadOrderLinks);
654 TRACE("Inserting DTE %p, name='%.*S' DllBase=%p \n", DataTableEntry,
655 DataTableEntry->BaseDllName.Length / 2,
656 VaToPa(DataTableEntry->BaseDllName.Buffer),
657 DataTableEntry->DllBase);
658
659 /* Save pointer to a newly allocated and initialized entry */
660 *NewEntry = DataTableEntry;
661
662 /* Return success */
663 return TRUE;
664 }
665
666 /*
667 * PeLdrLoadImage loads the specified image from the file (it doesn't
668 * perform any additional operations on the filename, just directly
669 * calls the file I/O routines), and relocates it so that it's ready
670 * to be used when paging is enabled.
671 * Addressing mode: physical
672 */
673 BOOLEAN
674 PeLdrLoadImage(
675 IN PCHAR FileName,
676 IN TYPE_OF_MEMORY MemoryType,
677 OUT PVOID *ImageBasePA)
678 {
679 ULONG FileId;
680 PVOID PhysicalBase;
681 PVOID VirtualBase = NULL;
682 UCHAR HeadersBuffer[SECTOR_SIZE * 2];
683 PIMAGE_NT_HEADERS NtHeaders;
684 PIMAGE_SECTION_HEADER SectionHeader;
685 ULONG VirtualSize, SizeOfRawData, NumberOfSections;
686 ARC_STATUS Status;
687 LARGE_INTEGER Position;
688 ULONG i, BytesRead;
689
690 TRACE("PeLdrLoadImage(%s, %ld, *)\n", FileName, MemoryType);
691
692 /* Open the image file */
693 Status = ArcOpen((PSTR)FileName, OpenReadOnly, &FileId);
694 if (Status != ESUCCESS)
695 {
696 WARN("ArcOpen(FileName: '%s') failed. Status: %u\n", FileName, Status);
697 return FALSE;
698 }
699
700 /* Load the first 2 sectors of the image so we can read the PE header */
701 Status = ArcRead(FileId, HeadersBuffer, SECTOR_SIZE * 2, &BytesRead);
702 if (Status != ESUCCESS)
703 {
704 ERR("ArcRead(File: '%s') failed. Status: %u\n", FileName, Status);
705 UiMessageBox("Error reading from file.");
706 ArcClose(FileId);
707 return FALSE;
708 }
709
710 /* Now read the MZ header to get the offset to the PE Header */
711 NtHeaders = RtlImageNtHeader(HeadersBuffer);
712 if (!NtHeaders)
713 {
714 ERR("No NT header found in \"%s\"\n", FileName);
715 UiMessageBox("Error: No NT header found.");
716 ArcClose(FileId);
717 return FALSE;
718 }
719
720 /* Ensure this is executable image */
721 if (((NtHeaders->FileHeader.Characteristics & IMAGE_FILE_EXECUTABLE_IMAGE) == 0))
722 {
723 ERR("Not an executable image \"%s\"\n", FileName);
724 UiMessageBox("Not an executable image.");
725 ArcClose(FileId);
726 return FALSE;
727 }
728
729 /* Store number of sections to read and a pointer to the first section */
730 NumberOfSections = NtHeaders->FileHeader.NumberOfSections;
731 SectionHeader = IMAGE_FIRST_SECTION(NtHeaders);
732
733 /* Try to allocate this memory, if fails - allocate somewhere else */
734 PhysicalBase = MmAllocateMemoryAtAddress(NtHeaders->OptionalHeader.SizeOfImage,
735 (PVOID)((ULONG)NtHeaders->OptionalHeader.ImageBase & (KSEG0_BASE - 1)),
736 MemoryType);
737
738 if (PhysicalBase == NULL)
739 {
740 /* It's ok, we don't panic - let's allocate again at any other "low" place */
741 PhysicalBase = MmAllocateMemoryWithType(NtHeaders->OptionalHeader.SizeOfImage, MemoryType);
742
743 if (PhysicalBase == NULL)
744 {
745 ERR("Failed to alloc %lu bytes for image %s\n", NtHeaders->OptionalHeader.SizeOfImage, FileName);
746 UiMessageBox("Failed to alloc pages for image.");
747 ArcClose(FileId);
748 return FALSE;
749 }
750 }
751
752 /* This is the real image base - in form of a virtual address */
753 VirtualBase = PaToVa(PhysicalBase);
754
755 TRACE("Base PA: 0x%X, VA: 0x%X\n", PhysicalBase, VirtualBase);
756
757 /* Set to 0 position and fully load the file image */
758 Position.QuadPart = 0;
759 Status = ArcSeek(FileId, &Position, SeekAbsolute);
760 if (Status != ESUCCESS)
761 {
762 ERR("ArcSeek(File: '%s') failed. Status: 0x%lx\n", FileName, Status);
763 UiMessageBox("Error seeking the start of a file.");
764 ArcClose(FileId);
765 return FALSE;
766 }
767
768 Status = ArcRead(FileId, PhysicalBase, NtHeaders->OptionalHeader.SizeOfHeaders, &BytesRead);
769 if (Status != ESUCCESS)
770 {
771 ERR("ArcRead(File: '%s') failed. Status: %u\n", FileName, Status);
772 UiMessageBox("Error reading headers.");
773 ArcClose(FileId);
774 return FALSE;
775 }
776
777 /* Reload the NT Header */
778 NtHeaders = RtlImageNtHeader(PhysicalBase);
779
780 /* Load the first section */
781 SectionHeader = IMAGE_FIRST_SECTION(NtHeaders);
782
783 /* Fill output parameters */
784 *ImageBasePA = PhysicalBase;
785
786 /* Walk through each section and read it (check/fix any possible
787 bad situations, if they arise) */
788 for (i = 0; i < NumberOfSections; i++)
789 {
790 VirtualSize = SectionHeader->Misc.VirtualSize;
791 SizeOfRawData = SectionHeader->SizeOfRawData;
792
793 /* Handle a case when VirtualSize equals 0 */
794 if (VirtualSize == 0)
795 VirtualSize = SizeOfRawData;
796
797 /* If PointerToRawData is 0, then force its size to be also 0 */
798 if (SectionHeader->PointerToRawData == 0)
799 {
800 SizeOfRawData = 0;
801 }
802 else
803 {
804 /* Cut the loaded size to the VirtualSize extents */
805 if (SizeOfRawData > VirtualSize)
806 SizeOfRawData = VirtualSize;
807 }
808
809 /* Actually read the section (if its size is not 0) */
810 if (SizeOfRawData != 0)
811 {
812 /* Seek to the correct position */
813 Position.LowPart = SectionHeader->PointerToRawData;
814 Status = ArcSeek(FileId, &Position, SeekAbsolute);
815
816 TRACE("SH->VA: 0x%X\n", SectionHeader->VirtualAddress);
817
818 /* Read this section from the file, size = SizeOfRawData */
819 Status = ArcRead(FileId, (PUCHAR)PhysicalBase + SectionHeader->VirtualAddress, SizeOfRawData, &BytesRead);
820 if (Status != ESUCCESS)
821 {
822 ERR("PeLdrLoadImage(): Error reading section from file!\n");
823 break;
824 }
825 }
826
827 /* Size of data is less than the virtual size - fill up the remainder with zeroes */
828 if (SizeOfRawData < VirtualSize)
829 {
830 TRACE("PeLdrLoadImage(): SORD %d < VS %d\n", SizeOfRawData, VirtualSize);
831 RtlZeroMemory((PVOID)(SectionHeader->VirtualAddress + (ULONG_PTR)PhysicalBase + SizeOfRawData), VirtualSize - SizeOfRawData);
832 }
833
834 SectionHeader++;
835 }
836
837 /* We are done with the file - close it */
838 ArcClose(FileId);
839
840 /* If loading failed - return right now */
841 if (Status != ESUCCESS)
842 return FALSE;
843
844 /* Relocate the image, if it needs it */
845 if (NtHeaders->OptionalHeader.ImageBase != (ULONG_PTR)VirtualBase)
846 {
847 WARN("Relocating %p -> %p\n", NtHeaders->OptionalHeader.ImageBase, VirtualBase);
848 return (BOOLEAN)LdrRelocateImageWithBias(PhysicalBase,
849 (ULONG_PTR)VirtualBase - (ULONG_PTR)PhysicalBase,
850 "FreeLdr",
851 TRUE,
852 TRUE, /* in case of conflict still return success */
853 FALSE);
854 }
855
856 TRACE("PeLdrLoadImage() done, PA = %p\n", *ImageBasePA);
857 return TRUE;
858 }