git.oblomov.eu Git - wine/blob - dlls/kernel32/resource.c

   1 /*
   2  * Resources
   3  *
   4  * Copyright 1993 Robert J. Amstadt
   5  * Copyright 1995, 2003 Alexandre Julliard
   6  * Copyright 2006 Mike McCormack
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include <stdarg.h>
  27
  28 #define NONAMELESSUNION
  29 #define NONAMELESSSTRUCT
  30 #include "ntstatus.h"
  31 #define WIN32_NO_STATUS
  32 #include "windef.h"
  33 #include "winbase.h"
  34 #include "winternl.h"
  35 #include "wine/debug.h"
  36 #include "wine/exception.h"
  37 #include "wine/unicode.h"
  38 #include "wine/list.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(resource);
  41
  42 /* retrieve the resource name to pass to the ntdll functions */
  43 static NTSTATUS get_res_nameA( LPCSTR name, UNICODE_STRING *str )
  44 {
  45     if (!HIWORD(name))
  46     {
  47         str->Buffer = ULongToPtr(LOWORD(name));
  48         return STATUS_SUCCESS;
  49     }
  50     if (name[0] == '#')
  51     {
  52         ULONG value;
  53         if (RtlCharToInteger( name + 1, 10, &value ) != STATUS_SUCCESS || HIWORD(value))
  54             return STATUS_INVALID_PARAMETER;
  55         str->Buffer = ULongToPtr(value);
  56         return STATUS_SUCCESS;
  57     }
  58     RtlCreateUnicodeStringFromAsciiz( str, name );
  59     RtlUpcaseUnicodeString( str, str, FALSE );
  60     return STATUS_SUCCESS;
  61 }
  62
  63 /* retrieve the resource name to pass to the ntdll functions */
  64 static NTSTATUS get_res_nameW( LPCWSTR name, UNICODE_STRING *str )
  65 {
  66     if (!HIWORD(name))
  67     {
  68         str->Buffer = ULongToPtr(LOWORD(name));
  69         return STATUS_SUCCESS;
  70     }
  71     if (name[0] == '#')
  72     {
  73         ULONG value;
  74         RtlInitUnicodeString( str, name + 1 );
  75         if (RtlUnicodeStringToInteger( str, 10, &value ) != STATUS_SUCCESS || HIWORD(value))
  76             return STATUS_INVALID_PARAMETER;
  77         str->Buffer = ULongToPtr(value);
  78         return STATUS_SUCCESS;
  79     }
  80     RtlCreateUnicodeString( str, name );
  81     RtlUpcaseUnicodeString( str, str, FALSE );
  82     return STATUS_SUCCESS;
  83 }
  84
  85 /* implementation of FindResourceExA */
  86 static HRSRC find_resourceA( HMODULE hModule, LPCSTR type, LPCSTR name, WORD lang )
  87 {
  88     NTSTATUS status;
  89     UNICODE_STRING nameW, typeW;
  90     LDR_RESOURCE_INFO info;
  91     const IMAGE_RESOURCE_DATA_ENTRY *entry = NULL;
  92
  93     nameW.Buffer = NULL;
  94     typeW.Buffer = NULL;
  95
  96     __TRY
  97     {
  98         if ((status = get_res_nameA( name, &nameW )) != STATUS_SUCCESS) goto done;
  99         if ((status = get_res_nameA( type, &typeW )) != STATUS_SUCCESS) goto done;
 100         info.Type = (ULONG_PTR)typeW.Buffer;
 101         info.Name = (ULONG_PTR)nameW.Buffer;
 102         info.Language = lang;
 103         status = LdrFindResource_U( hModule, &info, 3, &entry );
 104     done:
 105         if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
 106     }
 107     __EXCEPT_PAGE_FAULT
 108     {
 109         SetLastError( ERROR_INVALID_PARAMETER );
 110     }
 111     __ENDTRY
 112
 113     if (HIWORD(nameW.Buffer)) HeapFree( GetProcessHeap(), 0, nameW.Buffer );
 114     if (HIWORD(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
 115     return (HRSRC)entry;
 116 }
 117
 118
 119 /* implementation of FindResourceExW */
 120 static HRSRC find_resourceW( HMODULE hModule, LPCWSTR type, LPCWSTR name, WORD lang )
 121 {
 122     NTSTATUS status;
 123     UNICODE_STRING nameW, typeW;
 124     LDR_RESOURCE_INFO info;
 125     const IMAGE_RESOURCE_DATA_ENTRY *entry = NULL;
 126
 127     nameW.Buffer = typeW.Buffer = NULL;
 128
 129     __TRY
 130     {
 131         if ((status = get_res_nameW( name, &nameW )) != STATUS_SUCCESS) goto done;
 132         if ((status = get_res_nameW( type, &typeW )) != STATUS_SUCCESS) goto done;
 133         info.Type = (ULONG_PTR)typeW.Buffer;
 134         info.Name = (ULONG_PTR)nameW.Buffer;
 135         info.Language = lang;
 136         status = LdrFindResource_U( hModule, &info, 3, &entry );
 137     done:
 138         if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
 139     }
 140     __EXCEPT_PAGE_FAULT
 141     {
 142         SetLastError( ERROR_INVALID_PARAMETER );
 143     }
 144     __ENDTRY
 145
 146     if (HIWORD(nameW.Buffer)) HeapFree( GetProcessHeap(), 0, nameW.Buffer );
 147     if (HIWORD(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
 148     return (HRSRC)entry;
 149 }
 150
 151 /**********************************************************************
 152  *          FindResourceExA  (KERNEL32.@)
 153  */
 154 HRSRC WINAPI FindResourceExA( HMODULE hModule, LPCSTR type, LPCSTR name, WORD lang )
 155 {
 156     TRACE( "%p %s %s %04x\n", hModule, debugstr_a(type), debugstr_a(name), lang );
 157
 158     if (!hModule) hModule = GetModuleHandleW(0);
 159     return find_resourceA( hModule, type, name, lang );
 160 }
 161
 162
 163 /**********************************************************************
 164  *          FindResourceA    (KERNEL32.@)
 165  */
 166 HRSRC WINAPI FindResourceA( HMODULE hModule, LPCSTR name, LPCSTR type )
 167 {
 168     return FindResourceExA( hModule, type, name, MAKELANGID( LANG_NEUTRAL, SUBLANG_NEUTRAL ) );
 169 }
 170
 171
 172 /**********************************************************************
 173  *          FindResourceExW  (KERNEL32.@)
 174  */
 175 HRSRC WINAPI FindResourceExW( HMODULE hModule, LPCWSTR type, LPCWSTR name, WORD lang )
 176 {
 177     TRACE( "%p %s %s %04x\n", hModule, debugstr_w(type), debugstr_w(name), lang );
 178
 179     if (!hModule) hModule = GetModuleHandleW(0);
 180     return find_resourceW( hModule, type, name, lang );
 181 }
 182
 183
 184 /**********************************************************************
 185  *          FindResourceW    (KERNEL32.@)
 186  */
 187 HRSRC WINAPI FindResourceW( HINSTANCE hModule, LPCWSTR name, LPCWSTR type )
 188 {
 189     return FindResourceExW( hModule, type, name, MAKELANGID( LANG_NEUTRAL, SUBLANG_NEUTRAL ) );
 190 }
 191
 192
 193 /**********************************************************************
 194  *      EnumResourceTypesA      (KERNEL32.@)
 195  */
 196 BOOL WINAPI EnumResourceTypesA( HMODULE hmod, ENUMRESTYPEPROCA lpfun, LONG_PTR lparam )
 197 {
 198     int i;
 199     BOOL ret = FALSE;
 200     LPSTR type = NULL;
 201     DWORD len = 0, newlen;
 202     NTSTATUS status;
 203     const IMAGE_RESOURCE_DIRECTORY *resdir;
 204     const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 205     const IMAGE_RESOURCE_DIR_STRING_U *str;
 206
 207     TRACE( "%p %p %lx\n", hmod, lpfun, lparam );
 208
 209     if (!hmod) hmod = GetModuleHandleA( NULL );
 210
 211     if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &resdir )) != STATUS_SUCCESS)
 212     {
 213         SetLastError( RtlNtStatusToDosError(status) );
 214         return FALSE;
 215     }
 216     et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
 217     for (i = 0; i < resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries; i++)
 218     {
 219         if (et[i].u1.s1.NameIsString)
 220         {
 221             str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)resdir + et[i].u1.s1.NameOffset);
 222             newlen = WideCharToMultiByte( CP_ACP, 0, str->NameString, str->Length, NULL, 0, NULL, NULL);
 223             if (newlen + 1 > len)
 224             {
 225                 len = newlen + 1;
 226                 HeapFree( GetProcessHeap(), 0, type );
 227                 if (!(type = HeapAlloc( GetProcessHeap(), 0, len ))) return FALSE;
 228             }
 229             WideCharToMultiByte( CP_ACP, 0, str->NameString, str->Length, type, len, NULL, NULL);
 230             type[newlen] = 0;
 231             ret = lpfun(hmod,type,lparam);
 232         }
 233         else
 234         {
 235             ret = lpfun( hmod, UIntToPtr(et[i].u1.s2.Id), lparam );
 236         }
 237         if (!ret) break;
 238     }
 239     HeapFree( GetProcessHeap(), 0, type );
 240     return ret;
 241 }
 242
 243
 244 /**********************************************************************
 245  *      EnumResourceTypesW      (KERNEL32.@)
 246  */
 247 BOOL WINAPI EnumResourceTypesW( HMODULE hmod, ENUMRESTYPEPROCW lpfun, LONG_PTR lparam )
 248 {
 249     int i, len = 0;
 250     BOOL ret = FALSE;
 251     LPWSTR type = NULL;
 252     NTSTATUS status;
 253     const IMAGE_RESOURCE_DIRECTORY *resdir;
 254     const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 255     const IMAGE_RESOURCE_DIR_STRING_U *str;
 256
 257     TRACE( "%p %p %lx\n", hmod, lpfun, lparam );
 258
 259     if (!hmod) hmod = GetModuleHandleW( NULL );
 260
 261     if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &resdir )) != STATUS_SUCCESS)
 262     {
 263         SetLastError( RtlNtStatusToDosError(status) );
 264         return FALSE;
 265     }
 266     et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
 267     for (i = 0; i < resdir->NumberOfNamedEntries + resdir->NumberOfIdEntries; i++)
 268     {
 269         if (et[i].u1.s1.NameIsString)
 270         {
 271             str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)resdir + et[i].u1.s1.NameOffset);
 272             if (str->Length + 1 > len)
 273             {
 274                 len = str->Length + 1;
 275                 HeapFree( GetProcessHeap(), 0, type );
 276                 if (!(type = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return FALSE;
 277             }
 278             memcpy(type, str->NameString, str->Length * sizeof (WCHAR));
 279             type[str->Length] = 0;
 280             ret = lpfun(hmod,type,lparam);
 281         }
 282         else
 283         {
 284             ret = lpfun( hmod, UIntToPtr(et[i].u1.s2.Id), lparam );
 285         }
 286         if (!ret) break;
 287     }
 288     HeapFree( GetProcessHeap(), 0, type );
 289     return ret;
 290 }
 291
 292
 293 /**********************************************************************
 294  *      EnumResourceNamesA      (KERNEL32.@)
 295  */
 296 BOOL WINAPI EnumResourceNamesA( HMODULE hmod, LPCSTR type, ENUMRESNAMEPROCA lpfun, LONG_PTR lparam )
 297 {
 298     int i;
 299     BOOL ret = FALSE;
 300     DWORD len = 0, newlen;
 301     LPSTR name = NULL;
 302     NTSTATUS status;
 303     UNICODE_STRING typeW;
 304     LDR_RESOURCE_INFO info;
 305     const IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
 306     const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 307     const IMAGE_RESOURCE_DIR_STRING_U *str;
 308
 309     TRACE( "%p %s %p %lx\n", hmod, debugstr_a(type), lpfun, lparam );
 310
 311     if (!hmod) hmod = GetModuleHandleA( NULL );
 312     typeW.Buffer = NULL;
 313     if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &basedir )) != STATUS_SUCCESS)
 314         goto done;
 315     if ((status = get_res_nameA( type, &typeW )) != STATUS_SUCCESS)
 316         goto done;
 317     info.Type = (ULONG_PTR)typeW.Buffer;
 318     if ((status = LdrFindResourceDirectory_U( hmod, &info, 1, &resdir )) != STATUS_SUCCESS)
 319         goto done;
 320
 321     et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
 322     __TRY
 323     {
 324         for (i = 0; i < resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries; i++)
 325         {
 326             if (et[i].u1.s1.NameIsString)
 327             {
 328                 str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)basedir + et[i].u1.s1.NameOffset);
 329                 newlen = WideCharToMultiByte(CP_ACP, 0, str->NameString, str->Length, NULL, 0, NULL, NULL);
 330                 if (newlen + 1 > len)
 331                 {
 332                     len = newlen + 1;
 333                     HeapFree( GetProcessHeap(), 0, name );
 334                     if (!(name = HeapAlloc(GetProcessHeap(), 0, len + 1 )))
 335                     {
 336                         ret = FALSE;
 337                         break;
 338                     }
 339                 }
 340                 WideCharToMultiByte( CP_ACP, 0, str->NameString, str->Length, name, len, NULL, NULL );
 341                 name[newlen] = 0;
 342                 ret = lpfun(hmod,type,name,lparam);
 343             }
 344             else
 345             {
 346                 ret = lpfun( hmod, type, UIntToPtr(et[i].u1.s2.Id), lparam );
 347             }
 348             if (!ret) break;
 349         }
 350     }
 351     __EXCEPT_PAGE_FAULT
 352     {
 353         ret = FALSE;
 354         status = STATUS_ACCESS_VIOLATION;
 355     }
 356     __ENDTRY
 357
 358 done:
 359     HeapFree( GetProcessHeap(), 0, name );
 360     if (HIWORD(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
 361     if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
 362     return ret;
 363 }
 364
 365
 366 /**********************************************************************
 367  *      EnumResourceNamesW      (KERNEL32.@)
 368  */
 369 BOOL WINAPI EnumResourceNamesW( HMODULE hmod, LPCWSTR type, ENUMRESNAMEPROCW lpfun, LONG_PTR lparam )
 370 {
 371     int i, len = 0;
 372     BOOL ret = FALSE;
 373     LPWSTR name = NULL;
 374     NTSTATUS status;
 375     UNICODE_STRING typeW;
 376     LDR_RESOURCE_INFO info;
 377     const IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
 378     const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 379     const IMAGE_RESOURCE_DIR_STRING_U *str;
 380
 381     TRACE( "%p %s %p %lx\n", hmod, debugstr_w(type), lpfun, lparam );
 382
 383     if (!hmod) hmod = GetModuleHandleW( NULL );
 384     typeW.Buffer = NULL;
 385     if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &basedir )) != STATUS_SUCCESS)
 386         goto done;
 387     if ((status = get_res_nameW( type, &typeW )) != STATUS_SUCCESS)
 388         goto done;
 389     info.Type = (ULONG_PTR)typeW.Buffer;
 390     if ((status = LdrFindResourceDirectory_U( hmod, &info, 1, &resdir )) != STATUS_SUCCESS)
 391         goto done;
 392
 393     et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
 394     __TRY
 395     {
 396         for (i = 0; i < resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries; i++)
 397         {
 398             if (et[i].u1.s1.NameIsString)
 399             {
 400                 str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)basedir + et[i].u1.s1.NameOffset);
 401                 if (str->Length + 1 > len)
 402                 {
 403                     len = str->Length + 1;
 404                     HeapFree( GetProcessHeap(), 0, name );
 405                     if (!(name = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
 406                     {
 407                         ret = FALSE;
 408                         break;
 409                     }
 410                 }
 411                 memcpy(name, str->NameString, str->Length * sizeof (WCHAR));
 412                 name[str->Length] = 0;
 413                 ret = lpfun(hmod,type,name,lparam);
 414             }
 415             else
 416             {
 417                 ret = lpfun( hmod, type, UIntToPtr(et[i].u1.s2.Id), lparam );
 418             }
 419             if (!ret) break;
 420         }
 421     }
 422     __EXCEPT_PAGE_FAULT
 423     {
 424         ret = FALSE;
 425         status = STATUS_ACCESS_VIOLATION;
 426     }
 427     __ENDTRY
 428 done:
 429     HeapFree( GetProcessHeap(), 0, name );
 430     if (HIWORD(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
 431     if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
 432     return ret;
 433 }
 434
 435
 436 /**********************************************************************
 437  *      EnumResourceLanguagesA  (KERNEL32.@)
 438  */
 439 BOOL WINAPI EnumResourceLanguagesA( HMODULE hmod, LPCSTR type, LPCSTR name,
 440                                     ENUMRESLANGPROCA lpfun, LONG_PTR lparam )
 441 {
 442     int i;
 443     BOOL ret = FALSE;
 444     NTSTATUS status;
 445     UNICODE_STRING typeW, nameW;
 446     LDR_RESOURCE_INFO info;
 447     const IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
 448     const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 449
 450     TRACE( "%p %s %s %p %lx\n", hmod, debugstr_a(type), debugstr_a(name), lpfun, lparam );
 451
 452     if (!hmod) hmod = GetModuleHandleA( NULL );
 453     typeW.Buffer = nameW.Buffer = NULL;
 454     if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &basedir )) != STATUS_SUCCESS)
 455         goto done;
 456     if ((status = get_res_nameA( type, &typeW )) != STATUS_SUCCESS)
 457         goto done;
 458     if ((status = get_res_nameA( name, &nameW )) != STATUS_SUCCESS)
 459         goto done;
 460     info.Type = (ULONG_PTR)typeW.Buffer;
 461     info.Name = (ULONG_PTR)nameW.Buffer;
 462     if ((status = LdrFindResourceDirectory_U( hmod, &info, 2, &resdir )) != STATUS_SUCCESS)
 463         goto done;
 464
 465     et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
 466     __TRY
 467     {
 468         for (i = 0; i < resdir->NumberOfNamedEntries + resdir->NumberOfIdEntries; i++)
 469         {
 470             ret = lpfun( hmod, type, name, et[i].u1.s2.Id, lparam );
 471             if (!ret) break;
 472         }
 473     }
 474     __EXCEPT_PAGE_FAULT
 475     {
 476         ret = FALSE;
 477         status = STATUS_ACCESS_VIOLATION;
 478     }
 479     __ENDTRY
 480 done:
 481     if (HIWORD(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
 482     if (HIWORD(nameW.Buffer)) HeapFree( GetProcessHeap(), 0, nameW.Buffer );
 483     if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
 484     return ret;
 485 }
 486
 487
 488 /**********************************************************************
 489  *      EnumResourceLanguagesW  (KERNEL32.@)
 490  */
 491 BOOL WINAPI EnumResourceLanguagesW( HMODULE hmod, LPCWSTR type, LPCWSTR name,
 492                                     ENUMRESLANGPROCW lpfun, LONG_PTR lparam )
 493 {
 494     int i;
 495     BOOL ret = FALSE;
 496     NTSTATUS status;
 497     UNICODE_STRING typeW, nameW;
 498     LDR_RESOURCE_INFO info;
 499     const IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
 500     const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 501
 502     TRACE( "%p %s %s %p %lx\n", hmod, debugstr_w(type), debugstr_w(name), lpfun, lparam );
 503
 504     if (!hmod) hmod = GetModuleHandleW( NULL );
 505     typeW.Buffer = nameW.Buffer = NULL;
 506     if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &basedir )) != STATUS_SUCCESS)
 507         goto done;
 508     if ((status = get_res_nameW( type, &typeW )) != STATUS_SUCCESS)
 509         goto done;
 510     if ((status = get_res_nameW( name, &nameW )) != STATUS_SUCCESS)
 511         goto done;
 512     info.Type = (ULONG_PTR)typeW.Buffer;
 513     info.Name = (ULONG_PTR)nameW.Buffer;
 514     if ((status = LdrFindResourceDirectory_U( hmod, &info, 2, &resdir )) != STATUS_SUCCESS)
 515         goto done;
 516
 517     et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
 518     __TRY
 519     {
 520         for (i = 0; i < resdir->NumberOfNamedEntries + resdir->NumberOfIdEntries; i++)
 521         {
 522             ret = lpfun( hmod, type, name, et[i].u1.s2.Id, lparam );
 523             if (!ret) break;
 524         }
 525     }
 526     __EXCEPT_PAGE_FAULT
 527     {
 528         ret = FALSE;
 529         status = STATUS_ACCESS_VIOLATION;
 530     }
 531     __ENDTRY
 532 done:
 533     if (HIWORD(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
 534     if (HIWORD(nameW.Buffer)) HeapFree( GetProcessHeap(), 0, nameW.Buffer );
 535     if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
 536     return ret;
 537 }
 538
 539
 540 /**********************************************************************
 541  *          LoadResource     (KERNEL32.@)
 542  */
 543 HGLOBAL WINAPI LoadResource( HINSTANCE hModule, HRSRC hRsrc )
 544 {
 545     NTSTATUS status;
 546     void *ret = NULL;
 547
 548     TRACE( "%p %p\n", hModule, hRsrc );
 549
 550     if (!hRsrc) return 0;
 551     if (!hModule) hModule = GetModuleHandleA( NULL );
 552     status = LdrAccessResource( hModule, (IMAGE_RESOURCE_DATA_ENTRY *)hRsrc, &ret, NULL );
 553     if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
 554     return ret;
 555 }
 556
 557
 558 /**********************************************************************
 559  *          LockResource     (KERNEL32.@)
 560  */
 561 LPVOID WINAPI LockResource( HGLOBAL handle )
 562 {
 563     return handle;
 564 }
 565
 566
 567 /**********************************************************************
 568  *          FreeResource     (KERNEL32.@)
 569  */
 570 BOOL WINAPI FreeResource( HGLOBAL handle )
 571 {
 572     return 0;
 573 }
 574
 575
 576 /**********************************************************************
 577  *          SizeofResource   (KERNEL32.@)
 578  */
 579 DWORD WINAPI SizeofResource( HINSTANCE hModule, HRSRC hRsrc )
 580 {
 581     if (!hRsrc) return 0;
 582     return ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->Size;
 583 }
 584
 585 /*
 586  *  Data structure for updating resources.
 587  *  Type/Name/Language is a keyset for accessing resource data.
 588  *
 589  *  QUEUEDUPDATES (root) ->
 590  *    list of struct resource_dir_entry    (Type) ->
 591  *      list of struct resource_dir_entry  (Name)   ->
 592  *         list of struct resource_data    Language + Data
 593  */
 594
 595 typedef struct
 596 {
 597     LPWSTR pFileName;
 598     BOOL bDeleteExistingResources;
 599     struct list root;
 600 } QUEUEDUPDATES;
 601
 602 /* this structure is shared for types and names */
 603 struct resource_dir_entry {
 604     struct list entry;
 605     LPWSTR id;
 606     struct list children;
 607 };
 608
 609 /* this structure is the leaf */
 610 struct resource_data {
 611     struct list entry;
 612     LANGID lang;
 613     DWORD codepage;
 614     DWORD cbData;
 615     void *lpData;
 616 };
 617
 618 static int resource_strcmp( LPCWSTR a, LPCWSTR b )
 619 {
 620     if ( a == b )
 621         return 0;
 622     if (HIWORD( a ) && HIWORD( b ) )
 623         return lstrcmpW( a, b );
 624     /* strings come before ids */
 625     if (HIWORD( a ) && !HIWORD( b ))
 626         return -1;
 627     if (HIWORD( b ) && !HIWORD( a ))
 628         return 1;
 629     return ( a < b ) ? -1 : 1;
 630 }
 631
 632 static struct resource_dir_entry *find_resource_dir_entry( struct list *dir, LPCWSTR id )
 633 {
 634     struct resource_dir_entry *ent;
 635
 636     /* match either IDs or strings */
 637     LIST_FOR_EACH_ENTRY( ent, dir, struct resource_dir_entry, entry )
 638         if (!resource_strcmp( id, ent->id ))
 639             return ent;
 640
 641     return NULL;
 642 }
 643
 644 static struct resource_data *find_resource_data( struct list *dir, LANGID lang )
 645 {
 646     struct resource_data *res_data;
 647
 648     /* match only languages here */
 649     LIST_FOR_EACH_ENTRY( res_data, dir, struct resource_data, entry )
 650         if ( lang == res_data->lang )
 651              return res_data;
 652
 653     return NULL;
 654 }
 655
 656 static void add_resource_dir_entry( struct list *dir, struct resource_dir_entry *resdir )
 657 {
 658     struct resource_dir_entry *ent;
 659
 660     LIST_FOR_EACH_ENTRY( ent, dir, struct resource_dir_entry, entry )
 661     {
 662         if (0>resource_strcmp( ent->id, resdir->id ))
 663             continue;
 664
 665         list_add_before( &ent->entry, &resdir->entry );
 666         return;
 667     }
 668     list_add_tail( dir, &resdir->entry );
 669 }
 670
 671 static void add_resource_data_entry( struct list *dir, struct resource_data *resdata )
 672 {
 673     struct resource_data *ent;
 674
 675     LIST_FOR_EACH_ENTRY( ent, dir, struct resource_data, entry )
 676     {
 677         if (ent->lang < resdata->lang)
 678             continue;
 679
 680         list_add_before( &ent->entry, &resdata->entry );
 681         return;
 682     }
 683     list_add_tail( dir, &resdata->entry );
 684 }
 685
 686 static LPWSTR res_strdupW( LPCWSTR str )
 687 {
 688     LPWSTR ret;
 689     UINT len;
 690
 691     if (HIWORD(str) == 0)
 692         return (LPWSTR) (UINT_PTR) LOWORD(str);
 693     len = (lstrlenW( str ) + 1) * sizeof (WCHAR);
 694     ret = HeapAlloc( GetProcessHeap(), 0, len );
 695     memcpy( ret, str, len );
 696     return ret;
 697 }
 698
 699 static void res_free_str( LPWSTR str )
 700 {
 701     if (HIWORD(str))
 702         HeapFree( GetProcessHeap(), 0, str );
 703 }
 704
 705 static BOOL update_add_resource( QUEUEDUPDATES *updates, LPCWSTR Type, LPCWSTR Name,
 706                                  struct resource_data *resdata, BOOL overwrite_existing )
 707 {
 708     struct resource_dir_entry *restype, *resname;
 709     struct resource_data *existing;
 710
 711     TRACE("%p %s %s %p %d\n", updates,
 712           debugstr_w(Type), debugstr_w(Name), resdata, overwrite_existing );
 713
 714     restype = find_resource_dir_entry( &updates->root, Type );
 715     if (!restype)
 716     {
 717         restype = HeapAlloc( GetProcessHeap(), 0, sizeof *restype );
 718         restype->id = res_strdupW( Type );
 719         list_init( &restype->children );
 720         add_resource_dir_entry( &updates->root, restype );
 721     }
 722
 723     resname = find_resource_dir_entry( &restype->children, Name );
 724     if (!resname)
 725     {
 726         resname = HeapAlloc( GetProcessHeap(), 0, sizeof *resname );
 727         resname->id = res_strdupW( Name );
 728         list_init( &resname->children );
 729         add_resource_dir_entry( &restype->children, resname );
 730     }
 731
 732     /*
 733      * If there's an existing resource entry with matching (Type,Name,Language)
 734      *  it needs to be removed before adding the new data.
 735      */
 736     existing = find_resource_data( &resname->children, resdata->lang );
 737     if (existing)
 738     {
 739         if (!overwrite_existing)
 740             return FALSE;
 741         list_remove( &existing->entry );
 742         HeapFree( GetProcessHeap(), 0, existing );
 743     }
 744
 745     add_resource_data_entry( &resname->children, resdata );
 746
 747     return TRUE;
 748 }
 749
 750 static struct resource_data *allocate_resource_data( WORD Language, DWORD codepage,
 751                                                      LPVOID lpData, DWORD cbData, BOOL copy_data )
 752 {
 753     struct resource_data *resdata;
 754
 755     if (!lpData || !cbData)
 756         return NULL;
 757
 758     resdata = HeapAlloc( GetProcessHeap(), 0, sizeof *resdata + (copy_data ? cbData : 0) );
 759     if (resdata)
 760     {
 761         resdata->lang = Language;
 762         resdata->codepage = codepage;
 763         resdata->cbData = cbData;
 764         if (copy_data)
 765         {
 766             resdata->lpData = &resdata[1];
 767             memcpy( resdata->lpData, lpData, cbData );
 768         }
 769         else
 770             resdata->lpData = lpData;
 771     }
 772
 773     return resdata;
 774 }
 775
 776 static void free_resource_directory( struct list *head, int level )
 777 {
 778     struct list *ptr = NULL;
 779
 780     while ((ptr = list_head( head )))
 781     {
 782         list_remove( ptr );
 783         if (level)
 784         {
 785             struct resource_dir_entry *ent;
 786
 787             ent = LIST_ENTRY( ptr, struct resource_dir_entry, entry );
 788             res_free_str( ent->id );
 789             free_resource_directory( &ent->children, level - 1 );
 790             HeapFree(GetProcessHeap(), 0, ent);
 791         }
 792         else
 793         {
 794             struct resource_data *data;
 795
 796             data = LIST_ENTRY( ptr, struct resource_data, entry );
 797             HeapFree( GetProcessHeap(), 0, data );
 798         }
 799     }
 800 }
 801
 802 static IMAGE_NT_HEADERS *get_nt_header( void *base, DWORD mapping_size )
 803 {
 804     IMAGE_NT_HEADERS *nt;
 805     IMAGE_DOS_HEADER *dos;
 806
 807     if (mapping_size<sizeof (*dos))
 808         return NULL;
 809
 810     dos = base;
 811     if (dos->e_magic != IMAGE_DOS_SIGNATURE)
 812         return NULL;
 813
 814     if ((dos->e_lfanew + sizeof (*nt)) > mapping_size)
 815         return NULL;
 816
 817     nt = (void*) ((BYTE*)base + dos->e_lfanew);
 818
 819     if (nt->Signature != IMAGE_NT_SIGNATURE)
 820         return NULL;
 821
 822     return nt;
 823 }
 824
 825 static IMAGE_SECTION_HEADER *get_section_header( void *base, DWORD mapping_size, DWORD *num_sections )
 826 {
 827     IMAGE_NT_HEADERS *nt;
 828     IMAGE_SECTION_HEADER *sec;
 829     DWORD section_ofs;
 830
 831     nt = get_nt_header( base, mapping_size );
 832     if (!nt)
 833         return NULL;
 834
 835     /* check that we don't go over the end of the file accessing the sections */
 836     section_ofs = FIELD_OFFSET(IMAGE_NT_HEADERS, OptionalHeader) + nt->FileHeader.SizeOfOptionalHeader;
 837     if ((nt->FileHeader.NumberOfSections * sizeof (*sec) + section_ofs) > mapping_size)
 838         return NULL;
 839
 840     if (num_sections)
 841         *num_sections = nt->FileHeader.NumberOfSections;
 842
 843     /* from here we have a valid PE exe to update */
 844     return (void*) ((BYTE*)nt + section_ofs);
 845 }
 846
 847 static BOOL check_pe_exe( HANDLE file, QUEUEDUPDATES *updates )
 848 {
 849     const IMAGE_NT_HEADERS *nt;
 850     const IMAGE_SECTION_HEADER *sec;
 851     BOOL ret = FALSE;
 852     HANDLE mapping;
 853     DWORD mapping_size, num_sections = 0;
 854     void *base = NULL;
 855
 856     mapping_size = GetFileSize( file, NULL );
 857
 858     mapping = CreateFileMappingW( file, NULL, PAGE_READONLY, 0, 0, NULL );
 859     if (!mapping)
 860         goto done;
 861
 862     base = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, mapping_size );
 863     if (!base)
 864         goto done;
 865
 866     nt = get_nt_header( base, mapping_size );
 867     if (!nt)
 868         goto done;
 869
 870     TRACE("resources: %08x %08x\n",
 871           nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress,
 872           nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].Size);
 873
 874     sec = get_section_header( base, mapping_size, &num_sections );
 875     if (!sec)
 876         goto done;
 877
 878     ret = TRUE;
 879
 880 done:
 881     if (base)
 882         UnmapViewOfFile( base );
 883     if (mapping)
 884         CloseHandle( mapping );
 885
 886     return ret;
 887 }
 888
 889 struct resource_size_info {
 890     DWORD types_ofs;
 891     DWORD names_ofs;
 892     DWORD langs_ofs;
 893     DWORD data_entry_ofs;
 894     DWORD strings_ofs;
 895     DWORD data_ofs;
 896     DWORD total_size;
 897 };
 898
 899 struct mapping_info {
 900     HANDLE file;
 901     HANDLE mapping;
 902     void *base;
 903     DWORD size;
 904     BOOL read_write;
 905 };
 906
 907 static const IMAGE_SECTION_HEADER *section_from_rva( void *base, DWORD mapping_size, DWORD rva )
 908 {
 909     const IMAGE_SECTION_HEADER *sec;
 910     DWORD num_sections = 0;
 911     int i;
 912
 913     sec = get_section_header( base, mapping_size, &num_sections );
 914     if (!sec)
 915         return NULL;
 916
 917     for (i=num_sections-1; i>=0; i--)
 918     {
 919         if (sec[i].VirtualAddress <= rva &&
 920             rva <= (DWORD)sec[i].VirtualAddress + sec[i].SizeOfRawData)
 921         {
 922             return &sec[i];
 923         }
 924     }
 925
 926     return NULL;
 927 }
 928
 929 static void *address_from_rva( void *base, DWORD mapping_size, DWORD rva, DWORD len )
 930 {
 931     const IMAGE_SECTION_HEADER *sec;
 932
 933     sec = section_from_rva( base, mapping_size, rva );
 934     if (!sec)
 935         return NULL;
 936
 937     if (rva + len <= (DWORD)sec->VirtualAddress + sec->SizeOfRawData)
 938         return (void*)((LPBYTE) base + (sec->PointerToRawData + rva - sec->VirtualAddress));
 939
 940     return NULL;
 941 }
 942
 943 static LPWSTR resource_dup_string( const IMAGE_RESOURCE_DIRECTORY *root, const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry )
 944 {
 945     const IMAGE_RESOURCE_DIR_STRING_U* string;
 946     LPWSTR s;
 947
 948     if (!entry->u1.s1.NameIsString)
 949         return UIntToPtr(entry->u1.s2.Id);
 950
 951     string = (const IMAGE_RESOURCE_DIR_STRING_U*) (((const char *)root) + entry->u1.s1.NameOffset);
 952     s = HeapAlloc(GetProcessHeap(), 0, (string->Length + 1)*sizeof (WCHAR) );
 953     memcpy( s, string->NameString, (string->Length + 1)*sizeof (WCHAR) );
 954     s[string->Length] = 0;
 955
 956     return s;
 957 }
 958
 959 /* this function is based on the code in winedump's pe.c */
 960 static BOOL enumerate_mapped_resources( QUEUEDUPDATES *updates,
 961                              void *base, DWORD mapping_size,
 962                              const IMAGE_RESOURCE_DIRECTORY *root )
 963 {
 964     const IMAGE_RESOURCE_DIRECTORY *namedir, *langdir;
 965     const IMAGE_RESOURCE_DIRECTORY_ENTRY *e1, *e2, *e3;
 966     const IMAGE_RESOURCE_DATA_ENTRY *data;
 967     DWORD i, j, k;
 968
 969     TRACE("version (%d.%d) %d named %d id entries\n",
 970           root->MajorVersion, root->MinorVersion, root->NumberOfNamedEntries, root->NumberOfIdEntries);
 971
 972     for (i = 0; i< root->NumberOfNamedEntries + root->NumberOfIdEntries; i++)
 973     {
 974         LPWSTR Type;
 975
 976         e1 = (const IMAGE_RESOURCE_DIRECTORY_ENTRY*)(root + 1) + i;
 977
 978         Type = resource_dup_string( root, e1 );
 979
 980         namedir = (const IMAGE_RESOURCE_DIRECTORY *)((const char *)root + e1->u2.s3.OffsetToDirectory);
 981         for (j = 0; j < namedir->NumberOfNamedEntries + namedir->NumberOfIdEntries; j++)
 982         {
 983             LPWSTR Name;
 984
 985             e2 = (const IMAGE_RESOURCE_DIRECTORY_ENTRY*)(namedir + 1) + j;
 986
 987             Name = resource_dup_string( root, e2 );
 988
 989             langdir = (const IMAGE_RESOURCE_DIRECTORY *)((const char *)root + e2->u2.s3.OffsetToDirectory);
 990             for (k = 0; k < langdir->NumberOfNamedEntries + langdir->NumberOfIdEntries; k++)
 991             {
 992                 LANGID Lang;
 993                 void *p;
 994                 struct resource_data *resdata;
 995
 996                 e3 = (const IMAGE_RESOURCE_DIRECTORY_ENTRY*)(langdir + 1) + k;
 997
 998                 Lang = e3->u1.s2.Id;
 999
1000                 data = (const IMAGE_RESOURCE_DATA_ENTRY *)((const char *)root + e3->u2.OffsetToData);
1001
1002                 p = address_from_rva( base, mapping_size, data->OffsetToData, data->Size );
1003
1004                 resdata = allocate_resource_data( Lang, data->CodePage, p, data->Size, FALSE );
1005                 if (resdata)
1006                 {
1007                     if (!update_add_resource( updates, Type, Name, resdata, FALSE ))
1008                         HeapFree( GetProcessHeap(), 0, resdata );
1009                 }
1010             }
1011             res_free_str( Name );
1012         }
1013         res_free_str( Type );
1014     }
1015
1016     return TRUE;
1017 }
1018
1019 static BOOL read_mapped_resources( QUEUEDUPDATES *updates, void *base, DWORD mapping_size )
1020 {
1021     const IMAGE_RESOURCE_DIRECTORY *root;
1022     const IMAGE_NT_HEADERS *nt;
1023     const IMAGE_SECTION_HEADER *sec;
1024     DWORD num_sections = 0, i;
1025
1026     nt = get_nt_header( base, mapping_size );
1027     if (!nt)
1028         return FALSE;
1029
1030     sec = get_section_header( base, mapping_size, &num_sections );
1031     if (!sec)
1032         return FALSE;
1033
1034     for (i=0; i<num_sections; i++)
1035         if (!memcmp(sec[i].Name, ".rsrc", 6))
1036             break;
1037
1038     if (i == num_sections)
1039         return TRUE;
1040
1041     /* check the resource data is inside the mapping */
1042     if (sec[i].PointerToRawData > mapping_size ||
1043         (sec[i].PointerToRawData + sec[i].SizeOfRawData) > mapping_size)
1044         return TRUE;
1045
1046     TRACE("found .rsrc at %08x, size %08x\n", sec[i].PointerToRawData, sec[i].SizeOfRawData);
1047
1048     if (!sec[i].PointerToRawData || sec[i].SizeOfRawData < sizeof(IMAGE_RESOURCE_DIRECTORY))
1049         return TRUE;
1050
1051     root = (void*) ((BYTE*)base + sec[i].PointerToRawData);
1052     enumerate_mapped_resources( updates, base, mapping_size, root );
1053
1054     return TRUE;
1055 }
1056
1057 static BOOL map_file_into_memory( struct mapping_info *mi )
1058 {
1059     DWORD page_attr, perm;
1060
1061     if (mi->read_write)
1062     {
1063         page_attr = PAGE_READWRITE;
1064         perm = FILE_MAP_WRITE | FILE_MAP_READ;
1065     }
1066     else
1067     {
1068         page_attr = PAGE_READONLY;
1069         perm = FILE_MAP_READ;
1070     }
1071
1072     mi->mapping = CreateFileMappingW( mi->file, NULL, page_attr, 0, 0, NULL );
1073     if (!mi->mapping)
1074         return FALSE;
1075
1076     mi->base = MapViewOfFile( mi->mapping, perm, 0, 0, mi->size );
1077     if (!mi->base)
1078         return FALSE;
1079
1080     return TRUE;
1081 }
1082
1083 static BOOL unmap_file_from_memory( struct mapping_info *mi )
1084 {
1085     if (mi->base)
1086         UnmapViewOfFile( mi->base );
1087     mi->base = NULL;
1088     if (mi->mapping)
1089         CloseHandle( mi->mapping );
1090     mi->mapping = NULL;
1091     return TRUE;
1092 }
1093
1094 static void destroy_mapping( struct mapping_info *mi )
1095 {
1096     if (!mi)
1097         return;
1098     unmap_file_from_memory( mi );
1099     if (mi->file)
1100         CloseHandle( mi->file );
1101     HeapFree( GetProcessHeap(), 0, mi );
1102 }
1103
1104 static struct mapping_info *create_mapping( LPCWSTR name, BOOL rw )
1105 {
1106     struct mapping_info *mi;
1107
1108     mi = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof *mi );
1109     if (!mi)
1110         return NULL;
1111
1112     mi->read_write = rw;
1113
1114     mi->file = CreateFileW( name, GENERIC_READ | (rw ? GENERIC_WRITE : 0),
1115                             0, NULL, OPEN_EXISTING, 0, 0 );
1116
1117     if (mi->file != INVALID_HANDLE_VALUE)
1118     {
1119         mi->size = GetFileSize( mi->file, NULL );
1120
1121         if (map_file_into_memory( mi ))
1122             return mi;
1123     }
1124
1125     unmap_file_from_memory( mi );
1126     HeapFree( GetProcessHeap(), 0, mi );
1127
1128     return NULL;
1129 }
1130
1131 static BOOL resize_mapping( struct mapping_info *mi, DWORD new_size )
1132 {
1133     if (!unmap_file_from_memory( mi ))
1134         return FALSE;
1135
1136     /* change the file size */
1137     SetFilePointer( mi->file, new_size, NULL, FILE_BEGIN );
1138     if (!SetEndOfFile( mi->file ))
1139     {
1140         ERR("failed to set file size to %08x\n", new_size );
1141         return FALSE;
1142     }
1143
1144     mi->size = new_size;
1145
1146     return map_file_into_memory( mi );
1147 }
1148
1149 static void get_resource_sizes( QUEUEDUPDATES *updates, struct resource_size_info *si )
1150 {
1151     struct resource_dir_entry *types, *names;
1152     struct resource_data *data;
1153     DWORD num_types = 0, num_names = 0, num_langs = 0, strings_size = 0, data_size = 0;
1154
1155     memset( si, 0, sizeof *si );
1156
1157     LIST_FOR_EACH_ENTRY( types, &updates->root, struct resource_dir_entry, entry )
1158     {
1159         num_types++;
1160         if (HIWORD( types->id ))
1161             strings_size += sizeof (WORD) + lstrlenW( types->id )*sizeof (WCHAR);
1162
1163         LIST_FOR_EACH_ENTRY( names, &types->children, struct resource_dir_entry, entry )
1164         {
1165             num_names++;
1166
1167             if (HIWORD( names->id ))
1168                 strings_size += sizeof (WORD) + lstrlenW( names->id )*sizeof (WCHAR);
1169
1170             LIST_FOR_EACH_ENTRY( data, &names->children, struct resource_data, entry )
1171             {
1172                 num_langs++;
1173                 data_size += (data->cbData + 3) & ~3;
1174             }
1175         }
1176     }
1177
1178     /* names are at the end of the types */
1179     si->names_ofs = sizeof (IMAGE_RESOURCE_DIRECTORY) +
1180             num_types * sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
1181
1182     /* language directories are at the end of the names */
1183     si->langs_ofs = si->names_ofs +
1184             num_types * sizeof (IMAGE_RESOURCE_DIRECTORY) +
1185             num_names * sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
1186
1187     si->data_entry_ofs = si->langs_ofs +
1188             num_names * sizeof (IMAGE_RESOURCE_DIRECTORY) +
1189             num_langs * sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
1190
1191     si->strings_ofs = si->data_entry_ofs +
1192             num_langs * sizeof (IMAGE_RESOURCE_DATA_ENTRY);
1193
1194     si->data_ofs = si->strings_ofs + ((strings_size + 3) & ~3);
1195
1196     si->total_size = si->data_ofs + data_size;
1197
1198     TRACE("names %08x langs %08x data entries %08x strings %08x data %08x total %08x\n",
1199           si->names_ofs, si->langs_ofs, si->data_entry_ofs,
1200           si->strings_ofs, si->data_ofs, si->total_size);
1201 }
1202
1203 static void res_write_padding( BYTE *res_base, DWORD size )
1204 {
1205     static const BYTE pad[] = {
1206         'P','A','D','D','I','N','G','X','X','P','A','D','D','I','N','G' };
1207     DWORD i;
1208
1209     for ( i = 0; i < size / sizeof pad; i++ )
1210         memcpy( &res_base[i*sizeof pad], pad, sizeof pad );
1211     memcpy( &res_base[i*sizeof pad], pad, size%sizeof pad );
1212 }
1213
1214 static BOOL write_resources( QUEUEDUPDATES *updates, LPBYTE base, struct resource_size_info *si, DWORD rva )
1215 {
1216     struct resource_dir_entry *types, *names;
1217     struct resource_data *data;
1218     IMAGE_RESOURCE_DIRECTORY *root;
1219
1220     TRACE("%p %p %p %08x\n", updates, base, si, rva );
1221
1222     memset( base, 0, si->total_size );
1223
1224     /* the root entry always exists */
1225     root = (IMAGE_RESOURCE_DIRECTORY*) base;
1226     memset( root, 0, sizeof *root );
1227     root->MajorVersion = 4;
1228     si->types_ofs = sizeof *root;
1229     LIST_FOR_EACH_ENTRY( types, &updates->root, struct resource_dir_entry, entry )
1230     {
1231         IMAGE_RESOURCE_DIRECTORY_ENTRY *e1;
1232         IMAGE_RESOURCE_DIRECTORY *namedir;
1233
1234         e1 = (IMAGE_RESOURCE_DIRECTORY_ENTRY*) &base[si->types_ofs];
1235         memset( e1, 0, sizeof *e1 );
1236         if (HIWORD( types->id ))
1237         {
1238             WCHAR *strings;
1239             DWORD len;
1240
1241             root->NumberOfNamedEntries++;
1242             e1->u1.s1.NameIsString = 1;
1243             e1->u1.s1.NameOffset = si->strings_ofs;
1244
1245             strings = (WCHAR*) &base[si->strings_ofs];
1246             len = lstrlenW( types->id );
1247             strings[0] = len;
1248             memcpy( &strings[1], types->id, len * sizeof (WCHAR) );
1249             si->strings_ofs += (len + 1) * sizeof (WCHAR);
1250         }
1251         else
1252         {
1253             root->NumberOfIdEntries++;
1254             e1->u1.s2.Id = LOWORD( types->id );
1255         }
1256         e1->u2.s3.OffsetToDirectory = si->names_ofs;
1257         e1->u2.s3.DataIsDirectory = TRUE;
1258         si->types_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
1259
1260         namedir = (IMAGE_RESOURCE_DIRECTORY*) &base[si->names_ofs];
1261         memset( namedir, 0, sizeof *namedir );
1262         namedir->MajorVersion = 4;
1263         si->names_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY);
1264
1265         LIST_FOR_EACH_ENTRY( names, &types->children, struct resource_dir_entry, entry )
1266         {
1267             IMAGE_RESOURCE_DIRECTORY_ENTRY *e2;
1268             IMAGE_RESOURCE_DIRECTORY *langdir;
1269
1270             e2 = (IMAGE_RESOURCE_DIRECTORY_ENTRY*) &base[si->names_ofs];
1271             memset( e2, 0, sizeof *e2 );
1272             if (HIWORD( names->id ))
1273             {
1274                 WCHAR *strings;
1275                 DWORD len;
1276
1277                 namedir->NumberOfNamedEntries++;
1278                 e2->u1.s1.NameIsString = 1;
1279                 e2->u1.s1.NameOffset = si->strings_ofs;
1280
1281                 strings = (WCHAR*) &base[si->strings_ofs];
1282                 len = lstrlenW( names->id );
1283                 strings[0] = len;
1284                 memcpy( &strings[1], names->id, len * sizeof (WCHAR) );
1285                 si->strings_ofs += (len + 1) * sizeof (WCHAR);
1286             }
1287             else
1288             {
1289                 namedir->NumberOfIdEntries++;
1290                 e2->u1.s2.Id = LOWORD( names->id );
1291             }
1292             e2->u2.s3.OffsetToDirectory = si->langs_ofs;
1293             e2->u2.s3.DataIsDirectory = TRUE;
1294             si->names_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
1295
1296             langdir = (IMAGE_RESOURCE_DIRECTORY*) &base[si->langs_ofs];
1297             memset( langdir, 0, sizeof *langdir );
1298             langdir->MajorVersion = 4;
1299             si->langs_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY);
1300
1301             LIST_FOR_EACH_ENTRY( data, &names->children, struct resource_data, entry )
1302             {
1303                 IMAGE_RESOURCE_DIRECTORY_ENTRY *e3;
1304                 IMAGE_RESOURCE_DATA_ENTRY *de;
1305                 int pad_size;
1306
1307                 e3 = (IMAGE_RESOURCE_DIRECTORY_ENTRY*) &base[si->langs_ofs];
1308                 memset( e3, 0, sizeof *e3 );
1309                 langdir->NumberOfIdEntries++;
1310                 e3->u1.s2.Id = LOWORD( data->lang );
1311                 e3->u2.OffsetToData = si->data_entry_ofs;
1312
1313                 si->langs_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
1314
1315                 /* write out all the data entries */
1316                 de = (IMAGE_RESOURCE_DATA_ENTRY*) &base[si->data_entry_ofs];
1317                 memset( de, 0, sizeof *de );
1318                 de->OffsetToData = si->data_ofs + rva;
1319                 de->Size = data->cbData;
1320                 de->CodePage = data->codepage;
1321                 si->data_entry_ofs += sizeof (IMAGE_RESOURCE_DATA_ENTRY);
1322
1323                 /* write out the resource data */
1324                 memcpy( &base[si->data_ofs], data->lpData, data->cbData );
1325                 si->data_ofs += data->cbData;
1326
1327                 pad_size = (-si->data_ofs)&3;
1328                 res_write_padding( &base[si->data_ofs], pad_size );
1329                 si->data_ofs += pad_size;
1330             }
1331         }
1332     }
1333
1334     return TRUE;
1335 }
1336
1337 /*
1338  *  FIXME:
1339  *  Assumes that the resources are in .rsrc
1340  *   and .rsrc is the last section in the file.
1341  *  Not sure whether updating resources will other cases on Windows.
1342  *  If the resources lie in a section containing other data,
1343  *   resizing that section could possibly cause trouble.
1344  *  If the section with the resources isn't last, the remaining
1345  *   sections need to be moved down in the file, and the section header
1346  *   would need to be adjusted.
1347  *  If we needed to add a section, what would we name it?
1348  *  If we needed to add a section and there wasn't space in the file
1349  *   header, how would that work?
1350  *  Seems that at least some of these cases can't be handled properly.
1351  */
1352 static IMAGE_SECTION_HEADER *get_resource_section( void *base, DWORD mapping_size )
1353 {
1354     IMAGE_SECTION_HEADER *sec;
1355     IMAGE_NT_HEADERS *nt;
1356     DWORD i, num_sections = 0;
1357
1358     nt = get_nt_header( base, mapping_size );
1359     if (!nt)
1360         return NULL;
1361
1362     sec = get_section_header( base, mapping_size, &num_sections );
1363     if (!sec)
1364         return NULL;
1365
1366     /* find the resources section */
1367     for (i=0; i<num_sections; i++)
1368         if (!memcmp(sec[i].Name, ".rsrc", 6))
1369             break;
1370
1371     if (i == num_sections)
1372     {
1373         FIXME(".rsrc doesn't exist\n");
1374         return NULL;
1375     }
1376
1377     return &sec[i];
1378 }
1379
1380 static DWORD get_init_data_size( void *base, DWORD mapping_size )
1381 {
1382     DWORD i, sz = 0, num_sections = 0;
1383     IMAGE_SECTION_HEADER *s;
1384
1385     s = get_section_header( base, mapping_size, &num_sections );
1386
1387     for (i=0; i<num_sections; i++)
1388         if (s[i].Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
1389             sz += s[i].SizeOfRawData;
1390
1391     TRACE("size = %08x\n", sz);
1392
1393     return sz;
1394 }
1395
1396 static BOOL write_raw_resources( QUEUEDUPDATES *updates )
1397 {
1398     static const WCHAR prefix[] = { 'r','e','s','u',0 };
1399     WCHAR tempdir[MAX_PATH], tempfile[MAX_PATH];
1400     DWORD mapping_size, section_size, old_size;
1401     BOOL ret = FALSE;
1402     IMAGE_SECTION_HEADER *sec;
1403     IMAGE_NT_HEADERS *nt;
1404     struct resource_size_info res_size;
1405     BYTE *res_base;
1406     struct mapping_info *read_map = NULL, *write_map = NULL;
1407
1408     /* copy the exe to a temp file then update the temp file... */
1409     tempdir[0] = 0;
1410     if (!GetTempPathW( MAX_PATH, tempdir ))
1411         return ret;
1412
1413     if (!GetTempFileNameW( tempdir, prefix, 0, tempfile ))
1414         return ret;
1415
1416     if (!CopyFileW( updates->pFileName, tempfile, FALSE ))
1417         goto done;
1418
1419     TRACE("tempfile %s\n", debugstr_w(tempfile));
1420
1421     if (!updates->bDeleteExistingResources)
1422     {
1423         read_map = create_mapping( updates->pFileName, FALSE );
1424         if (!read_map)
1425             goto done;
1426
1427         ret = read_mapped_resources( updates, read_map->base, read_map->size );
1428         if (!ret)
1429         {
1430             ERR("failed to read existing resources\n");
1431             goto done;
1432         }
1433     }
1434
1435     write_map = create_mapping( tempfile, TRUE );
1436     if (!write_map)
1437         goto done;
1438
1439     nt = get_nt_header( write_map->base, write_map->size );
1440     if (!nt)
1441         goto done;
1442
1443     if (nt->OptionalHeader.SectionAlignment <= 0)
1444     {
1445         ERR("invalid section alignment %04x\n", nt->OptionalHeader.SectionAlignment);
1446         goto done;
1447     }
1448
1449     sec = get_resource_section( write_map->base, write_map->size );
1450     if (!sec)
1451         goto done;
1452
1453     if (!sec->PointerToRawData)  /* empty section */
1454     {
1455         sec->PointerToRawData = write_map->size;
1456         sec->SizeOfRawData = 0;
1457     }
1458     else if ((sec->SizeOfRawData + sec->PointerToRawData) != write_map->size)
1459     {
1460         FIXME(".rsrc isn't at the end of the image %08x + %08x != %08x for %s\n",
1461               sec->SizeOfRawData, sec->PointerToRawData, write_map->size, debugstr_w(updates->pFileName));
1462         goto done;
1463     }
1464
1465     TRACE("before .rsrc at %08x, size %08x\n", sec->PointerToRawData, sec->SizeOfRawData);
1466
1467     get_resource_sizes( updates, &res_size );
1468
1469     /* round up the section size */
1470     section_size = res_size.total_size;
1471     section_size += (-section_size) % nt->OptionalHeader.SectionAlignment;
1472
1473     mapping_size = sec->PointerToRawData + section_size;
1474
1475     TRACE("requires %08x (%08x) bytes\n", res_size.total_size, section_size );
1476
1477     /* check if the file size needs to be changed */
1478     if (section_size != sec->SizeOfRawData)
1479     {
1480         old_size = write_map->size;
1481
1482         TRACE("file size %08x -> %08x\n", old_size, mapping_size);
1483
1484         /* unmap the file before changing the file size */
1485         ret = resize_mapping( write_map, mapping_size );
1486
1487         /* get the pointers again - they might be different after remapping */
1488         nt = get_nt_header( write_map->base, mapping_size );
1489         if (!nt)
1490         {
1491             ERR("couldn't get NT header\n");
1492             goto done;
1493         }
1494
1495         sec = get_resource_section( write_map->base, mapping_size );
1496         if (!sec)
1497              goto done;
1498
1499         /* adjust the PE header information */
1500         nt->OptionalHeader.SizeOfImage += (mapping_size - old_size);
1501         sec->SizeOfRawData = section_size;
1502         sec->Misc.VirtualSize = section_size;
1503         nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].Size = res_size.total_size;
1504         nt->OptionalHeader.SizeOfInitializedData = get_init_data_size( write_map->base, mapping_size );
1505     }
1506
1507     res_base = (LPBYTE) write_map->base + sec->PointerToRawData;
1508
1509     TRACE("base = %p offset = %08x\n", write_map->base, sec->PointerToRawData);
1510
1511     ret = write_resources( updates, res_base, &res_size, sec->VirtualAddress );
1512
1513     res_write_padding( res_base + res_size.total_size, section_size - res_size.total_size );
1514
1515     TRACE("after  .rsrc at %08x, size %08x\n", sec->PointerToRawData, sec->SizeOfRawData);
1516
1517 done:
1518     destroy_mapping( read_map );
1519     destroy_mapping( write_map );
1520
1521     if (ret)
1522         ret = CopyFileW( tempfile, updates->pFileName, FALSE );
1523
1524     DeleteFileW( tempfile );
1525
1526     return ret;
1527 }
1528
1529 /***********************************************************************
1530  *          BeginUpdateResourceW                 (KERNEL32.@)
1531  */
1532 HANDLE WINAPI BeginUpdateResourceW( LPCWSTR pFileName, BOOL bDeleteExistingResources )
1533 {
1534     QUEUEDUPDATES *updates = NULL;
1535     HANDLE hUpdate, file, ret = NULL;
1536
1537     TRACE("%s, %d\n", debugstr_w(pFileName), bDeleteExistingResources);
1538
1539     hUpdate = GlobalAlloc(GHND, sizeof(QUEUEDUPDATES));
1540     if (!hUpdate)
1541         return ret;
1542
1543     updates = GlobalLock(hUpdate);
1544     if (updates)
1545     {
1546         list_init( &updates->root );
1547         updates->bDeleteExistingResources = bDeleteExistingResources;
1548         updates->pFileName = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(pFileName)+1)*sizeof(WCHAR));
1549         if (updates->pFileName)
1550         {
1551             lstrcpyW(updates->pFileName, pFileName);
1552
1553             file = CreateFileW( pFileName, GENERIC_READ | GENERIC_WRITE,
1554                                 0, NULL, OPEN_EXISTING, 0, 0 );
1555
1556             /* if resources are deleted, only the file's presence is checked */
1557             if (file != INVALID_HANDLE_VALUE &&
1558                 (bDeleteExistingResources || check_pe_exe( file, updates )))
1559                 ret = hUpdate;
1560             else
1561                 HeapFree( GetProcessHeap(), 0, updates->pFileName );
1562
1563             CloseHandle( file );
1564         }
1565         GlobalUnlock(hUpdate);
1566     }
1567
1568     if (!ret)
1569         GlobalFree(hUpdate);
1570
1571     return ret;
1572 }
1573
1574
1575 /***********************************************************************
1576  *          BeginUpdateResourceA                 (KERNEL32.@)
1577  */
1578 HANDLE WINAPI BeginUpdateResourceA( LPCSTR pFileName, BOOL bDeleteExistingResources )
1579 {
1580     UNICODE_STRING FileNameW;
1581     HANDLE ret;
1582     RtlCreateUnicodeStringFromAsciiz(&FileNameW, pFileName);
1583     ret = BeginUpdateResourceW(FileNameW.Buffer, bDeleteExistingResources);
1584     RtlFreeUnicodeString(&FileNameW);
1585     return ret;
1586 }
1587
1588
1589 /***********************************************************************
1590  *          EndUpdateResourceW                 (KERNEL32.@)
1591  */
1592 BOOL WINAPI EndUpdateResourceW( HANDLE hUpdate, BOOL fDiscard )
1593 {
1594     QUEUEDUPDATES *updates;
1595     BOOL ret;
1596
1597     TRACE("%p %d\n", hUpdate, fDiscard);
1598
1599     updates = GlobalLock(hUpdate);
1600     if (!updates)
1601         return FALSE;
1602
1603     ret = fDiscard || write_raw_resources( updates );
1604
1605     free_resource_directory( &updates->root, 2 );
1606
1607     HeapFree( GetProcessHeap(), 0, updates->pFileName );
1608     GlobalUnlock( hUpdate );
1609     GlobalFree( hUpdate );
1610
1611     return ret;
1612 }
1613
1614
1615 /***********************************************************************
1616  *          EndUpdateResourceA                 (KERNEL32.@)
1617  */
1618 BOOL WINAPI EndUpdateResourceA( HANDLE hUpdate, BOOL fDiscard )
1619 {
1620     return EndUpdateResourceW(hUpdate, fDiscard);
1621 }
1622
1623
1624 /***********************************************************************
1625  *           UpdateResourceW                 (KERNEL32.@)
1626  */
1627 BOOL WINAPI UpdateResourceW( HANDLE hUpdate, LPCWSTR lpType, LPCWSTR lpName,
1628                              WORD wLanguage, LPVOID lpData, DWORD cbData)
1629 {
1630     QUEUEDUPDATES *updates;
1631     BOOL ret = FALSE;
1632
1633     TRACE("%p %s %s %08x %p %d\n", hUpdate,
1634           debugstr_w(lpType), debugstr_w(lpName), wLanguage, lpData, cbData);
1635
1636     updates = GlobalLock(hUpdate);
1637     if (updates)
1638     {
1639         struct resource_data *data;
1640         data = allocate_resource_data( wLanguage, 0, lpData, cbData, TRUE );
1641         if (data)
1642             ret = update_add_resource( updates, lpType, lpName, data, TRUE );
1643         GlobalUnlock(hUpdate);
1644     }
1645     return ret;
1646 }
1647
1648
1649 /***********************************************************************
1650  *           UpdateResourceA                 (KERNEL32.@)
1651  */
1652 BOOL WINAPI UpdateResourceA( HANDLE hUpdate, LPCSTR lpType, LPCSTR lpName,
1653                              WORD wLanguage, LPVOID lpData, DWORD cbData)
1654 {
1655     BOOL ret;
1656     UNICODE_STRING TypeW;
1657     UNICODE_STRING NameW;
1658     if(!HIWORD(lpType))
1659         TypeW.Buffer = ULongToPtr(LOWORD(lpType));
1660     else
1661         RtlCreateUnicodeStringFromAsciiz(&TypeW, lpType);
1662     if(!HIWORD(lpName))
1663         NameW.Buffer = ULongToPtr(LOWORD(lpName));
1664     else
1665         RtlCreateUnicodeStringFromAsciiz(&NameW, lpName);
1666     ret = UpdateResourceW(hUpdate, TypeW.Buffer, NameW.Buffer, wLanguage, lpData, cbData);
1667     if(HIWORD(lpType)) RtlFreeUnicodeString(&TypeW);
1668     if(HIWORD(lpName)) RtlFreeUnicodeString(&NameW);
1669     return ret;
1670 }