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 <stdlib.h>
  14 #include <sys/types.h>
  15 #include "wine/winestring.h"
  16 #include "wine/unicode.h"
  17 #include "windef.h"
  18 #include "winnls.h"
  19 #include "module.h"
  20 #include "heap.h"
  21 #include "task.h"
  22 #include "process.h"
  23 #include "stackframe.h"
  24 #include "neexe.h"
  25 #include "debugtools.h"
  26
  27 /**********************************************************************
  28  *  get_resdir
  29  *
  30  * Get the resource directory of a PE module
  31  */
  32 static IMAGE_RESOURCE_DIRECTORY* get_resdir( HMODULE hmod )
  33 {
  34     IMAGE_DATA_DIRECTORY *dir;
  35     IMAGE_RESOURCE_DIRECTORY *ret = NULL;
  36
  37     if (!hmod) hmod = GetModuleHandleA( NULL );
  38     dir = &PE_HEADER(hmod)->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE];
  39     if (dir->Size && dir->VirtualAddress)
  40         ret = (IMAGE_RESOURCE_DIRECTORY *)((char *)hmod + dir->VirtualAddress);
  41     return ret;
  42 }
  43
  44
  45 /**********************************************************************
  46  *          GetResDirEntryW
  47  *
  48  *      Helper function - goes down one level of PE resource tree
  49  *
  50  */
  51 PIMAGE_RESOURCE_DIRECTORY GetResDirEntryW(PIMAGE_RESOURCE_DIRECTORY resdirptr,
  52                                            LPCWSTR name,DWORD root,
  53                                            BOOL allowdefault)
  54 {
  55     int entrynum;
  56     PIMAGE_RESOURCE_DIRECTORY_ENTRY entryTable;
  57     int namelen;
  58
  59     if (HIWORD(name)) {
  60         if (name[0]=='#') {
  61                 char    buf[10];
  62                 if (!WideCharToMultiByte( CP_ACP, 0, name+1, -1, buf, sizeof(buf), NULL, NULL ))
  63                     return NULL;
  64                 return GetResDirEntryW(resdirptr,(LPCWSTR)atoi(buf),root,allowdefault);
  65         }
  66         entryTable = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(resdirptr + 1);
  67         namelen = strlenW(name);
  68         for (entrynum = 0; entrynum < resdirptr->NumberOfNamedEntries; entrynum++)
  69         {
  70                 PIMAGE_RESOURCE_DIR_STRING_U str =
  71                 (PIMAGE_RESOURCE_DIR_STRING_U) (root +
  72                         entryTable[entrynum].u1.s.NameOffset);
  73                 if(namelen != str->Length)
  74                         continue;
  75                 if(strncmpiW(name,str->NameString,str->Length)==0)
  76                         return (PIMAGE_RESOURCE_DIRECTORY) (
  77                                 root +
  78                                 entryTable[entrynum].u2.s.OffsetToDirectory);
  79         }
  80         return NULL;
  81     } else {
  82         entryTable = (PIMAGE_RESOURCE_DIRECTORY_ENTRY) (
  83                         (BYTE *) resdirptr +
  84                         sizeof(IMAGE_RESOURCE_DIRECTORY) +
  85                         resdirptr->NumberOfNamedEntries * sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
  86         for (entrynum = 0; entrynum < resdirptr->NumberOfIdEntries; entrynum++)
  87             if ((DWORD)entryTable[entrynum].u1.Name == (DWORD)name)
  88                 return (PIMAGE_RESOURCE_DIRECTORY) (
  89                         root +
  90                         entryTable[entrynum].u2.s.OffsetToDirectory);
  91         /* just use first entry if no default can be found */
  92         if (allowdefault && !name && resdirptr->NumberOfIdEntries)
  93                 return (PIMAGE_RESOURCE_DIRECTORY) (
  94                         root +
  95                         entryTable[0].u2.s.OffsetToDirectory);
  96         return NULL;
  97     }
  98 }
  99
 100 /**********************************************************************
 101  *          GetResDirEntryA
 102  */
 103 PIMAGE_RESOURCE_DIRECTORY GetResDirEntryA( PIMAGE_RESOURCE_DIRECTORY resdirptr,
 104                                            LPCSTR name, DWORD root,
 105                                            BOOL allowdefault )
 106 {
 107     PIMAGE_RESOURCE_DIRECTORY retv;
 108     LPWSTR nameW = HIWORD(name)? HEAP_strdupAtoW( GetProcessHeap(), 0, name )
 109                                : (LPWSTR)name;
 110
 111     retv = GetResDirEntryW( resdirptr, nameW, root, allowdefault );
 112
 113     if ( HIWORD(name) ) HeapFree( GetProcessHeap(), 0, nameW );
 114
 115     return retv;
 116 }
 117
 118 /**********************************************************************
 119  *          PE_FindResourceExW
 120  *
 121  * FindResourceExA/W does search in the following order:
 122  * 1. Exact specified language
 123  * 2. Language with neutral sublanguage
 124  * 3. Neutral language with neutral sublanguage
 125  * 4. Neutral language with default sublanguage
 126  */
 127 HRSRC PE_FindResourceExW( HMODULE hmod, LPCWSTR name, LPCWSTR type, WORD lang )
 128 {
 129     PIMAGE_RESOURCE_DIRECTORY resdirptr = get_resdir(hmod);
 130     DWORD root;
 131     HRSRC result;
 132
 133     if (!resdirptr) return 0;
 134
 135     root = (DWORD) resdirptr;
 136     if ((resdirptr = GetResDirEntryW(resdirptr, type, root, FALSE)) == NULL)
 137         return 0;
 138     if ((resdirptr = GetResDirEntryW(resdirptr, name, root, FALSE)) == NULL)
 139         return 0;
 140
 141     /* 1. Exact specified language */
 142     result = (HANDLE)GetResDirEntryW(resdirptr, (LPCWSTR)(UINT)lang, root, FALSE);
 143
 144     if (!result)
 145     {
 146         /* 2. Language with neutral sublanguage */
 147         lang = MAKELANGID(PRIMARYLANGID(lang), SUBLANG_NEUTRAL);
 148         result = (HANDLE)GetResDirEntryW(resdirptr, (LPCWSTR)(UINT)lang, root, FALSE);
 149     }
 150
 151     if (!result)
 152     {
 153         /* 3. Neutral language with neutral sublanguage */
 154         lang = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
 155         result = (HANDLE)GetResDirEntryW(resdirptr, (LPCWSTR)(UINT)lang, root, FALSE);
 156     }
 157
 158     if (!result)
 159     {
 160         /* 4. Neutral language with default sublanguage */
 161         lang = MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT);
 162         result = (HANDLE)GetResDirEntryW(resdirptr, (LPCWSTR)(UINT)lang, root, FALSE);
 163     }
 164
 165     return result;
 166 }
 167
 168 /**********************************************************************
 169  *          PE_FindResourceW
 170  *
 171  * Load[String]/[Icon]/[Menu]/[etc.] does use FindResourceA/W.
 172  * FindResourceA/W does search in the following order:
 173  * 1. Neutral language with neutral sublanguage
 174  * 2. Neutral language with default sublanguage
 175  * 3. Current locale lang id
 176  * 4. Current locale lang id with neutral sublanguage
 177  * 5. (!) LANG_ENGLISH, SUBLANG_DEFAULT
 178  * 6. Return first in the list
 179  */
 180 HRSRC PE_FindResourceW( HMODULE hmod, LPCWSTR name, LPCWSTR type )
 181 {
 182     PIMAGE_RESOURCE_DIRECTORY resdirptr = get_resdir(hmod);
 183     DWORD root;
 184     HRSRC result;
 185     WORD lang;
 186
 187     if (!resdirptr) return 0;
 188
 189     root = (DWORD) resdirptr;
 190     if ((resdirptr = GetResDirEntryW(resdirptr, type, root, FALSE)) == NULL)
 191         return 0;
 192     if ((resdirptr = GetResDirEntryW(resdirptr, name, root, FALSE)) == NULL)
 193         return 0;
 194
 195     /* 1. Neutral language with neutral sublanguage */
 196     lang = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
 197     result = (HANDLE)GetResDirEntryW(resdirptr, (LPCWSTR)(UINT)lang, root, FALSE);
 198
 199     if (!result)
 200     {
 201         /* 2. Neutral language with default sublanguage */
 202         lang = MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT);
 203         result = (HANDLE)GetResDirEntryW(resdirptr, (LPCWSTR)(UINT)lang, root, FALSE);
 204     }
 205
 206     if (!result)
 207     {
 208         /* 3. Current locale lang id */
 209         lang = LANGIDFROMLCID(GetUserDefaultLCID());
 210         result = (HANDLE)GetResDirEntryW(resdirptr, (LPCWSTR)(UINT)lang, root, FALSE);
 211     }
 212
 213     if (!result)
 214     {
 215         /* 4. Current locale lang id with neutral sublanguage */
 216         lang = MAKELANGID(PRIMARYLANGID(lang), SUBLANG_NEUTRAL);
 217         result = (HANDLE)GetResDirEntryW(resdirptr, (LPCWSTR)(UINT)lang, root, FALSE);
 218     }
 219
 220     if (!result)
 221     {
 222         /* 5. (!) LANG_ENGLISH, SUBLANG_DEFAULT */
 223         lang = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
 224         result = (HANDLE)GetResDirEntryW(resdirptr, (LPCWSTR)(UINT)lang, root, FALSE);
 225     }
 226
 227     if (!result)
 228     {
 229         /* 6. Return first in the list */
 230         result = (HANDLE)GetResDirEntryW(resdirptr, (LPCWSTR)(UINT)0, root, TRUE);
 231     }
 232
 233     return result;
 234 }
 235
 236
 237 /**********************************************************************
 238  *          PE_LoadResource
 239  */
 240 HANDLE PE_LoadResource( HMODULE hmod, HANDLE hRsrc )
 241 {
 242     if (!hRsrc) return 0;
 243     return (HANDLE)(hmod + ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->OffsetToData);
 244 }
 245
 246
 247 /**********************************************************************
 248  *          PE_SizeofResource
 249  */
 250 DWORD PE_SizeofResource( HANDLE hRsrc )
 251 {
 252     if (!hRsrc) return 0;
 253     return ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->Size;
 254 }
 255
 256
 257 /**********************************************************************
 258  *      EnumResourceTypesA      (KERNEL32.90)
 259  */
 260 BOOL WINAPI EnumResourceTypesA( HMODULE hmod, ENUMRESTYPEPROCA lpfun, LONG lparam)
 261 {
 262     int         i;
 263     PIMAGE_RESOURCE_DIRECTORY resdir = get_resdir(hmod);
 264     PIMAGE_RESOURCE_DIRECTORY_ENTRY     et;
 265     BOOL        ret;
 266     HANDLE      heap = GetProcessHeap();
 267
 268     if (!resdir) return FALSE;
 269
 270     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)(resdir + 1);
 271     ret = FALSE;
 272     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
 273         LPSTR   name;
 274
 275         if (et[i].u1.s.NameIsString)
 276                 name = HEAP_strdupWtoA(heap,0,(LPWSTR)((LPBYTE)resdir + et[i].u1.s.NameOffset));
 277         else
 278                 name = (LPSTR)(int)et[i].u1.Id;
 279         ret = lpfun(hmod,name,lparam);
 280         if (HIWORD(name))
 281                 HeapFree(heap,0,name);
 282         if (!ret)
 283                 break;
 284     }
 285     return ret;
 286 }
 287
 288
 289 /**********************************************************************
 290  *      EnumResourceTypesW      (KERNEL32.91)
 291  */
 292 BOOL WINAPI EnumResourceTypesW( HMODULE hmod, ENUMRESTYPEPROCW lpfun, LONG lparam)
 293 {
 294     int         i;
 295     PIMAGE_RESOURCE_DIRECTORY           resdir = get_resdir(hmod);
 296     PIMAGE_RESOURCE_DIRECTORY_ENTRY     et;
 297     BOOL        ret;
 298
 299     if (!resdir) return FALSE;
 300
 301     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)(resdir + 1);
 302     ret = FALSE;
 303     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
 304         LPWSTR  type;
 305         if (et[i].u1.s.NameIsString)
 306                 type = (LPWSTR)((LPBYTE)resdir + et[i].u1.s.NameOffset);
 307         else
 308                 type = (LPWSTR)(int)et[i].u1.Id;
 309
 310         ret = lpfun(hmod,type,lparam);
 311         if (!ret)
 312                 break;
 313     }
 314     return ret;
 315 }
 316
 317
 318 /**********************************************************************
 319  *      EnumResourceNamesA      (KERNEL32.88)
 320  */
 321 BOOL WINAPI EnumResourceNamesA( HMODULE hmod, LPCSTR type, ENUMRESNAMEPROCA lpfun, LONG lparam )
 322 {
 323     int         i;
 324     PIMAGE_RESOURCE_DIRECTORY           basedir = get_resdir(hmod);
 325     PIMAGE_RESOURCE_DIRECTORY           resdir;
 326     PIMAGE_RESOURCE_DIRECTORY_ENTRY     et;
 327     BOOL        ret;
 328     HANDLE      heap = GetProcessHeap();
 329     LPWSTR      typeW;
 330
 331     if (!basedir) return FALSE;
 332
 333     if (HIWORD(type))
 334         typeW = HEAP_strdupAtoW(heap,0,type);
 335     else
 336         typeW = (LPWSTR)type;
 337     resdir = GetResDirEntryW(basedir,typeW,(DWORD)basedir,FALSE);
 338     if (HIWORD(typeW))
 339         HeapFree(heap,0,typeW);
 340     if (!resdir)
 341         return FALSE;
 342     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)(resdir + 1);
 343     ret = FALSE;
 344     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
 345         LPSTR   name;
 346
 347         if (et[i].u1.s.NameIsString)
 348             name = HEAP_strdupWtoA(heap,0,(LPWSTR)((LPBYTE)basedir + et[i].u1.s.NameOffset));
 349         else
 350             name = (LPSTR)(int)et[i].u1.Id;
 351         ret = lpfun(hmod,type,name,lparam);
 352         if (HIWORD(name)) HeapFree(heap,0,name);
 353         if (!ret)
 354                 break;
 355     }
 356     return ret;
 357 }
 358
 359
 360 /**********************************************************************
 361  *      EnumResourceNamesW      (KERNEL32.89)
 362  */
 363 BOOL WINAPI EnumResourceNamesW( HMODULE hmod, LPCWSTR type, ENUMRESNAMEPROCW lpfun, LONG lparam )
 364 {
 365     int         i;
 366     PIMAGE_RESOURCE_DIRECTORY           basedir = get_resdir(hmod);
 367     PIMAGE_RESOURCE_DIRECTORY           resdir;
 368     PIMAGE_RESOURCE_DIRECTORY_ENTRY     et;
 369     BOOL        ret;
 370
 371     if (!basedir) return FALSE;
 372
 373     resdir = GetResDirEntryW(basedir,type,(DWORD)basedir,FALSE);
 374     if (!resdir)
 375         return FALSE;
 376     et = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(resdir + 1);
 377     ret = FALSE;
 378     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
 379         LPWSTR  name;
 380         if (et[i].u1.s.NameIsString)
 381                 name = (LPWSTR)((LPBYTE)basedir + et[i].u1.s.NameOffset);
 382         else
 383                 name = (LPWSTR)(int)et[i].u1.Id;
 384         ret = lpfun(hmod,type,name,lparam);
 385         if (!ret)
 386                 break;
 387     }
 388     return ret;
 389 }
 390
 391
 392 /**********************************************************************
 393  *      EnumResourceLanguagesA  (KERNEL32.86)
 394  */
 395 BOOL WINAPI EnumResourceLanguagesA( HMODULE hmod, LPCSTR type, LPCSTR name,
 396                                     ENUMRESLANGPROCA lpfun, LONG lparam )
 397 {
 398     int         i;
 399     PIMAGE_RESOURCE_DIRECTORY           basedir = get_resdir(hmod);
 400     PIMAGE_RESOURCE_DIRECTORY           resdir;
 401     PIMAGE_RESOURCE_DIRECTORY_ENTRY     et;
 402     BOOL        ret;
 403     HANDLE      heap = GetProcessHeap();
 404
 405     if (!basedir) return FALSE;
 406
 407     if (HIWORD(type))
 408     {
 409         LPWSTR typeW = HEAP_strdupAtoW(heap,0,type);
 410         resdir = GetResDirEntryW(basedir,typeW,(DWORD)basedir,FALSE);
 411         HeapFree(heap,0,typeW);
 412     }
 413     else resdir = GetResDirEntryW(basedir,(LPWSTR)type,(DWORD)basedir,FALSE);
 414     if (!resdir)
 415         return FALSE;
 416
 417     if (HIWORD(name))
 418     {
 419         LPWSTR nameW = HEAP_strdupAtoW(heap,0,name);
 420         resdir = GetResDirEntryW(resdir,nameW,(DWORD)basedir,FALSE);
 421         HeapFree(heap,0,nameW);
 422     }
 423     else resdir = GetResDirEntryW(resdir,(LPWSTR)name,(DWORD)basedir,FALSE);
 424     if (!resdir)
 425         return FALSE;
 426
 427     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)(resdir + 1);
 428     ret = FALSE;
 429     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
 430         /* languages are just ids... I hope */
 431         ret = lpfun(hmod,type,name,et[i].u1.Id,lparam);
 432         if (!ret)
 433                 break;
 434     }
 435     return ret;
 436 }
 437
 438
 439 /**********************************************************************
 440  *      EnumResourceLanguagesW  (KERNEL32.87)
 441  */
 442 BOOL WINAPI EnumResourceLanguagesW( HMODULE hmod, LPCWSTR type, LPCWSTR name,
 443                                     ENUMRESLANGPROCW lpfun, LONG lparam )
 444 {
 445     int         i;
 446     PIMAGE_RESOURCE_DIRECTORY           basedir = get_resdir(hmod);
 447     PIMAGE_RESOURCE_DIRECTORY           resdir;
 448     PIMAGE_RESOURCE_DIRECTORY_ENTRY     et;
 449     BOOL        ret;
 450
 451     if (!basedir) return FALSE;
 452
 453     resdir = GetResDirEntryW(basedir,type,(DWORD)basedir,FALSE);
 454     if (!resdir)
 455         return FALSE;
 456     resdir = GetResDirEntryW(resdir,name,(DWORD)basedir,FALSE);
 457     if (!resdir)
 458         return FALSE;
 459     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)(resdir + 1);
 460     ret = FALSE;
 461     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
 462         ret = lpfun(hmod,type,name,et[i].u1.Id,lparam);
 463         if (!ret)
 464                 break;
 465     }
 466     return ret;
 467 }