Microsoft/Windows2000
Microsoft/Windows2000
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
Windows2000/private/ntos/rtl/ldrrsrc.c

1712 lines
61 KiB
C
Raw Permalink Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*++
Copyright (c) 1991 Microsoft Corporation
Module Name:
ldrrsrc.c
Abstract:
Loader API calls for accessing resource sections.
Author:
Steve Wood (stevewo) 16-Sep-1991
--*/
#include "ntrtlp.h"
#if defined(ALLOC_PRAGMA) && defined(NTOS_KERNEL_RUNTIME)
#pragma alloc_text(PAGE,LdrAccessResource)
#pragma alloc_text(PAGE,LdrpAccessResourceData)
#pragma alloc_text(PAGE,LdrFindEntryForAddress)
#pragma alloc_text(PAGE,LdrFindResource_U)
#pragma alloc_text(PAGE,LdrFindResourceDirectory_U)
#pragma alloc_text(PAGE,LdrpCompareResourceNames_U)
#pragma alloc_text(PAGE,LdrpSearchResourceSection_U)
#pragma alloc_text(PAGE,LdrEnumResources)
#endif
#ifndef NTOS_KERNEL_RUNTIME
PALT_RESOURCE_MODULE AlternateResourceModules;
ULONG AlternateResourceModuleCount;
ULONG AltResMemBlockCount;
LANGID UILangId, InstallLangId;
#define MEMBLOCKSIZE 16
#define RESMODSIZE sizeof(ALT_RESOURCE_MODULE)
#endif
NTSTATUS
LdrAccessResource(
IN PVOID DllHandle,
IN PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry,
OUT PVOID *Address OPTIONAL,
OUT PULONG Size OPTIONAL
)
/*++
Routine Description:
This function locates the address of the specified resource in the specified DLL and returns its address.
Arguments:
DllHandle - Supplies a handle to the image file that the resource is contained in.
ResourceDataEntry - Supplies a pointer to the resource data entry in
the resource data section of the image file specified by the
DllHandle parameter. This pointer should have been one returned
by the LdrFindResource function.
Address - Optional pointer to a variable that will receive the
address of the resource specified by the first two parameters.
Size - Optional pointer to a variable that will receive the size of
the resource specified by the first two parameters.
Return Value:
TBD
--*/
{
RTL_PAGED_CODE();
return LdrpAccessResourceData(
DllHandle,
ResourceDataEntry,
Address,
Size
);
}
NTSTATUS
LdrpAccessResourceData(
IN PVOID DllHandle,
IN PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry,
OUT PVOID *Address OPTIONAL,
OUT PULONG Size OPTIONAL
)
/*++
Routine Description:
This function returns the data necessary to actually examine the contents of a particular resource.
Arguments:
DllHandle - Supplies a handle to the image file that the resource is contained in.
ResourceDataEntry - Supplies a pointer to the resource data entry in
the resource data directory of the image file specified by the
DllHandle parameter. This pointer should have been one returned
by the LdrFindResource function.
Address - Optional pointer to a variable that will receive the address of the resource specified by the first two parameters.
Size - Optional pointer to a variable that will receive the size of the resource specified by the first two parameters.
Return Value:
TBD
--*/
{
PIMAGE_RESOURCE_DIRECTORY ResourceDirectory;
ULONG ResourceSize;
PIMAGE_NT_HEADERS NtHeaders;
ULONG_PTR VirtualAddressOffset;
PIMAGE_SECTION_HEADER NtSection;
RTL_PAGED_CODE();
#ifndef NTOS_KERNEL_RUNTIME
ResourceDirectory = (PIMAGE_RESOURCE_DIRECTORY)
RtlImageDirectoryEntryToData(DllHandle,
TRUE,
IMAGE_DIRECTORY_ENTRY_RESOURCE,
&ResourceSize
);
if (!ResourceDirectory) {
return( STATUS_RESOURCE_DATA_NOT_FOUND );
}
if ((ULONG_PTR)ResourceDataEntry < (ULONG_PTR) ResourceDirectory ){
DllHandle = LdrLoadAlternateResourceModule (DllHandle, NULL);
} else{
NtHeaders = RtlImageNtHeader(
(PVOID)((ULONG_PTR)DllHandle & ~0x00000001)
);
if (NtHeaders) {
// Find the bounds of the image so we can see if this resource entry is in an alternate
// resource dll.
ULONG_PTR ImageStart = (ULONG_PTR)DllHandle & ~0x00000001;
SIZE_T ImageSize = 0;
if ((ULONG_PTR)DllHandle & 0x00000001) {
// mapped as datafile. Ask mm for the size
NTSTATUS Status;
MEMORY_BASIC_INFORMATION MemInfo;
Status = NtQueryVirtualMemory(NtCurrentProcess(), (PVOID) ImageStart, MemoryBasicInformation, (PVOID)&MemInfo, sizeof(MemInfo), NULL);
if ( !NT_SUCCESS(Status) ) {
ImageSize = 0;
} else {
ImageSize = MemInfo.RegionSize;
}
} else {
ImageSize = ((PIMAGE_NT_HEADERS32)NtHeaders)->OptionalHeader.SizeOfImage;
}
if (!(((ULONG_PTR)ResourceDataEntry >= ImageStart) && ((ULONG_PTR)ResourceDataEntry < (ImageStart + ImageSize)))) {
// Doesn't fall within the specified image. Must be an alternate dll.
DllHandle = LdrLoadAlternateResourceModule (DllHandle, NULL);
}
}
}
if (!DllHandle){
return ( STATUS_RESOURCE_DATA_NOT_FOUND );
}
#endif
try {
ResourceDirectory = (PIMAGE_RESOURCE_DIRECTORY)
RtlImageDirectoryEntryToData(DllHandle,
TRUE,
IMAGE_DIRECTORY_ENTRY_RESOURCE,
&ResourceSize
);
if (!ResourceDirectory) {
return( STATUS_RESOURCE_DATA_NOT_FOUND );
}
if ((ULONG_PTR)DllHandle & 0x00000001) {
ULONG ResourceRVA;
DllHandle = (PVOID)((ULONG_PTR)DllHandle & ~0x00000001);
NtHeaders = RtlImageNtHeader( DllHandle );
if (NtHeaders->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
ResourceRVA=((PIMAGE_NT_HEADERS32)NtHeaders)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_RESOURCE ].VirtualAddress;
} else if (NtHeaders->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
ResourceRVA=((PIMAGE_NT_HEADERS64)NtHeaders)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_RESOURCE ].VirtualAddress;
} else {
ResourceRVA = 0;
}
if (!ResourceRVA) {
return( STATUS_RESOURCE_DATA_NOT_FOUND );
}
VirtualAddressOffset = (ULONG_PTR)DllHandle + ResourceRVA - (ULONG_PTR)ResourceDirectory;
// Now, we must check to see if the resource is not in the
// same section as the resource table. If it's in .rsrc1,
// we've got to adjust the RVA in the ResourceDataEntry
// to point to the correct place in the non-VA data file.
NtSection= RtlSectionTableFromVirtualAddress( NtHeaders, DllHandle, ResourceRVA);
if (!NtSection) {
return( STATUS_RESOURCE_DATA_NOT_FOUND );
}
if ( ResourceDataEntry->OffsetToData > NtSection->Misc.VirtualSize ) {
ULONG rva;
rva = NtSection->VirtualAddress;
NtSection= RtlSectionTableFromVirtualAddress(NtHeaders,
DllHandle,
ResourceDataEntry->OffsetToData
);
VirtualAddressOffset +=
((ULONG_PTR)NtSection->VirtualAddress - rva) -
((ULONG_PTR)RtlAddressInSectionTable ( NtHeaders, DllHandle, NtSection->VirtualAddress ) - (ULONG_PTR)ResourceDirectory);
}
}
else {
VirtualAddressOffset = 0;
}
if (ARGUMENT_PRESENT( Address )) {
*Address = (PVOID)( (PCHAR)DllHandle +
(ResourceDataEntry->OffsetToData - VirtualAddressOffset)
);
}
if (ARGUMENT_PRESENT( Size )) {
*Size = ResourceDataEntry->Size;
}
}
except (EXCEPTION_EXECUTE_HANDLER) {
return GetExceptionCode();
}
return( STATUS_SUCCESS );
}
NTSTATUS LdrFindEntryForAddress(IN PVOID Address, OUT PLDR_DATA_TABLE_ENTRY *TableEntry)
/*++
Routine Description:
This function returns the load data table entry that describes the virtual address range that contains the passed virtual address.
Arguments:
Address - Supplies a 32-bit virtual address.
TableEntry - Supplies a pointer to the variable that will receive the address of the loader data table entry.
Return Value:
Status
--*/
{
PPEB_LDR_DATA Ldr;
PLIST_ENTRY Head, Next;
PLDR_DATA_TABLE_ENTRY Entry;
PIMAGE_NT_HEADERS NtHeaders;
PVOID ImageBase;
PVOID EndOfImage;
Ldr = NtCurrentPeb()->Ldr;
if (Ldr == NULL) {
return( STATUS_NO_MORE_ENTRIES );
}
Head = &Ldr->InMemoryOrderModuleList;
Next = Head->Flink;
while ( Next != Head )
{
Entry = CONTAINING_RECORD( Next, LDR_DATA_TABLE_ENTRY, InMemoryOrderLinks );
NtHeaders = RtlImageNtHeader( Entry->DllBase );
if (NtHeaders != NULL) {
ImageBase = (PVOID)Entry->DllBase;
EndOfImage = (PVOID) ((ULONG_PTR)ImageBase + NtHeaders->OptionalHeader.SizeOfImage);
if ((ULONG_PTR)Address >= (ULONG_PTR)ImageBase && (ULONG_PTR)Address < (ULONG_PTR)EndOfImage) {
*TableEntry = Entry;
return( STATUS_SUCCESS );
}
}
Next = Next->Flink;
}
return( STATUS_NO_MORE_ENTRIES );
}
NTSTATUS
LdrFindResource_U(
IN PVOID DllHandle,
IN PULONG_PTR ResourceIdPath,
IN ULONG ResourceIdPathLength,
OUT PIMAGE_RESOURCE_DATA_ENTRY *ResourceDataEntry
)
/*++
Routine Description:
This function locates the address of the specified resource in the specified DLL and returns its address.
Arguments:
DllHandle - Supplies a handle to the image file that the resource is contained in.
ResourceIdPath - Supplies a pointer to an array of 32-bit resource
identifiers. Each identifier is either an integer or a pointer
to a STRING structure that specifies a resource name. The array
is used to traverse the directory structure contained in the
resource section in the image file specified by the DllHandle
parameter.
ResourceIdPathLength - Supplies the number of elements in the
ResourceIdPath array.
ResourceDataEntry - Supplies a pointer to a variable that will
receive the address of the resource data entry in the resource
data section of the image file specified by the DllHandle parameter.
Return Value:
TBD
--*/
{
RTL_PAGED_CODE();
return LdrpSearchResourceSection_U(
DllHandle,
ResourceIdPath,
ResourceIdPathLength,
FALSE, // Look for a leaf node
FALSE,
(PVOID *)ResourceDataEntry
);
}
NTSTATUS
LdrFindResourceDirectory_U(
IN PVOID DllHandle,
IN PULONG_PTR ResourceIdPath,
IN ULONG ResourceIdPathLength,
OUT PIMAGE_RESOURCE_DIRECTORY *ResourceDirectory
)
/*++
Routine Description:
This function locates the address of the specified resource directory in
specified DLL and returns its address.
Arguments:
DllHandle - Supplies a handle to the image file that the resource
directory is contained in.
ResourceIdPath - Supplies a pointer to an array of 32-bit resource
identifiers. Each identifier is either an integer or a pointer
to a STRING structure that specifies a resource name. The array
is used to traverse the directory structure contained in the
resource section in the image file specified by the DllHandle
parameter.
ResourceIdPathLength - Supplies the number of elements in the ResourceIdPath array.
ResourceDirectory - Supplies a pointer to a variable that will receive the address of the resource directory specified by ResourceIdPath in the resource data section of the image file the DllHandle parameter.
Return Value:
TBD
--*/
{
RTL_PAGED_CODE();
return LdrpSearchResourceSection_U(
DllHandle,
ResourceIdPath,
ResourceIdPathLength,
TRUE, // Look for a directory node
FALSE,
(PVOID *)ResourceDirectory
);
}
LONG
LdrpCompareResourceNames_U(
IN ULONG_PTR ResourceName,
IN PIMAGE_RESOURCE_DIRECTORY ResourceDirectory,
IN PIMAGE_RESOURCE_DIRECTORY_ENTRY ResourceDirectoryEntry
)
{
LONG li;
PIMAGE_RESOURCE_DIR_STRING_U ResourceNameString;
if (ResourceName & LDR_RESOURCE_ID_NAME_MASK) {
if (!ResourceDirectoryEntry->NameIsString) {
return( -1 );
}
ResourceNameString = (PIMAGE_RESOURCE_DIR_STRING_U) ((PCHAR)ResourceDirectory + ResourceDirectoryEntry->NameOffset);
li = wcsncmp( (LPWSTR)ResourceName, ResourceNameString->NameString, ResourceNameString->Length);
if (!li && wcslen((PWSTR)ResourceName) != ResourceNameString->Length) {
return( 1 );
}
return(li);
} else {
if (ResourceDirectoryEntry->NameIsString) {
return( 1 );
}
return( (ULONG)(ResourceName - ResourceDirectoryEntry->Name) );
}
}
#define USE_FIRSTAVAILABLE_LANGID (0xFFFFFFFF & ~LDR_RESOURCE_ID_NAME_MASK)
NTSTATUS
LdrpSearchResourceSection_U(
IN PVOID DllHandle,
IN PULONG_PTR ResourceIdPath,
IN ULONG ResourceIdPathLength,
IN BOOLEAN FindDirectoryEntry,
IN BOOLEAN ExactLangMatchOnly,
OUT PVOID *ResourceDirectoryOrData
)
/*++
Routine Description:
This function locates the address of the specified resource in the specified DLL and returns its address.
Arguments:
DllHandle - Supplies a handle to the image file that the resource is contained in.
ResourceIdPath - Supplies a pointer to an array of 32-bit resource
identifiers. Each identifier is either an integer or a pointer
to a null terminated string (PSZ) that specifies a resource
name. The array is used to traverse the directory structure
contained in the resource section in the image file specified by
the DllHandle parameter.
ResourceIdPathLength - Supplies the number of elements in the
ResourceIdPath array.
FindDirectoryEntry - Supplies a boolean that is TRUE if caller is
searching for a resource directory, otherwise the caller is
searching for a resource data entry.
ExactLangMatchOnly - Supplies a boolean that is TRUE if caller is
searching for a resource with, and only with, the language id
specified in ResourceIdPath, otherwise the caller wants the routine
to come up with default when specified langid is not found.
ResourceDirectoryOrData - Supplies a pointer to a variable that will
receive the address of the resource directory or data entry in
the resource data section of the image file specified by the
DllHandle parameter.
Return Value:
TBD
--*/
{
NTSTATUS Status;
PIMAGE_RESOURCE_DIRECTORY LanguageResourceDirectory, ResourceDirectory, TopResourceDirectory;
PIMAGE_RESOURCE_DIRECTORY_ENTRY ResourceDirEntLow;
PIMAGE_RESOURCE_DIRECTORY_ENTRY ResourceDirEntMiddle;
PIMAGE_RESOURCE_DIRECTORY_ENTRY ResourceDirEntHigh;
PIMAGE_RESOURCE_DATA_ENTRY ResourceEntry;
USHORT n, half;
LONG dir;
ULONG size;
ULONG_PTR ResourceIdRetry;
ULONG RetryCount;
LANGID NewLangId;
PULONG_PTR IdPath = ResourceIdPath;
ULONG IdPathLength = ResourceIdPathLength;
BOOLEAN fIsNeutral = FALSE;
LANGID GivenLanguage;
#ifndef NTOS_KERNEL_RUNTIME
LCID DefaultThreadLocale, DefaultSystemLocale;
PVOID AltResourceDllHandle = NULL;
ULONG_PTR UIResourceIdPath[3];
#endif
RTL_PAGED_CODE();
try {
TopResourceDirectory = (PIMAGE_RESOURCE_DIRECTORY)
RtlImageDirectoryEntryToData(DllHandle,
TRUE,
IMAGE_DIRECTORY_ENTRY_RESOURCE,
&size
);
if (!TopResourceDirectory) {
return( STATUS_RESOURCE_DATA_NOT_FOUND );
}
ResourceDirectory = TopResourceDirectory;
ResourceIdRetry = USE_FIRSTAVAILABLE_LANGID;
RetryCount = 0;
ResourceEntry = NULL;
LanguageResourceDirectory = NULL;
while (ResourceDirectory != NULL && ResourceIdPathLength--) {
// If search path includes a language id, then attempt to
// match the following language ids in this order:
// (0) use given language id
// (1) use primary language of given language id
// (2) use id 0 (neutral resource)
// (3) use default UI language id
// If the PRIMARY language id is ZERO, then ALSO attempt to
// match the following language ids in this order:
// (4) use lang id of TEB if different from user locale
// (5) use UI lang from exe resource
// (6) use primary UI lang from exe resource
// (7) use Install Language
// (8) use lang id from user's locale id
// (9) use primary language of user's locale id
// (10) use lang id from system default locale id
// (11) use primary language of system default locale id
// (12) use US English lang id
// (13) use any lang id that matches requested info
if (ResourceIdPathLength == 0 && IdPathLength == 3) {
LanguageResourceDirectory = ResourceDirectory;
}
if (LanguageResourceDirectory != NULL) {
GivenLanguage = (LANGID)IdPath[ 2 ];
fIsNeutral = (PRIMARYLANGID( GivenLanguage ) == LANG_NEUTRAL);
TryNextLangId:
switch( RetryCount++ ) {
#ifdef NTOS_KERNEL_RUNTIME
case 0: // Use given language id
NewLangId = GivenLanguage;
break;
case 1: // Use primary language of given language id
NewLangId = PRIMARYLANGID( GivenLanguage );
break;
case 2: // Use id 0 (neutral resource)
NewLangId = 0;
break;
case 3: // Use user's default UI language
NewLangId = (LANGID)ResourceIdRetry;
break;
case 4: // Use native UI language
if ( !fIsNeutral ) {
// Stop looking - Not in the neutral case
goto ReturnFailure;
break;
}
NewLangId = PsInstallUILanguageId;
break;
case 5: // Use default system locale
NewLangId = LANGIDFROMLCID(PsDefaultSystemLocaleId);
break;
case 6:
// Use US English language
NewLangId = MAKELANGID( LANG_ENGLISH, SUBLANG_ENGLISH_US );
break;
case 7: // Take any lang id that matches
NewLangId = USE_FIRSTAVAILABLE_LANGID;
break;
#else
case 0: // Use given language id
NewLangId = GivenLanguage;
break;
case 1: // Use primary language of given language id
if ( ExactLangMatchOnly) {
// Did not find an exact language match.
// Stop looking.
goto ReturnFailure;
}
NewLangId = PRIMARYLANGID( GivenLanguage );
break;
case 2: // Use id 0 (neutral resource)
NewLangId = 0;
break;
case 3: // Use user's default UI language
if (!UILangId){
Status = NtQueryDefaultUILanguage( &UILangId );
if (!NT_SUCCESS( Status )) {
// Failed reading key. Skip this lookup.
NewLangId = (LANGID)ResourceIdRetry;
break;
}
}
NewLangId = UILangId;
// Arabic/Hebrew MUI files may contain resources with LANG ID different than 401/40d.
// e.g. Comdlg32.dll has two sets of Arabic/Hebrew resources one mirrored (401/40d)
// and one flipped (801/80d).
if( !fIsNeutral &&
((PRIMARYLANGID (GivenLanguage) == LANG_ARABIC) || (PRIMARYLANGID (GivenLanguage) == LANG_HEBREW)) &&
(PRIMARYLANGID (GivenLanguage) == PRIMARYLANGID (NewLangId))
) {
NewLangId = GivenLanguage;
}
if (fIsNeutral || GivenLanguage == NewLangId){
// Load alternate resource dll.
AltResourceDllHandle=LdrLoadAlternateResourceModule(
DllHandle,
NULL);
if (!AltResourceDllHandle){
// Alternate resource dll not available.
// Skip this lookup.
NewLangId = (LANGID)ResourceIdRetry;
break;
}
// Map to alternate resource dll and search
// it instead.
UIResourceIdPath[0]=IdPath[0];
UIResourceIdPath[1]=IdPath[1];
UIResourceIdPath[2]=NewLangId;
Status = LdrpSearchResourceSection_U(
AltResourceDllHandle,
UIResourceIdPath,
3,
FindDirectoryEntry,
TRUE,
(PVOID *)ResourceDirectoryOrData
);
if (NT_SUCCESS(Status)){
// We sucessfully found alternate resource,
// return it.
return Status;
}
}
// Caller does not want alternate resource, or
// alternate resource not found.
NewLangId = (LANGID)ResourceIdRetry;
break;
case 4: // Use langid of ThreadLocale if different from user locale
if ( !fIsNeutral ) {
// Stop looking - Not in the neutral case
goto ReturnFailure;
break;
}
// Try the thread locale language-id if it is different from
// user locale.
if (NtCurrentTeb()){
Status = NtQueryDefaultLocale(
TRUE,
&DefaultThreadLocale
);
if (NT_SUCCESS( Status ) &&
DefaultThreadLocale !=
NtCurrentTeb()->CurrentLocale) {
// Thread locale is different from
// default locale.
NewLangId = LANGIDFROMLCID(NtCurrentTeb()->CurrentLocale);
break;
}
}
NewLangId = (LANGID)ResourceIdRetry;
break;
case 5: // UI language from the executable resource
if (!UILangId){
NewLangId = (LANGID)ResourceIdRetry;
} else {
NewLangId = UILangId;
}
break;
case 6: // Parimary lang of UI language from the executable resource
if (!UILangId){
NewLangId = (LANGID)ResourceIdRetry;
} else {
NewLangId = PRIMARYLANGID( (LANGID) UILangId );
}
break;
case 7: // Use install -native- language
// Thread locale is the same as the user locale, then let's
// try loading the native (install) ui language resources.
if (!InstallLangId){
Status = NtQueryInstallUILanguage(&InstallLangId);
if (!NT_SUCCESS( Status )) {
// Failed reading key. Skip this lookup.
NewLangId = (LANGID)ResourceIdRetry;
break;
}
}
NewLangId = InstallLangId;
break;
case 8: // Use lang id from locale in TEB
if (SUBLANGID( GivenLanguage ) == SUBLANG_SYS_DEFAULT) {
// Skip over all USER locale options
DefaultThreadLocale = 0;
RetryCount += 2;
break;
}
if (NtCurrentTeb() != NULL) {
NewLangId = LANGIDFROMLCID(NtCurrentTeb()->CurrentLocale);
}
break;
case 9: // Use User's default locale
Status = NtQueryDefaultLocale( TRUE, &DefaultThreadLocale );
if (NT_SUCCESS( Status )) {
NewLangId = LANGIDFROMLCID(DefaultThreadLocale);
break;
}
RetryCount++;
break;
case 10: // Use primary language of User's default locale
NewLangId = PRIMARYLANGID( (LANGID)ResourceIdRetry );
break;
case 11: // Use System default locale
Status = NtQueryDefaultLocale( FALSE, &DefaultSystemLocale );
if (!NT_SUCCESS( Status )) {
RetryCount++;
break;
}
if (DefaultSystemLocale != DefaultThreadLocale) {
NewLangId = LANGIDFROMLCID(DefaultSystemLocale);
break;
}
RetryCount += 2;
// fall through
case 13: // Use US English language
NewLangId = MAKELANGID( LANG_ENGLISH, SUBLANG_ENGLISH_US );
break;
case 12: // Use primary language of System default locale
NewLangId = PRIMARYLANGID( (LANGID)ResourceIdRetry );
break;
case 14: // Take any lang id that matches
NewLangId = USE_FIRSTAVAILABLE_LANGID;
break;
#endif
default: // No lang ids to match
goto ReturnFailure;
break;
}
// If looking for a specific language id and same as the
// one we just looked up, then skip it.
if (NewLangId != USE_FIRSTAVAILABLE_LANGID &&
NewLangId == ResourceIdRetry
) {
goto TryNextLangId;
}
// Try this new language Id
ResourceIdRetry = (ULONG_PTR)NewLangId;
ResourceIdPath = &ResourceIdRetry;
ResourceDirectory = LanguageResourceDirectory;
}
n = ResourceDirectory->NumberOfNamedEntries;
ResourceDirEntLow = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(ResourceDirectory+1);
if (!(*ResourceIdPath & LDR_RESOURCE_ID_NAME_MASK)) {
ResourceDirEntLow += n;
n = ResourceDirectory->NumberOfIdEntries;
}
if (!n) {
ResourceDirectory = NULL;
goto NotFound;
}
if (LanguageResourceDirectory != NULL &&
*ResourceIdPath == USE_FIRSTAVAILABLE_LANGID
) {
ResourceDirectory = NULL;
ResourceIdRetry = ResourceDirEntLow->Name;
ResourceEntry = (PIMAGE_RESOURCE_DATA_ENTRY)
((PCHAR)TopResourceDirectory +
ResourceDirEntLow->OffsetToData
);
break;
}
ResourceDirectory = NULL;
ResourceDirEntHigh = ResourceDirEntLow + n - 1;
while (ResourceDirEntLow <= ResourceDirEntHigh) {
if ((half = (n >> 1)) != 0) {
ResourceDirEntMiddle = ResourceDirEntLow;
if (*(PUCHAR)&n & 1) {
ResourceDirEntMiddle += half;
}
else {
ResourceDirEntMiddle += half - 1;
}
dir = LdrpCompareResourceNames_U( *ResourceIdPath,
TopResourceDirectory,
ResourceDirEntMiddle
);
if (!dir) {
if (ResourceDirEntMiddle->DataIsDirectory) {
ResourceDirectory = (PIMAGE_RESOURCE_DIRECTORY)
((PCHAR)TopResourceDirectory +
ResourceDirEntMiddle->OffsetToDirectory
);
}
else {
ResourceDirectory = NULL;
ResourceEntry = (PIMAGE_RESOURCE_DATA_ENTRY)
((PCHAR)TopResourceDirectory +
ResourceDirEntMiddle->OffsetToData
);
}
break;
}
else {
if (dir < 0) {
ResourceDirEntHigh = ResourceDirEntMiddle - 1;
if (*(PUCHAR)&n & 1) {
n = half;
}
else {
n = half - 1;
}
}
else {
ResourceDirEntLow = ResourceDirEntMiddle + 1;
n = half;
}
}
}
else {
if (n != 0) {
dir = LdrpCompareResourceNames_U( *ResourceIdPath,
TopResourceDirectory,
ResourceDirEntLow
);
if (!dir) {
if (ResourceDirEntLow->DataIsDirectory) {
ResourceDirectory = (PIMAGE_RESOURCE_DIRECTORY)
((PCHAR)TopResourceDirectory +
ResourceDirEntLow->OffsetToDirectory
);
}
else {
ResourceEntry = (PIMAGE_RESOURCE_DATA_ENTRY)
((PCHAR)TopResourceDirectory +
ResourceDirEntLow->OffsetToData
);
}
}
}
break;
}
}
ResourceIdPath++;
}
if (ResourceEntry != NULL && !FindDirectoryEntry) {
*ResourceDirectoryOrData = (PVOID)ResourceEntry;
Status = STATUS_SUCCESS;
}
else
if (ResourceDirectory != NULL && FindDirectoryEntry) {
*ResourceDirectoryOrData = (PVOID)ResourceDirectory;
Status = STATUS_SUCCESS;
}
else {
NotFound:
switch( IdPathLength - ResourceIdPathLength) {
case 3: Status = STATUS_RESOURCE_LANG_NOT_FOUND; break;
case 2: Status = STATUS_RESOURCE_NAME_NOT_FOUND; break;
case 1: Status = STATUS_RESOURCE_TYPE_NOT_FOUND; break;
default: Status = STATUS_INVALID_PARAMETER; break;
}
}
if (Status == STATUS_RESOURCE_LANG_NOT_FOUND &&
LanguageResourceDirectory != NULL
) {
ResourceEntry = NULL;
goto TryNextLangId;
ReturnFailure: ;
Status = STATUS_RESOURCE_LANG_NOT_FOUND;
}
}
except (EXCEPTION_EXECUTE_HANDLER) {
Status = GetExceptionCode();
}
return Status;
}
NTSTATUS
LdrEnumResources(
IN PVOID DllHandle,
IN PULONG_PTR ResourceIdPath,
IN ULONG ResourceIdPathLength,
IN OUT PULONG NumberOfResources,
OUT PLDR_ENUM_RESOURCE_ENTRY Resources OPTIONAL
)
{
NTSTATUS Status;
PIMAGE_RESOURCE_DIRECTORY TopResourceDirectory;
PIMAGE_RESOURCE_DIRECTORY TypeResourceDirectory;
PIMAGE_RESOURCE_DIRECTORY NameResourceDirectory;
PIMAGE_RESOURCE_DIRECTORY LangResourceDirectory;
PIMAGE_RESOURCE_DIRECTORY_ENTRY TypeResourceDirectoryEntry;
PIMAGE_RESOURCE_DIRECTORY_ENTRY NameResourceDirectoryEntry;
PIMAGE_RESOURCE_DIRECTORY_ENTRY LangResourceDirectoryEntry;
ULONG TypeDirectoryIndex, NumberOfTypeDirectoryEntries;
ULONG NameDirectoryIndex, NumberOfNameDirectoryEntries;
ULONG LangDirectoryIndex, NumberOfLangDirectoryEntries;
BOOLEAN ScanTypeDirectory;
BOOLEAN ScanNameDirectory;
BOOLEAN ReturnThisResource;
PIMAGE_RESOURCE_DIR_STRING_U ResourceNameString;
ULONG_PTR TypeResourceNameOrId;
ULONG_PTR NameResourceNameOrId;
ULONG_PTR LangResourceNameOrId;
PLDR_ENUM_RESOURCE_ENTRY ResourceInfo;
PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry;
ULONG ResourceIndex, MaxResourceIndex;
ULONG Size;
ResourceIndex = 0;
if (!ARGUMENT_PRESENT( Resources )) {
MaxResourceIndex = 0;
}
else {
MaxResourceIndex = *NumberOfResources;
}
*NumberOfResources = 0;
TopResourceDirectory = (PIMAGE_RESOURCE_DIRECTORY)
RtlImageDirectoryEntryToData( DllHandle,
TRUE,
IMAGE_DIRECTORY_ENTRY_RESOURCE,
&Size
);
if (!TopResourceDirectory) {
return STATUS_RESOURCE_DATA_NOT_FOUND;
}
TypeResourceDirectory = TopResourceDirectory;
TypeResourceDirectoryEntry = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(TypeResourceDirectory+1);
NumberOfTypeDirectoryEntries = TypeResourceDirectory->NumberOfNamedEntries +
TypeResourceDirectory->NumberOfIdEntries;
TypeDirectoryIndex = 0;
Status = STATUS_SUCCESS;
for (TypeDirectoryIndex=0;
TypeDirectoryIndex<NumberOfTypeDirectoryEntries;
TypeDirectoryIndex++, TypeResourceDirectoryEntry++
) {
if (ResourceIdPathLength > 0) {
ScanTypeDirectory = LdrpCompareResourceNames_U( ResourceIdPath[ 0 ],
TopResourceDirectory,
TypeResourceDirectoryEntry
) == 0;
}
else {
ScanTypeDirectory = TRUE;
}
if (ScanTypeDirectory) {
if (!TypeResourceDirectoryEntry->DataIsDirectory) {
return STATUS_INVALID_IMAGE_FORMAT;
}
if (TypeResourceDirectoryEntry->NameIsString) {
ResourceNameString = (PIMAGE_RESOURCE_DIR_STRING_U)
((PCHAR)TopResourceDirectory + TypeResourceDirectoryEntry->NameOffset);
TypeResourceNameOrId = (ULONG_PTR)ResourceNameString;
}
else {
TypeResourceNameOrId = (ULONG_PTR)TypeResourceDirectoryEntry->Id;
}
NameResourceDirectory = (PIMAGE_RESOURCE_DIRECTORY)
((PCHAR)TopResourceDirectory + TypeResourceDirectoryEntry->OffsetToDirectory);
NameResourceDirectoryEntry = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(NameResourceDirectory+1);
NumberOfNameDirectoryEntries = NameResourceDirectory->NumberOfNamedEntries +
NameResourceDirectory->NumberOfIdEntries;
NameDirectoryIndex = 0;
for (NameDirectoryIndex=0;
NameDirectoryIndex<NumberOfNameDirectoryEntries;
NameDirectoryIndex++, NameResourceDirectoryEntry++
) {
if (ResourceIdPathLength > 1) {
ScanNameDirectory = LdrpCompareResourceNames_U( ResourceIdPath[ 1 ],
TopResourceDirectory,
NameResourceDirectoryEntry
) == 0;
}
else {
ScanNameDirectory = TRUE;
}
if (ScanNameDirectory) {
if (!NameResourceDirectoryEntry->DataIsDirectory) {
return STATUS_INVALID_IMAGE_FORMAT;
}
if (NameResourceDirectoryEntry->NameIsString) {
ResourceNameString = (PIMAGE_RESOURCE_DIR_STRING_U)
((PCHAR)TopResourceDirectory + NameResourceDirectoryEntry->NameOffset);
NameResourceNameOrId = (ULONG_PTR)ResourceNameString;
}
else {
NameResourceNameOrId = (ULONG_PTR)NameResourceDirectoryEntry->Id;
}
LangResourceDirectory = (PIMAGE_RESOURCE_DIRECTORY)
((PCHAR)TopResourceDirectory + NameResourceDirectoryEntry->OffsetToDirectory);
LangResourceDirectoryEntry = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(LangResourceDirectory+1);
NumberOfLangDirectoryEntries = LangResourceDirectory->NumberOfNamedEntries +
LangResourceDirectory->NumberOfIdEntries;
LangDirectoryIndex = 0;
for (LangDirectoryIndex=0;
LangDirectoryIndex<NumberOfLangDirectoryEntries;
LangDirectoryIndex++, LangResourceDirectoryEntry++
) {
if (ResourceIdPathLength > 2) {
ReturnThisResource = LdrpCompareResourceNames_U( ResourceIdPath[ 2 ],
TopResourceDirectory,
LangResourceDirectoryEntry
) == 0;
}
else {
ReturnThisResource = TRUE;
}
if (ReturnThisResource) {
if (LangResourceDirectoryEntry->DataIsDirectory) {
return STATUS_INVALID_IMAGE_FORMAT;
}
if (LangResourceDirectoryEntry->NameIsString) {
ResourceNameString = (PIMAGE_RESOURCE_DIR_STRING_U)
((PCHAR)TopResourceDirectory + LangResourceDirectoryEntry->NameOffset);
LangResourceNameOrId = (ULONG_PTR)ResourceNameString;
}
else {
LangResourceNameOrId = (ULONG_PTR)LangResourceDirectoryEntry->Id;
}
ResourceDataEntry = (PIMAGE_RESOURCE_DATA_ENTRY)
((PCHAR)TopResourceDirectory + LangResourceDirectoryEntry->OffsetToData);
ResourceInfo = &Resources[ ResourceIndex++ ];
if (ResourceIndex <= MaxResourceIndex) {
ResourceInfo->Path[ 0 ].NameOrId = TypeResourceNameOrId;
ResourceInfo->Path[ 1 ].NameOrId = NameResourceNameOrId;
ResourceInfo->Path[ 2 ].NameOrId = LangResourceNameOrId;
ResourceInfo->Data = (PVOID)((ULONG_PTR)DllHandle + ResourceDataEntry->OffsetToData);
ResourceInfo->Size = ResourceDataEntry->Size;
ResourceInfo->Reserved = 0;
}
else {
Status = STATUS_INFO_LENGTH_MISMATCH;
}
}
}
}
}
}
}
*NumberOfResources = ResourceIndex;
return Status;
}
#ifndef NTOS_KERNEL_RUNTIME
BOOLEAN LdrAlternateResourcesEnabled(VOID)
/*++
Routine Description:
This function determines if the althernate resources are enabled.
Return Value:
True - Alternate Resource enabled.
False - Alternate Resource not enabled.
--*/
{
NTSTATUS Status;
if (!UILangId){
Status = NtQueryDefaultUILanguage( &UILangId );
if (!NT_SUCCESS( Status )) {
return FALSE;// Failed to get UI LangID. AltResource not enabled.
}
}
if (!InstallLangId){
Status = NtQueryInstallUILanguage( &InstallLangId);
if (!NT_SUCCESS( Status )) {
return FALSE;// Failed to get Intall LangID. AltResource not enabled.
}
}
if (UILangId == InstallLangId) {
return FALSE;// UI Lang matches Installed Lang. AltResource not enabled.
}
return TRUE;
}
PVOID LdrGetAlternateResourceModuleHandle(IN PVOID Module)
/*++
Routine Description:
This function gets the alternate resource module from the table containing the handle.
Arguments:
Module - Module of which alternate resource module needs to loaded.
Return Value:
Handle of the alternate resource module.
--*/
{
ULONG ModuleIndex;
for (ModuleIndex = 0; ModuleIndex < AlternateResourceModuleCount; ModuleIndex++ ){
if (AlternateResourceModules[ModuleIndex].ModuleBase == Module){
return AlternateResourceModules[ModuleIndex].AlternateModule;
}
}
return NULL;
}
BOOLEAN
LdrpGetFileVersion(
IN PVOID ImageBase,
IN LANGID LangId,
OUT PULONGLONG Version
)
/*++
Routine Description:
Get the version stamp out of the VS_FIXEDFILEINFO resource in a PE image.
Arguments:
ImageBase - supplies the address in memory where the file is mapped in.
Version - receives 64bit version number, or 0 if the file is not a PE image or has no version data.
Return Value:
None.
--*/
{
PIMAGE_RESOURCE_DATA_ENTRY DataEntry;
NTSTATUS Status;
ULONG_PTR IdPath[3];
ULONG ResourceSize;
typedef struct tagVS_FIXEDFILEINFO
{
LONG dwSignature; /* e.g. 0xfeef04bd */
LONG dwStrucVersion; /* e.g. 0x00000042 = "0.42" */
LONG dwFileVersionMS; /* e.g. 0x00030075 = "3.75" */
LONG dwFileVersionLS; /* e.g. 0x00000031 = "0.31" */
LONG dwProductVersionMS; /* e.g. 0x00030010 = "3.10" */
LONG dwProductVersionLS; /* e.g. 0x00000031 = "0.31" */
LONG dwFileFlagsMask; /* = 0x3F for version "0.42" */
LONG dwFileFlags; /* e.g. VFF_DEBUG | VFF_PRERELEASE */
LONG dwFileOS; /* e.g. VOS_DOS_WINDOWS16 */
LONG dwFileType; /* e.g. VFT_DRIVER */
LONG dwFileSubtype; /* e.g. VFT2_DRV_KEYBOARD */
LONG dwFileDateMS; /* e.g. 0 */
LONG dwFileDateLS; /* e.g. 0 */
} VS_FIXEDFILEINFO;
struct {
USHORT TotalSize;
USHORT DataSize;
USHORT Type;
WCHAR Name[16]; // L"VS_VERSION_INFO" + unicode nul
VS_FIXEDFILEINFO FixedFileInfo;
} *Resource;
*Version = 0;
IdPath[0] = 16;
IdPath[1] = 1;
IdPath[2] = LangId;
try {
Status = LdrpSearchResourceSection_U(
ImageBase,
IdPath,
3,
FALSE,
TRUE,
&DataEntry);
} except(EXCEPTION_EXECUTE_HANDLER) {
Status = STATUS_UNSUCCESSFUL;
}
if(!NT_SUCCESS(Status)) {
return FALSE;
}
try {
Status = LdrpAccessResourceData(
ImageBase,
DataEntry,
&Resource,
&ResourceSize);
} except(EXCEPTION_EXECUTE_HANDLER) {
Status = STATUS_UNSUCCESSFUL;
}
if(!NT_SUCCESS(Status)) {
return FALSE;
}
try {
if((ResourceSize >= sizeof(*Resource)) && !_wcsicmp(Resource->Name,L"VS_VERSION_INFO")) {
*Version = ((ULONGLONG)Resource->FixedFileInfo.dwFileVersionMS << 32) | (ULONGLONG)Resource->FixedFileInfo.dwFileVersionLS;
} else {
DbgPrint(("LDR: Warning: invalid version resource\n"));
return FALSE;
}
} except(EXCEPTION_EXECUTE_HANDLER) {
DbgPrint(("LDR: Exception encountered processing bogus version resource\n"));
return FALSE;
}
return TRUE;
}
BOOLEAN LdrpVerifyAlternateResourceModule(IN PVOID Module, IN PVOID AlternateModule)
/*++
Routine Description:
This function verifies if the alternate resource module has the same version of the base module.
Arguments:
Module - The handle of the base module.
AlternateModule - The handle of the alternate resource module
Return Value:
TBD.
--*/
{
ULONGLONG ModuleVersion;
ULONGLONG AltModuleVersion;
NTSTATUS Status;
if (!UILangId){
Status = NtQueryDefaultUILanguage( &UILangId);
if (!NT_SUCCESS( Status )) {
return FALSE;// Failed to get UI LangID. AltResource not enabled.
}
}
if (!LdrpGetFileVersion(AlternateModule, UILangId, &AltModuleVersion)){
return FALSE;
}
if (!InstallLangId){
Status = NtQueryInstallUILanguage (&InstallLangId);
if (!NT_SUCCESS( Status )) {
return FALSE;// Failed to get Install LangID. AltResource not enabled.
}
}
if (!LdrpGetFileVersion(Module, InstallLangId, &ModuleVersion)){
return FALSE;
}
if (ModuleVersion == AltModuleVersion){
return TRUE;
} else{
return FALSE;
}
}
BOOLEAN
LdrpSetAlternateResourceModuleHandle(
IN PVOID Module,
IN PVOID AlternateModule
)
/*++
Routine Description:
This function records the handle of the base module and alternate resource module in an array.
Arguments:
Module - The handle of the base module.
AlternateModule - The handle of the alternate resource module
Return Value:
TBD.
--*/
{
PALT_RESOURCE_MODULE NewModules;
if (AlternateResourceModules == NULL){
// Allocate memory of initial size MEMBLOCKSIZE.
NewModules = RtlAllocateHeap(RtlProcessHeap(), HEAP_ZERO_MEMORY, RESMODSIZE * MEMBLOCKSIZE);
if (!NewModules){
return FALSE;
}
AlternateResourceModules = NewModules;
AltResMemBlockCount = MEMBLOCKSIZE;
}
else
if (AlternateResourceModuleCount >= AltResMemBlockCount ){
// ReAllocate another chunk of memory.
NewModules = RtlReAllocateHeap(
RtlProcessHeap(),
0,
AlternateResourceModules,
(AltResMemBlockCount + MEMBLOCKSIZE) * RESMODSIZE
);
if (!NewModules){
return FALSE;
}
AlternateResourceModules = NewModules;
AltResMemBlockCount += MEMBLOCKSIZE;
}
AlternateResourceModules[AlternateResourceModuleCount].ModuleBase = Module;
AlternateResourceModules[AlternateResourceModuleCount].AlternateModule = AlternateModule;
AlternateResourceModuleCount++;
return TRUE;
}
PVOID LdrLoadAlternateResourceModule(IN PVOID Module, IN LPCWSTR PathToAlternateModule OPTIONAL)
/*++
Routine Description:
This function does the acutally loading into memory of the alternate resource module, or loads from the table if it was loaded before.
Arguments:
Module - The handle of the base module.
PathToAlternateModule - Optional path from which module is being loaded.
Return Value:
Handle to the alternate resource module.
--*/
{
PVOID AlternateModule, DllBase;
PLDR_DATA_TABLE_ENTRY Entry;
HANDLE FileHandle, MappingHandle;
PIMAGE_NT_HEADERS NtHeaders;
NTSTATUS Status;
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING AltDllName;
PVOID FreeBuffer;
LPWSTR BaseDllName, p;
WCHAR DllPathName[DOS_MAX_PATH_LENGTH];
ULONG DllPathNameLength, BaseDllNameLength, CopyCount;
ULONG Digit;
int i, RetryCount;
WCHAR AltModulePath[DOS_MAX_PATH_LENGTH];
WCHAR AltModulePathMUI[DOS_MAX_PATH_LENGTH];
WCHAR AltModulePathFallback[DOS_MAX_PATH_LENGTH];
IO_STATUS_BLOCK IoStatusBlock;
RTL_RELATIVE_NAME RelativeName;
SIZE_T ViewSize;
LARGE_INTEGER SectionOffset;
WCHAR LangIdDir[6];
UNICODE_STRING AltModulePathList[3];
UNICODE_STRING NtSystemRoot;
if (!LdrAlternateResourcesEnabled()) {
return NULL;
}
RtlEnterCriticalSection((PRTL_CRITICAL_SECTION)NtCurrentPeb()->LoaderLock);
AlternateModule = LdrGetAlternateResourceModuleHandle(Module);
if (AlternateModule == NO_ALTERNATE_RESOURCE_MODULE){// We tried to load this module before but failed. Don't try again in the future.
RtlLeaveCriticalSection((PRTL_CRITICAL_SECTION)NtCurrentPeb()->LoaderLock);
return NULL;
} else if (AlternateModule > 0){// We found the previously loaded match
RtlLeaveCriticalSection((PRTL_CRITICAL_SECTION)NtCurrentPeb()->LoaderLock);
return AlternateModule;
}
if (ARGUMENT_PRESENT(PathToAlternateModule)){
// Caller suplied path.
CopyCount = wcslen(PathToAlternateModule);
for (p = (LPWSTR) PathToAlternateModule + CopyCount; p > PathToAlternateModule; p--){
if (*(p-1) == L'\\'){
break;
}
}
if (p == PathToAlternateModule){
goto error_exit;
}
DllPathNameLength = (ULONG)(p - PathToAlternateModule) * sizeof(WCHAR);
RtlCopyMemory(DllPathName, PathToAlternateModule, DllPathNameLength);
BaseDllName = p ;
BaseDllNameLength = CopyCount * sizeof(WCHAR) - DllPathNameLength;
} else{// Try to get full dll path from Ldr data table.
Status = LdrFindEntryForAddress(Module, &Entry);
if (!NT_SUCCESS( Status )){
goto error_exit;
}
DllPathNameLength = Entry->FullDllName.Length - Entry->BaseDllName.Length;
RtlCopyMemory(DllPathName, Entry->FullDllName.Buffer, DllPathNameLength);
BaseDllName = Entry->BaseDllName.Buffer;
BaseDllNameLength = Entry->BaseDllName.Length;
}
DllPathName[DllPathNameLength / sizeof(WCHAR)] = UNICODE_NULL;
// Generate the langid directory like "0804\"
if (!UILangId){
Status = NtQueryDefaultUILanguage( &UILangId );
if (!NT_SUCCESS( Status )) {
goto error_exit;
}
}
CopyCount = 0;
for (i = 12; i >= 0; i -= 4)
{
Digit = ((UILangId >> i) & 0xF);
if (Digit >= 10){
LangIdDir[CopyCount++] = (WCHAR) (Digit - 10 + L'A');
} else{
LangIdDir[CopyCount++] = (WCHAR) (Digit + L'0');
}
}
LangIdDir[CopyCount++] = L'\\';
LangIdDir[CopyCount++] = UNICODE_NULL;
// Generate the first path c:\winnt\system32\mui\0804\ntdll.dll.mui
AltModulePathList[1].Buffer = AltModulePath;
AltModulePathList[1].Length = 0;
AltModulePathList[1].MaximumLength = sizeof(AltModulePath);
RtlAppendUnicodeToString(&AltModulePathList[1], DllPathName);
RtlAppendUnicodeToString(&AltModulePathList[1], L"mui\\");
RtlAppendUnicodeToString(&AltModulePathList[1], LangIdDir);
RtlAppendUnicodeToString(&AltModulePathList[1], BaseDllName);
// Generate the first path c:\winnt\system32\mui\0804\ntdll.dll
AltModulePathList[0].Buffer = AltModulePathMUI;
AltModulePathList[0].Length = 0;
AltModulePathList[0].MaximumLength = sizeof(AltModulePathMUI);
RtlCopyUnicodeString(&AltModulePathList[0], &AltModulePathList[1]);
RtlAppendUnicodeToString(&AltModulePathList[0], L".mui");
// Generate path c:\winnt\mui\fallback\0804\foo.exe.mui
AltModulePathList[2].Buffer = AltModulePathFallback;
AltModulePathList[2].Length = 0;
AltModulePathList[2].MaximumLength = sizeof(AltModulePathFallback);
RtlInitUnicodeString(&NtSystemRoot, USER_SHARED_DATA->NtSystemRoot);
RtlAppendUnicodeStringToString(&AltModulePathList[2], &NtSystemRoot);
RtlAppendUnicodeToString(&AltModulePathList[2], L"\\mui\\fallback\\");
RtlAppendUnicodeToString(&AltModulePathList[2], LangIdDir);
RtlAppendUnicodeToString(&AltModulePathList[2], BaseDllName);
RtlAppendUnicodeToString(&AltModulePathList[2], L".mui");
// Try name with .mui extesion first.
RetryCount = 0;
while (RetryCount < sizeof(AltModulePathList)/sizeof(UNICODE_STRING))
{
if (!RtlDosPathNameToNtPathName_U(AltModulePathList[RetryCount].Buffer, &AltDllName, NULL, &RelativeName)){
goto error_exit;
}
FreeBuffer = AltDllName.Buffer;
if ( RelativeName.RelativeName.Length ) {
AltDllName = *(PUNICODE_STRING)&RelativeName.RelativeName;
} else {
RelativeName.ContainingDirectory = NULL;
}
InitializeObjectAttributes(&ObjectAttributes, &AltDllName, OBJ_CASE_INSENSITIVE, RelativeName.ContainingDirectory, NULL);
Status = NtCreateFile(
&FileHandle,
(ACCESS_MASK) GENERIC_READ | SYNCHRONIZE | FILE_READ_ATTRIBUTES,
&ObjectAttributes,
&IoStatusBlock,
NULL,
0L,
FILE_SHARE_READ | FILE_SHARE_DELETE,
FILE_OPEN,
0L,
NULL,
0L
);
RtlFreeHeap(RtlProcessHeap(), 0, FreeBuffer);
if (NT_SUCCESS( Status )){
break;
}
if (Status != STATUS_OBJECT_NAME_NOT_FOUND && RetryCount == 0) {
// Error other than the file name with .mui not found.
// Most likely directory is missing. Skip file name w/o .mui and goto fallback directory.
RetryCount++;
}
RetryCount++;
}
Status = NtCreateSection(&MappingHandle, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ, NULL, NULL, PAGE_WRITECOPY, SEC_COMMIT, FileHandle);
if (!NT_SUCCESS( Status )){
goto error_exit;
}
NtClose( FileHandle );
SectionOffset.LowPart = 0;
SectionOffset.HighPart = 0;
ViewSize = 0;
DllBase = NULL;
Status = NtMapViewOfSection(MappingHandle, NtCurrentProcess(), &DllBase, 0L, 0L, &SectionOffset, &ViewSize, ViewShare, 0L, PAGE_WRITECOPY);
NtClose( MappingHandle );
if (!NT_SUCCESS( Status )){
goto error_exit;
}
NtHeaders = RtlImageNtHeader( DllBase );
if (!NtHeaders) {
NtUnmapViewOfSection(NtCurrentProcess(), (PVOID) DllBase);
goto error_exit;
}
AlternateModule = (HANDLE)((ULONG_PTR)DllBase | 0x00000001);
// Disable version check now to make testing with an earlier
// localized version easier.
// if(!LdrpVerifyAlternateResourceModule(Module, AlternateModule)){
// NtUnmapViewOfSection(NtCurrentProcess(), (PVOID) DllBase);
// goto error_exit;
// }
LdrpSetAlternateResourceModuleHandle(Module, AlternateModule);
RtlLeaveCriticalSection((PRTL_CRITICAL_SECTION)NtCurrentPeb()->LoaderLock);
return AlternateModule;
error_exit:
LdrpSetAlternateResourceModuleHandle(Module, NO_ALTERNATE_RESOURCE_MODULE);
RtlLeaveCriticalSection((PRTL_CRITICAL_SECTION)NtCurrentPeb()->LoaderLock);
return NULL;
}
BOOLEAN LdrUnloadAlternateResourceModule(IN PVOID Module)
/*++
Routine Description:
This function unmaps an alternate resource module from the process' address space and updates alternate resource module table.
Arguments:
Module - handle of the base module.
Return Value:
TBD.
--*/
{
ULONG ModuleIndex;
PALT_RESOURCE_MODULE AltModule;
RtlEnterCriticalSection((PRTL_CRITICAL_SECTION)NtCurrentPeb()->LoaderLock);
if (AlternateResourceModuleCount == 0){
RtlLeaveCriticalSection((PRTL_CRITICAL_SECTION)NtCurrentPeb()->LoaderLock);
return TRUE;
}
for (ModuleIndex = AlternateResourceModuleCount; ModuleIndex > 0; ModuleIndex--){
if (AlternateResourceModules[ModuleIndex-1].ModuleBase == Module){
break;
}
}
if (ModuleIndex == 0){
RtlLeaveCriticalSection((PRTL_CRITICAL_SECTION)NtCurrentPeb()->LoaderLock);
return FALSE;
}
// Adjust to the actual index
ModuleIndex --;
AltModule = &AlternateResourceModules[ModuleIndex];
if (AltModule->AlternateModule != NO_ALTERNATE_RESOURCE_MODULE) {
NtUnmapViewOfSection(NtCurrentProcess(), (PVOID)((ULONG_PTR)AltModule->AlternateModule & ~0x00000001));
}
__try {
if (ModuleIndex != AlternateResourceModuleCount - 1){
// Consolidate the array. Skip this if unloaded item is the last element.
RtlMoveMemory(AltModule, AltModule + 1, (AlternateResourceModuleCount - ModuleIndex - 1) * RESMODSIZE);
}
} __except (EXCEPTION_EXECUTE_HANDLER) {
RtlLeaveCriticalSection((PRTL_CRITICAL_SECTION)NtCurrentPeb()->LoaderLock);
return FALSE;
}
AlternateResourceModuleCount --;
if (AlternateResourceModuleCount == 0){
RtlFreeHeap(RtlProcessHeap(), 0, AlternateResourceModules);
AlternateResourceModules = NULL;
AltResMemBlockCount = 0;
}
else
if (AlternateResourceModuleCount < AltResMemBlockCount - MEMBLOCKSIZE){
AltModule = RtlReAllocateHeap(RtlProcessHeap(), 0, AlternateResourceModules, (AltResMemBlockCount - MEMBLOCKSIZE) * RESMODSIZE);
if (!AltModule){
RtlLeaveCriticalSection((PRTL_CRITICAL_SECTION)NtCurrentPeb()->LoaderLock);
return FALSE;
}
AlternateResourceModules = AltModule;
AltResMemBlockCount -= MEMBLOCKSIZE;
}
RtlLeaveCriticalSection((PRTL_CRITICAL_SECTION)NtCurrentPeb()->LoaderLock);
return TRUE;
}
BOOLEAN LdrFlushAlternateResourceModules(VOID)
/*++
Routine Description:
This function unmaps all the alternate resouce modules for the process address space.
This function would be used mainly by CSRSS, and any sub-systems that are permanent during logon and logoff.
Return Value:
TRUE : Successful
FALSE : Failed
--*/
{
ULONG ModuleIndex;
PALT_RESOURCE_MODULE AltModule;
// Grab the loader lock
RtlEnterCriticalSection((PRTL_CRITICAL_SECTION)NtCurrentPeb()->LoaderLock);
if (AlternateResourceModuleCount > 0) {
// Let's unmap the alternate resource modules from the process address space
for (ModuleIndex=0; ModuleIndex<AlternateResourceModuleCount; ModuleIndex++) {
AltModule = &AlternateResourceModules[ModuleIndex];
if (AltModule->AlternateModule != NO_ALTERNATE_RESOURCE_MODULE) {
NtUnmapViewOfSection(NtCurrentProcess(), (PVOID)((ULONG_PTR)AltModule->AlternateModule & ~0x00000001));
}
}
// Cleanup alternate resource modules memory
RtlFreeHeap(RtlProcessHeap(), 0, AlternateResourceModules);
AlternateResourceModules = NULL;
AlternateResourceModuleCount = 0;
AltResMemBlockCount = 0;
}
// Re-Initialize the UI language for the current process,
// and leave the LoaderLock
UILangId = 0;
RtlLeaveCriticalSection((PRTL_CRITICAL_SECTION)NtCurrentPeb()->LoaderLock);
return TRUE;
}
#endif
Reference in New Issue Copy Permalink