OUT PKDB_MODULE_INFO pInfo)
{
PLIST_ENTRY current_entry;
- MODULE_TEXT_SECTION* current;
- extern LIST_ENTRY ModuleTextListHead;
+ PLDR_DATA_TABLE_ENTRY current;
+ extern LIST_ENTRY ModuleListHead;
INT Count = 0;
- current_entry = ModuleTextListHead.Flink;
+ current_entry = ModuleListHead.Flink;
- while (current_entry != &ModuleTextListHead &&
- current_entry != NULL)
+ while (current_entry != &ModuleListHead)
{
- current = CONTAINING_RECORD(current_entry, MODULE_TEXT_SECTION, ListEntry);
+ current = CONTAINING_RECORD(current_entry, LDR_DATA_TABLE_ENTRY, InLoadOrderModuleList);
- if ((Address != NULL && (Address >= (PVOID)current->Base &&
- Address < (PVOID)(current->Base + current->Length))) ||
- (Name != NULL && _wcsicmp(current->Name, Name) == 0) ||
+ if ((Address != NULL && (Address >= (PVOID)current->DllBase &&
+ Address < (PVOID)((ULONG_PTR)current->DllBase + current->SizeOfImage))) ||
+ (Name != NULL && _wcsnicmp(current->BaseDllName.Buffer, Name,
+ current->BaseDllName.Length / sizeof(WCHAR)) == 0) ||
(Index >= 0 && Count++ == Index))
{
- wcsncpy(pInfo->Name, current->Name, 255);
+ wcsncpy(pInfo->Name, current->BaseDllName.Buffer,
+ min(255, current->BaseDllName.Length / sizeof(WCHAR)));
pInfo->Name[255] = L'\0';
- pInfo->Base = (ULONG_PTR)current->Base;
- pInfo->Size = current->Length;
+ pInfo->Base = (ULONG_PTR)current->DllBase;
+ pInfo->Size = current->SizeOfImage;
pInfo->RosSymInfo = current->RosSymInfo;
return TRUE;
}
/*! \brief Load symbol info for a driver.
*
* \param Filename Filename of the driver.
- * \param Module Pointer to the driver MODULE_OBJECT.
+ * \param Module Pointer to the driver LDR_DATA_TABLE_ENTRY.
*/
VOID
KdbSymLoadDriverSymbols(IN PUNICODE_STRING Filename,
- IN PMODULE_OBJECT Module)
+ IN PLDR_DATA_TABLE_ENTRY Module)
{
/* Load symbols for the image if available */
DPRINT("Loading driver %wZ symbols (driver @ %08x)\n", Filename, Module->Base);
- Module->TextSection->RosSymInfo = NULL;
+ Module->RosSymInfo = NULL;
- KdbpSymLoadModuleSymbols(Filename, &Module->TextSection->RosSymInfo);
+ KdbpSymLoadModuleSymbols(Filename, (PROSSYM_INFO*)&Module->RosSymInfo);
}
/*! \brief Unloads symbol info for a driver.
*
- * \param ModuleObject Pointer to the driver MODULE_OBJECT.
+ * \param ModuleObject Pointer to the driver LDR_DATA_TABLE_ENTRY.
*/
VOID
-KdbSymUnloadDriverSymbols(IN PMODULE_OBJECT ModuleObject)
+KdbSymUnloadDriverSymbols(IN PLDR_DATA_TABLE_ENTRY ModuleObject)
{
/* Unload symbols for module if available */
- KdbpSymUnloadModuleSymbols(ModuleObject->TextSection->RosSymInfo);
- ModuleObject->TextSection->RosSymInfo = NULL;
+ KdbpSymUnloadModuleSymbols(ModuleObject->RosSymInfo);
+ ModuleObject->RosSymInfo = NULL;
}
/*! \brief Called when a symbol file is loaded by the loader?
VOID
KdbSymProcessBootSymbols(IN PCHAR FileName)
{
- PMODULE_OBJECT ModuleObject;
+ PLDR_DATA_TABLE_ENTRY ModuleObject;
UNICODE_STRING UnicodeString;
PLOADER_MODULE KeLoaderModules = (PLOADER_MODULE)KeLoaderBlock.ModsAddr;
ANSI_STRING AnsiString;
{
if (! LoadSymbols)
{
- ModuleObject->TextSection->RosSymInfo = NULL;
+ ModuleObject->RosSymInfo = NULL;
return;
}
if (i < KeLoaderBlock.ModsCount)
{
KeLoaderModules[i].Reserved = 1;
- if (ModuleObject->TextSection->RosSymInfo != NULL)
+ if (ModuleObject->RosSymInfo != NULL)
{
- KdbpSymRemoveCachedFile(ModuleObject->TextSection->RosSymInfo);
+ KdbpSymRemoveCachedFile(ModuleObject->RosSymInfo);
}
if (IsRaw)
{
if (! RosSymCreateFromRaw((PVOID) KeLoaderModules[i].ModStart,
KeLoaderModules[i].ModEnd - KeLoaderModules[i].ModStart,
- &ModuleObject->TextSection->RosSymInfo))
+ (PROSSYM_INFO*)&ModuleObject->RosSymInfo))
{
return;
}
{
if (! RosSymCreateFromMem((PVOID) KeLoaderModules[i].ModStart,
KeLoaderModules[i].ModEnd - KeLoaderModules[i].ModStart,
- &ModuleObject->TextSection->RosSymInfo))
+ (PROSSYM_INFO*)&ModuleObject->RosSymInfo))
{
return;
}
/* add file to cache */
RtlInitAnsiString(&AnsiString, FileName);
RtlAnsiStringToUnicodeString(&UnicodeString, &AnsiString, TRUE);
- KdbpSymAddCachedFile(&UnicodeString, ModuleObject->TextSection->RosSymInfo);
+ KdbpSymAddCachedFile(&UnicodeString, ModuleObject->RosSymInfo);
RtlFreeUnicodeString(&UnicodeString);
DPRINT("Installed symbols: %s@%08x-%08x %p\n",
FileName,
- ModuleObject->Base,
- ModuleObject->Length + ModuleObject->Base,
- ModuleObject->TextSection->RosSymInfo);
+ ModuleObject->DllBase,
+ ModuleObject->SizeOfImage + ModuleObject->DllBase,
+ ModuleObject->RosSymInfo);
}
}
}
/*! \brief Initializes the KDB symbols implementation.
*
- * \param NtoskrnlTextSection MODULE_TEXT_SECTION of ntoskrnl.exe
- * \param LdrHalTextSection MODULE_TEXT_SECTION of hal.sys
+ * \param NtoskrnlModuleObject LDR_DATA_TABLE_ENTRY of ntoskrnl.exe
+ * \param LdrHalModuleObject LDR_DATA_TABLE_ENTRY of hal.sys
*/
VOID
-KdbSymInit(IN PMODULE_TEXT_SECTION NtoskrnlTextSection,
- IN PMODULE_TEXT_SECTION LdrHalTextSection)
+KdbSymInit(IN PLDR_DATA_TABLE_ENTRY NtoskrnlModuleObject,
+ IN PLDR_DATA_TABLE_ENTRY LdrHalModuleObject)
{
PCHAR p1, p2;
int Found;
char YesNo;
- NtoskrnlTextSection->RosSymInfo = NULL;
- LdrHalTextSection->RosSymInfo = NULL;
+ NtoskrnlModuleObject->RosSymInfo = NULL;
+ LdrHalModuleObject->RosSymInfo = NULL;
InitializeListHead(&SymbolFileListHead);
KeInitializeSpinLock(&SymbolFileListLock);
LIST_ENTRY ModuleListHead;
KSPIN_LOCK ModuleListLock;
-MODULE_OBJECT NtoskrnlModuleObject;
-MODULE_OBJECT HalModuleObject;
+LDR_DATA_TABLE_ENTRY NtoskrnlModuleObject;
+LDR_DATA_TABLE_ENTRY HalModuleObject;
-LIST_ENTRY ModuleTextListHead;
-STATIC MODULE_TEXT_SECTION NtoskrnlTextSection;
-STATIC MODULE_TEXT_SECTION LdrHalTextSection;
ULONG_PTR LdrHalBase;
/* FORWARD DECLARATIONS ******************************************************/
LdrProcessModule (
PVOID ModuleLoadBase,
PUNICODE_STRING ModuleName,
- PMODULE_OBJECT *ModuleObject );
+ PLDR_DATA_TABLE_ENTRY *ModuleObject );
static VOID
LdrpBuildModuleBaseName (
LdrPEProcessModule (
PVOID ModuleLoadBase,
PUNICODE_STRING FileName,
- PMODULE_OBJECT *ModuleObject );
+ PLDR_DATA_TABLE_ENTRY *ModuleObject );
static PVOID
LdrPEGetExportByName (
ULONG DriverSize );
static NTSTATUS
-LdrPEFixupImports ( PMODULE_OBJECT Module );
+LdrPEFixupImports ( PLDR_DATA_TABLE_ENTRY Module );
/* FUNCTIONS *****************************************************************/
VOID
LdrInitDebug ( PLOADER_MODULE Module, PWCH Name )
{
- PLIST_ENTRY current_entry;
- MODULE_TEXT_SECTION* current;
-
- current_entry = ModuleTextListHead.Flink;
- while (current_entry != &ModuleTextListHead)
- {
- current =
- CONTAINING_RECORD(current_entry, MODULE_TEXT_SECTION, ListEntry);
- if (wcscmp(current->Name, Name) == 0)
- {
- break;
- }
- current_entry = current_entry->Flink;
- }
-
- if (current_entry == &ModuleTextListHead)
- {
- return;
- }
}
VOID INIT_FUNCTION
LdrInit1 ( VOID )
{
- PIMAGE_NT_HEADERS NtHeader;
- PIMAGE_SECTION_HEADER SectionList;
-
- InitializeListHead(&ModuleTextListHead);
-
- /* Setup ntoskrnl.exe text section */
- /*
- * This isn't the base of the text segment, but the start of the
- * full image (in memory)
- * Also, the Length field isn't set to the length of the segment,
- * but is more like the offset, from the image base, to the end
- * of the segment.
- */
- NtHeader = RtlImageNtHeader((PVOID)KERNEL_BASE);
- SectionList = IMAGE_FIRST_SECTION(NtHeader);
- NtoskrnlTextSection.Base = KERNEL_BASE;
- NtoskrnlTextSection.Length = SectionList[0].Misc.VirtualSize
- + SectionList[0].VirtualAddress;
- NtoskrnlTextSection.Name = KERNEL_MODULE_NAME;
- NtoskrnlTextSection.OptionalHeader = OPTHDROFFSET(KERNEL_BASE);
- InsertTailList(&ModuleTextListHead, &NtoskrnlTextSection.ListEntry);
-
- /* Setup hal.dll text section */
- /* Same comment as above applies */
- NtHeader = RtlImageNtHeader((PVOID)LdrHalBase);
- SectionList = IMAGE_FIRST_SECTION(NtHeader);
- LdrHalTextSection.Base = LdrHalBase;
- LdrHalTextSection.Length = SectionList[0].Misc.VirtualSize
- + SectionList[0].VirtualAddress;
- LdrHalTextSection.Name = HAL_MODULE_NAME;
- LdrHalTextSection.OptionalHeader = OPTHDROFFSET(LdrHalBase);
- InsertTailList(&ModuleTextListHead, &LdrHalTextSection.ListEntry);
-
/* Hook for KDB on initialization of the loader. */
- KDB_LOADERINIT_HOOK(&NtoskrnlTextSection, &LdrHalTextSection);
+ KDB_LOADERINIT_HOOK(&NtoskrnlModuleObject, &HalModuleObject);
}
VOID INIT_FUNCTION
KeInitializeSpinLock(&ModuleListLock);
/* Initialize ModuleObject for NTOSKRNL */
- RtlZeroMemory(&NtoskrnlModuleObject, sizeof(MODULE_OBJECT));
- NtoskrnlModuleObject.Base = (PVOID) KERNEL_BASE;
- NtoskrnlModuleObject.Flags = MODULE_FLAG_PE;
- RtlInitUnicodeString(&NtoskrnlModuleObject.FullName, KERNEL_MODULE_NAME);
- LdrpBuildModuleBaseName(&NtoskrnlModuleObject.BaseName, &NtoskrnlModuleObject.FullName);
+ RtlZeroMemory(&NtoskrnlModuleObject, sizeof(LDR_DATA_TABLE_ENTRY));
+ NtoskrnlModuleObject.DllBase = (PVOID) KERNEL_BASE;
+ RtlInitUnicodeString(&NtoskrnlModuleObject.FullDllName, KERNEL_MODULE_NAME);
+ LdrpBuildModuleBaseName(&NtoskrnlModuleObject.BaseDllName, &NtoskrnlModuleObject.FullDllName);
NtHeader = RtlImageNtHeader((PVOID)KERNEL_BASE);
- NtoskrnlModuleObject.Image.PE.FileHeader = &NtHeader->FileHeader;
- NtoskrnlModuleObject.Image.PE.OptionalHeader = &NtHeader->OptionalHeader;
- NtoskrnlModuleObject.Image.PE.SectionList = IMAGE_FIRST_SECTION(NtHeader);
- NtoskrnlModuleObject.EntryPoint = (PVOID) ((ULONG_PTR) NtoskrnlModuleObject.Base + NtHeader->OptionalHeader.AddressOfEntryPoint);
+ NtoskrnlModuleObject.EntryPoint = (PVOID) ((ULONG_PTR) NtoskrnlModuleObject.DllBase + NtHeader->OptionalHeader.AddressOfEntryPoint);
DPRINT("ModuleObject:%08x entrypoint at %x\n", &NtoskrnlModuleObject, NtoskrnlModuleObject.EntryPoint);
- NtoskrnlModuleObject.Length = NtoskrnlModuleObject.Image.PE.OptionalHeader->SizeOfImage;
- NtoskrnlModuleObject.TextSection = &NtoskrnlTextSection;
+ NtoskrnlModuleObject.SizeOfImage = NtHeader->OptionalHeader.SizeOfImage;
- InsertTailList(&ModuleListHead,
- &NtoskrnlModuleObject.ListEntry);
+ InsertTailList(&ModuleListHead, &NtoskrnlModuleObject.InLoadOrderModuleList);
/* Initialize ModuleObject for HAL */
- RtlZeroMemory(&HalModuleObject, sizeof(MODULE_OBJECT));
- HalModuleObject.Base = (PVOID) LdrHalBase;
- HalModuleObject.Flags = MODULE_FLAG_PE;
+ RtlZeroMemory(&HalModuleObject, sizeof(LDR_DATA_TABLE_ENTRY));
+ HalModuleObject.DllBase = (PVOID) LdrHalBase;
- RtlInitUnicodeString(&HalModuleObject.FullName, HAL_MODULE_NAME);
- LdrpBuildModuleBaseName(&HalModuleObject.BaseName, &HalModuleObject.FullName);
+ RtlInitUnicodeString(&HalModuleObject.FullDllName, HAL_MODULE_NAME);
+ LdrpBuildModuleBaseName(&HalModuleObject.BaseDllName, &HalModuleObject.FullDllName);
NtHeader = RtlImageNtHeader((PVOID)LdrHalBase);
- HalModuleObject.Image.PE.FileHeader = &NtHeader->FileHeader;
- HalModuleObject.Image.PE.OptionalHeader = &NtHeader->OptionalHeader;
- HalModuleObject.Image.PE.SectionList = IMAGE_FIRST_SECTION(NtHeader);
- HalModuleObject.EntryPoint = (PVOID) ((ULONG_PTR) HalModuleObject.Base + NtHeader->OptionalHeader.AddressOfEntryPoint);
+ HalModuleObject.EntryPoint = (PVOID) ((ULONG_PTR) HalModuleObject.DllBase + NtHeader->OptionalHeader.AddressOfEntryPoint);
DPRINT("ModuleObject:%08x entrypoint at %x\n", &HalModuleObject, HalModuleObject.EntryPoint);
- HalModuleObject.Length = HalModuleObject.Image.PE.OptionalHeader->SizeOfImage;
- HalModuleObject.TextSection = &LdrHalTextSection;
+ HalModuleObject.SizeOfImage = NtHeader->OptionalHeader.SizeOfImage;
- InsertTailList(&ModuleListHead,
- &HalModuleObject.ListEntry);
+ InsertTailList(&ModuleListHead, &HalModuleObject.InLoadOrderModuleList);
}
NTSTATUS
PVOID *EntryPoint,
PVOID *ExportSectionPointer )
{
- PMODULE_OBJECT ModuleObject;
+ PLDR_DATA_TABLE_ENTRY ModuleObject;
NTSTATUS Status;
ModuleObject = LdrGetModuleObject(DriverName);
}
if (ModuleBase)
- *ModuleBase = ModuleObject->Base;
+ *ModuleBase = ModuleObject->DllBase;
//if (SectionPointer)
// *SectionPointer = ModuleObject->
LdrpLoadAndCallImage ( PUNICODE_STRING ModuleName )
{
PDRIVER_INITIALIZE DriverEntry;
- PMODULE_OBJECT ModuleObject;
+ PLDR_DATA_TABLE_ENTRY ModuleObject;
+ DRIVER_OBJECT DriverObject;
NTSTATUS Status;
ModuleObject = LdrGetModuleObject(ModuleName);
DriverEntry = (PDRIVER_INITIALIZE)ModuleObject->EntryPoint;
- Status = DriverEntry(NULL, NULL);
+ RtlZeroMemory(&DriverObject, sizeof(DriverObject));
+ DriverObject.DriverStart = ModuleObject->DllBase;
+
+ Status = DriverEntry(&DriverObject, NULL);
if (!NT_SUCCESS(Status))
{
LdrUnloadModule(ModuleObject);
NTSTATUS
LdrLoadModule(
PUNICODE_STRING Filename,
- PMODULE_OBJECT *ModuleObject )
+ PLDR_DATA_TABLE_ENTRY *ModuleObject )
{
PVOID ModuleLoadBase;
NTSTATUS Status;
HANDLE FileHandle;
OBJECT_ATTRIBUTES ObjectAttributes;
- PMODULE_OBJECT Module;
+ PLDR_DATA_TABLE_ENTRY Module;
FILE_STANDARD_INFORMATION FileStdInfo;
IO_STATUS_BLOCK IoStatusBlock;
NTSTATUS
-LdrUnloadModule ( PMODULE_OBJECT ModuleObject )
+LdrUnloadModule ( PLDR_DATA_TABLE_ENTRY ModuleObject )
{
KIRQL Irql;
/* Remove the module from the module list */
KeAcquireSpinLock(&ModuleListLock,&Irql);
- RemoveEntryList(&ModuleObject->ListEntry);
+ RemoveEntryList(&ModuleObject->InLoadOrderModuleList);
KeReleaseSpinLock(&ModuleListLock, Irql);
/* Hook for KDB on unloading a driver. */
KDB_UNLOADDRIVER_HOOK(ModuleObject);
- /* Free text section */
- if (ModuleObject->TextSection != NULL)
- {
- ExFreePool(ModuleObject->TextSection->Name);
- RemoveEntryList(&ModuleObject->TextSection->ListEntry);
- ExFreePool(ModuleObject->TextSection);
- ModuleObject->TextSection = NULL;
- }
-
/* Free module section */
- // MmFreeSection(ModuleObject->Base);
+ // MmFreeSection(ModuleObject->DllBase);
- ExFreePool(ModuleObject->FullName.Buffer);
+ ExFreePool(ModuleObject->FullDllName.Buffer);
ExFreePool(ModuleObject);
return(STATUS_SUCCESS);
LdrProcessModule(
PVOID ModuleLoadBase,
PUNICODE_STRING ModuleName,
- PMODULE_OBJECT *ModuleObject )
+ PLDR_DATA_TABLE_ENTRY *ModuleObject )
{
PIMAGE_DOS_HEADER PEDosHeader;
PULONG ReqSize )
{
PLIST_ENTRY current_entry;
- PMODULE_OBJECT current;
+ PLDR_DATA_TABLE_ENTRY current;
ULONG ModuleCount = 0;
PSYSTEM_MODULE_INFORMATION Smi;
ANSI_STRING AnsiName;
current_entry = ModuleListHead.Flink;
while (current_entry != (&ModuleListHead))
{
- current = CONTAINING_RECORD(current_entry,MODULE_OBJECT,ListEntry);
+ current = CONTAINING_RECORD(current_entry,LDR_DATA_TABLE_ENTRY,InLoadOrderModuleList);
Smi->Module[ModuleCount].Unknown1 = 0; /* Always 0 */
Smi->Module[ModuleCount].Unknown2 = 0; /* Always 0 */
- Smi->Module[ModuleCount].Base = current->Base;
- Smi->Module[ModuleCount].Size = current->Length;
+ Smi->Module[ModuleCount].Base = current->DllBase;
+ Smi->Module[ModuleCount].Size = current->SizeOfImage;
Smi->Module[ModuleCount].Flags = 0; /* Flags ??? (GN) */
Smi->Module[ModuleCount].Index = (USHORT)ModuleCount;
Smi->Module[ModuleCount].NameLength = 0;
AnsiName.MaximumLength = 256;
AnsiName.Buffer = Smi->Module[ModuleCount].ImageName;
RtlUnicodeStringToAnsiString(&AnsiName,
- ¤t->FullName,
+ ¤t->FullDllName,
FALSE);
p = strrchr(AnsiName.Buffer, '\\');
return(0);
}
-PMODULE_OBJECT
+PLDR_DATA_TABLE_ENTRY
LdrGetModuleObject ( PUNICODE_STRING ModuleName )
{
- PMODULE_OBJECT Module;
+ PLDR_DATA_TABLE_ENTRY Module;
PLIST_ENTRY Entry;
KIRQL Irql;
Entry = ModuleListHead.Flink;
while (Entry != &ModuleListHead)
{
- Module = CONTAINING_RECORD(Entry, MODULE_OBJECT, ListEntry);
+ Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InLoadOrderModuleList);
DPRINT("Comparing %wZ and %wZ\n",
&Module->BaseName,
ModuleName);
- if (!LdrpCompareModuleNames(&Module->BaseName, ModuleName))
+ if (!LdrpCompareModuleNames(&Module->BaseDllName, ModuleName))
{
- DPRINT("Module %wZ\n", &Module->BaseName);
+ DPRINT("Module %wZ\n", &Module->BaseDllName);
KeReleaseSpinLock(&ModuleListLock, Irql);
return(Module);
}
LdrPEProcessModule(
PVOID ModuleLoadBase,
PUNICODE_STRING FileName,
- PMODULE_OBJECT *ModuleObject )
+ PLDR_DATA_TABLE_ENTRY *ModuleObject )
{
unsigned int DriverSize, Idx;
DWORD CurrentSize;
PIMAGE_DOS_HEADER PEDosHeader;
PIMAGE_NT_HEADERS PENtHeaders;
PIMAGE_SECTION_HEADER PESectionHeaders;
- PMODULE_OBJECT CreatedModuleObject;
- MODULE_TEXT_SECTION* ModuleTextSection;
+ PLDR_DATA_TABLE_ENTRY CreatedModuleObject;
NTSTATUS Status;
KIRQL Irql;
/* Create the module */
CreatedModuleObject = ExAllocatePoolWithTag (
- NonPagedPool, sizeof(MODULE_OBJECT), TAG_MODULE_OBJECT );
+ NonPagedPool, sizeof(LDR_DATA_TABLE_ENTRY), TAG_MODULE_OBJECT );
if (CreatedModuleObject == NULL)
{
// MmFreeSection(DriverBase);
return STATUS_INSUFFICIENT_RESOURCES;
}
- RtlZeroMemory(CreatedModuleObject, sizeof(MODULE_OBJECT));
+ RtlZeroMemory(CreatedModuleObject, sizeof(LDR_DATA_TABLE_ENTRY));
/* Initialize ModuleObject data */
- CreatedModuleObject->Base = DriverBase;
- CreatedModuleObject->Flags = MODULE_FLAG_PE;
-
- CreatedModuleObject->FullName.Length = 0;
- CreatedModuleObject->FullName.MaximumLength = FileName->Length + sizeof(UNICODE_NULL);
- CreatedModuleObject->FullName.Buffer =
- ExAllocatePoolWithTag(PagedPool, CreatedModuleObject->FullName.MaximumLength, TAG_LDR_WSTR);
- if (CreatedModuleObject->FullName.Buffer == NULL)
+ CreatedModuleObject->DllBase = DriverBase;
+
+ CreatedModuleObject->FullDllName.Length = 0;
+ CreatedModuleObject->FullDllName.MaximumLength = FileName->Length + sizeof(UNICODE_NULL);
+ CreatedModuleObject->FullDllName.Buffer =
+ ExAllocatePoolWithTag(PagedPool, CreatedModuleObject->FullDllName.MaximumLength, TAG_LDR_WSTR);
+ if (CreatedModuleObject->FullDllName.Buffer == NULL)
{
ExFreePool(CreatedModuleObject);
// MmFreeSection(DriverBase);
return STATUS_INSUFFICIENT_RESOURCES;
}
- RtlCopyUnicodeString(&CreatedModuleObject->FullName, FileName);
- LdrpBuildModuleBaseName(&CreatedModuleObject->BaseName,
- &CreatedModuleObject->FullName);
+ RtlCopyUnicodeString(&CreatedModuleObject->FullDllName, FileName);
+ LdrpBuildModuleBaseName(&CreatedModuleObject->BaseDllName,
+ &CreatedModuleObject->FullDllName);
CreatedModuleObject->EntryPoint =
(PVOID)((ULONG_PTR)DriverBase +
PENtHeaders->OptionalHeader.AddressOfEntryPoint);
- CreatedModuleObject->Length = DriverSize;
+ CreatedModuleObject->SizeOfImage = DriverSize;
DPRINT("EntryPoint at %x\n", CreatedModuleObject->EntryPoint);
- CreatedModuleObject->Image.PE.FileHeader =
- (PIMAGE_FILE_HEADER) ((unsigned int) DriverBase + PEDosHeader->e_lfanew + sizeof(ULONG));
-
- DPRINT("FileHeader at %x\n", CreatedModuleObject->Image.PE.FileHeader);
- CreatedModuleObject->Image.PE.OptionalHeader =
- (PIMAGE_OPTIONAL_HEADER) ((unsigned int) DriverBase + PEDosHeader->e_lfanew + sizeof(ULONG) +
- sizeof(IMAGE_FILE_HEADER));
- DPRINT("OptionalHeader at %x\n", CreatedModuleObject->Image.PE.OptionalHeader);
- CreatedModuleObject->Image.PE.SectionList =
- (PIMAGE_SECTION_HEADER) ((unsigned int) DriverBase + PEDosHeader->e_lfanew + sizeof(ULONG) +
- sizeof(IMAGE_FILE_HEADER) + CreatedModuleObject->Image.PE.FileHeader->SizeOfOptionalHeader);
- DPRINT("SectionList at %x\n", CreatedModuleObject->Image.PE.SectionList);
-
/* Perform import fixups */
Status = LdrPEFixupImports(CreatedModuleObject);
if (!NT_SUCCESS(Status))
{
// MmFreeSection(DriverBase);
- ExFreePool(CreatedModuleObject->FullName.Buffer);
+ ExFreePool(CreatedModuleObject->FullDllName.Buffer);
ExFreePool(CreatedModuleObject);
return Status;
}
/* Insert module */
KeAcquireSpinLock(&ModuleListLock, &Irql);
InsertTailList(&ModuleListHead,
- &CreatedModuleObject->ListEntry);
+ &CreatedModuleObject->InLoadOrderModuleList);
KeReleaseSpinLock(&ModuleListLock, Irql);
-
- ModuleTextSection = ExAllocatePoolWithTag (
- NonPagedPool,
- sizeof(MODULE_TEXT_SECTION),
- TAG_MODULE_TEXT_SECTION );
- ASSERT(ModuleTextSection);
- RtlZeroMemory(ModuleTextSection, sizeof(MODULE_TEXT_SECTION));
- ModuleTextSection->Base = (ULONG)DriverBase;
- ModuleTextSection->Length = DriverSize;
- ModuleTextSection->Name = ExAllocatePoolWithTag (
- NonPagedPool,
- (CreatedModuleObject->BaseName.Length + 1) * sizeof(WCHAR),
- TAG_LDR_WSTR );
- RtlCopyMemory(ModuleTextSection->Name,
- CreatedModuleObject->BaseName.Buffer,
- CreatedModuleObject->BaseName.Length);
- ModuleTextSection->Name[CreatedModuleObject->BaseName.Length / sizeof(WCHAR)] = 0;
- ModuleTextSection->OptionalHeader =
- CreatedModuleObject->Image.PE.OptionalHeader;
- InsertTailList(&ModuleTextListHead, &ModuleTextSection->ListEntry);
-
- CreatedModuleObject->TextSection = ModuleTextSection;
-
*ModuleObject = CreatedModuleObject;
DPRINT("Loading Module %wZ...\n", FileName);
DPRINT("Module %wZ loaded at 0x%.08x.\n",
- FileName, CreatedModuleObject->Base);
+ FileName, CreatedModuleObject->DllBase);
return STATUS_SUCCESS;
}
CHAR NameBuffer[128];
UNICODE_STRING ModuleName;
PCHAR p;
- PMODULE_OBJECT ModuleObject;
+ PLDR_DATA_TABLE_ENTRY ModuleObject;
DPRINT("LdrPEFixupForward (%s)\n", ForwardName);
CPRINT("LdrPEFixupForward: failed to find module %s\n", NameBuffer);
return NULL;
}
- return LdrPEGetExportByName(ModuleObject->Base, (PUCHAR)(p+1), 0xffff);
+ return LdrPEGetExportByName(ModuleObject->DllBase, (PUCHAR)(p+1), 0xffff);
}
static NTSTATUS
static NTSTATUS
LdrPEGetOrLoadModule (
- PMODULE_OBJECT Module,
+ PLDR_DATA_TABLE_ENTRY Module,
PCHAR ImportedName,
- PMODULE_OBJECT* ImportedModule)
+ PLDR_DATA_TABLE_ENTRY* ImportedModule)
{
UNICODE_STRING DriverName;
UNICODE_STRING NameString;
PWCHAR PathEnd;
ULONG PathLength;
- PathEnd = wcsrchr(Module->FullName.Buffer, L'\\');
+ PathEnd = wcsrchr(Module->FullDllName.Buffer, L'\\');
if (NULL != PathEnd)
{
- PathLength = (PathEnd - Module->FullName.Buffer + 1) * sizeof(WCHAR);
- RtlCopyMemory(NameBuffer, Module->FullName.Buffer, PathLength);
+ PathLength = (PathEnd - Module->FullDllName.Buffer + 1) * sizeof(WCHAR);
+ RtlCopyMemory(NameBuffer, Module->FullDllName.Buffer, PathLength);
RtlCopyMemory(NameBuffer + (PathLength / sizeof(WCHAR)), DriverName.Buffer, DriverName.Length);
NameString.Buffer = NameBuffer;
NameString.MaximumLength = NameString.Length = PathLength + DriverName.Length;
static NTSTATUS
LdrPEProcessImportDirectoryEntry(
PVOID DriverBase,
- PMODULE_OBJECT ImportedModule,
+ PLDR_DATA_TABLE_ENTRY ImportedModule,
PIMAGE_IMPORT_DESCRIPTOR ImportModuleDirectory )
{
PVOID* ImportAddressList;
if ((*FunctionNameList) & 0x80000000)
{
Ordinal = (*FunctionNameList) & 0x7fffffff;
- *ImportAddressList = LdrPEGetExportByOrdinal(ImportedModule->Base, Ordinal);
+ *ImportAddressList = LdrPEGetExportByOrdinal(ImportedModule->DllBase, Ordinal);
if ((*ImportAddressList) == NULL)
{
- DPRINT1("Failed to import #%ld from %wZ\n", Ordinal, &ImportedModule->FullName);
+ DPRINT1("Failed to import #%ld from %wZ\n", Ordinal, &ImportedModule->FullDllName);
return STATUS_UNSUCCESSFUL;
}
}
{
IMAGE_IMPORT_BY_NAME *pe_name;
pe_name = RVA(DriverBase, *FunctionNameList);
- *ImportAddressList = LdrPEGetExportByName(ImportedModule->Base, pe_name->Name, pe_name->Hint);
+ *ImportAddressList = LdrPEGetExportByName(ImportedModule->DllBase, pe_name->Name, pe_name->Hint);
if ((*ImportAddressList) == NULL)
{
- DPRINT1("Failed to import %s from %wZ\n", pe_name->Name, &ImportedModule->FullName);
+ DPRINT1("Failed to import %s from %wZ\n", pe_name->Name, &ImportedModule->FullDllName);
return STATUS_UNSUCCESSFUL;
}
}
}
static NTSTATUS
-LdrPEFixupImports ( PMODULE_OBJECT Module )
+LdrPEFixupImports ( PLDR_DATA_TABLE_ENTRY Module )
{
PIMAGE_IMPORT_DESCRIPTOR ImportModuleDirectory;
PCHAR ImportedName;
- PMODULE_OBJECT ImportedModule;
+ PLDR_DATA_TABLE_ENTRY ImportedModule;
NTSTATUS Status;
/* Process each import module */
ImportModuleDirectory = (PIMAGE_IMPORT_DESCRIPTOR)
- RtlImageDirectoryEntryToData(Module->Base,
+ RtlImageDirectoryEntryToData(Module->DllBase,
TRUE,
IMAGE_DIRECTORY_ENTRY_IMPORT,
NULL);
DPRINT("Processeing import directory at %p\n", ImportModuleDirectory);
while (ImportModuleDirectory->Name)
{
- if (Module->Length <= ImportModuleDirectory->Name)
+ if (Module->SizeOfImage <= ImportModuleDirectory->Name)
{
- DPRINT1("Invalid import directory in %wZ\n", &Module->FullName);
+ DPRINT1("Invalid import directory in %wZ\n", &Module->FullDllName);
return STATUS_SECTION_NOT_IMAGE;
}
/* Check to make sure that import lib is kernel */
- ImportedName = (PCHAR) Module->Base + ImportModuleDirectory->Name;
+ ImportedName = (PCHAR) Module->DllBase + ImportModuleDirectory->Name;
Status = LdrPEGetOrLoadModule(Module, ImportedName, &ImportedModule);
if (!NT_SUCCESS(Status))
return Status;
}
- Status = LdrPEProcessImportDirectoryEntry(Module->Base, ImportedModule, ImportModuleDirectory);
+ Status = LdrPEProcessImportDirectoryEntry(Module->DllBase, ImportedModule, ImportModuleDirectory);
if (!NT_SUCCESS(Status))
{
return Status;