Bugfix: really *do* switch to the initial task's stack.
[wine] / 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 "wintypes.h"
16 #include "windows.h"
17 #include "pe_image.h"
18 #include "module.h"
19 #include "heap.h"
20 #include "task.h"
21 #include "process.h"
22 #include "libres.h"
23 #include "stackframe.h"
24 #include "neexe.h"
25 #include "debug.h"
26
27 /**********************************************************************
28  *  HMODULE32toPE_MODREF 
29  *
30  * small helper function to get a PE_MODREF from a passed HMODULE32
31  */
32 static PE_MODREF*
33 HMODULE32toPE_MODREF(HMODULE32 hmod) {
34         WINE_MODREF     *wm;
35         PDB32           *pdb = PROCESS_Current();
36
37         wm = MODULE32_LookupHMODULE( pdb, hmod );
38         if (!wm || wm->type!=MODULE32_PE)
39                 return NULL;
40         return &(wm->binfmt.pe);
41 }
42
43 /**********************************************************************
44  *          GetResDirEntryW
45  *
46  *      Helper function - goes down one level of PE resource tree
47  *
48  */
49 PIMAGE_RESOURCE_DIRECTORY GetResDirEntryW(PIMAGE_RESOURCE_DIRECTORY resdirptr,
50                                            LPCWSTR name,DWORD root,
51                                            BOOL32 allowdefault)
52 {
53     int entrynum;
54     PIMAGE_RESOURCE_DIRECTORY_ENTRY entryTable;
55     int namelen;
56
57     if (HIWORD(name)) {
58         if (name[0]=='#') {
59                 char    buf[10];
60
61                 lstrcpynWtoA(buf,name+1,10);
62                 return GetResDirEntryW(resdirptr,(LPCWSTR)atoi(buf),root,allowdefault);
63         }
64         entryTable = (PIMAGE_RESOURCE_DIRECTORY_ENTRY) (
65                         (BYTE *) resdirptr + 
66                         sizeof(IMAGE_RESOURCE_DIRECTORY));
67         namelen = lstrlen32W(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(lstrncmpi32W(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  *          PE_FindResourceEx32W
102  */
103 HANDLE32 PE_FindResourceEx32W(
104         WINE_MODREF *wm,LPCWSTR name,LPCWSTR type,WORD lang
105 ) {
106     PIMAGE_RESOURCE_DIRECTORY resdirptr;
107     DWORD root;
108     HANDLE32 result;
109     PE_MODREF   *pem = &(wm->binfmt.pe);
110
111     if (!pem || !pem->pe_resource)
112         return 0;
113
114     resdirptr = pem->pe_resource;
115     root = (DWORD) resdirptr;
116     if ((resdirptr = GetResDirEntryW(resdirptr, type, root, FALSE)) == NULL)
117         return 0;
118     if ((resdirptr = GetResDirEntryW(resdirptr, name, root, FALSE)) == NULL)
119         return 0;
120     result = (HANDLE32)GetResDirEntryW(resdirptr, (LPCWSTR)(UINT32)lang, root, FALSE);
121         /* Try LANG_NEUTRAL, too */
122     if(!result)
123         return (HANDLE32)GetResDirEntryW(resdirptr, (LPCWSTR)0, root, TRUE);
124     return result;
125 }
126
127
128 /**********************************************************************
129  *          PE_LoadResource32
130  */
131 HANDLE32 PE_LoadResource32( WINE_MODREF *wm, HANDLE32 hRsrc )
132 {
133     if (!hRsrc || !wm || wm->type!=MODULE32_PE)
134         return 0;
135     return (HANDLE32) (wm->module + ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->OffsetToData);
136 }
137
138
139 /**********************************************************************
140  *          PE_SizeofResource32
141  */
142 DWORD PE_SizeofResource32( HINSTANCE32 hModule, HANDLE32 hRsrc )
143 {
144     /* we don't need hModule */
145     if (!hRsrc)
146          return 0;
147     return ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->Size;
148 }
149
150 /**********************************************************************
151  *          PE_EnumResourceTypes32A
152  */
153 BOOL32
154 PE_EnumResourceTypes32A(HMODULE32 hmod,ENUMRESTYPEPROC32A lpfun,LONG lparam) {
155     PE_MODREF   *pem = HMODULE32toPE_MODREF(hmod);
156     int         i;
157     PIMAGE_RESOURCE_DIRECTORY           resdir;
158     PIMAGE_RESOURCE_DIRECTORY_ENTRY     et;
159     BOOL32      ret;
160     HANDLE32    heap = GetProcessHeap();        
161
162     if (!pem || !pem->pe_resource)
163         return FALSE;
164
165     resdir = (PIMAGE_RESOURCE_DIRECTORY)pem->pe_resource;
166     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
167     ret = FALSE;
168     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
169         LPSTR   name;
170
171         if (HIWORD(et[i].u1.Name))
172                 name = HEAP_strdupWtoA(heap,0,(LPWSTR)((LPBYTE)pem->pe_resource+et[i].u1.Name));
173         else
174                 name = (LPSTR)et[i].u1.Name;
175         ret = lpfun(hmod,name,lparam);
176         if (HIWORD(name))
177                 HeapFree(heap,0,name);
178         if (!ret)
179                 break;
180     }
181     return ret;
182 }
183
184 /**********************************************************************
185  *          PE_EnumResourceTypes32W
186  */
187 BOOL32
188 PE_EnumResourceTypes32W(HMODULE32 hmod,ENUMRESTYPEPROC32W lpfun,LONG lparam) {
189     PE_MODREF   *pem = HMODULE32toPE_MODREF(hmod);
190     int         i;
191     PIMAGE_RESOURCE_DIRECTORY           resdir;
192     PIMAGE_RESOURCE_DIRECTORY_ENTRY     et;
193     BOOL32      ret;
194
195     if (!pem || !pem->pe_resource)
196         return FALSE;
197
198     resdir = (PIMAGE_RESOURCE_DIRECTORY)pem->pe_resource;
199     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
200     ret = FALSE;
201     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
202         LPWSTR  type;
203         if (HIWORD(et[i].u1.Name))
204                 type = (LPWSTR)((LPBYTE)pem->pe_resource+et[i].u1.Name);
205         else
206                 type = (LPWSTR)et[i].u1.Name;
207
208         ret = lpfun(hmod,type,lparam);
209         if (!ret)
210                 break;
211     }
212     return ret;
213 }
214
215 /**********************************************************************
216  *          PE_EnumResourceNames32A
217  */
218 BOOL32
219 PE_EnumResourceNames32A(
220         HMODULE32 hmod,LPCSTR type,ENUMRESNAMEPROC32A lpfun,LONG lparam
221 ) {
222     PE_MODREF   *pem = HMODULE32toPE_MODREF(hmod);
223     int         i;
224     PIMAGE_RESOURCE_DIRECTORY           resdir;
225     PIMAGE_RESOURCE_DIRECTORY_ENTRY     et;
226     BOOL32      ret;
227     HANDLE32    heap = GetProcessHeap();        
228     LPWSTR      typeW;
229
230     if (!pem || !pem->pe_resource)
231         return FALSE;
232     resdir = (PIMAGE_RESOURCE_DIRECTORY)pem->pe_resource;
233     if (HIWORD(type))
234         typeW = HEAP_strdupAtoW(heap,0,type);
235     else
236         typeW = (LPWSTR)type;
237     resdir = GetResDirEntryW(resdir,typeW,(DWORD)pem->pe_resource,FALSE);
238     if (HIWORD(typeW))
239         HeapFree(heap,0,typeW);
240     if (!resdir)
241         return FALSE;
242     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
243     ret = FALSE;
244     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
245         LPSTR   name;
246
247         if (HIWORD(et[i].u1.Name))
248             name = HEAP_strdupWtoA(heap,0,(LPWSTR)((LPBYTE)pem->pe_resource+et[i].u1.Name));
249         else
250             name = (LPSTR)et[i].u1.Name;
251         ret = lpfun(hmod,type,name,lparam);
252         if (HIWORD(name)) HeapFree(heap,0,name);
253         if (!ret)
254                 break;
255     }
256     return ret;
257 }
258
259 /**********************************************************************
260  *          PE_EnumResourceNames32W
261  */
262 BOOL32
263 PE_EnumResourceNames32W(
264         HMODULE32 hmod,LPCWSTR type,ENUMRESNAMEPROC32W lpfun,LONG lparam
265 ) {
266     PE_MODREF   *pem = HMODULE32toPE_MODREF(hmod);
267     int         i;
268     PIMAGE_RESOURCE_DIRECTORY           resdir;
269     PIMAGE_RESOURCE_DIRECTORY_ENTRY     et;
270     BOOL32      ret;
271
272     if (!pem || !pem->pe_resource)
273         return FALSE;
274
275     resdir = (PIMAGE_RESOURCE_DIRECTORY)pem->pe_resource;
276     resdir = GetResDirEntryW(resdir,type,(DWORD)pem->pe_resource,FALSE);
277     if (!resdir)
278         return FALSE;
279     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
280     ret = FALSE;
281     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
282         LPWSTR  name;
283         if (HIWORD(et[i].u1.Name))
284                 name = (LPWSTR)((LPBYTE)pem->pe_resource+et[i].u1.Name);
285         else
286                 name = (LPWSTR)et[i].u1.Name;
287         ret = lpfun(hmod,type,name,lparam);
288         if (!ret)
289                 break;
290     }
291     return ret;
292 }
293
294 /**********************************************************************
295  *          PE_EnumResourceNames32A
296  */
297 BOOL32
298 PE_EnumResourceLanguages32A(
299         HMODULE32 hmod,LPCSTR name,LPCSTR type,ENUMRESLANGPROC32A lpfun,
300         LONG lparam
301 ) {
302     PE_MODREF   *pem = HMODULE32toPE_MODREF(hmod);
303     int         i;
304     PIMAGE_RESOURCE_DIRECTORY           resdir;
305     PIMAGE_RESOURCE_DIRECTORY_ENTRY     et;
306     BOOL32      ret;
307     HANDLE32    heap = GetProcessHeap();        
308     LPWSTR      nameW,typeW;
309
310     if (!pem || !pem->pe_resource)
311         return FALSE;
312
313     resdir = (PIMAGE_RESOURCE_DIRECTORY)pem->pe_resource;
314     if (HIWORD(name))
315         nameW = HEAP_strdupAtoW(heap,0,name);
316     else
317         nameW = (LPWSTR)name;
318     resdir = GetResDirEntryW(resdir,nameW,(DWORD)pem->pe_resource,FALSE);
319     if (HIWORD(nameW))
320         HeapFree(heap,0,nameW);
321     if (!resdir)
322         return FALSE;
323     if (HIWORD(type))
324         typeW = HEAP_strdupAtoW(heap,0,type);
325     else
326         typeW = (LPWSTR)type;
327     resdir = GetResDirEntryW(resdir,typeW,(DWORD)pem->pe_resource,FALSE);
328     if (HIWORD(typeW))
329         HeapFree(heap,0,typeW);
330     if (!resdir)
331         return FALSE;
332     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
333     ret = FALSE;
334     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
335         /* languages are just ids... I hopem */
336         ret = lpfun(hmod,name,type,et[i].u1.Id,lparam);
337         if (!ret)
338                 break;
339     }
340     return ret;
341 }
342
343 /**********************************************************************
344  *          PE_EnumResourceLanguages32W
345  */
346 BOOL32
347 PE_EnumResourceLanguages32W(
348         HMODULE32 hmod,LPCWSTR name,LPCWSTR type,ENUMRESLANGPROC32W lpfun,
349         LONG lparam
350 ) {
351     PE_MODREF   *pem = HMODULE32toPE_MODREF(hmod);
352     int         i;
353     PIMAGE_RESOURCE_DIRECTORY           resdir;
354     PIMAGE_RESOURCE_DIRECTORY_ENTRY     et;
355     BOOL32      ret;
356
357     if (!pem || !pem->pe_resource)
358         return FALSE;
359
360     resdir = (PIMAGE_RESOURCE_DIRECTORY)pem->pe_resource;
361     resdir = GetResDirEntryW(resdir,name,(DWORD)pem->pe_resource,FALSE);
362     if (!resdir)
363         return FALSE;
364     resdir = GetResDirEntryW(resdir,type,(DWORD)pem->pe_resource,FALSE);
365     if (!resdir)
366         return FALSE;
367     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
368     ret = FALSE;
369     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
370         ret = lpfun(hmod,name,type,et[i].u1.Id,lparam);
371         if (!ret)
372                 break;
373     }
374     return ret;
375 }