res.c File Reference

#include <k32.h>
#include <wine/list.h>
#include <debug.h>

Include dependency graph for res.c:

Go to the source code of this file.

Classes
struct	QUEUEDUPDATES
struct	resource_dir_entry
struct	resource_data
struct	resource_size_info
struct	mapping_info

Macros
#define	NDEBUG

Functions
	DEBUG_CHANNEL (resource)
static NTSTATUS	get_res_nameA (LPCSTR name, UNICODE_STRING *str)
static NTSTATUS	get_res_nameW (LPCWSTR name, UNICODE_STRING *str)
static HRSRC	find_resourceA (HMODULE hModule, LPCSTR type, LPCSTR name, WORD lang)
static HRSRC	find_resourceW (HMODULE hModule, LPCWSTR type, LPCWSTR name, WORD lang)
HRSRC WINAPI	FindResourceExA (HMODULE hModule, LPCSTR type, LPCSTR name, WORD lang)
HRSRC WINAPI	FindResourceA (HMODULE hModule, LPCSTR name, LPCSTR type)
HRSRC WINAPI	FindResourceExW (HMODULE hModule, LPCWSTR type, LPCWSTR name, WORD lang)
HRSRC WINAPI	FindResourceW (HINSTANCE hModule, LPCWSTR name, LPCWSTR type)
BOOL WINAPI	EnumResourceTypesA (HMODULE hmod, ENUMRESTYPEPROCA lpfun, LONG_PTR lparam)
BOOL WINAPI	EnumResourceTypesW (HMODULE hmod, ENUMRESTYPEPROCW lpfun, LONG_PTR lparam)
BOOL WINAPI	EnumResourceNamesA (HMODULE hmod, LPCSTR type, ENUMRESNAMEPROCA lpfun, LONG_PTR lparam)
BOOL WINAPI	EnumResourceNamesW (HMODULE hmod, LPCWSTR type, ENUMRESNAMEPROCW lpfun, LONG_PTR lparam)
BOOL WINAPI	EnumResourceLanguagesA (HMODULE hmod, LPCSTR type, LPCSTR name, ENUMRESLANGPROCA lpfun, LONG_PTR lparam)
BOOL WINAPI	EnumResourceLanguagesW (HMODULE hmod, LPCWSTR type, LPCWSTR name, ENUMRESLANGPROCW lpfun, LONG_PTR lparam)
HGLOBAL WINAPI	LoadResource (HINSTANCE hModule, HRSRC hRsrc)
LPVOID WINAPI	LockResource (HGLOBAL handle)
BOOL WINAPI	FreeResource (HGLOBAL handle)
DWORD WINAPI	SizeofResource (HINSTANCE hModule, HRSRC hRsrc)
static int	resource_strcmp (LPCWSTR a, LPCWSTR b)
static struct resource_dir_entry *	find_resource_dir_entry (struct list *dir, LPCWSTR id)
static struct resource_data *	find_resource_data (struct list *dir, LANGID lang)
static void	add_resource_dir_entry (struct list *dir, struct resource_dir_entry *resdir)
static void	add_resource_data_entry (struct list *dir, struct resource_data *resdata)
static LPWSTR	res_strdupW (LPCWSTR str)
static void	res_free_str (LPWSTR str)
static BOOL	update_add_resource (QUEUEDUPDATES *updates, LPCWSTR Type, LPCWSTR Name, LANGID Lang, struct resource_data *resdata, BOOL overwrite_existing)
static struct resource_data *	allocate_resource_data (WORD Language, DWORD codepage, LPVOID lpData, DWORD cbData, BOOL copy_data)
static void	free_resource_directory (struct list *head, int level)
static IMAGE_NT_HEADERS *	get_nt_header (void *base, DWORD mapping_size)
static IMAGE_SECTION_HEADER *	get_section_header (void *base, DWORD mapping_size, DWORD *num_sections)
static BOOL	check_pe_exe (HANDLE file, QUEUEDUPDATES *updates)
static const IMAGE_SECTION_HEADER *	section_from_rva (void *base, DWORD mapping_size, DWORD rva)
static void *	address_from_rva (void *base, DWORD mapping_size, DWORD rva, DWORD len)
static LPWSTR	resource_dup_string (const IMAGE_RESOURCE_DIRECTORY *root, const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry)
static BOOL	enumerate_mapped_resources (QUEUEDUPDATES *updates, void *base, DWORD mapping_size, const IMAGE_RESOURCE_DIRECTORY *root)
static BOOL	read_mapped_resources (QUEUEDUPDATES *updates, void *base, DWORD mapping_size)
static BOOL	map_file_into_memory (struct mapping_info *mi)
static BOOL	unmap_file_from_memory (struct mapping_info *mi)
static void	destroy_mapping (struct mapping_info *mi)
static struct mapping_info *	create_mapping (LPCWSTR name, BOOL rw)
static BOOL	resize_mapping (struct mapping_info *mi, DWORD new_size)
static void	get_resource_sizes (QUEUEDUPDATES *updates, struct resource_size_info *si)
static void	res_write_padding (BYTE *res_base, DWORD size)
static BOOL	write_resources (QUEUEDUPDATES *updates, LPBYTE base, struct resource_size_info *si, DWORD rva)
static IMAGE_SECTION_HEADER *	get_resource_section (void *base, DWORD mapping_size)
static DWORD	get_init_data_size (void *base, DWORD mapping_size)
static BOOL	write_raw_resources (QUEUEDUPDATES *updates)
HANDLE WINAPI	BeginUpdateResourceW (LPCWSTR pFileName, BOOL bDeleteExistingResources)
HANDLE WINAPI	BeginUpdateResourceA (LPCSTR pFileName, BOOL bDeleteExistingResources)
BOOL WINAPI	EndUpdateResourceW (HANDLE hUpdate, BOOL fDiscard)
BOOL WINAPI	EndUpdateResourceA (HANDLE hUpdate, BOOL fDiscard)
BOOL WINAPI	UpdateResourceW (HANDLE hUpdate, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cbData)
BOOL WINAPI	UpdateResourceA (HANDLE hUpdate, LPCSTR lpType, LPCSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cbData)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 27 of file res.c.

Function Documentation

add_resource_data_entry()

static void add_resource_data_entry ( struct list *  dir, struct resource_data *  resdata  )

static

Definition at line 660 of file res.c.

{
    struct resource_data *ent;
 
    LIST_FOR_EACH_ENTRY( ent, dir, struct resource_data, entry )
    {
        if (ent->lang < resdata->lang)
            continue;
 
        list_add_before( &ent->entry, &resdata->entry );
        return;
    }
    list_add_tail( dir, &resdata->entry );
}

Referenced by update_add_resource().

add_resource_dir_entry()

static void add_resource_dir_entry ( struct list *  dir, struct resource_dir_entry *  resdir  )

static

Definition at line 645 of file res.c.

{
    struct resource_dir_entry *ent;
 
    LIST_FOR_EACH_ENTRY( ent, dir, struct resource_dir_entry, entry )
    {
        if (0>resource_strcmp( ent->id, resdir->id ))
            continue;
 
        list_add_before( &ent->entry, &resdir->entry );
        return;
    }
    list_add_tail( dir, &resdir->entry );
}

Referenced by update_add_resource().

address_from_rva()

static void * address_from_rva ( void *  base, DWORD  mapping_size, DWORD  rva, DWORD  len  )

static

Definition at line 925 of file res.c.

{
    const IMAGE_SECTION_HEADER *sec;
 
    sec = section_from_rva( base, mapping_size, rva );
    if (!sec)
        return NULL;
 
    if (rva + len <= (DWORD)sec->VirtualAddress + sec->SizeOfRawData)
        return (void*)((LPBYTE) base + (sec->PointerToRawData + rva - sec->VirtualAddress));
 
    return NULL;
}

Referenced by enumerate_mapped_resources().

allocate_resource_data()

static struct resource_data * allocate_resource_data ( WORD  Language, DWORD  codepage, LPVOID  lpData, DWORD  cbData, BOOL  copy_data  )

static

Definition at line 741 of file res.c.

{
    struct resource_data *resdata;
 
    if (!lpData || !cbData)
        return NULL;
 
    resdata = HeapAlloc( GetProcessHeap(), 0, sizeof *resdata + (copy_data ? cbData : 0) );
    if (resdata)
    {
        resdata->lang = Language;
        resdata->codepage = codepage;
        resdata->cbData = cbData;
        if (copy_data)
        {
            resdata->lpData = &resdata[1];
            memcpy( resdata->lpData, lpData, cbData );
        }
        else
            resdata->lpData = lpData;
    }
 
    return resdata;
}

Referenced by enumerate_mapped_resources(), and UpdateResourceW().

BeginUpdateResourceA()

HANDLE WINAPI BeginUpdateResourceA	(	LPCSTR	pFileName,
		BOOL	bDeleteExistingResources
	)

Definition at line 1657 of file res.c.

{
    UNICODE_STRING FileNameW;
    HANDLE ret;
    RtlCreateUnicodeStringFromAsciiz(&FileNameW, pFileName);
    ret = BeginUpdateResourceW(FileNameW.Buffer, bDeleteExistingResources);
    RtlFreeUnicodeString(&FileNameW);
    return ret;
}

Referenced by create_file_with_version(), update_empty_exe(), update_missing_exe(), update_resources_bigdata(), update_resources_delete(), update_resources_none(), and update_resources_version().

BeginUpdateResourceW()

HANDLE WINAPI BeginUpdateResourceW	(	LPCWSTR	pFileName,
		BOOL	bDeleteExistingResources
	)

Definition at line 1611 of file res.c.

{
    QUEUEDUPDATES *updates = NULL;
    HANDLE hUpdate, file, ret = NULL;
 
    TRACE("%s, %d\n", debugstr_w(pFileName), bDeleteExistingResources);
 
    hUpdate = GlobalAlloc(GHND, sizeof(QUEUEDUPDATES));
    if (!hUpdate)
        return ret;
 
    updates = GlobalLock(hUpdate);
    if (updates)
    {
        list_init( &updates->root );
        updates->bDeleteExistingResources = bDeleteExistingResources;
        updates->pFileName = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(pFileName)+1)*sizeof(WCHAR));
        if (updates->pFileName)
        {
            lstrcpyW(updates->pFileName, pFileName);
 
            file = CreateFileW( pFileName, GENERIC_READ | GENERIC_WRITE,
                                0, NULL, OPEN_EXISTING, 0, 0 );
 
            /* if resources are deleted, only the file's presence is checked */
            if (file != INVALID_HANDLE_VALUE &&
                (bDeleteExistingResources || check_pe_exe( file, updates )))
                ret = hUpdate;
            else
                HeapFree( GetProcessHeap(), 0, updates->pFileName );
 
            CloseHandle( file );
        }
        GlobalUnlock(hUpdate);
    }
 
    if (!ret)
        GlobalFree(hUpdate);
 
    return ret;
}

Referenced by BeginUpdateResourceA().

check_pe_exe()

static BOOL check_pe_exe ( HANDLE  file, QUEUEDUPDATES *  updates  )

static

Definition at line 837 of file res.c.

{
    const IMAGE_NT_HEADERS32 *nt;
    const IMAGE_NT_HEADERS64 *nt64;
    const IMAGE_SECTION_HEADER *sec;
    const IMAGE_DATA_DIRECTORY *dd;
    BOOL ret = FALSE;
    HANDLE mapping;
    DWORD mapping_size, num_sections = 0;
    void *base = NULL;
 
    mapping_size = GetFileSize( file, NULL );
 
    mapping = CreateFileMappingW( file, NULL, PAGE_READONLY, 0, 0, NULL );
    if (!mapping)
        goto done;
 
    base = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, mapping_size );
    if (!base)
        goto done;
 
    nt = (IMAGE_NT_HEADERS32 *)get_nt_header( base, mapping_size );
    if (!nt)
        goto done;
 
    nt64 = (IMAGE_NT_HEADERS64*)nt;
    dd = &nt->OptionalHeader.DataDirectory[0];
    if (nt->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC)
        dd = &nt64->OptionalHeader.DataDirectory[0];
 
    TRACE("resources: %08x %08x\n",
          dd[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress,
          dd[IMAGE_DIRECTORY_ENTRY_RESOURCE].Size);
 
    sec = get_section_header( base, mapping_size, &num_sections );
    if (!sec)
        goto done;
 
    ret = TRUE;
 
done:
    if (base)
        UnmapViewOfFile( base );
    if (mapping)
        CloseHandle( mapping );
 
    return ret;
}

Referenced by BeginUpdateResourceW().

create_mapping()

static struct mapping_info * create_mapping ( LPCWSTR  name, BOOL  rw  )

static

Definition at line 1096 of file res.c.

{
    struct mapping_info *mi;
 
    mi = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof *mi );
    if (!mi)
        return NULL;
 
    mi->read_write = rw;
 
    mi->file = CreateFileW( name, GENERIC_READ | (rw ? GENERIC_WRITE : 0),
                            0, NULL, OPEN_EXISTING, 0, 0 );
 
    if (mi->file != INVALID_HANDLE_VALUE)
    {
        mi->size = GetFileSize( mi->file, NULL );
 
        if (map_file_into_memory( mi ))
            return mi;
    }
    destroy_mapping( mi );
    return NULL;
}

Referenced by write_raw_resources().

DEBUG_CHANNEL()

DEBUG_CHANNEL

(

resource

)

destroy_mapping()

static void destroy_mapping ( struct mapping_info *  mi )

static

Definition at line 1086 of file res.c.

{
    if (!mi)
        return;
    unmap_file_from_memory( mi );
    if (mi->file)
        CloseHandle( mi->file );
    HeapFree( GetProcessHeap(), 0, mi );
}

Referenced by create_mapping(), and write_raw_resources().

EndUpdateResourceA()

BOOL WINAPI EndUpdateResourceA	(	HANDLE	hUpdate,
		BOOL	fDiscard
	)

Definition at line 1697 of file res.c.

{
    return EndUpdateResourceW(hUpdate, fDiscard);
}

Referenced by create_file_with_version(), update_empty_exe(), update_resources_bigdata(), update_resources_delete(), update_resources_none(), and update_resources_version().

EndUpdateResourceW()

BOOL WINAPI EndUpdateResourceW	(	HANDLE	hUpdate,
		BOOL	fDiscard
	)

Definition at line 1671 of file res.c.

{
    QUEUEDUPDATES *updates;
    BOOL ret;
 
    TRACE("%p %d\n", hUpdate, fDiscard);
 
    updates = GlobalLock(hUpdate);
    if (!updates)
        return FALSE;
 
    ret = fDiscard || write_raw_resources( updates );
 
    free_resource_directory( &updates->root, 2 );
 
    HeapFree( GetProcessHeap(), 0, updates->pFileName );
    GlobalUnlock( hUpdate );
    GlobalFree( hUpdate );
 
    return ret;
}

Referenced by EndUpdateResourceA().

enumerate_mapped_resources()

static BOOL enumerate_mapped_resources ( QUEUEDUPDATES *  updates, void *  base, DWORD  mapping_size, const IMAGE_RESOURCE_DIRECTORY *  root  )

static

Definition at line 956 of file res.c.

{
    const IMAGE_RESOURCE_DIRECTORY *namedir, *langdir;
    const IMAGE_RESOURCE_DIRECTORY_ENTRY *e1, *e2, *e3;
    const IMAGE_RESOURCE_DATA_ENTRY *data;
    DWORD i, j, k;
 
    TRACE("version (%d.%d) %d named %d id entries\n",
          root->MajorVersion, root->MinorVersion, root->NumberOfNamedEntries, root->NumberOfIdEntries);
 
    for (i = 0; i< root->NumberOfNamedEntries + root->NumberOfIdEntries; i++)
    {
        LPWSTR Type;
 
        e1 = (const IMAGE_RESOURCE_DIRECTORY_ENTRY*)(root + 1) + i;
 
        Type = resource_dup_string( root, e1 );
 
        namedir = (const IMAGE_RESOURCE_DIRECTORY *)((const char *)root + e1->OffsetToDirectory);
        for (j = 0; j < namedir->NumberOfNamedEntries + namedir->NumberOfIdEntries; j++)
        {
            LPWSTR Name;
 
            e2 = (const IMAGE_RESOURCE_DIRECTORY_ENTRY*)(namedir + 1) + j;
 
            Name = resource_dup_string( root, e2 );
 
            langdir = (const IMAGE_RESOURCE_DIRECTORY *)((const char *)root + e2->OffsetToDirectory);
            for (k = 0; k < langdir->NumberOfNamedEntries + langdir->NumberOfIdEntries; k++)
            {
                LANGID Lang;
                void *p;
                struct resource_data *resdata;
 
                e3 = (const IMAGE_RESOURCE_DIRECTORY_ENTRY*)(langdir + 1) + k;
 
                Lang = e3->Id;
 
                data = (const IMAGE_RESOURCE_DATA_ENTRY *)((const char *)root + e3->OffsetToData);
 
                p = address_from_rva( base, mapping_size, data->OffsetToData, data->Size );
 
                resdata = allocate_resource_data( Lang, data->CodePage, p, data->Size, FALSE );
                if (resdata)
                {
                    if (!update_add_resource( updates, Type, Name, Lang, resdata, FALSE ))
                        HeapFree( GetProcessHeap(), 0, resdata );
                }
            }
            res_free_str( Name );
        }
        res_free_str( Type );
    }
 
    return TRUE;
}

Referenced by read_mapped_resources().

EnumResourceLanguagesA()

BOOL WINAPI EnumResourceLanguagesA	(	HMODULE	hmod,
		LPCSTR	type,
		LPCSTR	name,
		ENUMRESLANGPROCA	lpfun,
		LONG_PTR	lparam
	)

Definition at line 428 of file res.c.

{
    int i;
    BOOL ret = FALSE;
    NTSTATUS status;
    UNICODE_STRING typeW, nameW;
    LDR_RESOURCE_INFO info;
    IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
    const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 
    TRACE( "%p %s %s %p %lx\n", hmod, debugstr_a(type), debugstr_a(name), lpfun, lparam );
 
    if (!hmod) hmod = GetModuleHandleA( NULL );
    typeW.Buffer = nameW.Buffer = NULL;
    if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &basedir )) != STATUS_SUCCESS)
        goto done;
    if ((status = get_res_nameA( type, &typeW )) != STATUS_SUCCESS)
        goto done;
    if ((status = get_res_nameA( name, &nameW )) != STATUS_SUCCESS)
        goto done;
    info.Type = (ULONG_PTR)typeW.Buffer;
    info.Name = (ULONG_PTR)nameW.Buffer;
    if ((status = LdrFindResourceDirectory_U( hmod, &info, 2, &resdir )) != STATUS_SUCCESS)
        goto done;
 
    et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
    __TRY
    {
        for (i = 0; i < resdir->NumberOfNamedEntries + resdir->NumberOfIdEntries; i++)
        {
            ret = lpfun( hmod, type, name, et[i].Id, lparam );
            if (!ret) break;
        }
    }
    __EXCEPT_PAGE_FAULT
    {
        ret = FALSE;
        status = STATUS_ACCESS_VIOLATION;
    }
    __ENDTRY
done:
    if (!IS_INTRESOURCE(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
    if (!IS_INTRESOURCE(nameW.Buffer)) HeapFree( GetProcessHeap(), 0, nameW.Buffer );
    if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
    return ret;
}

Referenced by EnumSystemLocalesA(), EnumUILanguagesA(), and MSVCRT_locale_to_LCID().

EnumResourceLanguagesW()

BOOL WINAPI EnumResourceLanguagesW	(	HMODULE	hmod,
		LPCWSTR	type,
		LPCWSTR	name,
		ENUMRESLANGPROCW	lpfun,
		LONG_PTR	lparam
	)

Definition at line 480 of file res.c.

{
    int i;
    BOOL ret = FALSE;
    NTSTATUS status;
    UNICODE_STRING typeW, nameW;
    LDR_RESOURCE_INFO info;
    IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
    const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 
    TRACE( "%p %s %s %p %lx\n", hmod, debugstr_w(type), debugstr_w(name), lpfun, lparam );
 
    if (!hmod) hmod = GetModuleHandleW( NULL );
    typeW.Buffer = nameW.Buffer = NULL;
    if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &basedir )) != STATUS_SUCCESS)
        goto done;
    if ((status = get_res_nameW( type, &typeW )) != STATUS_SUCCESS)
        goto done;
    if ((status = get_res_nameW( name, &nameW )) != STATUS_SUCCESS)
        goto done;
    info.Type = (ULONG_PTR)typeW.Buffer;
    info.Name = (ULONG_PTR)nameW.Buffer;
    if ((status = LdrFindResourceDirectory_U( hmod, &info, 2, &resdir )) != STATUS_SUCCESS)
        goto done;
 
    et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
    __TRY
    {
        for (i = 0; i < resdir->NumberOfNamedEntries + resdir->NumberOfIdEntries; i++)
        {
            ret = lpfun( hmod, type, name, et[i].Id, lparam );
            if (!ret) break;
        }
    }
    __EXCEPT_PAGE_FAULT
    {
        ret = FALSE;
        status = STATUS_ACCESS_VIOLATION;
    }
    __ENDTRY
done:
    if (!IS_INTRESOURCE(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
    if (!IS_INTRESOURCE(nameW.Buffer)) HeapFree( GetProcessHeap(), 0, nameW.Buffer );
    if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
    return ret;
}

Referenced by EnumSystemLocalesEx(), EnumSystemLocalesW(), EnumUILanguagesW(), and TEST_LocaleTests().

EnumResourceNamesA()

BOOL WINAPI EnumResourceNamesA	(	HMODULE	hmod,
		LPCSTR	type,
		ENUMRESNAMEPROCA	lpfun,
		LONG_PTR	lparam
	)

Definition at line 285 of file res.c.

{
    int i;
    BOOL ret = FALSE;
    DWORD len = 0, newlen;
    LPSTR name = NULL;
    NTSTATUS status;
    UNICODE_STRING typeW;
    LDR_RESOURCE_INFO info;
    IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
    const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
    const IMAGE_RESOURCE_DIR_STRING_U *str;
 
    TRACE( "%p %s %p %lx\n", hmod, debugstr_a(type), lpfun, lparam );
 
    if (!hmod) hmod = GetModuleHandleA( NULL );
    typeW.Buffer = NULL;
    if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &basedir )) != STATUS_SUCCESS)
        goto done;
    if ((status = get_res_nameA( type, &typeW )) != STATUS_SUCCESS)
        goto done;
    info.Type = (ULONG_PTR)typeW.Buffer;
    if ((status = LdrFindResourceDirectory_U( hmod, &info, 1, &resdir )) != STATUS_SUCCESS)
        goto done;
 
    et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
    __TRY
    {
        for (i = 0; i < resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries; i++)
        {
            if (et[i].NameIsString)
            {
                str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)basedir + et[i].NameOffset);
                newlen = WideCharToMultiByte(CP_ACP, 0, str->NameString, str->Length, NULL, 0, NULL, NULL);
                if (newlen + 1 > len)
                {
                    len = newlen + 1;
                    HeapFree( GetProcessHeap(), 0, name );
                    if (!(name = HeapAlloc(GetProcessHeap(), 0, len + 1 )))
                    {
                        ret = FALSE;
                        break;
                    }
                }
                WideCharToMultiByte( CP_ACP, 0, str->NameString, str->Length, name, len, NULL, NULL );
                name[newlen] = 0;
                ret = lpfun(hmod,type,name,lparam);
            }
            else
            {
                ret = lpfun( hmod, type, UIntToPtr(et[i].Id), lparam );
            }
            if (!ret) break;
        }
    }
    __EXCEPT_PAGE_FAULT
    {
        ret = FALSE;
        status = STATUS_ACCESS_VIOLATION;
    }
    __ENDTRY;
 
done:
    HeapFree( GetProcessHeap(), 0, name );
    if (!IS_INTRESOURCE(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
    if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
    return ret;
}

Referenced by START_TEST().

EnumResourceNamesW()

BOOL WINAPI EnumResourceNamesW	(	HMODULE	hmod,
		LPCWSTR	type,
		ENUMRESNAMEPROCW	lpfun,
		LONG_PTR	lparam
	)

Definition at line 358 of file res.c.

{
    int i, len = 0;
    BOOL ret = FALSE;
    LPWSTR name = NULL;
    NTSTATUS status;
    UNICODE_STRING typeW;
    LDR_RESOURCE_INFO info;
    IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
    const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
    const IMAGE_RESOURCE_DIR_STRING_U *str;
 
    TRACE( "%p %s %p %lx\n", hmod, debugstr_w(type), lpfun, lparam );
 
    if (!hmod) hmod = GetModuleHandleW( NULL );
    typeW.Buffer = NULL;
    if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &basedir )) != STATUS_SUCCESS)
        goto done;
    if ((status = get_res_nameW( type, &typeW )) != STATUS_SUCCESS)
        goto done;
    info.Type = (ULONG_PTR)typeW.Buffer;
    if ((status = LdrFindResourceDirectory_U( hmod, &info, 1, &resdir )) != STATUS_SUCCESS)
        goto done;
 
    et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
    __TRY
    {
        for (i = 0; i < resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries; i++)
        {
            if (et[i].NameIsString)
            {
                str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)basedir + et[i].NameOffset);
                if (str->Length + 1 > len)
                {
                    len = str->Length + 1;
                    HeapFree( GetProcessHeap(), 0, name );
                    if (!(name = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
                    {
                        ret = FALSE;
                        break;
                    }
                }
                memcpy(name, str->NameString, str->Length * sizeof (WCHAR));
                name[str->Length] = 0;
                ret = lpfun(hmod,type,name,lparam);
            }
            else
            {
                ret = lpfun( hmod, type, UIntToPtr(et[i].Id), lparam );
            }
            if (!ret) break;
        }
    }
    __EXCEPT_PAGE_FAULT
    {
        ret = FALSE;
        status = STATUS_ACCESS_VIOLATION;
    }
    __ENDTRY
done:
    HeapFree( GetProcessHeap(), 0, name );
    if (!IS_INTRESOURCE(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
    if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
    return ret;
}

Referenced by __wine_register_resources(), __wine_unregister_resources(), DIALOG_SYMBOL_DlgProc(), DoLoadIcons(), ITERATE_RegisterTypeLibraries(), ITypeInfo_fnGetRefTypeInfo(), and LoadIMEIcon().

EnumResourceTypesA()

BOOL WINAPI EnumResourceTypesA	(	HMODULE	hmod,
		ENUMRESTYPEPROCA	lpfun,
		LONG_PTR	lparam
	)

Definition at line 185 of file res.c.

{
    int i;
    BOOL ret = FALSE;
    LPSTR type = NULL;
    DWORD len = 0, newlen;
    NTSTATUS status;
    IMAGE_RESOURCE_DIRECTORY *resdir;
    const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
    const IMAGE_RESOURCE_DIR_STRING_U *str;
 
    TRACE( "%p %p %lx\n", hmod, lpfun, lparam );
 
    if (!hmod) hmod = GetModuleHandleA( NULL );
 
    if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &resdir )) != STATUS_SUCCESS)
    {
        SetLastError( RtlNtStatusToDosError(status) );
        return FALSE;
    }
    et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
    for (i = 0; i < resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries; i++)
    {
        if (et[i].NameIsString)
        {
            str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)resdir + et[i].NameOffset);
            newlen = WideCharToMultiByte( CP_ACP, 0, str->NameString, str->Length, NULL, 0, NULL, NULL);
            if (newlen + 1 > len)
            {
                len = newlen + 1;
                HeapFree( GetProcessHeap(), 0, type );
                if (!(type = HeapAlloc( GetProcessHeap(), 0, len ))) return FALSE;
            }
            WideCharToMultiByte( CP_ACP, 0, str->NameString, str->Length, type, len, NULL, NULL);
            type[newlen] = 0;
            ret = lpfun(hmod,type,lparam);
        }
        else
        {
            ret = lpfun( hmod, UIntToPtr(et[i].Id), lparam );
        }
        if (!ret) break;
    }
    HeapFree( GetProcessHeap(), 0, type );
    return ret;
}

EnumResourceTypesW()

BOOL WINAPI EnumResourceTypesW	(	HMODULE	hmod,
		ENUMRESTYPEPROCW	lpfun,
		LONG_PTR	lparam
	)

Definition at line 236 of file res.c.

{
    int i, len = 0;
    BOOL ret = FALSE;
    LPWSTR type = NULL;
    NTSTATUS status;
    IMAGE_RESOURCE_DIRECTORY *resdir;
    const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
    const IMAGE_RESOURCE_DIR_STRING_U *str;
 
    TRACE( "%p %p %lx\n", hmod, lpfun, lparam );
 
    if (!hmod) hmod = GetModuleHandleW( NULL );
 
    if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &resdir )) != STATUS_SUCCESS)
    {
        SetLastError( RtlNtStatusToDosError(status) );
        return FALSE;
    }
    et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
    for (i = 0; i < resdir->NumberOfNamedEntries + resdir->NumberOfIdEntries; i++)
    {
        if (et[i].NameIsString)
        {
            str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)resdir + et[i].NameOffset);
            if (str->Length + 1 > len)
            {
                len = str->Length + 1;
                HeapFree( GetProcessHeap(), 0, type );
                if (!(type = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return FALSE;
            }
            memcpy(type, str->NameString, str->Length * sizeof (WCHAR));
            type[str->Length] = 0;
            ret = lpfun(hmod,type,lparam);
        }
        else
        {
            ret = lpfun( hmod, UIntToPtr(et[i].Id), lparam );
        }
        if (!ret) break;
    }
    HeapFree( GetProcessHeap(), 0, type );
    return ret;
}

find_resource_data()

static struct resource_data * find_resource_data ( struct list *  dir, LANGID  lang  )

static

Definition at line 633 of file res.c.

{
    struct resource_data *res_data;
 
    /* match only languages here */
    LIST_FOR_EACH_ENTRY( res_data, dir, struct resource_data, entry )
        if ( lang == res_data->lang )
             return res_data;
 
    return NULL;
}

Referenced by update_add_resource().

find_resource_dir_entry()

static struct resource_dir_entry * find_resource_dir_entry ( struct list *  dir, LPCWSTR  id  )

static

Definition at line 621 of file res.c.

{
    struct resource_dir_entry *ent;
 
    /* match either IDs or strings */
    LIST_FOR_EACH_ENTRY( ent, dir, struct resource_dir_entry, entry )
        if (!resource_strcmp( id, ent->id ))
            return ent;
 
    return NULL;
}

Referenced by update_add_resource().

find_resourceA()

static HRSRC find_resourceA ( HMODULE  hModule, LPCSTR  type, LPCSTR  name, WORD  lang  )

static

Definition at line 75 of file res.c.

{
    NTSTATUS status;
    UNICODE_STRING nameW, typeW;
    LDR_RESOURCE_INFO info;
    IMAGE_RESOURCE_DATA_ENTRY *entry = NULL;
 
    nameW.Buffer = NULL;
    typeW.Buffer = NULL;
 
    __TRY
    {
        if ((status = get_res_nameA( name, &nameW )) != STATUS_SUCCESS) goto done;
        if ((status = get_res_nameA( type, &typeW )) != STATUS_SUCCESS) goto done;
        info.Type = (ULONG_PTR)typeW.Buffer;
        info.Name = (ULONG_PTR)nameW.Buffer;
        info.Language = lang;
        status = LdrFindResource_U( hModule, &info, 3, &entry );
    done:
        if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
    }
    __EXCEPT_PAGE_FAULT
    {
        SetLastError( ERROR_INVALID_PARAMETER );
    }
    __ENDTRY
 
    if (!IS_INTRESOURCE(nameW.Buffer)) HeapFree( GetProcessHeap(), 0, nameW.Buffer );
    if (!IS_INTRESOURCE(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
    return (HRSRC)entry;
}

Referenced by FindResourceExA().

find_resourceW()

static HRSRC find_resourceW ( HMODULE  hModule, LPCWSTR  type, LPCWSTR  name, WORD  lang  )

static

Definition at line 109 of file res.c.

{
    NTSTATUS status;
    UNICODE_STRING nameW, typeW;
    LDR_RESOURCE_INFO info;
    IMAGE_RESOURCE_DATA_ENTRY *entry = NULL;
 
    nameW.Buffer = typeW.Buffer = NULL;
 
    __TRY
    {
        if ((status = get_res_nameW( name, &nameW )) != STATUS_SUCCESS) goto done;
        if ((status = get_res_nameW( type, &typeW )) != STATUS_SUCCESS) goto done;
        info.Type = (ULONG_PTR)typeW.Buffer;
        info.Name = (ULONG_PTR)nameW.Buffer;
        info.Language = lang;
        status = LdrFindResource_U( hModule, &info, 3, &entry );
    done:
        if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
    }
    __EXCEPT_PAGE_FAULT
    {
        SetLastError( ERROR_INVALID_PARAMETER );
    }
    __ENDTRY
 
    if (!IS_INTRESOURCE(nameW.Buffer)) HeapFree( GetProcessHeap(), 0, nameW.Buffer );
    if (!IS_INTRESOURCE(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
    return (HRSRC)entry;
}

Referenced by FindResourceExW().

FindResourceA()

HRSRC WINAPI FindResourceA	(	HMODULE	hModule,
		LPCSTR	name,
		LPCSTR	type
	)

Definition at line 155 of file res.c.

{
    return FindResourceExA( hModule, type, name, MAKELANGID( LANG_NEUTRAL, SUBLANG_NEUTRAL ) );
}

Referenced by ChooseFontA(), COMDLG32_FR_DoFindReplace(), create_chm(), create_testfontfile(), CreateDialogParamA(), CreateTemplateDialog(), D3DXAssembleShaderFromResourceA(), D3DXCompileShaderFromResourceA(), D3DXCreateEffectCompilerFromResourceA(), D3DXCreateEffectFromResourceExA(), D3DXCreateTextureFromResourceExA(), D3DXGetImageInfoFromResourceA(), D3DXLoadMeshFromXResource(), D3DXLoadSurfaceFromResourceA(), D3DXPreprocessShaderFromResourceA(), DialogBoxParamA(), extract_one(), extract_resource(), FD31_GetTemplate(), get_res_data(), IDirectXFileImpl_CreateEnumObject(), load_res(), load_resource(), LoadMenuA(), MDI_MoreWindowsDialog(), OleUIInsertObjectA(), pagesetup_get_template(), PRINTDLG_GetDlgTemplateA(), PROPSHEET_CollectPageInfo(), PROPSHEET_CreateDialog(), PROPSHEET_CreatePage(), run_from_res(), sheet_callback(), START_TEST(), test_arrange(), test_enum_proc(), test_focus(), test_LoadImage(), test_resizable2(), test_SaveRestoreFocus(), write_resource_file(), and write_typelib().

FindResourceExA()

HRSRC WINAPI FindResourceExA	(	HMODULE	hModule,
		LPCSTR	type,
		LPCSTR	name,
		WORD	lang
	)

Definition at line 143 of file res.c.

{
    TRACE( "%p %s %s %04x\n", hModule, debugstr_a(type), debugstr_a(name), lang );
 
    if (!hModule) hModule = GetModuleHandleW(0);
    return find_resourceA( hModule, type, name, lang );
}

Referenced by FindResourceA(), LoadAcceleratorsA(), and test_GetFileVersionInfoEx().

FindResourceExW()

HRSRC WINAPI FindResourceExW	(	HMODULE	hModule,
		LPCWSTR	type,
		LPCWSTR	name,
		WORD	lang
	)

Definition at line 164 of file res.c.

{
    TRACE( "%p %s %s %04x\n", hModule, debugstr_w(type), debugstr_w(name), lang );
 
    if (!hModule) hModule = GetModuleHandleW(0);
    return find_resourceW( hModule, type, name, lang );
}

Referenced by ATL::AtlGetStringResourceImage(), FindResourceW(), GetFileVersionInfoExW(), GetFileVersionInfoSizeExW(), GetLocaleInfoW(), GetLocalisedText(), IsValidLocale(), K32LoadStringExW(), LoadAcceleratorsW(), MsiLoadStringW(), NLS_GetLanguageGroupName(), test_find_resource(), and VARIANT_GetLocalisedText().

FindResourceW()

HRSRC WINAPI FindResourceW	(	HINSTANCE	hModule,
		LPCWSTR	name,
		LPCWSTR	type
	)

Definition at line 176 of file res.c.

{
    return FindResourceExW( hModule, type, name, MAKELANGID( LANG_NEUTRAL, SUBLANG_NEUTRAL ) );
}

Referenced by ANIMATE_LoadResW(), AtlAxCreateDialogW(), AtlAxDialogBoxW(), ATL::AtlGetStringResourceImage(), BITMAP_LoadImageW(), ChooseColorW(), ChooseFontA(), ChooseFontW(), COMDLG32_FR_DoFindReplace(), create_tmp_ini_file(), CreateDialogParamW(), CreateIconFromResourceEx(), CreateMappedBitmap(), CreateTemplateDialog(), CURSORICON_LoadImageW(), D3DXAssembleShaderFromResourceW(), D3DXCompileShaderFromResourceW(), D3DXCreateEffectCompilerFromResourceW(), D3DXCreateEffectFromResourceExW(), D3DXCreateTextureFromResourceExW(), D3DXGetImageInfoFromResourceW(), D3DXLoadSurfaceFromResourceW(), D3DXPreprocessShaderFromResourceW(), DialogBoxParamW(), DoEntry(), EngFindResource(), extract_resource(), FD31_GetTemplate(), GetFileName95(), GetFileVersionInfoExW(), GetFileVersionInfoSizeExW(), GetResource(), GplDlgProc(), include_pac_utils(), LengthOfStrResource(), load_resource(), load_string(), LoadDialogResource(), LoadMenuW(), LoadStringA(), LoadStringW(), LoadXMLDocumentFromResource(), LsapGetResourceStringLengthEx(), LsapLoadString(), LsapLoadStringEx(), MCI_GetCommandTable(), mciLoadCommandResource(), MSSTYLES_GetActiveThemeIni(), MSSTYLES_OpenThemeFile(), MSSTYLES_TryLoadPng(), OleCreatePropertyFrameIndirect(), OleUIPasteSpecialW(), pagesetup_get_template(), PlaySound_GetMMIO(), PRINTDLG_GetDlgTemplateW(), PROPSHEET_CollectPageInfo(), PROPSHEET_CreateDialog(), PROPSHEET_CreatePage(), register_resource(), ATL::CRegObject::resource_register(), resource_register(), ResourceToFile(), ResourceToFileW(), ResProtocol_Start(), SampLoadString(), ShellAboutW(), test_find_resource(), TLB_PEFile_Open(), TOOLBAR_AddStringW(), unpack_avi_file(), and UXINI_LoadINI().

free_resource_directory()

static void free_resource_directory ( struct list *  head, int  level  )

static

Definition at line 767 of file res.c.

{
    struct list *ptr = NULL;
 
    while ((ptr = list_head( head )))
    {
        list_remove( ptr );
        if (level)
        {
            struct resource_dir_entry *ent;
 
            ent = LIST_ENTRY( ptr, struct resource_dir_entry, entry );
            res_free_str( ent->id );
            free_resource_directory( &ent->children, level - 1 );
            HeapFree(GetProcessHeap(), 0, ent);
        }
        else
        {
            struct resource_data *data;
 
            data = LIST_ENTRY( ptr, struct resource_data, entry );
            HeapFree( GetProcessHeap(), 0, data );
        }
    }
}

Referenced by EndUpdateResourceW(), and free_resource_directory().

FreeResource()

BOOL WINAPI FreeResource

(

HGLOBAL

handle

)

Definition at line 559 of file res.c.

{
    return FALSE;
}

Referenced by ANIMATE_Free(), ANIMATE_LoadResW(), AtlAxCreateDialogW(), AtlAxDialogBoxW(), BITMAP_LoadImageW(), create_tmp_ini_file(), CreateIconFromResourceEx(), CreateMappedBitmap(), CURSORICON_LoadImageW(), get_module_version(), GetFileVersionInfoExW(), LoadXMLDocumentFromResource(), mciFreeCommandResource(), mciLoadCommandResource(), MSSTYLES_TryLoadPng(), NLS_GetLanguageGroupName(), PlaySound_GetMMIO(), START_TEST(), and TLB_PEFile_Release().

get_init_data_size()

static DWORD get_init_data_size ( void *  base, DWORD  mapping_size  )

static

Definition at line 1366 of file res.c.

{
    DWORD i, sz = 0, num_sections = 0;
    IMAGE_SECTION_HEADER *s;
 
    s = get_section_header( base, mapping_size, &num_sections );
 
    for (i=0; i<num_sections; i++)
        if (s[i].Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
            sz += s[i].SizeOfRawData;
 
    TRACE("size = %08x\n", sz);
 
    return sz;
}

Referenced by write_raw_resources().

get_nt_header()

static IMAGE_NT_HEADERS * get_nt_header ( void *  base, DWORD  mapping_size  )

static

Definition at line 793 of file res.c.

{
    IMAGE_NT_HEADERS *nt;
    IMAGE_DOS_HEADER *dos;
 
    if (mapping_size<sizeof (*dos))
        return NULL;
 
    dos = base;
    if (dos->e_magic != IMAGE_DOS_SIGNATURE)
        return NULL;
 
    if ((dos->e_lfanew + sizeof (*nt)) > mapping_size)
        return NULL;
 
    nt = (void*) ((BYTE*)base + dos->e_lfanew);
 
    if (nt->Signature != IMAGE_NT_SIGNATURE)
        return NULL;
 
    return nt;
}

Referenced by check_pe_exe(), get_resource_section(), get_section_header(), read_mapped_resources(), and write_raw_resources().

get_res_nameA()

static NTSTATUS get_res_nameA ( LPCSTR  name, UNICODE_STRING *  str  )

static

Definition at line 32 of file res.c.

{
    if (IS_INTRESOURCE(name))
    {
        str->Buffer = ULongToPtr(LOWORD(name));
        return STATUS_SUCCESS;
    }
    if (name[0] == '#')
    {
        ULONG value;
        if (RtlCharToInteger( name + 1, 10, &value ) != STATUS_SUCCESS || HIWORD(value))
            return STATUS_INVALID_PARAMETER;
        str->Buffer = ULongToPtr(value);
        return STATUS_SUCCESS;
    }
    RtlCreateUnicodeStringFromAsciiz( str, name );
    RtlUpcaseUnicodeString( str, str, FALSE );
    return STATUS_SUCCESS;
}

Referenced by EnumResourceLanguagesA(), EnumResourceNamesA(), and find_resourceA().

get_res_nameW()

static NTSTATUS get_res_nameW ( LPCWSTR  name, UNICODE_STRING *  str  )

static

Definition at line 53 of file res.c.

{
    if (IS_INTRESOURCE(name))
    {
        str->Buffer = ULongToPtr(LOWORD(name));
        return STATUS_SUCCESS;
    }
    if (name[0] == '#')
    {
        ULONG value;
        RtlInitUnicodeString( str, name + 1 );
        if (RtlUnicodeStringToInteger( str, 10, &value ) != STATUS_SUCCESS || HIWORD(value))
            return STATUS_INVALID_PARAMETER;
        str->Buffer = ULongToPtr(value);
        return STATUS_SUCCESS;
    }
    RtlCreateUnicodeString( str, name );
    RtlUpcaseUnicodeString( str, str, FALSE );
    return STATUS_SUCCESS;
}

Referenced by EnumResourceLanguagesW(), EnumResourceNamesW(), and find_resourceW().

get_resource_section()

static IMAGE_SECTION_HEADER * get_resource_section ( void *  base, DWORD  mapping_size  )

static

Definition at line 1341 of file res.c.

{
    IMAGE_SECTION_HEADER *sec;
    IMAGE_NT_HEADERS *nt;
    DWORD i, num_sections = 0;
 
    nt = get_nt_header( base, mapping_size );
    if (!nt)
        return NULL;
 
    sec = get_section_header( base, mapping_size, &num_sections );
    if (!sec)
        return NULL;
 
    /* find the resources section */
    for (i=0; i<num_sections; i++)
        if (!memcmp(sec[i].Name, ".rsrc", 6))
            break;
 
    if (i == num_sections)
        return NULL;
 
    return &sec[i];
}

Referenced by write_raw_resources().

get_resource_sizes()

static void get_resource_sizes ( QUEUEDUPDATES *  updates, struct resource_size_info *  si  )

static

Definition at line 1138 of file res.c.

{
    struct resource_dir_entry *types, *names;
    struct resource_data *data;
    DWORD num_types = 0, num_names = 0, num_langs = 0, strings_size = 0, data_size = 0;
 
    memset( si, 0, sizeof *si );
 
    LIST_FOR_EACH_ENTRY( types, &updates->root, struct resource_dir_entry, entry )
    {
        num_types++;
        if (!IS_INTRESOURCE( types->id ))
            strings_size += sizeof (WORD) + lstrlenW( types->id )*sizeof (WCHAR);
 
        LIST_FOR_EACH_ENTRY( names, &types->children, struct resource_dir_entry, entry )
        {
            num_names++;
 
            if (!IS_INTRESOURCE( names->id ))
                strings_size += sizeof (WORD) + lstrlenW( names->id )*sizeof (WCHAR);
 
            LIST_FOR_EACH_ENTRY( data, &names->children, struct resource_data, entry )
            {
                num_langs++;
                data_size += (data->cbData + 3) & ~3;
            }
        }
    }
 
    /* names are at the end of the types */
    si->names_ofs = sizeof (IMAGE_RESOURCE_DIRECTORY) +
            num_types * sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
 
    /* language directories are at the end of the names */
    si->langs_ofs = si->names_ofs +
            num_types * sizeof (IMAGE_RESOURCE_DIRECTORY) +
            num_names * sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
 
    si->data_entry_ofs = si->langs_ofs +
            num_names * sizeof (IMAGE_RESOURCE_DIRECTORY) +
            num_langs * sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
 
    si->strings_ofs = si->data_entry_ofs +
            num_langs * sizeof (IMAGE_RESOURCE_DATA_ENTRY);
 
    si->data_ofs = si->strings_ofs + ((strings_size + 3) & ~3);
 
    si->total_size = si->data_ofs + data_size;
 
    TRACE("names %08x langs %08x data entries %08x strings %08x data %08x total %08x\n",
          si->names_ofs, si->langs_ofs, si->data_entry_ofs,
          si->strings_ofs, si->data_ofs, si->total_size);
}

Referenced by write_raw_resources().

get_section_header()

static IMAGE_SECTION_HEADER * get_section_header ( void *  base, DWORD  mapping_size, DWORD *  num_sections  )

static

Definition at line 816 of file res.c.

{
    IMAGE_NT_HEADERS *nt;
    DWORD section_ofs;
 
    nt = get_nt_header( base, mapping_size );
    if (!nt)
        return NULL;
 
    /* check that we don't go over the end of the file accessing the sections */
    section_ofs = FIELD_OFFSET(IMAGE_NT_HEADERS, OptionalHeader) + nt->FileHeader.SizeOfOptionalHeader;
    if ((nt->FileHeader.NumberOfSections * sizeof (IMAGE_SECTION_HEADER) + section_ofs) > mapping_size)
        return NULL;
 
    if (num_sections)
        *num_sections = nt->FileHeader.NumberOfSections;
 
    /* from here we have a valid PE exe to update */
    return (void*) ((BYTE*)nt + section_ofs);
}

Referenced by check_pe_exe(), get_init_data_size(), get_resource_section(), read_mapped_resources(), section_from_rva(), and write_raw_resources().

LoadResource()

HGLOBAL WINAPI LoadResource	(	HINSTANCE	hModule,
		HRSRC	hRsrc
	)

Definition at line 532 of file res.c.

{
    NTSTATUS status;
    void *ret = NULL;
 
    TRACE( "%p %p\n", hModule, hRsrc );
 
    if (!hRsrc) return 0;
    if (!hModule) hModule = GetModuleHandleA( NULL );
    status = LdrAccessResource( hModule, (IMAGE_RESOURCE_DATA_ENTRY *)hRsrc, &ret, NULL );
    if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
    return ret;
}

Referenced by ATL::_AtlGetStringResourceImage(), ANIMATE_LoadResW(), AtlAxCreateDialogW(), AtlAxDialogBoxW(), BITMAP_LoadImageW(), ChooseColorW(), ChooseFontA(), ChooseFontW(), COMDLG32_FR_DoFindReplace(), create_chm(), create_testfontfile(), create_tmp_ini_file(), CreateDialogParamA(), CreateDialogParamW(), CreateIconFromResourceEx(), CreateMappedBitmap(), CreateTemplateDialog(), CURSORICON_LoadImageW(), DialogBoxParamA(), DialogBoxParamW(), DoEntry(), EngFindResource(), CShellCommandHelp::Execute(), extract_one(), extract_rcdata(), extract_resource(), FD31_GetTemplate(), get_module_version(), get_res_data(), GetFileName95(), GetFileVersionInfoExW(), GetLocaleInfoW(), GetLocalisedText(), GetResource(), GplDlgProc(), IDirectXFileImpl_CreateEnumObject(), include_pac_utils(), K32LoadStringExW(), LengthOfStrResource(), load_res(), load_resource(), load_resource_into_memory(), load_string(), LoadDialogResource(), LoadMenuA(), LoadMenuW(), LoadStringA(), LoadStringW(), LoadXMLDocumentFromResource(), LsapGetResourceStringLengthEx(), LsapLoadString(), LsapLoadStringEx(), MCI_GetCommandTable(), mciLoadCommandResource(), MDI_MoreWindowsDialog(), MsiLoadStringW(), MSSTYLES_GetActiveThemeIni(), MSSTYLES_OpenThemeFile(), MSSTYLES_TryLoadPng(), NLS_GetLanguageGroupName(), OleCreatePropertyFrameIndirect(), OleUIInsertObjectA(), OleUIPasteSpecialW(), OnInitDialog(), pagesetup_get_template(), PlaySound_GetMMIO(), PRINTDLG_GetDlgTemplateA(), PRINTDLG_GetDlgTemplateW(), PROPSHEET_CollectPageInfo(), PROPSHEET_CreateDialog(), PROPSHEET_CreatePage(), register_resource(), ATL::CRegObject::resource_register(), resource_register(), ResourceToFile(), ResourceToFileW(), ResProtocol_Start(), run_from_res(), SampLoadString(), ShellAboutW(), START_TEST(), test_arrange(), test_enum_proc(), test_focus(), test_resizable2(), test_SaveRestoreFocus(), TLB_PEFile_Open(), U32LoadAccelerators(), unpack_avi_file(), UXINI_LoadINI(), VARIANT_GetLocalisedText(), write_resource_file(), and write_typelib().

LockResource()

LPVOID WINAPI LockResource

(

HGLOBAL

handle

)

Definition at line 550 of file res.c.

{
    return handle;
}

Referenced by ATL::_AtlGetStringResourceImage(), ANIMATE_LoadResW(), AtlAxCreateDialogW(), AtlAxDialogBoxW(), BITMAP_LoadImageW(), ChooseColorW(), ChooseFontA(), ChooseFontW(), COMDLG32_FR_DoFindReplace(), create_testfontfile(), create_tmp_ini_file(), CreateIconFromResourceEx(), CreateMappedBitmap(), CreateTemplateDialog(), CURSORICON_LoadImageW(), DoEntry(), EngFindResource(), CShellCommandHelp::Execute(), extract_one(), extract_rcdata(), extract_resource(), FD31_GetTemplate(), get_module_version(), get_res_data(), GetFileName95(), GetFileVersionInfoExW(), GetLocaleInfoW(), GetLocalisedText(), GetResource(), GplDlgProc(), IDirectXFileImpl_CreateEnumObject(), K32LoadStringExW(), LengthOfStrResource(), load_resource(), load_resource_into_memory(), load_string(), LoadDialogResource(), LoadStringA(), LoadStringW(), LoadXMLDocumentFromResource(), LsapGetResourceStringLengthEx(), LsapLoadString(), LsapLoadStringEx(), MCI_SetCommandTable(), MDI_MoreWindowsDialog(), MsiLoadStringW(), MSSTYLES_TryLoadPng(), NLS_GetLanguageGroupName(), OleCreatePropertyFrameIndirect(), OleUIInsertObjectA(), OnInitDialog(), pagesetup_get_template(), PlaySound_GetMMIO(), PrintDlgA(), PrintDlgW(), PROPSHEET_CollectPageInfo(), PROPSHEET_CreatePage(), ResourceToFile(), ResourceToFileW(), SampLoadString(), START_TEST(), test_arrange(), test_focus(), test_SaveRestoreFocus(), TLB_PEFile_Open(), unpack_avi_file(), VARIANT_GetLocalisedText(), write_resource_file(), and write_typelib().

map_file_into_memory()

static BOOL map_file_into_memory ( struct mapping_info *  mi )

static

Definition at line 1053 of file res.c.

{
    DWORD page_attr, perm;
    HANDLE mapping;
 
    if (mi->read_write)
    {
        page_attr = PAGE_READWRITE;
        perm = FILE_MAP_WRITE | FILE_MAP_READ;
    }
    else
    {
        page_attr = PAGE_READONLY;
        perm = FILE_MAP_READ;
    }
 
    mapping = CreateFileMappingW( mi->file, NULL, page_attr, 0, 0, NULL );
    if (!mapping) return FALSE;
 
    mi->base = MapViewOfFile( mapping, perm, 0, 0, mi->size );
    CloseHandle( mapping );
 
    return mi->base != NULL;
}

Referenced by create_mapping(), and resize_mapping().

read_mapped_resources()

static BOOL read_mapped_resources ( QUEUEDUPDATES *  updates, void *  base, DWORD  mapping_size  )

static

Definition at line 1015 of file res.c.

{
    const IMAGE_RESOURCE_DIRECTORY *root;
    const IMAGE_NT_HEADERS *nt;
    const IMAGE_SECTION_HEADER *sec;
    DWORD num_sections = 0, i;
 
    nt = get_nt_header( base, mapping_size );
    if (!nt)
        return FALSE;
 
    sec = get_section_header( base, mapping_size, &num_sections );
    if (!sec)
        return FALSE;
 
    for (i=0; i<num_sections; i++)
        if (!memcmp(sec[i].Name, ".rsrc", 6))
            break;
 
    if (i == num_sections)
        return TRUE;
 
    /* check the resource data is inside the mapping */
    if (sec[i].PointerToRawData > mapping_size ||
        (sec[i].PointerToRawData + sec[i].SizeOfRawData) > mapping_size)
        return TRUE;
 
    TRACE("found .rsrc at %08x, size %08x\n", sec[i].PointerToRawData, sec[i].SizeOfRawData);
 
    if (!sec[i].PointerToRawData || sec[i].SizeOfRawData < sizeof(IMAGE_RESOURCE_DIRECTORY))
        return TRUE;
 
    root = (void*) ((BYTE*)base + sec[i].PointerToRawData);
    enumerate_mapped_resources( updates, base, mapping_size, root );
 
    return TRUE;
}

Referenced by write_raw_resources().

res_free_str()

static void res_free_str ( LPWSTR  str )

static

Definition at line 688 of file res.c.

{
    if (!IS_INTRESOURCE(str))
        HeapFree( GetProcessHeap(), 0, str );
}

Referenced by enumerate_mapped_resources(), and free_resource_directory().

res_strdupW()

static LPWSTR res_strdupW ( LPCWSTR  str )

static

Definition at line 675 of file res.c.

{
    LPWSTR ret;
    UINT len;
 
    if (IS_INTRESOURCE(str))
        return (LPWSTR) (UINT_PTR) LOWORD(str);
    len = (lstrlenW( str ) + 1) * sizeof (WCHAR);
    ret = HeapAlloc( GetProcessHeap(), 0, len );
    memcpy( ret, str, len );
    return ret;
}

Referenced by update_add_resource().

res_write_padding()

static void res_write_padding ( BYTE *  res_base, DWORD  size  )

static

Definition at line 1192 of file res.c.

{
    static const BYTE pad[] = {
        'P','A','D','D','I','N','G','X','X','P','A','D','D','I','N','G' };
    DWORD i;
 
    for ( i = 0; i < size / sizeof pad; i++ )
        memcpy( &res_base[i*sizeof pad], pad, sizeof pad );
    memcpy( &res_base[i*sizeof pad], pad, size%sizeof pad );
}

Referenced by write_raw_resources(), and write_resources().

resize_mapping()

static BOOL resize_mapping ( struct mapping_info *  mi, DWORD  new_size  )

static

Definition at line 1120 of file res.c.

{
    if (!unmap_file_from_memory( mi ))
        return FALSE;
 
    /* change the file size */
    SetFilePointer( mi->file, new_size, NULL, FILE_BEGIN );
    if (!SetEndOfFile( mi->file ))
    {
        ERR("failed to set file size to %08x\n", new_size );
        return FALSE;
    }
 
    mi->size = new_size;
 
    return map_file_into_memory( mi );
}

Referenced by write_raw_resources().

resource_dup_string()

static LPWSTR resource_dup_string ( const IMAGE_RESOURCE_DIRECTORY *  root, const IMAGE_RESOURCE_DIRECTORY_ENTRY *  entry  )

static

Definition at line 939 of file res.c.

{
    const IMAGE_RESOURCE_DIR_STRING_U* string;
    LPWSTR s;
 
    if (!entry->NameIsString)
        return UIntToPtr(entry->Id);
 
    string = (const IMAGE_RESOURCE_DIR_STRING_U*) (((const char *)root) + entry->NameOffset);
    s = HeapAlloc(GetProcessHeap(), 0, (string->Length + 1)*sizeof (WCHAR) );
    memcpy( s, string->NameString, (string->Length + 1)*sizeof (WCHAR) );
    s[string->Length] = 0;
 
    return s;
}

Referenced by enumerate_mapped_resources().

resource_strcmp()

static int resource_strcmp ( LPCWSTR  a, LPCWSTR  b  )

static

Definition at line 607 of file res.c.

{
    if ( a == b )
        return 0;
    if (!IS_INTRESOURCE( a ) && !IS_INTRESOURCE( b ) )
        return lstrcmpW( a, b );
    /* strings come before ids */
    if (!IS_INTRESOURCE( a ) && IS_INTRESOURCE( b ))
        return -1;
    if (!IS_INTRESOURCE( b ) && IS_INTRESOURCE( a ))
        return 1;
    return ( a < b ) ? -1 : 1;
}

Referenced by add_resource_dir_entry(), and find_resource_dir_entry().

section_from_rva()

static const IMAGE_SECTION_HEADER * section_from_rva ( void *  base, DWORD  mapping_size, DWORD  rva  )

static

Definition at line 903 of file res.c.

{
    const IMAGE_SECTION_HEADER *sec;
    DWORD num_sections = 0;
    int i;
 
    sec = get_section_header( base, mapping_size, &num_sections );
    if (!sec)
        return NULL;
 
    for (i=num_sections-1; i>=0; i--)
    {
        if (sec[i].VirtualAddress <= rva &&
            rva <= (DWORD)sec[i].VirtualAddress + sec[i].SizeOfRawData)
        {
            return &sec[i];
        }
    }
 
    return NULL;
}

Referenced by address_from_rva().

SizeofResource()

DWORD WINAPI SizeofResource	(	HINSTANCE	hModule,
		HRSRC	hRsrc
	)

Definition at line 568 of file res.c.

{
    if (!hRsrc) return 0;
    return ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->Size;
}

Referenced by ATL::_AtlGetStringResourceImage(), ANIMATE_LoadResW(), BITMAP_LoadImageW(), create_chm(), create_testfontfile(), create_tmp_ini_file(), DoEntry(), EngFindResource(), CShellCommandHelp::Execute(), extract_one(), extract_rcdata(), extract_resource(), get_module_version(), get_res_data(), GetFileVersionInfoExW(), GetFileVersionInfoSizeExW(), GetResource(), GplDlgProc(), IDirectXFileImpl_CreateEnumObject(), include_pac_utils(), load_res(), load_resource(), load_resource_into_memory(), LoadDialogResource(), LoadXMLDocumentFromResource(), MSSTYLES_OpenThemeFile(), MSSTYLES_TryLoadPng(), PROPSHEET_CreateDialog(), PROPSHEET_CreatePage(), register_resource(), ATL::CRegObject::resource_register(), resource_register(), ResourceToFile(), ResourceToFileW(), ResProtocol_Start(), run_from_res(), sheet_callback(), START_TEST(), test_enum_proc(), TLB_PEFile_Open(), U32LoadAccelerators(), unpack_avi_file(), UXINI_LoadINI(), write_resource_file(), and write_typelib().

unmap_file_from_memory()

static BOOL unmap_file_from_memory ( struct mapping_info *  mi )

static

Definition at line 1078 of file res.c.

{
    if (mi->base)
        UnmapViewOfFile( mi->base );
    mi->base = NULL;
    return TRUE;
}

Referenced by destroy_mapping(), and resize_mapping().

update_add_resource()

static BOOL update_add_resource ( QUEUEDUPDATES *  updates, LPCWSTR  Type, LPCWSTR  Name, LANGID  Lang, struct resource_data *  resdata, BOOL  overwrite_existing  )

static

Definition at line 694 of file res.c.

{
    struct resource_dir_entry *restype, *resname;
    struct resource_data *existing;
 
    TRACE("%p %s %s %p %d\n", updates,
          debugstr_w(Type), debugstr_w(Name), resdata, overwrite_existing );
 
    restype = find_resource_dir_entry( &updates->root, Type );
    if (!restype)
    {
        restype = HeapAlloc( GetProcessHeap(), 0, sizeof *restype );
        restype->id = res_strdupW( Type );
        list_init( &restype->children );
        add_resource_dir_entry( &updates->root, restype );
    }
 
    resname = find_resource_dir_entry( &restype->children, Name );
    if (!resname)
    {
        resname = HeapAlloc( GetProcessHeap(), 0, sizeof *resname );
        resname->id = res_strdupW( Name );
        list_init( &resname->children );
        add_resource_dir_entry( &restype->children, resname );
    }
 
    /*
     * If there's an existing resource entry with matching (Type,Name,Language)
     *  it needs to be removed before adding the new data.
     */
    existing = find_resource_data( &resname->children, Lang );
    if (existing)
    {
        if (!overwrite_existing)
            return FALSE;
        list_remove( &existing->entry );
        HeapFree( GetProcessHeap(), 0, existing );
    }
 
    if (resdata)
        add_resource_data_entry( &resname->children, resdata );
 
    return TRUE;
}

Referenced by enumerate_mapped_resources(), and UpdateResourceW().

UpdateResourceA()

BOOL WINAPI UpdateResourceA	(	HANDLE	hUpdate,
		LPCSTR	lpType,
		LPCSTR	lpName,
		WORD	wLanguage,
		LPVOID	lpData,
		DWORD	cbData
	)

Definition at line 1738 of file res.c.

{
    BOOL ret;
    UNICODE_STRING TypeW;
    UNICODE_STRING NameW;
    if(IS_INTRESOURCE(lpType))
        TypeW.Buffer = ULongToPtr(LOWORD(lpType));
    else
        RtlCreateUnicodeStringFromAsciiz(&TypeW, lpType);
    if(IS_INTRESOURCE(lpName))
        NameW.Buffer = ULongToPtr(LOWORD(lpName));
    else
        RtlCreateUnicodeStringFromAsciiz(&NameW, lpName);
    ret = UpdateResourceW(hUpdate, TypeW.Buffer, NameW.Buffer, wLanguage, lpData, cbData);
    if(!IS_INTRESOURCE(lpType)) RtlFreeUnicodeString(&TypeW);
    if(!IS_INTRESOURCE(lpName)) RtlFreeUnicodeString(&NameW);
    return ret;
}

Referenced by create_file_with_version(), update_resources_bigdata(), and update_resources_version().

UpdateResourceW()

BOOL WINAPI UpdateResourceW	(	HANDLE	hUpdate,
		LPCWSTR	lpType,
		LPCWSTR	lpName,
		WORD	wLanguage,
		LPVOID	lpData,
		DWORD	cbData
	)

Definition at line 1706 of file res.c.

{
    QUEUEDUPDATES *updates;
    BOOL ret = FALSE;
 
    TRACE("%p %s %s %08x %p %d\n", hUpdate,
          debugstr_w(lpType), debugstr_w(lpName), wLanguage, lpData, cbData);
 
    updates = GlobalLock(hUpdate);
    if (updates)
    {
        if (lpData == NULL && cbData == 0)  /* remove resource */
        {
            ret = update_add_resource( updates, lpType, lpName, wLanguage, NULL, TRUE );
        }
        else
        {
            struct resource_data *data;
            data = allocate_resource_data( wLanguage, 0, lpData, cbData, TRUE );
            if (data)
                ret = update_add_resource( updates, lpType, lpName, wLanguage, data, TRUE );
        }
        GlobalUnlock(hUpdate);
    }
    return ret;
}

Referenced by UpdateResourceA().

write_raw_resources()

static BOOL write_raw_resources ( QUEUEDUPDATES *  updates )

static

Definition at line 1382 of file res.c.

{
    static const WCHAR prefix[] = { 'r','e','s','u',0 };
    WCHAR tempdir[MAX_PATH], tempfile[MAX_PATH];
    DWORD i, section_size;
    BOOL ret = FALSE;
    IMAGE_SECTION_HEADER *sec;
    IMAGE_NT_HEADERS32 *nt;
    IMAGE_NT_HEADERS64 *nt64;
    struct resource_size_info res_size;
    BYTE *res_base;
    struct mapping_info *read_map = NULL, *write_map = NULL;
    DWORD PeSectionAlignment, PeFileAlignment, PeSizeOfImage;
 
    /* copy the exe to a temp file then update the temp file... */
    tempdir[0] = 0;
    if (!GetTempPathW( MAX_PATH, tempdir ))
        return ret;
 
    if (!GetTempFileNameW( tempdir, prefix, 0, tempfile ))
        return ret;
 
    if (!CopyFileW( updates->pFileName, tempfile, FALSE ))
        goto done;
 
    TRACE("tempfile %s\n", debugstr_w(tempfile));
 
    if (!updates->bDeleteExistingResources)
    {
        read_map = create_mapping( updates->pFileName, FALSE );
        if (!read_map)
            goto done;
 
        ret = read_mapped_resources( updates, read_map->base, read_map->size );
        if (!ret)
        {
            ERR("failed to read existing resources\n");
            goto done;
        }
    }
 
    write_map = create_mapping( tempfile, TRUE );
    if (!write_map)
        goto done;
 
    nt = (IMAGE_NT_HEADERS32*)get_nt_header( write_map->base, write_map->size );
    if (!nt)
        goto done;
 
    nt64 = (IMAGE_NT_HEADERS64*)nt;
    if (nt->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
        PeSectionAlignment = nt64->OptionalHeader.SectionAlignment;
        PeFileAlignment = nt64->OptionalHeader.FileAlignment;
        PeSizeOfImage = nt64->OptionalHeader.SizeOfImage;
    } else {
        PeSectionAlignment = nt->OptionalHeader.SectionAlignment;
        PeFileAlignment = nt->OptionalHeader.FileAlignment;
        PeSizeOfImage = nt->OptionalHeader.SizeOfImage;
    }
 
    if ((LONG)PeSectionAlignment <= 0)
    {
        ERR("invalid section alignment %08x\n", PeSectionAlignment);
        goto done;
    }
 
    if ((LONG)PeFileAlignment <= 0)
    {
        ERR("invalid file alignment %08x\n", PeFileAlignment);
        goto done;
    }
 
    sec = get_resource_section( write_map->base, write_map->size );
    if (!sec) /* no section, add one */
    {
        DWORD num_sections;
 
        sec = get_section_header( write_map->base, write_map->size, &num_sections );
        if (!sec)
            goto done;
 
        sec += num_sections;
        nt->FileHeader.NumberOfSections++;
 
        memset( sec, 0, sizeof *sec );
        memcpy( sec->Name, ".rsrc", 5 );
        sec->Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
        sec->VirtualAddress = PeSizeOfImage;
    }
 
    if (!sec->PointerToRawData)  /* empty section */
    {
        sec->PointerToRawData = write_map->size + (-write_map->size) % PeFileAlignment;
        sec->SizeOfRawData = 0;
    }
 
    TRACE("before .rsrc at %08x, size %08x\n", sec->PointerToRawData, sec->SizeOfRawData);
 
    get_resource_sizes( updates, &res_size );
 
    /* round up the section size */
    section_size = res_size.total_size;
    section_size += (-section_size) % PeFileAlignment;
 
    TRACE("requires %08x (%08x) bytes\n", res_size.total_size, section_size );
 
    /* check if the file size needs to be changed */
    if (section_size != sec->SizeOfRawData)
    {
        DWORD old_size = write_map->size;
        DWORD virtual_section_size = res_size.total_size + (-res_size.total_size) % PeSectionAlignment;
        int delta = section_size - (sec->SizeOfRawData + (-sec->SizeOfRawData) % PeFileAlignment);
        int rva_delta = virtual_section_size -
            (sec->Misc.VirtualSize + (-sec->Misc.VirtualSize) % PeSectionAlignment);
        /* when new section is added it could end past current mapping size */
        BOOL rsrc_is_last = sec->PointerToRawData + sec->SizeOfRawData >= old_size;
    /* align .rsrc size when possible */
        DWORD mapping_size = rsrc_is_last ? sec->PointerToRawData + section_size : old_size + delta;
 
        /* postpone file truncation if there are some data to be moved down from file end */
        BOOL resize_after = mapping_size < old_size && !rsrc_is_last;
 
        TRACE("file size %08x -> %08x\n", old_size, mapping_size);
 
        if (!resize_after)
        {
            /* unmap the file before changing the file size */
            ret = resize_mapping( write_map, mapping_size );
 
            /* get the pointers again - they might be different after remapping */
            nt = (IMAGE_NT_HEADERS32*)get_nt_header( write_map->base, mapping_size );
            if (!nt)
            {
                ERR("couldn't get NT header\n");
                goto done;
            }
            nt64 = (IMAGE_NT_HEADERS64*)nt;
 
            sec = get_resource_section( write_map->base, mapping_size );
            if (!sec)
                 goto done;
        }
 
        if (!rsrc_is_last) /* not last section, relocate trailing sections */
        {
            IMAGE_SECTION_HEADER *s;
            DWORD tail_start = sec->PointerToRawData + sec->SizeOfRawData;
            DWORD i, num_sections = 0;
 
            memmove( (char*)write_map->base + tail_start + delta, (char*)write_map->base + tail_start, old_size - tail_start );
 
            s = get_section_header( write_map->base, mapping_size, &num_sections );
 
            for (i=0; i<num_sections; i++)
            {
                if (s[i].PointerToRawData > sec->PointerToRawData)
                {
                    s[i].PointerToRawData += delta;
                    s[i].VirtualAddress += rva_delta;
                }
            }
        }
 
        if (resize_after)
        {
            ret = resize_mapping( write_map, mapping_size );
 
            nt = (IMAGE_NT_HEADERS32*)get_nt_header( write_map->base, mapping_size );
            if (!nt)
            {
                ERR("couldn't get NT header\n");
                goto done;
            }
            nt64 = (IMAGE_NT_HEADERS64*)nt;
 
            sec = get_resource_section( write_map->base, mapping_size );
            if (!sec)
                 goto done;
        }
 
        /* adjust the PE header information */
        sec->SizeOfRawData = section_size;
        sec->Misc.VirtualSize = virtual_section_size;
        if (nt->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
            nt64->OptionalHeader.SizeOfImage += rva_delta;
            nt64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress = sec->VirtualAddress;
            nt64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].Size = res_size.total_size;
            nt64->OptionalHeader.SizeOfInitializedData = get_init_data_size( write_map->base, mapping_size );
 
            for (i=0; i<nt64->OptionalHeader.NumberOfRvaAndSizes; i++)
                if (nt64->OptionalHeader.DataDirectory[i].VirtualAddress > sec->VirtualAddress)
                    nt64->OptionalHeader.DataDirectory[i].VirtualAddress += rva_delta;
        } else {
            nt->OptionalHeader.SizeOfImage += rva_delta;
            nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress = sec->VirtualAddress;
            nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].Size = res_size.total_size;
            nt->OptionalHeader.SizeOfInitializedData = get_init_data_size( write_map->base, mapping_size );
 
            for (i=0; i<nt->OptionalHeader.NumberOfRvaAndSizes; i++)
                if (nt->OptionalHeader.DataDirectory[i].VirtualAddress > sec->VirtualAddress)
                    nt->OptionalHeader.DataDirectory[i].VirtualAddress += rva_delta;
        }
    }
 
    res_base = (LPBYTE) write_map->base + sec->PointerToRawData;
 
    TRACE("base = %p offset = %08x\n", write_map->base, sec->PointerToRawData);
 
    ret = write_resources( updates, res_base, &res_size, sec->VirtualAddress );
 
    res_write_padding( res_base + res_size.total_size, section_size - res_size.total_size );
 
    TRACE("after  .rsrc at %08x, size %08x\n", sec->PointerToRawData, sec->SizeOfRawData);
 
done:
    destroy_mapping( read_map );
    destroy_mapping( write_map );
 
    if (ret)
        ret = CopyFileW( tempfile, updates->pFileName, FALSE );
 
    DeleteFileW( tempfile );
 
    return ret;
}

Referenced by EndUpdateResourceW().

write_resources()

static BOOL write_resources ( QUEUEDUPDATES *  updates, LPBYTE  base, struct resource_size_info *  si, DWORD  rva  )

static

Definition at line 1203 of file res.c.

{
    struct resource_dir_entry *types, *names;
    struct resource_data *data;
    IMAGE_RESOURCE_DIRECTORY *root;
 
    TRACE("%p %p %p %08x\n", updates, base, si, rva );
 
    memset( base, 0, si->total_size );
 
    /* the root entry always exists */
    root = (IMAGE_RESOURCE_DIRECTORY*) base;
    memset( root, 0, sizeof *root );
    root->MajorVersion = 4;
    si->types_ofs = sizeof *root;
    LIST_FOR_EACH_ENTRY( types, &updates->root, struct resource_dir_entry, entry )
    {
        IMAGE_RESOURCE_DIRECTORY_ENTRY *e1;
        IMAGE_RESOURCE_DIRECTORY *namedir;
 
        e1 = (IMAGE_RESOURCE_DIRECTORY_ENTRY*) &base[si->types_ofs];
        memset( e1, 0, sizeof *e1 );
        if (!IS_INTRESOURCE( types->id ))
        {
            WCHAR *strings;
            DWORD len;
 
            root->NumberOfNamedEntries++;
            e1->NameIsString = 1;
            e1->NameOffset = si->strings_ofs;
 
            strings = (WCHAR*) &base[si->strings_ofs];
            len = lstrlenW( types->id );
            strings[0] = len;
            memcpy( &strings[1], types->id, len * sizeof (WCHAR) );
            si->strings_ofs += (len + 1) * sizeof (WCHAR);
        }
        else
        {
            root->NumberOfIdEntries++;
            e1->Id = LOWORD( types->id );
        }
        e1->OffsetToDirectory = si->names_ofs;
        e1->DataIsDirectory = TRUE;
        si->types_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
 
        namedir = (IMAGE_RESOURCE_DIRECTORY*) &base[si->names_ofs];
        memset( namedir, 0, sizeof *namedir );
        namedir->MajorVersion = 4;
        si->names_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY);
 
        LIST_FOR_EACH_ENTRY( names, &types->children, struct resource_dir_entry, entry )
        {
            IMAGE_RESOURCE_DIRECTORY_ENTRY *e2;
            IMAGE_RESOURCE_DIRECTORY *langdir;
 
            e2 = (IMAGE_RESOURCE_DIRECTORY_ENTRY*) &base[si->names_ofs];
            memset( e2, 0, sizeof *e2 );
            if (!IS_INTRESOURCE( names->id ))
            {
                WCHAR *strings;
                DWORD len;
 
                namedir->NumberOfNamedEntries++;
                e2->NameIsString = 1;
                e2->NameOffset = si->strings_ofs;
 
                strings = (WCHAR*) &base[si->strings_ofs];
                len = lstrlenW( names->id );
                strings[0] = len;
                memcpy( &strings[1], names->id, len * sizeof (WCHAR) );
                si->strings_ofs += (len + 1) * sizeof (WCHAR);
            }
            else
            {
                namedir->NumberOfIdEntries++;
                e2->Id = LOWORD( names->id );
            }
            e2->OffsetToDirectory = si->langs_ofs;
            e2->DataIsDirectory = TRUE;
            si->names_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
 
            langdir = (IMAGE_RESOURCE_DIRECTORY*) &base[si->langs_ofs];
            memset( langdir, 0, sizeof *langdir );
            langdir->MajorVersion = 4;
            si->langs_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY);
 
            LIST_FOR_EACH_ENTRY( data, &names->children, struct resource_data, entry )
            {
                IMAGE_RESOURCE_DIRECTORY_ENTRY *e3;
                IMAGE_RESOURCE_DATA_ENTRY *de;
                int pad_size;
 
                e3 = (IMAGE_RESOURCE_DIRECTORY_ENTRY*) &base[si->langs_ofs];
                memset( e3, 0, sizeof *e3 );
                langdir->NumberOfIdEntries++;
                e3->Id = LOWORD( data->lang );
                e3->OffsetToData = si->data_entry_ofs;
 
                si->langs_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
 
                /* write out all the data entries */
                de = (IMAGE_RESOURCE_DATA_ENTRY*) &base[si->data_entry_ofs];
                memset( de, 0, sizeof *de );
                de->OffsetToData = si->data_ofs + rva;
                de->Size = data->cbData;
                de->CodePage = data->codepage;
                si->data_entry_ofs += sizeof (IMAGE_RESOURCE_DATA_ENTRY);
 
                /* write out the resource data */
                memcpy( &base[si->data_ofs], data->lpData, data->cbData );
                si->data_ofs += data->cbData;
 
                pad_size = (-si->data_ofs)&3;
                res_write_padding( &base[si->data_ofs], pad_size );
                si->data_ofs += pad_size;
            }
        }
    }
 
    return TRUE;
}

Referenced by write_raw_resources().