loader/pe_resource.c

   1 /*
   2  * PE (Portable Execute) File Resources
   3  *
   4  * Copyright 1995 Thomas Sandford
   5  * Copyright 1996 Martin von Loewis
   6  *
   7  * Based on the Win16 resource handling code in loader/resource.c
   8  * Copyright 1993 Robert J. Amstadt
   9  * Copyright 1995 Alexandre Julliard
  10  * Copyright 1997 Marcus Meissner
  11  */
  12
  13 #include "config.h"
  14
  15 #include <stdlib.h>
  16 #include <sys/types.h>
  17
  18 #include "wine/unicode.h"
  19 #include "windef.h"
  20 #include "winnls.h"
  21 #include "winerror.h"
  22 #include "module.h"
  23 #include "stackframe.h"
  24 #include "debugtools.h"
  25
  26 DEFAULT_DEBUG_CHANNEL(resource);
  27
  28
  29 /**********************************************************************
  30  *  get_module_base
  31  *
  32  * Get the base address of a module
  33  */
  34 static const void *get_module_base( HMODULE hmod )
  35 {
  36     if (!hmod) hmod = GetModuleHandleA( NULL );
  37     else if (!HIWORD(hmod))
  38     {
  39         FIXME("Enumeration of 16-bit resources is not supported\n");
  40         SetLastError(ERROR_INVALID_HANDLE);
  41         return NULL;
  42     }
  43
  44     /* clear low order bit in case of LOAD_LIBRARY_AS_DATAFILE module */
  45     return (void *)((ULONG_PTR)hmod & ~1);
  46 }
  47
  48
  49 /**********************************************************************
  50  *  get_resdir
  51  *
  52  * Get the resource directory of a PE module
  53  */
  54 static const IMAGE_RESOURCE_DIRECTORY* get_resdir( HMODULE hmod )
  55 {
  56     const IMAGE_DATA_DIRECTORY *dir;
  57     const IMAGE_RESOURCE_DIRECTORY *ret = NULL;
  58     const void *base = get_module_base( hmod );
  59
  60     if (base)
  61     {
  62         dir = &PE_HEADER(base)->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE];
  63         if (dir->Size && dir->VirtualAddress)
  64             ret = (IMAGE_RESOURCE_DIRECTORY *)((char *)base + dir->VirtualAddress);
  65     }
  66     return ret;
  67 }
  68
  69
  70 /**********************************************************************
  71  *  find_entry_by_id
  72  *
  73  * Find an entry by id in a resource directory
  74  */
  75 static const IMAGE_RESOURCE_DIRECTORY *find_entry_by_id( const IMAGE_RESOURCE_DIRECTORY *dir,
  76                                                          WORD id, const void *root )
  77 {
  78     const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry;
  79     int min, max, pos;
  80
  81     entry = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1);
  82     min = dir->NumberOfNamedEntries;
  83     max = min + dir->NumberOfIdEntries - 1;
  84     while (min <= max)
  85     {
  86         pos = (min + max) / 2;
  87         if (entry[pos].u1.s2.Id == id)
  88             return (IMAGE_RESOURCE_DIRECTORY *)((char *)root + entry[pos].u2.s3.OffsetToDirectory);
  89         if (entry[pos].u1.s2.Id > id) max = pos - 1;
  90         else min = pos + 1;
  91     }
  92     return NULL;
  93 }
  94
  95
  96 /**********************************************************************
  97  *  find_entry_by_nameW
  98  *
  99  * Find an entry by name in a resource directory
 100  */
 101 static const IMAGE_RESOURCE_DIRECTORY *find_entry_by_nameW( const IMAGE_RESOURCE_DIRECTORY *dir,
 102                                                             LPCWSTR name, const void *root )
 103 {
 104     const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry;
 105     const IMAGE_RESOURCE_DIR_STRING_U *str;
 106     int min, max, res, pos, namelen;
 107
 108     if (!HIWORD(name)) return find_entry_by_id( dir, LOWORD(name), root );
 109     if (name[0] == '#')
 110     {
 111         char buf[16];
 112         if (!WideCharToMultiByte( CP_ACP, 0, name+1, -1, buf, sizeof(buf), NULL, NULL ))
 113             return NULL;
 114         return find_entry_by_id( dir, atoi(buf), root );
 115     }
 116
 117     entry = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1);
 118     namelen = strlenW(name);
 119     min = 0;
 120     max = dir->NumberOfNamedEntries - 1;
 121     while (min <= max)
 122     {
 123         pos = (min + max) / 2;
 124         str = (IMAGE_RESOURCE_DIR_STRING_U *)((char *)root + entry[pos].u1.s1.NameOffset);
 125         res = strncmpiW( name, str->NameString, str->Length );
 126         if (!res && namelen == str->Length)
 127             return (IMAGE_RESOURCE_DIRECTORY *)((char *)root + entry[pos].u2.s3.OffsetToDirectory);
 128         if (res < 0) max = pos - 1;
 129         else min = pos + 1;
 130     }
 131     return NULL;
 132 }
 133
 134
 135 /**********************************************************************
 136  *  find_entry_by_nameA
 137  *
 138  * Find an entry by name in a resource directory
 139  */
 140 static const IMAGE_RESOURCE_DIRECTORY *find_entry_by_nameA( const IMAGE_RESOURCE_DIRECTORY *dir,
 141                                                             LPCSTR name, const void *root )
 142 {
 143     const IMAGE_RESOURCE_DIRECTORY *ret = NULL;
 144     LPWSTR nameW;
 145     INT len;
 146
 147     if (!HIWORD(name)) return find_entry_by_id( dir, LOWORD(name), root );
 148     if (name[0] == '#')
 149     {
 150         return find_entry_by_id( dir, atoi(name+1), root );
 151     }
 152
 153     len = MultiByteToWideChar( CP_ACP, 0, name, -1, NULL, 0 );
 154     if ((nameW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
 155     {
 156         MultiByteToWideChar( CP_ACP, 0, name, -1, nameW, len );
 157         ret = find_entry_by_nameW( dir, nameW, root );
 158         HeapFree( GetProcessHeap(), 0, nameW );
 159     }
 160     return ret;
 161 }
 162
 163
 164 /**********************************************************************
 165  *  find_entry_default
 166  *
 167  * Find a default entry in a resource directory
 168  */
 169 static const IMAGE_RESOURCE_DIRECTORY *find_entry_default( const IMAGE_RESOURCE_DIRECTORY *dir,
 170                                                            const void *root )
 171 {
 172     const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry;
 173
 174     entry = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1);
 175     return (IMAGE_RESOURCE_DIRECTORY *)((char *)root + entry->u2.s3.OffsetToDirectory);
 176 }
 177
 178
 179 /**********************************************************************
 180  *          PE_FindResourceExW
 181  *
 182  * FindResourceExA/W does search in the following order:
 183  * 1. Exact specified language
 184  * 2. Language with neutral sublanguage
 185  * 3. Neutral language with neutral sublanguage
 186  * 4. Neutral language with default sublanguage
 187  */
 188 HRSRC PE_FindResourceExW( HMODULE hmod, LPCWSTR name, LPCWSTR type, WORD lang )
 189 {
 190     const IMAGE_RESOURCE_DIRECTORY *resdirptr = get_resdir(hmod);
 191     const void *root;
 192     HRSRC result;
 193
 194     if (!resdirptr) return 0;
 195
 196     root = resdirptr;
 197     if (!(resdirptr = find_entry_by_nameW(resdirptr, type, root))) return 0;
 198     if (!(resdirptr = find_entry_by_nameW(resdirptr, name, root))) return 0;
 199
 200     /* 1. Exact specified language */
 201     if ((result = (HRSRC)find_entry_by_id( resdirptr, lang, root ))) goto found;
 202
 203     /* 2. Language with neutral sublanguage */
 204     lang = MAKELANGID(PRIMARYLANGID(lang), SUBLANG_NEUTRAL);
 205     if ((result = (HRSRC)find_entry_by_id( resdirptr, lang, root ))) goto found;
 206
 207     /* 3. Neutral language with neutral sublanguage */
 208     lang = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
 209     if ((result = (HRSRC)find_entry_by_id( resdirptr, lang, root ))) goto found;
 210
 211     /* 4. Neutral language with default sublanguage */
 212     lang = MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT);
 213     result = (HRSRC)find_entry_by_id( resdirptr, lang, root );
 214
 215  found:
 216     return result;
 217 }
 218
 219 /**********************************************************************
 220  *          PE_FindResourceW
 221  *
 222  * Load[String]/[Icon]/[Menu]/[etc.] does use FindResourceA/W.
 223  * FindResourceA/W does search in the following order:
 224  * 1. Neutral language with neutral sublanguage
 225  * 2. Neutral language with default sublanguage
 226  * 3. Current locale lang id
 227  * 4. Current locale lang id with neutral sublanguage
 228  * 5. (!) LANG_ENGLISH, SUBLANG_DEFAULT
 229  * 6. Return first in the list
 230  */
 231 HRSRC PE_FindResourceW( HMODULE hmod, LPCWSTR name, LPCWSTR type )
 232 {
 233     const IMAGE_RESOURCE_DIRECTORY *resdirptr = get_resdir(hmod);
 234     const void *root;
 235     HRSRC result;
 236     WORD lang;
 237
 238     if (!resdirptr) return 0;
 239
 240     root = resdirptr;
 241     if (!(resdirptr = find_entry_by_nameW(resdirptr, type, root))) return 0;
 242     if (!(resdirptr = find_entry_by_nameW(resdirptr, name, root))) return 0;
 243
 244     /* 1. Neutral language with neutral sublanguage */
 245     lang = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
 246     if ((result = (HRSRC)find_entry_by_id( resdirptr, lang, root ))) goto found;
 247
 248     /* 2. Neutral language with default sublanguage */
 249     lang = MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT);
 250     if ((result = (HRSRC)find_entry_by_id( resdirptr, lang, root ))) goto found;
 251
 252     /* 3. Current locale lang id */
 253     lang = LANGIDFROMLCID(GetUserDefaultLCID());
 254     if ((result = (HRSRC)find_entry_by_id( resdirptr, lang, root ))) goto found;
 255
 256     /* 4. Current locale lang id with neutral sublanguage */
 257     lang = MAKELANGID(PRIMARYLANGID(lang), SUBLANG_NEUTRAL);
 258     if ((result = (HRSRC)find_entry_by_id( resdirptr, lang, root ))) goto found;
 259
 260     /* 5. (!) LANG_ENGLISH, SUBLANG_DEFAULT */
 261     lang = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
 262     if ((result = (HRSRC)find_entry_by_id( resdirptr, lang, root ))) goto found;
 263
 264     /* 6. Return first in the list */
 265     result = (HRSRC)find_entry_default( resdirptr, root );
 266
 267  found:
 268     return result;
 269 }
 270
 271
 272 /**********************************************************************
 273  *          PE_LoadResource
 274  */
 275 HGLOBAL PE_LoadResource( HMODULE hmod, HRSRC hRsrc )
 276 {
 277     const void *base = get_module_base( hmod );
 278     if (!hRsrc) return 0;
 279     return (HANDLE)((char *)base + ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->OffsetToData);
 280 }
 281
 282
 283 /**********************************************************************
 284  *          PE_SizeofResource
 285  */
 286 DWORD PE_SizeofResource( HRSRC hRsrc )
 287 {
 288     if (!hRsrc) return 0;
 289     return ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->Size;
 290 }
 291
 292
 293 /**********************************************************************
 294  *      EnumResourceTypesA      (KERNEL32.@)
 295  */
 296 BOOL WINAPI EnumResourceTypesA( HMODULE hmod, ENUMRESTYPEPROCA lpfun, LONG lparam)
 297 {
 298     int         i;
 299     const IMAGE_RESOURCE_DIRECTORY *resdir = get_resdir(hmod);
 300     const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 301     BOOL        ret;
 302
 303     if (!resdir) return FALSE;
 304
 305     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)(resdir + 1);
 306     ret = FALSE;
 307     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
 308         LPSTR type;
 309
 310         if (et[i].u1.s1.NameIsString)
 311         {
 312             PIMAGE_RESOURCE_DIR_STRING_U pResString = (PIMAGE_RESOURCE_DIR_STRING_U) ((LPBYTE) resdir + et[i].u1.s1.NameOffset);
 313             DWORD len = WideCharToMultiByte( CP_ACP, 0, pResString->NameString, pResString->Length,
 314                                              NULL, 0, NULL, NULL);
 315             if (!(type = HeapAlloc(GetProcessHeap(), 0, len + 1)))
 316                 return FALSE;
 317             WideCharToMultiByte( CP_ACP, 0, pResString->NameString, pResString->Length,
 318                                  type, len, NULL, NULL);
 319             type[len] = '\0';
 320             ret = lpfun(hmod,type,lparam);
 321             HeapFree(GetProcessHeap(), 0, type);
 322         }
 323         else
 324         {
 325             type = (LPSTR)(int)et[i].u1.s2.Id;
 326             ret = lpfun(hmod,type,lparam);
 327         }
 328         if (!ret)
 329                 break;
 330     }
 331     return ret;
 332 }
 333
 334
 335 /**********************************************************************
 336  *      EnumResourceTypesW      (KERNEL32.@)
 337  */
 338 BOOL WINAPI EnumResourceTypesW( HMODULE hmod, ENUMRESTYPEPROCW lpfun, LONG lparam)
 339 {
 340     int         i;
 341     const IMAGE_RESOURCE_DIRECTORY *resdir = get_resdir(hmod);
 342     const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 343     BOOL        ret;
 344
 345     if (!resdir) return FALSE;
 346
 347     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)(resdir + 1);
 348     ret = FALSE;
 349     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
 350         LPWSTR  type;
 351
 352         if (et[i].u1.s1.NameIsString)
 353         {
 354             PIMAGE_RESOURCE_DIR_STRING_U pResString = (PIMAGE_RESOURCE_DIR_STRING_U) ((LPBYTE) resdir + et[i].u1.s1.NameOffset);
 355             if (!(type = HeapAlloc(GetProcessHeap(), 0, (pResString->Length+1) * sizeof (WCHAR))))
 356                 return FALSE;
 357             memcpy(type, pResString->NameString, pResString->Length * sizeof (WCHAR));
 358             type[pResString->Length] = '\0';
 359             ret = lpfun(hmod,type,lparam);
 360             HeapFree(GetProcessHeap(), 0, type);
 361         }
 362         else
 363         {
 364             type = (LPWSTR)(int)et[i].u1.s2.Id;
 365             ret = lpfun(hmod,type,lparam);
 366         }
 367         if (!ret)
 368                 break;
 369     }
 370     return ret;
 371 }
 372
 373
 374 /**********************************************************************
 375  *      EnumResourceNamesA      (KERNEL32.@)
 376  */
 377 BOOL WINAPI EnumResourceNamesA( HMODULE hmod, LPCSTR type, ENUMRESNAMEPROCA lpfun, LONG lparam )
 378 {
 379     int         i;
 380     const IMAGE_RESOURCE_DIRECTORY *basedir = get_resdir(hmod);
 381     const IMAGE_RESOURCE_DIRECTORY *resdir;
 382     const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 383     BOOL        ret;
 384
 385     if (!basedir) return FALSE;
 386
 387     if (!(resdir = find_entry_by_nameA( basedir, type, basedir ))) return FALSE;
 388
 389     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)(resdir + 1);
 390     ret = FALSE;
 391     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
 392         LPSTR name;
 393
 394         if (et[i].u1.s1.NameIsString)
 395         {
 396             PIMAGE_RESOURCE_DIR_STRING_U pResString = (PIMAGE_RESOURCE_DIR_STRING_U) ((LPBYTE) basedir + et[i].u1.s1.NameOffset);
 397             DWORD len = WideCharToMultiByte(CP_ACP, 0, pResString->NameString, pResString->Length,
 398                                             NULL, 0, NULL, NULL);
 399             if (!(name = HeapAlloc(GetProcessHeap(), 0, len + 1 )))
 400                 return FALSE;
 401             WideCharToMultiByte( CP_ACP, 0, pResString->NameString, pResString->Length,
 402                                  name, len, NULL, NULL );
 403             name[len] = '\0';
 404             ret = lpfun(hmod,type,name,lparam);
 405             HeapFree( GetProcessHeap(), 0, name );
 406         }
 407         else
 408         {
 409             name = (LPSTR)(int)et[i].u1.s2.Id;
 410             ret = lpfun(hmod,type,name,lparam);
 411         }
 412         if (!ret)
 413                 break;
 414     }
 415     return ret;
 416 }
 417
 418
 419 /**********************************************************************
 420  *      EnumResourceNamesW      (KERNEL32.@)
 421  */
 422 BOOL WINAPI EnumResourceNamesW( HMODULE hmod, LPCWSTR type, ENUMRESNAMEPROCW lpfun, LONG lparam )
 423 {
 424     int         i;
 425     const IMAGE_RESOURCE_DIRECTORY *basedir = get_resdir(hmod);
 426     const IMAGE_RESOURCE_DIRECTORY *resdir;
 427     const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 428     BOOL        ret;
 429
 430     if (!basedir) return FALSE;
 431
 432     if (!(resdir = find_entry_by_nameW( basedir, type, basedir ))) return FALSE;
 433
 434     et = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(resdir + 1);
 435     ret = FALSE;
 436     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
 437         LPWSTR name;
 438
 439         if (et[i].u1.s1.NameIsString)
 440         {
 441             PIMAGE_RESOURCE_DIR_STRING_U pResString = (PIMAGE_RESOURCE_DIR_STRING_U) ((LPBYTE) basedir + et[i].u1.s1.NameOffset);
 442             if (!(name = HeapAlloc(GetProcessHeap(), 0, (pResString->Length + 1) * sizeof (WCHAR))))
 443                 return FALSE;
 444             memcpy(name, pResString->NameString, pResString->Length * sizeof (WCHAR));
 445             name[pResString->Length] = '\0';
 446             ret = lpfun(hmod,type,name,lparam);
 447             HeapFree(GetProcessHeap(), 0, name);
 448         }
 449         else
 450         {
 451             name = (LPWSTR)(int)et[i].u1.s2.Id;
 452             ret = lpfun(hmod,type,name,lparam);
 453         }
 454         if (!ret)
 455                 break;
 456     }
 457     return ret;
 458 }
 459
 460
 461 /**********************************************************************
 462  *      EnumResourceLanguagesA  (KERNEL32.@)
 463  */
 464 BOOL WINAPI EnumResourceLanguagesA( HMODULE hmod, LPCSTR type, LPCSTR name,
 465                                     ENUMRESLANGPROCA lpfun, LONG lparam )
 466 {
 467     int         i;
 468     const IMAGE_RESOURCE_DIRECTORY *basedir = get_resdir(hmod);
 469     const IMAGE_RESOURCE_DIRECTORY *resdir;
 470     const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 471     BOOL        ret;
 472
 473     if (!basedir) return FALSE;
 474     if (!(resdir = find_entry_by_nameA( basedir, type, basedir ))) return FALSE;
 475     if (!(resdir = find_entry_by_nameA( resdir, name, basedir ))) return FALSE;
 476
 477     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)(resdir + 1);
 478     ret = FALSE;
 479     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
 480         /* languages are just ids... I hope */
 481         ret = lpfun(hmod,type,name,et[i].u1.s2.Id,lparam);
 482         if (!ret)
 483                 break;
 484     }
 485     return ret;
 486 }
 487
 488
 489 /**********************************************************************
 490  *      EnumResourceLanguagesW  (KERNEL32.@)
 491  */
 492 BOOL WINAPI EnumResourceLanguagesW( HMODULE hmod, LPCWSTR type, LPCWSTR name,
 493                                     ENUMRESLANGPROCW lpfun, LONG lparam )
 494 {
 495     int         i;
 496     const IMAGE_RESOURCE_DIRECTORY *basedir = get_resdir(hmod);
 497     const IMAGE_RESOURCE_DIRECTORY *resdir;
 498     const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 499     BOOL        ret;
 500
 501     if (!basedir) return FALSE;
 502
 503     if (!(resdir = find_entry_by_nameW( basedir, type, basedir ))) return FALSE;
 504     if (!(resdir = find_entry_by_nameW( resdir, name, basedir ))) return FALSE;
 505
 506     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)(resdir + 1);
 507     ret = FALSE;
 508     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
 509         ret = lpfun(hmod,type,name,et[i].u1.s2.Id,lparam);
 510         if (!ret)
 511                 break;
 512     }
 513     return ret;
 514 }