lib/rtl/res.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;
}