mirror of
https://github.com/reactos/reactos.git
synced 2024-08-30 15:18:33 +00:00
502 lines
16 KiB
C
502 lines
16 KiB
C
/*
|
|
* PE file resources
|
|
*
|
|
* Copyright 1995 Thomas Sandford
|
|
* Copyright 1996 Martin von Loewis
|
|
* Copyright 2003 Alexandre Julliard
|
|
* Copyright 1993 Robert J. Amstadt
|
|
* Copyright 1997 Marcus Meissner
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
/* INCLUDES *****************************************************************/
|
|
|
|
#include <rtl.h>
|
|
|
|
#define NDEBUG
|
|
#include <debug.h>
|
|
|
|
NTSTATUS find_entry( PVOID BaseAddress, LDR_RESOURCE_INFO *info,
|
|
ULONG level, void **ret, int want_dir );
|
|
|
|
/* FUNCTIONS ****************************************************************/
|
|
|
|
int page_fault(ULONG ExceptionCode)
|
|
{
|
|
if (ExceptionCode == EXCEPTION_ACCESS_VIOLATION ||
|
|
ExceptionCode == EXCEPTION_PRIV_INSTRUCTION)
|
|
return EXCEPTION_EXECUTE_HANDLER;
|
|
return EXCEPTION_CONTINUE_SEARCH;
|
|
}
|
|
|
|
/**********************************************************************
|
|
* is_data_file_module
|
|
*
|
|
* Check if a module handle is for a LOAD_LIBRARY_AS_DATAFILE module.
|
|
*/
|
|
static int is_data_file_module( PVOID BaseAddress )
|
|
{
|
|
return (ULONG_PTR)BaseAddress & 1;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* push_language
|
|
*
|
|
* push a language in the list of languages to try
|
|
*/
|
|
int push_language( USHORT *list, ULONG pos, WORD lang )
|
|
{
|
|
ULONG i;
|
|
for (i = 0; i < pos; i++) if (list[i] == lang) return pos;
|
|
list[pos++] = lang;
|
|
return pos;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* find_first_entry
|
|
*
|
|
* Find the first suitable entry in a resource directory
|
|
*/
|
|
IMAGE_RESOURCE_DIRECTORY *find_first_entry( IMAGE_RESOURCE_DIRECTORY *dir,
|
|
void *root, int want_dir )
|
|
{
|
|
const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1);
|
|
int pos;
|
|
|
|
for (pos = 0; pos < dir->NumberOfNamedEntries + dir->NumberOfIdEntries; pos++)
|
|
{
|
|
if (!entry[pos].DataIsDirectory == !want_dir)
|
|
return (IMAGE_RESOURCE_DIRECTORY *)((char *)root + entry[pos].OffsetToDirectory);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* find_entry_by_id
|
|
*
|
|
* Find an entry by id in a resource directory
|
|
*/
|
|
IMAGE_RESOURCE_DIRECTORY *find_entry_by_id( IMAGE_RESOURCE_DIRECTORY *dir,
|
|
WORD id, void *root, int want_dir )
|
|
{
|
|
const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry;
|
|
int min, max, pos;
|
|
|
|
entry = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1);
|
|
min = dir->NumberOfNamedEntries;
|
|
max = min + dir->NumberOfIdEntries - 1;
|
|
while (min <= max)
|
|
{
|
|
pos = (min + max) / 2;
|
|
if (entry[pos].Id == id)
|
|
{
|
|
if (!entry[pos].DataIsDirectory == !want_dir)
|
|
{
|
|
DPRINT("root %p dir %p id %04x ret %p\n",
|
|
root, dir, id, (const char*)root + entry[pos].OffsetToDirectory);
|
|
return (IMAGE_RESOURCE_DIRECTORY *)((char *)root + entry[pos].OffsetToDirectory);
|
|
}
|
|
break;
|
|
}
|
|
if (entry[pos].Id > id) max = pos - 1;
|
|
else min = pos + 1;
|
|
}
|
|
DPRINT("root %p dir %p id %04x not found\n", root, dir, id );
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* find_entry_by_name
|
|
*
|
|
* Find an entry by name in a resource directory
|
|
*/
|
|
IMAGE_RESOURCE_DIRECTORY *find_entry_by_name( IMAGE_RESOURCE_DIRECTORY *dir,
|
|
LPCWSTR name, void *root,
|
|
int want_dir )
|
|
{
|
|
const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry;
|
|
const IMAGE_RESOURCE_DIR_STRING_U *str;
|
|
int min, max, res, pos;
|
|
size_t namelen;
|
|
|
|
if (!((ULONG_PTR)name & 0xFFFF0000)) return find_entry_by_id( dir, (ULONG_PTR)name & 0xFFFF, root, want_dir );
|
|
entry = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1);
|
|
namelen = wcslen(name);
|
|
min = 0;
|
|
max = dir->NumberOfNamedEntries - 1;
|
|
while (min <= max)
|
|
{
|
|
pos = (min + max) / 2;
|
|
str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const char *)root + entry[pos].NameOffset);
|
|
res = _wcsnicmp( name, str->NameString, str->Length );
|
|
if (!res && namelen == str->Length)
|
|
{
|
|
if (!entry[pos].DataIsDirectory == !want_dir)
|
|
{
|
|
DPRINT("root %p dir %p name %ws ret %p\n",
|
|
root, dir, name, (const char*)root + entry[pos].OffsetToDirectory);
|
|
return (IMAGE_RESOURCE_DIRECTORY *)((char *)root + entry[pos].OffsetToDirectory);
|
|
}
|
|
break;
|
|
}
|
|
if (res < 0) max = pos - 1;
|
|
else min = pos + 1;
|
|
}
|
|
DPRINT("root %p dir %p name %ws not found\n", root, dir, name);
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef __i386__
|
|
NTSTATUS NTAPI LdrpAccessResource( PVOID BaseAddress, IMAGE_RESOURCE_DATA_ENTRY *entry,
|
|
void **ptr, ULONG *size )
|
|
#else
|
|
static NTSTATUS LdrpAccessResource( PVOID BaseAddress, IMAGE_RESOURCE_DATA_ENTRY *entry,
|
|
void **ptr, ULONG *size )
|
|
#endif
|
|
{
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
|
|
_SEH2_TRY
|
|
{
|
|
ULONG dirsize;
|
|
|
|
if (!RtlImageDirectoryEntryToData( BaseAddress, TRUE, IMAGE_DIRECTORY_ENTRY_RESOURCE, &dirsize ))
|
|
status = STATUS_RESOURCE_DATA_NOT_FOUND;
|
|
else
|
|
{
|
|
if (ptr)
|
|
{
|
|
if (is_data_file_module(BaseAddress))
|
|
{
|
|
PVOID mod = (PVOID)((ULONG_PTR)BaseAddress & ~1);
|
|
*ptr = RtlImageRvaToVa( RtlImageNtHeader(mod), mod, entry->OffsetToData, NULL );
|
|
}
|
|
else *ptr = (char *)BaseAddress + entry->OffsetToData;
|
|
}
|
|
if (size) *size = entry->Size;
|
|
}
|
|
}
|
|
_SEH2_EXCEPT(page_fault(_SEH2_GetExceptionCode()))
|
|
{
|
|
status = _SEH2_GetExceptionCode();
|
|
}
|
|
_SEH2_END;
|
|
return status;
|
|
}
|
|
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
NTSTATUS NTAPI
|
|
LdrFindResource_U(PVOID BaseAddress,
|
|
PLDR_RESOURCE_INFO ResourceInfo,
|
|
ULONG Level,
|
|
PIMAGE_RESOURCE_DATA_ENTRY* ResourceDataEntry)
|
|
{
|
|
void *res;
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
|
|
_SEH2_TRY
|
|
{
|
|
if (ResourceInfo)
|
|
{
|
|
DPRINT( "module %p type %lx name %lx lang %04lx level %lu\n",
|
|
BaseAddress, ResourceInfo->Type,
|
|
Level > 1 ? ResourceInfo->Name : 0,
|
|
Level > 2 ? ResourceInfo->Language : 0, Level );
|
|
}
|
|
|
|
status = find_entry( BaseAddress, ResourceInfo, Level, &res, FALSE );
|
|
if (NT_SUCCESS(status))
|
|
*ResourceDataEntry = res;
|
|
}
|
|
_SEH2_EXCEPT(page_fault(_SEH2_GetExceptionCode()))
|
|
{
|
|
status = _SEH2_GetExceptionCode();
|
|
}
|
|
_SEH2_END;
|
|
return status;
|
|
}
|
|
|
|
#ifndef __i386__
|
|
/*
|
|
* @implemented
|
|
*/
|
|
NTSTATUS NTAPI
|
|
LdrAccessResource(IN PVOID BaseAddress,
|
|
IN PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry,
|
|
OUT PVOID* Resource OPTIONAL,
|
|
OUT PULONG Size OPTIONAL)
|
|
{
|
|
return LdrpAccessResource( BaseAddress, ResourceDataEntry, Resource, Size );
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
NTSTATUS NTAPI
|
|
LdrFindResourceDirectory_U(IN PVOID BaseAddress,
|
|
IN PLDR_RESOURCE_INFO info,
|
|
IN ULONG level,
|
|
OUT PIMAGE_RESOURCE_DIRECTORY* addr)
|
|
{
|
|
void *res;
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
|
|
_SEH2_TRY
|
|
{
|
|
if (info)
|
|
{
|
|
DPRINT( "module %p type %ws name %ws lang %04lx level %lu\n",
|
|
BaseAddress, (LPCWSTR)info->Type,
|
|
level > 1 ? (LPCWSTR)info->Name : L"",
|
|
level > 2 ? info->Language : 0, level );
|
|
}
|
|
|
|
status = find_entry( BaseAddress, info, level, &res, TRUE );
|
|
if (NT_SUCCESS(status))
|
|
*addr = res;
|
|
}
|
|
_SEH2_EXCEPT(page_fault(_SEH2_GetExceptionCode()))
|
|
{
|
|
status = _SEH2_GetExceptionCode();
|
|
}
|
|
_SEH2_END;
|
|
return status;
|
|
}
|
|
|
|
|
|
#define NAME_FROM_RESOURCE_ENTRY(RootDirectory, Entry) \
|
|
((Entry)->NameIsString ? (ULONG_PTR)(RootDirectory) + (Entry)->NameOffset : (Entry)->Id)
|
|
|
|
static
|
|
LONG
|
|
LdrpCompareResourceNames_U(
|
|
_In_ PUCHAR ResourceData,
|
|
_In_ PIMAGE_RESOURCE_DIRECTORY_ENTRY Entry,
|
|
_In_ ULONG_PTR CompareName)
|
|
{
|
|
PIMAGE_RESOURCE_DIR_STRING_U ResourceString;
|
|
PWSTR String1, String2;
|
|
USHORT ResourceStringLength;
|
|
WCHAR Char1, Char2;
|
|
|
|
/* Check if the resource name is an ID */
|
|
if (CompareName <= USHRT_MAX)
|
|
{
|
|
/* Just compare the 2 IDs */
|
|
return (CompareName - Entry->Id);
|
|
}
|
|
else
|
|
{
|
|
/* Get the resource string */
|
|
ResourceString = (PIMAGE_RESOURCE_DIR_STRING_U)(ResourceData +
|
|
Entry->NameOffset);
|
|
|
|
/* Get the string length */
|
|
ResourceStringLength = ResourceString->Length;
|
|
|
|
String1 = ResourceString->NameString;
|
|
String2 = (PWSTR)CompareName;
|
|
|
|
/* Loop all characters of the resource string */
|
|
while (ResourceStringLength--)
|
|
{
|
|
/* Get the next characters */
|
|
Char1 = *String1++;
|
|
Char2 = *String2++;
|
|
|
|
/* Check if they don't match, or if the compare string ends */
|
|
if ((Char1 != Char2) || (Char2 == 0))
|
|
{
|
|
/* They don't match, fail */
|
|
return Char2 - Char1;
|
|
}
|
|
}
|
|
|
|
/* All characters match, check if the compare string ends here */
|
|
return (*String2 == 0) ? 0 : 1;
|
|
}
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
LdrEnumResources(
|
|
_In_ PVOID ImageBase,
|
|
_In_ PLDR_RESOURCE_INFO ResourceInfo,
|
|
_In_ ULONG Level,
|
|
_Inout_ ULONG *ResourceCount,
|
|
_Out_writes_to_(*ResourceCount,*ResourceCount) LDR_ENUM_RESOURCE_INFO *Resources)
|
|
{
|
|
PUCHAR ResourceData;
|
|
NTSTATUS Status;
|
|
ULONG i, j, k;
|
|
ULONG NumberOfTypeEntries, NumberOfNameEntries, NumberOfLangEntries;
|
|
ULONG Count, MaxResourceCount;
|
|
PIMAGE_RESOURCE_DIRECTORY TypeDirectory, NameDirectory, LangDirectory;
|
|
PIMAGE_RESOURCE_DIRECTORY_ENTRY TypeEntry, NameEntry, LangEntry;
|
|
PIMAGE_RESOURCE_DATA_ENTRY DataEntry;
|
|
ULONG Size;
|
|
LONG Result;
|
|
|
|
/* If the caller wants data, get the maximum count of entries */
|
|
MaxResourceCount = (Resources != NULL) ? *ResourceCount : 0;
|
|
|
|
/* Default to 0 */
|
|
*ResourceCount = 0;
|
|
|
|
/* Locate the resource directory */
|
|
ResourceData = RtlImageDirectoryEntryToData(ImageBase,
|
|
TRUE,
|
|
IMAGE_DIRECTORY_ENTRY_RESOURCE,
|
|
&Size);
|
|
if (ResourceData == NULL)
|
|
return STATUS_RESOURCE_DATA_NOT_FOUND;
|
|
|
|
/* The type directory is at the root, followed by the entries */
|
|
TypeDirectory = (PIMAGE_RESOURCE_DIRECTORY)ResourceData;
|
|
TypeEntry = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(TypeDirectory + 1);
|
|
|
|
/* Get the number of entries in the type directory */
|
|
NumberOfTypeEntries = TypeDirectory->NumberOfNamedEntries +
|
|
TypeDirectory->NumberOfIdEntries;
|
|
|
|
/* Start with 0 resources and status success */
|
|
Status = STATUS_SUCCESS;
|
|
Count = 0;
|
|
|
|
/* Loop all entries in the type directory */
|
|
for (i = 0; i < NumberOfTypeEntries; ++i, ++TypeEntry)
|
|
{
|
|
/* Check if comparison of types is requested */
|
|
if (Level > RESOURCE_TYPE_LEVEL)
|
|
{
|
|
/* Compare the type with the requested Type */
|
|
Result = LdrpCompareResourceNames_U(ResourceData,
|
|
TypeEntry,
|
|
ResourceInfo->Type);
|
|
|
|
/* Not equal, continue with next entry */
|
|
if (Result != 0) continue;
|
|
}
|
|
|
|
/* The entry must point to the name directory */
|
|
if (!TypeEntry->DataIsDirectory)
|
|
{
|
|
return STATUS_INVALID_IMAGE_FORMAT;
|
|
}
|
|
|
|
/* Get a pointer to the name subdirectory and it's first entry */
|
|
NameDirectory = (PIMAGE_RESOURCE_DIRECTORY)(ResourceData +
|
|
TypeEntry->OffsetToDirectory);
|
|
NameEntry = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(NameDirectory + 1);
|
|
|
|
/* Get the number of entries in the name directory */
|
|
NumberOfNameEntries = NameDirectory->NumberOfNamedEntries +
|
|
NameDirectory->NumberOfIdEntries;
|
|
|
|
/* Loop all entries in the name directory */
|
|
for (j = 0; j < NumberOfNameEntries; ++j, ++NameEntry)
|
|
{
|
|
/* Check if comparison of names is requested */
|
|
if (Level > RESOURCE_NAME_LEVEL)
|
|
{
|
|
/* Compare the name with the requested name */
|
|
Result = LdrpCompareResourceNames_U(ResourceData,
|
|
NameEntry,
|
|
ResourceInfo->Name);
|
|
|
|
/* Not equal, continue with next entry */
|
|
if (Result != 0) continue;
|
|
}
|
|
|
|
/* The entry must point to the language directory */
|
|
if (!NameEntry->DataIsDirectory)
|
|
{
|
|
return STATUS_INVALID_IMAGE_FORMAT;
|
|
}
|
|
|
|
/* Get a pointer to the language subdirectory and it's first entry */
|
|
LangDirectory = (PIMAGE_RESOURCE_DIRECTORY)(ResourceData +
|
|
NameEntry->OffsetToDirectory);
|
|
LangEntry = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(LangDirectory + 1);
|
|
|
|
/* Get the number of entries in the language directory */
|
|
NumberOfLangEntries = LangDirectory->NumberOfNamedEntries +
|
|
LangDirectory->NumberOfIdEntries;
|
|
|
|
/* Loop all entries in the language directory */
|
|
for (k = 0; k < NumberOfLangEntries; ++k, ++LangEntry)
|
|
{
|
|
/* Check if comparison of languages is requested */
|
|
if (Level > RESOURCE_LANGUAGE_LEVEL)
|
|
{
|
|
/* Compare the language with the requested language */
|
|
Result = LdrpCompareResourceNames_U(ResourceData,
|
|
LangEntry,
|
|
ResourceInfo->Language);
|
|
|
|
/* Not equal, continue with next entry */
|
|
if (Result != 0) continue;
|
|
}
|
|
|
|
/* This entry must point to data */
|
|
if (LangEntry->DataIsDirectory)
|
|
{
|
|
return STATUS_INVALID_IMAGE_FORMAT;
|
|
}
|
|
|
|
/* Get a pointer to the data entry */
|
|
DataEntry = (PIMAGE_RESOURCE_DATA_ENTRY)(ResourceData +
|
|
LangEntry->OffsetToData);
|
|
|
|
/* Check if there is still space to store the data */
|
|
if (Count < MaxResourceCount)
|
|
{
|
|
/* There is, fill the entry */
|
|
Resources[Count].Type =
|
|
NAME_FROM_RESOURCE_ENTRY(ResourceData, TypeEntry);
|
|
Resources[Count].Name =
|
|
NAME_FROM_RESOURCE_ENTRY(ResourceData, NameEntry);
|
|
Resources[Count].Language =
|
|
NAME_FROM_RESOURCE_ENTRY(ResourceData, LangEntry);
|
|
Resources[Count].Data = (PUCHAR)ImageBase + DataEntry->OffsetToData;
|
|
Resources[Count].Reserved = 0;
|
|
Resources[Count].Size = DataEntry->Size;
|
|
}
|
|
else
|
|
{
|
|
/* There is not enough space, save error status */
|
|
Status = STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
/* Count this resource */
|
|
++Count;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Return the number of matching resources */
|
|
*ResourceCount = Count;
|
|
return Status;
|
|
}
|