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