Remove vlc-config
[vlc.git] / libs / loader / pe_resource.c
1 /*
2  * PE (Portable Execute) File Resources
3  * $Id$
4  *
5  * Copyright 1995 Thomas Sandford
6  * Copyright 1996 Martin von Loewis
7  *
8  * Based on the Win16 resource handling code in loader/resource.c
9  * Copyright 1993 Robert J. Amstadt
10  * Copyright 1995 Alexandre Julliard
11  * Copyright 1997 Marcus Meissner
12  *
13  * Modified for use with MPlayer, detailed CVS changelog at
14  * http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/
15  *
16  * File now distributed as part of VLC media player with no modifications.
17  *
18  * This program is free software; you can redistribute it and/or modify
19  * it under the terms of the GNU General Public License as published by
20  * the Free Software Foundation; either version 2 of the License, or
21  * (at your option) any later version.
22  *
23  * This program is distributed in the hope that it will be useful,
24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
26  * GNU General Public License for more details.
27  *
28  * You should have received a copy of the GNU General Public License
29  * along with this program; if not, write to the Free Software
30  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
31  */
32 #include "config.h"
33
34 #include <stdlib.h>
35 #include <sys/types.h>
36 #include "wine/winestring.h"
37 #include "wine/windef.h"
38 #include "wine/pe_image.h"
39 #include "wine/module.h"
40 #include "wine/heap.h"
41 //#include "task.h"
42 //#include "process.h"
43 //#include "stackframe.h"
44 #include "wine/debugtools.h"
45 #include "ext.h"
46
47 /**********************************************************************
48  *  HMODULE32toPE_MODREF 
49  *
50  * small helper function to get a PE_MODREF from a passed HMODULE32
51  */
52 static PE_MODREF*
53 HMODULE32toPE_MODREF(HMODULE hmod) {
54         WINE_MODREF     *wm;
55
56         wm = MODULE32_LookupHMODULE( hmod );
57         if (!wm || wm->type!=MODULE32_PE)
58                 return NULL;
59         return &(wm->binfmt.pe);
60 }
61
62 /**********************************************************************
63  *          GetResDirEntryW
64  *
65  *      Helper function - goes down one level of PE resource tree
66  *
67  */
68 PIMAGE_RESOURCE_DIRECTORY GetResDirEntryW(PIMAGE_RESOURCE_DIRECTORY resdirptr,
69                                            LPCWSTR name,DWORD root,
70                                            WIN_BOOL allowdefault)
71 {
72     int entrynum;
73     PIMAGE_RESOURCE_DIRECTORY_ENTRY entryTable;
74     int namelen;
75
76     if (HIWORD(name)) {
77         if (name[0]=='#') {
78                 char    buf[10];
79
80                 lstrcpynWtoA(buf,name+1,10);
81                 return GetResDirEntryW(resdirptr,(LPCWSTR)atoi(buf),root,allowdefault);
82         }
83         entryTable = (PIMAGE_RESOURCE_DIRECTORY_ENTRY) (
84                         (BYTE *) resdirptr + 
85                         sizeof(IMAGE_RESOURCE_DIRECTORY));
86         namelen = lstrlenW(name);
87         for (entrynum = 0; entrynum < resdirptr->NumberOfNamedEntries; entrynum++)
88         {
89                 PIMAGE_RESOURCE_DIR_STRING_U str =
90                 (PIMAGE_RESOURCE_DIR_STRING_U) (root + 
91                         entryTable[entrynum].u1.s.NameOffset);
92                 if(namelen != str->Length)
93                         continue;
94                 if(wcsnicmp(name,str->NameString,str->Length)==0)
95                         return (PIMAGE_RESOURCE_DIRECTORY) (
96                                 root +
97                                 entryTable[entrynum].u2.s.OffsetToDirectory);
98         }
99         return NULL;
100     } else {
101         entryTable = (PIMAGE_RESOURCE_DIRECTORY_ENTRY) (
102                         (BYTE *) resdirptr + 
103                         sizeof(IMAGE_RESOURCE_DIRECTORY) +
104                         resdirptr->NumberOfNamedEntries * sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
105         for (entrynum = 0; entrynum < resdirptr->NumberOfIdEntries; entrynum++)
106             if ((DWORD)entryTable[entrynum].u1.Name == (DWORD)name)
107                 return (PIMAGE_RESOURCE_DIRECTORY) (
108                         root +
109                         entryTable[entrynum].u2.s.OffsetToDirectory);
110         /* just use first entry if no default can be found */
111         if (allowdefault && !name && resdirptr->NumberOfIdEntries)
112                 return (PIMAGE_RESOURCE_DIRECTORY) (
113                         root +
114                         entryTable[0].u2.s.OffsetToDirectory);
115         return NULL;
116     }
117 }
118
119 /**********************************************************************
120  *          GetResDirEntryA
121  */
122 PIMAGE_RESOURCE_DIRECTORY GetResDirEntryA( PIMAGE_RESOURCE_DIRECTORY resdirptr,
123                                            LPCSTR name, DWORD root,
124                                            WIN_BOOL allowdefault )
125 {
126     PIMAGE_RESOURCE_DIRECTORY retv;
127     LPWSTR nameW = HIWORD(name)? HEAP_strdupAtoW( GetProcessHeap(), 0, name ) 
128                                : (LPWSTR)name;
129
130     retv = GetResDirEntryW( resdirptr, nameW, root, allowdefault );
131
132     if ( HIWORD(name) ) HeapFree( GetProcessHeap(), 0, nameW );
133
134     return retv;
135 }
136
137 /**********************************************************************
138  *          PE_FindResourceEx32W
139  */
140 HANDLE PE_FindResourceExW(
141         WINE_MODREF *wm,LPCWSTR name,LPCWSTR type,WORD lang
142 ) {
143     PIMAGE_RESOURCE_DIRECTORY resdirptr;
144     DWORD root;
145     HANDLE result;
146     PE_MODREF   *pem = &(wm->binfmt.pe);
147
148     if (!pem || !pem->pe_resource)
149         return 0;
150
151     resdirptr = pem->pe_resource;
152     root = (DWORD) resdirptr;
153     if ((resdirptr = GetResDirEntryW(resdirptr, type, root, FALSE)) == NULL)
154         return 0;
155     if ((resdirptr = GetResDirEntryW(resdirptr, name, root, FALSE)) == NULL)
156         return 0;
157     result = (HANDLE)GetResDirEntryW(resdirptr, (LPCWSTR)(UINT)lang, root, FALSE);
158         /* Try LANG_NEUTRAL, too */
159     if(!result)
160         return (HANDLE)GetResDirEntryW(resdirptr, (LPCWSTR)0, root, TRUE);
161     return result;
162 }
163
164
165 /**********************************************************************
166  *          PE_LoadResource32
167  */
168 HANDLE PE_LoadResource( WINE_MODREF *wm, HANDLE hRsrc )
169 {
170     if (!hRsrc || !wm || wm->type!=MODULE32_PE)
171         return 0;
172     return (HANDLE) (wm->module + ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->OffsetToData);
173 }
174
175
176 /**********************************************************************
177  *          PE_SizeofResource32
178  */
179 DWORD PE_SizeofResource( HINSTANCE hModule, HANDLE hRsrc )
180 {
181     /* we don't need hModule */
182     if (!hRsrc)
183          return 0;
184     return ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->Size;
185 }
186
187 /**********************************************************************
188  *          PE_EnumResourceTypes32A
189  */
190 WIN_BOOL
191 PE_EnumResourceTypesA(HMODULE hmod,ENUMRESTYPEPROCA lpfun,LONG lparam) {
192     PE_MODREF   *pem = HMODULE32toPE_MODREF(hmod);
193     int         i;
194     PIMAGE_RESOURCE_DIRECTORY           resdir;
195     PIMAGE_RESOURCE_DIRECTORY_ENTRY     et;
196     WIN_BOOL    ret;
197     HANDLE      heap = GetProcessHeap();        
198
199     if (!pem || !pem->pe_resource)
200         return FALSE;
201
202     resdir = (PIMAGE_RESOURCE_DIRECTORY)pem->pe_resource;
203     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
204     ret = FALSE;
205     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
206         LPSTR   name;
207
208         if (et[i].u1.s.NameIsString)
209                 name = HEAP_strdupWtoA(heap,0,(LPWSTR)((LPBYTE)pem->pe_resource+et[i].u1.s.NameOffset));
210         else
211                 name = (LPSTR)(int)et[i].u1.Id;
212         ret = lpfun(hmod,name,lparam);
213         if (HIWORD(name))
214                 HeapFree(heap,0,name);
215         if (!ret)
216                 break;
217     }
218     return ret;
219 }
220
221 /**********************************************************************
222  *          PE_EnumResourceTypes32W
223  */
224 WIN_BOOL
225 PE_EnumResourceTypesW(HMODULE hmod,ENUMRESTYPEPROCW lpfun,LONG lparam) {
226     PE_MODREF   *pem = HMODULE32toPE_MODREF(hmod);
227     int         i;
228     PIMAGE_RESOURCE_DIRECTORY           resdir;
229     PIMAGE_RESOURCE_DIRECTORY_ENTRY     et;
230     WIN_BOOL    ret;
231
232     if (!pem || !pem->pe_resource)
233         return FALSE;
234
235     resdir = (PIMAGE_RESOURCE_DIRECTORY)pem->pe_resource;
236     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
237     ret = FALSE;
238     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
239         LPWSTR  type;
240         if (et[i].u1.s.NameIsString)
241                 type = (LPWSTR)((LPBYTE)pem->pe_resource+et[i].u1.s.NameOffset);
242         else
243                 type = (LPWSTR)(int)et[i].u1.Id;
244
245         ret = lpfun(hmod,type,lparam);
246         if (!ret)
247                 break;
248     }
249     return ret;
250 }
251
252 /**********************************************************************
253  *          PE_EnumResourceNames32A
254  */
255 WIN_BOOL
256 PE_EnumResourceNamesA(
257         HMODULE hmod,LPCSTR type,ENUMRESNAMEPROCA lpfun,LONG lparam
258 ) {
259     PE_MODREF   *pem = HMODULE32toPE_MODREF(hmod);
260     int         i;
261     PIMAGE_RESOURCE_DIRECTORY           resdir;
262     PIMAGE_RESOURCE_DIRECTORY_ENTRY     et;
263     WIN_BOOL    ret;
264     HANDLE      heap = GetProcessHeap();        
265     LPWSTR      typeW;
266
267     if (!pem || !pem->pe_resource)
268         return FALSE;
269     resdir = (PIMAGE_RESOURCE_DIRECTORY)pem->pe_resource;
270     if (HIWORD(type))
271         typeW = HEAP_strdupAtoW(heap,0,type);
272     else
273         typeW = (LPWSTR)type;
274     resdir = GetResDirEntryW(resdir,typeW,(DWORD)pem->pe_resource,FALSE);
275     if (HIWORD(typeW))
276         HeapFree(heap,0,typeW);
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         LPSTR   name;
283
284         if (et[i].u1.s.NameIsString)
285             name = HEAP_strdupWtoA(heap,0,(LPWSTR)((LPBYTE)pem->pe_resource+et[i].u1.s.NameOffset));
286         else
287             name = (LPSTR)(int)et[i].u1.Id;
288         ret = lpfun(hmod,type,name,lparam);
289         if (HIWORD(name)) HeapFree(heap,0,name);
290         if (!ret)
291                 break;
292     }
293     return ret;
294 }
295
296 /**********************************************************************
297  *          PE_EnumResourceNames32W
298  */
299 WIN_BOOL
300 PE_EnumResourceNamesW(
301         HMODULE hmod,LPCWSTR type,ENUMRESNAMEPROCW lpfun,LONG lparam
302 ) {
303     PE_MODREF   *pem = HMODULE32toPE_MODREF(hmod);
304     int         i;
305     PIMAGE_RESOURCE_DIRECTORY           resdir;
306     PIMAGE_RESOURCE_DIRECTORY_ENTRY     et;
307     WIN_BOOL    ret;
308
309     if (!pem || !pem->pe_resource)
310         return FALSE;
311
312     resdir = (PIMAGE_RESOURCE_DIRECTORY)pem->pe_resource;
313     resdir = GetResDirEntryW(resdir,type,(DWORD)pem->pe_resource,FALSE);
314     if (!resdir)
315         return FALSE;
316     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
317     ret = FALSE;
318     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
319         LPWSTR  name;
320         if (et[i].u1.s.NameIsString)
321                 name = (LPWSTR)((LPBYTE)pem->pe_resource+et[i].u1.s.NameOffset);
322         else
323                 name = (LPWSTR)(int)et[i].u1.Id;
324         ret = lpfun(hmod,type,name,lparam);
325         if (!ret)
326                 break;
327     }
328     return ret;
329 }
330
331 /**********************************************************************
332  *          PE_EnumResourceNames32A
333  */
334 WIN_BOOL
335 PE_EnumResourceLanguagesA(
336         HMODULE hmod,LPCSTR name,LPCSTR type,ENUMRESLANGPROCA lpfun,
337         LONG lparam
338 ) {
339     PE_MODREF   *pem = HMODULE32toPE_MODREF(hmod);
340     int         i;
341     PIMAGE_RESOURCE_DIRECTORY           resdir;
342     PIMAGE_RESOURCE_DIRECTORY_ENTRY     et;
343     WIN_BOOL    ret;
344     HANDLE      heap = GetProcessHeap();        
345     LPWSTR      nameW,typeW;
346
347     if (!pem || !pem->pe_resource)
348         return FALSE;
349
350     resdir = (PIMAGE_RESOURCE_DIRECTORY)pem->pe_resource;
351     if (HIWORD(name))
352         nameW = HEAP_strdupAtoW(heap,0,name);
353     else
354         nameW = (LPWSTR)name;
355     resdir = GetResDirEntryW(resdir,nameW,(DWORD)pem->pe_resource,FALSE);
356     if (HIWORD(nameW))
357         HeapFree(heap,0,nameW);
358     if (!resdir)
359         return FALSE;
360     if (HIWORD(type))
361         typeW = HEAP_strdupAtoW(heap,0,type);
362     else
363         typeW = (LPWSTR)type;
364     resdir = GetResDirEntryW(resdir,typeW,(DWORD)pem->pe_resource,FALSE);
365     if (HIWORD(typeW))
366         HeapFree(heap,0,typeW);
367     if (!resdir)
368         return FALSE;
369     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
370     ret = FALSE;
371     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
372         /* languages are just ids... I hopem */
373         ret = lpfun(hmod,name,type,et[i].u1.Id,lparam);
374         if (!ret)
375                 break;
376     }
377     return ret;
378 }
379
380 /**********************************************************************
381  *          PE_EnumResourceLanguages32W
382  */
383 WIN_BOOL
384 PE_EnumResourceLanguagesW(
385         HMODULE hmod,LPCWSTR name,LPCWSTR type,ENUMRESLANGPROCW lpfun,
386         LONG lparam
387 ) {
388     PE_MODREF   *pem = HMODULE32toPE_MODREF(hmod);
389     int         i;
390     PIMAGE_RESOURCE_DIRECTORY           resdir;
391     PIMAGE_RESOURCE_DIRECTORY_ENTRY     et;
392     WIN_BOOL    ret;
393
394     if (!pem || !pem->pe_resource)
395         return FALSE;
396
397     resdir = (PIMAGE_RESOURCE_DIRECTORY)pem->pe_resource;
398     resdir = GetResDirEntryW(resdir,name,(DWORD)pem->pe_resource,FALSE);
399     if (!resdir)
400         return FALSE;
401     resdir = GetResDirEntryW(resdir,type,(DWORD)pem->pe_resource,FALSE);
402     if (!resdir)
403         return FALSE;
404     et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
405     ret = FALSE;
406     for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
407         ret = lpfun(hmod,name,type,et[i].u1.Id,lparam);
408         if (!ret)
409                 break;
410     }
411     return ret;
412 }