able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/boot/lib/blbindt.c

730 lines
22 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1991 Microsoft Corporation
Module Name:
blbind.c
Abstract:
This module contains the code that implements the funtions required
to relocate an image and bind DLL entry points.
Author:
David N. Cutler (davec) 21-May-1991
Revision History:
Forrest Foltz (forrestf) 10-Jun-2000
Broke out x86 32/64 code into this module
--*/
ARC_STATUS
BlAllocateDataTableEntry (
IN PCHAR BaseDllName,
IN PCHAR FullDllName,
IN PVOID Base,
OUT PKLDR_DATA_TABLE_ENTRY *AllocatedEntry
)
/*++
Routine Description:
This routine allocates a data table entry for the specified image
and inserts the entry in the loaded module list.
Arguments:
BaseDllName - Supplies a pointer to a zero terminated base DLL name.
FullDllName - Supplies a pointer to a zero terminated full DLL name.
Base - Supplies a pointer to the base of the DLL image.
AllocatedEntry - Supplies a pointer to a variable that receives a
pointer to the allocated data table entry.
Return Value:
ESUCCESS is returned if a data table entry is allocated. Otherwise,
return a unsuccessful status.
--*/
{
PWSTR Buffer;
PKLDR_DATA_TABLE_ENTRY DataTableEntry;
PIMAGE_NT_HEADERS NtHeaders;
USHORT Length;
//
// Allocate a data table entry.
//
DataTableEntry =
(PKLDR_DATA_TABLE_ENTRY)BlAllocateHeap(sizeof(KLDR_DATA_TABLE_ENTRY));
if (DataTableEntry == NULL) {
return ENOMEM;
}
//
// Initialize the address of the DLL image file header and the entry
// point address.
//
NtHeaders = RtlImageNtHeader(Base);
DataTableEntry->DllBase = Base;
DataTableEntry->SizeOfImage = NtHeaders->OptionalHeader.SizeOfImage;
DataTableEntry->EntryPoint = (PVOID)((ULONG_PTR)Base +
NtHeaders->OptionalHeader.AddressOfEntryPoint);
DataTableEntry->SectionPointer = 0;
DataTableEntry->CheckSum = NtHeaders->OptionalHeader.CheckSum;
//
// Compute the length of the base DLL name, allocate a buffer to hold
// the name, copy the name into the buffer, and initialize the base
// DLL string descriptor.
//
Length = (USHORT)(strlen(BaseDllName) * sizeof(WCHAR));
Buffer = (PWSTR)BlAllocateHeap(Length);
if (Buffer == NULL) {
return ENOMEM;
}
DataTableEntry->BaseDllName.Length = Length;
DataTableEntry->BaseDllName.MaximumLength = Length;
DataTableEntry->BaseDllName.Buffer = Buffer;
while (*BaseDllName != 0) {
*Buffer++ = *BaseDllName++;
}
//
// Compute the length of the full DLL name, allocate a buffer to hold
// the name, copy the name into the buffer, and initialize the full
// DLL string descriptor.
//
Length = (USHORT)(strlen(FullDllName) * sizeof(WCHAR));
Buffer = (PWSTR)BlAllocateHeap(Length);
if (Buffer == NULL) {
return ENOMEM;
}
DataTableEntry->FullDllName.Length = Length;
DataTableEntry->FullDllName.MaximumLength = Length;
DataTableEntry->FullDllName.Buffer = Buffer;
while (*FullDllName != 0) {
*Buffer++ = *FullDllName++;
}
//
// Initialize the flags, load count, and insert the data table entry
// in the loaded module list.
//
DataTableEntry->Flags = LDRP_ENTRY_PROCESSED;
DataTableEntry->LoadCount = 1;
InsertTailList(&BlLoaderBlock->LoadOrderListHead,
&DataTableEntry->InLoadOrderLinks);
*AllocatedEntry = DataTableEntry;
return ESUCCESS;
}
ARC_STATUS
BlpBindImportName (
IN PVOID DllBase,
IN PVOID ImageBase,
IN PIMAGE_THUNK_DATA ThunkEntry,
IN PIMAGE_EXPORT_DIRECTORY ExportDirectory,
IN ULONG ExportSize,
IN BOOLEAN SnapForwarder
)
/*++
Routine Description:
This routine binds an import table reference with an exported entry
point and fills in the thunk data.
Arguments:
DllBase - Supplies the base address of the DLL image that contains
the export directory. On x86 systems, a NULL DllBase binds the
import table reference to the OsLoader's exported entry points.
ImageBase - Supplies the base address of the image that contains
the import thunk table.
ThunkEntry - Supplies a pointer to a thunk table entry.
ExportDirectory - Supplies a pointer to the export directory of the
DLL from which references are to be resolved.
SnapForwarder - determine if the snap is for a forwarder, and therefore
Address of Data is already setup.
Return Value:
ESUCCESS is returned if the specified thunk is bound. Otherwise, an
return an unsuccessful status.
--*/
{
PULONG FunctionTable;
LONG High;
ULONG HintIndex;
LONG Low;
LONG Middle;
PULONG NameTable;
ULONG Ordinal;
PUSHORT OrdinalTable;
LONG Result;
PUCHAR Temp;
#if defined(_X86_)
if(DllBase == NULL) {
DllBase = (PVOID)OsLoaderBase;
}
#endif
//
// If the reference is by ordinal, then compute the ordinal number.
// Otherwise, lookup the import name in the export directory.
//
if (IMAGE_SNAP_BY_ORDINAL(ThunkEntry->u1.Ordinal) && !SnapForwarder) {
//
// Compute the ordinal.
//
Ordinal = (ULONG)(IMAGE_ORDINAL(ThunkEntry->u1.Ordinal) - ExportDirectory->Base);
} else {
if (!SnapForwarder) {
//
// Change AddressOfData from an RVA to a VA.
//
ThunkEntry->u1.AddressOfData = ((ULONG_PTR)ImageBase + ThunkEntry->u1.AddressOfData);
}
//
// Lookup the import name in the export table to determine the
// ordinal.
//
NameTable = (PULONG)((ULONG_PTR)DllBase +
ExportDirectory->AddressOfNames);
OrdinalTable = (PUSHORT)((ULONG_PTR)DllBase +
ExportDirectory->AddressOfNameOrdinals);
//
// If the hint index is within the limits of the name table and the
// import and export names match, then the ordinal number can be
// obtained directly from the ordinal table. Otherwise, the name
// table must be searched for the specified name.
//
HintIndex = ((PIMAGE_IMPORT_BY_NAME)ThunkEntry->u1.AddressOfData)->Hint;
if ((HintIndex < ExportDirectory->NumberOfNames) &&
(strcmp(&((PIMAGE_IMPORT_BY_NAME)ThunkEntry->u1.AddressOfData)->Name[0],
(PCHAR)((ULONG_PTR)DllBase + NameTable[HintIndex])) == 0)) {
//
// Get the ordinal number from the ordinal table.
//
Ordinal = OrdinalTable[HintIndex];
} else {
//
// Lookup the import name in the name table using a binary search.
//
Low = 0;
High = ExportDirectory->NumberOfNames - 1;
while (High >= Low) {
//
// Compute the next probe index and compare the import name
// with the export name entry.
//
Middle = (Low + High) >> 1;
Result = strcmp(&((PIMAGE_IMPORT_BY_NAME)ThunkEntry->u1.AddressOfData)->Name[0],
(PCHAR)((ULONG_PTR)DllBase + NameTable[Middle]));
if (Result < 0) {
High = Middle - 1;
} else if (Result > 0) {
Low = Middle + 1;
} else {
break;
}
}
//
// If the high index is less than the low index, then a matching
// table entry was not found. Otherwise, get the ordinal number
// from the ordinal table.
//
if (High < Low) {
return EINVAL;
} else {
Ordinal = OrdinalTable[Middle];
}
}
}
//
// If the ordinal number is valid, then bind the import reference and
// return success. Otherwise, return an unsuccessful status.
//
if (Ordinal >= ExportDirectory->NumberOfFunctions) {
return EINVAL;
} else {
FunctionTable = (PULONG)((ULONG_PTR)DllBase + ExportDirectory->AddressOfFunctions);
ThunkEntry->u1.Function = ((ULONG_PTR)DllBase + FunctionTable[Ordinal]);
//
// Check for a forwarder.
//
if ( ((ULONG_PTR)ThunkEntry->u1.Function > (ULONG_PTR)ExportDirectory) &&
((ULONG_PTR)ThunkEntry->u1.Function < ((ULONG_PTR)ExportDirectory + ExportSize)) ) {
CHAR ForwardDllName[10];
PKLDR_DATA_TABLE_ENTRY DataTableEntry;
ULONG TargetExportSize;
PIMAGE_EXPORT_DIRECTORY TargetExportDirectory;
RtlCopyMemory(ForwardDllName,
(PCHAR)ThunkEntry->u1.Function,
sizeof(ForwardDllName));
Temp = strchr(ForwardDllName,'.');
ASSERT(Temp != NULL); // Malformed name, stop here and debug why.
if (Temp != NULL) {
*Temp = '\0';
}
if (!BlCheckForLoadedDll(ForwardDllName,&DataTableEntry)) {
//
// Should load the referenced DLL here, just return failure for now.
//
return(EINVAL);
}
TargetExportDirectory = (PIMAGE_EXPORT_DIRECTORY)
RtlImageDirectoryEntryToData(DataTableEntry->DllBase,
TRUE,
IMAGE_DIRECTORY_ENTRY_EXPORT,
&TargetExportSize);
if (TargetExportDirectory) {
IMAGE_THUNK_DATA thunkData;
PIMAGE_IMPORT_BY_NAME addressOfData;
UCHAR Buffer[128];
ULONG length;
PCHAR ImportName;
ARC_STATUS Status;
ImportName = strchr((PCHAR)ThunkEntry->u1.Function, '.') + 1;
addressOfData = (PIMAGE_IMPORT_BY_NAME)Buffer;
RtlCopyMemory(&addressOfData->Name[0], ImportName, strlen(ImportName)+1);
addressOfData->Hint = 0;
thunkData.u1.AddressOfData = (ULONG_PTR)addressOfData;
Status = BlpBindImportName(DataTableEntry->DllBase,
ImageBase,
&thunkData,
TargetExportDirectory,
TargetExportSize,
TRUE);
ThunkEntry->u1 = thunkData.u1;
return(Status);
} else {
return(EINVAL);
}
}
return ESUCCESS;
}
}
ARC_STATUS
BlpScanImportAddressTable(
IN PVOID DllBase,
IN PVOID ImageBase,
IN PIMAGE_THUNK_DATA ThunkTable
)
/*++
Routine Description:
This routine scans the import address table for the specified image
file and snaps each reference.
Arguments:
DllBase - Supplies the base address of the specified DLL.
If NULL, then references in the image's import table are to
be resolved against the osloader's export table.
ImageBase - Supplies the base address of the image.
ThunkTable - Supplies a pointer to the import thunk table.
Return Value:
ESUCCESS is returned in the scan is successful. Otherwise, return an
unsuccessful status.
--*/
{
PIMAGE_EXPORT_DIRECTORY ExportDirectory;
ULONG ExportTableSize;
ARC_STATUS Status;
//
// Locate the export table in the image specified by the DLL base
// address.
//
#if i386
if (DllBase == NULL) {
ExportDirectory = (PIMAGE_EXPORT_DIRECTORY)OsLoaderExports;
ExportTableSize = 0; // this is OK as this is only used to bind forwarded exports and osloader does not have any
} else {
ExportDirectory =
(PIMAGE_EXPORT_DIRECTORY)RtlImageDirectoryEntryToData(DllBase,
TRUE,
IMAGE_DIRECTORY_ENTRY_EXPORT,
&ExportTableSize);
}
#else
ExportDirectory =
(PIMAGE_EXPORT_DIRECTORY)RtlImageDirectoryEntryToData(DllBase,
TRUE,
IMAGE_DIRECTORY_ENTRY_EXPORT,
&ExportTableSize);
#endif
if (ExportDirectory == NULL) {
return EBADF;
}
//
// Scan the thunk table and bind each import reference.
//
while (ThunkTable->u1.AddressOfData) {
Status = BlpBindImportName(DllBase,
ImageBase,
ThunkTable++,
ExportDirectory,
ExportTableSize,
FALSE);
if (Status != ESUCCESS) {
return Status;
}
}
return ESUCCESS;
}
ARC_STATUS
BlScanImportDescriptorTable(
IN PPATH_SET PathSet,
IN PKLDR_DATA_TABLE_ENTRY ScanEntry,
IN TYPE_OF_MEMORY MemoryType
)
/*++
Routine Description:
This routine scans the import descriptor table for the specified image
file and loads each DLL that is referenced.
Arguments:
PathSet - Supplies a pointer to a set of paths to scan when searching
for DLL's.
ScanEntry - Supplies a pointer to the data table entry for the
image whose import table is to be scanned.
MemoryType - Supplies the type of memory to to be assigned to any DLL's
referenced.
Return Value:
ESUCCESS is returned in the scan is successful. Otherwise, return an
unsuccessful status.
--*/
{
PKLDR_DATA_TABLE_ENTRY DataTableEntry;
CHAR FullDllName[256];
PVOID Base;
PIMAGE_IMPORT_DESCRIPTOR ImportDescriptor;
ULONG ImportTableSize;
ARC_STATUS Status;
PSZ ImportName;
ULONG Index;
PPATH_SOURCE PathSource;
//
// Locate the import table in the image specified by the data table entry.
//
ImportDescriptor =
(PIMAGE_IMPORT_DESCRIPTOR)RtlImageDirectoryEntryToData(ScanEntry->DllBase,
TRUE,
IMAGE_DIRECTORY_ENTRY_IMPORT,
&ImportTableSize);
//
// If the image has an import directory, then scan the import table and
// load the specified DLLs.
//
if (ImportDescriptor != NULL) {
while ((ImportDescriptor->Name != 0) &&
(ImportDescriptor->FirstThunk != 0)) {
//
// Change the name from an RVA to a VA.
//
ImportName = (PSZ)((ULONG_PTR)ScanEntry->DllBase + ImportDescriptor->Name);
//
// If the DLL references itself, then skip the import entry.
//
if (BlpCompareDllName((PCHAR)ImportName,
&ScanEntry->BaseDllName) == FALSE) {
//
// If the DLL is not already loaded, then load the DLL and
// scan its import table.
//
if (BlCheckForLoadedDll((PCHAR)ImportName,
&DataTableEntry) == FALSE) {
//
// Start walking our list of DevicePaths. If the list is
// empty (bad caller!) we fail with ENOENT.
//
Status = ENOENT;
for(Index=0; Index < PathSet->PathCount; Index++) {
PathSource = &PathSet->Source[Index];
strcpy(&FullDllName[0], PathSource->DirectoryPath);
strcat(&FullDllName[0], PathSet->PathOffset);
strcat(&FullDllName[0], (PCHAR)ImportName);
Status = BlLoadImage(
PathSource->DeviceId,
MemoryType,
&FullDllName[0],
TARGET_IMAGE,
&Base
);
if (Status == ESUCCESS) {
BlOutputLoadMessage(
(PCHAR) PathSource->DeviceName,
&FullDllName[0],
NULL
);
break;
}
}
if (Status != ESUCCESS) {
return Status;
}
//
// ISSUE - 2000/29/03 - ADRIAO: Existant namespace polution
// For the FullDllName field We should really be passing
// in AliasName\PathOffset\ImportName.
//
Status = BlAllocateDataTableEntry((PCHAR)ImportName,
&FullDllName[0],
Base,
&DataTableEntry);
if (Status != ESUCCESS) {
return Status;
}
DataTableEntry->Flags |= (ScanEntry->Flags & LDRP_DRIVER_DEPENDENT_DLL);
Status = BlScanImportDescriptorTable(PathSet,
DataTableEntry,
MemoryType);
if (Status != ESUCCESS) {
return Status;
}
//
// BlAllocateDataTableEntry inserts the data table entry into the load order
// linked list in the order the dlls were found. We want the order to be the
// order of dependency. For example if driver A needed Dll B which needed Dll C
// we want the order to be ACB and not ABC. So here we remove this DLLs entry
// and add it at the end. This way when IoInitializeBootDrivers calls DllInitialize
// it will call them in the right order.
//
if (DataTableEntry->Flags &LDRP_DRIVER_DEPENDENT_DLL) {
RemoveEntryList(&(DataTableEntry)->InLoadOrderLinks);
InsertTailList(&BlLoaderBlock->LoadOrderListHead,
&DataTableEntry->InLoadOrderLinks);
}
} else {
//
// Dll already exists but it might not be marked as a driver dependent DLL.
// For example it might be a driver. So mark it now.
//
DataTableEntry->Flags |= (ScanEntry->Flags & LDRP_DRIVER_DEPENDENT_DLL);
}
//
// Scan the import address table and snap links.
//
Status = BlpScanImportAddressTable(DataTableEntry->DllBase,
ScanEntry->DllBase,
(PIMAGE_THUNK_DATA)((ULONG_PTR)ScanEntry->DllBase +
ImportDescriptor->FirstThunk));
if (Status != ESUCCESS) {
return Status;
}
}
ImportDescriptor += 1;
}
}
return ESUCCESS;
}
ARC_STATUS
BlScanOsloaderBoundImportTable (
IN PKLDR_DATA_TABLE_ENTRY ScanEntry
)
/*++
Routine Description:
This routine scans the import descriptor table for the specified image
file and loads each DLL that is referenced.
Arguments:
DataTableEntry - Supplies a pointer to the data table entry for the
image whose import table is to be scanned.
Return Value:
ESUCCESS is returned in the scan is successful. Otherwise, return an
unsuccessful status.
--*/
{
PIMAGE_IMPORT_DESCRIPTOR ImportDescriptor;
ULONG ImportTableSize;
ARC_STATUS Status;
PSZ ImportName;
//
// Locate the import table in the image specified by the data table entry.
//
ImportDescriptor =
(PIMAGE_IMPORT_DESCRIPTOR)RtlImageDirectoryEntryToData(ScanEntry->DllBase,
TRUE,
IMAGE_DIRECTORY_ENTRY_IMPORT,
&ImportTableSize);
//
// If the image has an import directory, then scan the import table.
//
if (ImportDescriptor != NULL) {
while ((ImportDescriptor->Name != 0) &&
(ImportDescriptor->FirstThunk != 0)) {
//
// Change the name from an RVA to a VA.
//
ImportName = (PSZ)((ULONG_PTR)ScanEntry->DllBase + ImportDescriptor->Name);
//
// If the DLL references itself, then skip the import entry.
//
if (BlpCompareDllName((PCHAR)ImportName,
&ScanEntry->BaseDllName) == FALSE) {
//
// Scan the import address table and snap links.
//
Status = BlpScanImportAddressTable(NULL,
ScanEntry->DllBase,
(PIMAGE_THUNK_DATA)((ULONG_PTR)ScanEntry->DllBase +
ImportDescriptor->FirstThunk));
if (Status != ESUCCESS) {
return Status;
}
}
ImportDescriptor += 1;
}
}
return ESUCCESS;
}
Reference in a new issue Copy permalink