]> git.sesse.net Git - vlc/blob - loader/resource.c
* mozilla/vlcplugin.h: compilation fix.
[vlc] / loader / resource.c
1 /*
2  * Resources
3  *
4  * Copyright 1993 Robert J. Amstadt
5  * Copyright 1995 Alexandre Julliard
6  *
7  * Modified for use with MPlayer, detailed CVS changelog at
8  * http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/
9  * $Id$
10  *
11  */
12 #include "config.h"
13
14 #include <assert.h>
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <string.h>
18 #include <sys/types.h>
19 #include <sys/stat.h>
20 #include <fcntl.h>
21 #include <unistd.h>
22
23 #include "wine/winbase.h"
24 #include "wine/windef.h"
25 #include "wine/winuser.h"
26 #include "wine/heap.h"
27 #include "wine/module.h"
28 #include "wine/debugtools.h"
29 #include "wine/winerror.h"
30 #include "loader.h"
31
32 #define CP_ACP                                  0
33
34 WORD WINE_LanguageId=0x409;//english
35
36 #define HRSRC_MAP_BLOCKSIZE 16
37
38 typedef struct _HRSRC_ELEM
39 {
40     HANDLE hRsrc;
41     WORD     type;
42 } HRSRC_ELEM;
43
44 typedef struct _HRSRC_MAP
45 {
46     int nAlloc;
47     int nUsed;
48     HRSRC_ELEM *elem;
49 } HRSRC_MAP;
50
51 static HRSRC RES_FindResource2( HMODULE hModule, LPCSTR type,
52                                 LPCSTR name, WORD lang, int unicode)
53 {
54     HRSRC hRsrc = 0;
55     LPWSTR typeStr, nameStr;    
56     WINE_MODREF *wm = MODULE32_LookupHMODULE( hModule );
57
58     if(!wm)
59         return 0;    
60     /* 32-bit PE module */
61
62     
63     if ( HIWORD( type ) && (!unicode))
64         typeStr = HEAP_strdupAtoW( GetProcessHeap(), 0, type );
65     else
66         typeStr = (LPWSTR)type;
67     if ( HIWORD( name ) && (!unicode))
68         nameStr = HEAP_strdupAtoW( GetProcessHeap(), 0, name );
69     else
70         nameStr = (LPWSTR)name;
71     
72     hRsrc = PE_FindResourceExW( wm, nameStr, typeStr, lang );
73     
74     if ( HIWORD( type ) && (!unicode)) 
75         HeapFree( GetProcessHeap(), 0, typeStr );
76     if ( HIWORD( name ) && (!unicode)) 
77         HeapFree( GetProcessHeap(), 0, nameStr );
78
79     return hRsrc;
80 }
81
82 /**********************************************************************
83  *          RES_FindResource
84  */
85
86 static HRSRC RES_FindResource( HMODULE hModule, LPCSTR type,
87                                LPCSTR name, WORD lang, int unicode )
88 {
89     HRSRC hRsrc;
90 //    __TRY
91 //    {
92         hRsrc = RES_FindResource2(hModule, type, name, lang, unicode);
93 //    }
94 //    __EXCEPT(page_fault)
95 //    {
96 //      WARN("page fault\n");
97 //      SetLastError(ERROR_INVALID_PARAMETER);
98 //      return 0;
99 //    }
100 //    __ENDTRY
101     return hRsrc;
102 }
103
104 /**********************************************************************
105  *          RES_SizeofResource
106  */
107 static DWORD RES_SizeofResource( HMODULE hModule, HRSRC hRsrc)
108 {
109     DWORD size = 0;
110     HRSRC hRsrc32;
111
112 //    HMODULE16 hMod16   = MapHModuleLS( hModule );
113 //    NE_MODULE *pModule = NE_GetPtr( hMod16 );
114 //    WINE_MODREF *wm    = pModule && pModule->module32? 
115 //                         MODULE32_LookupHMODULE( pModule->module32 ) : NULL;
116     WINE_MODREF *wm = MODULE32_LookupHMODULE( hModule );
117
118     if ( !hModule || !hRsrc ) return 0;
119
120     /* 32-bit PE module */
121     /* If we got a 16-bit hRsrc, convert it */
122 //    hRsrc32  = HIWORD(hRsrc)? hRsrc : MapHRsrc16To32( pModule, hRsrc );
123     if(!HIWORD(hRsrc))
124     {
125         printf("16-bit hRsrcs not supported\n");
126         return 0;
127     }   
128     size = PE_SizeofResource( hModule, hRsrc );
129     return size;
130 }
131
132 /**********************************************************************
133  *          RES_AccessResource
134  */
135 static HFILE RES_AccessResource( HMODULE hModule, HRSRC hRsrc )
136 {
137     HFILE hFile = HFILE_ERROR;
138
139     WINE_MODREF *wm = MODULE32_LookupHMODULE( hModule );
140
141     if ( !hModule || !hRsrc ) return HFILE_ERROR;
142
143     /* 32-bit PE module */
144     FIXME("32-bit modules not yet supported.\n" );
145     hFile = HFILE_ERROR;
146
147     return hFile;
148 }
149
150 /**********************************************************************
151  *          RES_LoadResource
152  */
153 static HGLOBAL RES_LoadResource( HMODULE hModule, HRSRC hRsrc)
154 {
155     HGLOBAL hMem = 0;
156     HRSRC hRsrc32;
157     WINE_MODREF *wm = MODULE32_LookupHMODULE( hModule );
158
159
160     if ( !hModule || !hRsrc ) return 0;
161
162     /* 32-bit PE module */
163
164     /* If we got a 16-bit hRsrc, convert it */
165 //    hRsrc32 = HIWORD(hRsrc)? hRsrc : MapHRsrc16To32( pModule, hRsrc );
166     if(!HIWORD(hRsrc))
167     {
168         printf("16-bit hRsrcs not supported\n");
169         return 0;
170     }
171     hMem = PE_LoadResource( wm, hRsrc );
172
173     return hMem;
174 }
175
176 /**********************************************************************
177  *          RES_LockResource
178  */
179 static LPVOID RES_LockResource( HGLOBAL handle )
180 {
181     LPVOID bits = NULL;
182
183     TRACE("(%08x, %s)\n", handle, "PE" );
184
185     bits = (LPVOID)handle;
186
187     return bits;
188 }
189
190 /**********************************************************************
191  *          RES_FreeResource
192  */
193 static WIN_BOOL RES_FreeResource( HGLOBAL handle )
194 {
195     HGLOBAL retv = handle;
196     return (WIN_BOOL)retv;
197 }
198
199 /**********************************************************************
200  *          FindResourceA    (KERNEL32.128)
201  */
202 HANDLE WINAPI FindResourceA( HMODULE hModule, LPCSTR name, LPCSTR type )
203 {
204     return RES_FindResource( hModule, type, name, 
205                              WINE_LanguageId, 0);
206 }
207 HANDLE WINAPI FindResourceW( HMODULE hModule, LPCWSTR name, LPCWSTR type )
208 {
209     return RES_FindResource( hModule, (LPCSTR)type, (LPCSTR)name, 
210                              WINE_LanguageId, 1);
211 }
212
213 /**********************************************************************
214  *          FindResourceExA  (KERNEL32.129)
215  */
216 HANDLE WINAPI FindResourceExA( HMODULE hModule, 
217                                LPCSTR type, LPCSTR name, WORD lang )
218 {
219     return RES_FindResource( hModule, type, name, 
220                              lang, 0 );
221 }
222
223 HANDLE WINAPI FindResourceExW( HMODULE hModule, 
224                                LPCWSTR type, LPCWSTR name, WORD lang )
225 {
226     return RES_FindResource( hModule, (LPCSTR)type, (LPCSTR)name, 
227                              lang, 1 );
228 }
229
230
231
232 /**********************************************************************
233  *          LockResource     (KERNEL32.384)
234  */
235 LPVOID WINAPI LockResource( HGLOBAL handle )
236 {
237     return RES_LockResource( handle );
238 }
239
240
241 /**********************************************************************
242  *          FreeResource     (KERNEL32.145)
243  */
244 WIN_BOOL WINAPI FreeResource( HGLOBAL handle )
245 {
246     return RES_FreeResource( handle );
247 }
248
249
250 /**********************************************************************
251  *          AccessResource   (KERNEL32.64)
252  */
253 INT WINAPI AccessResource( HMODULE hModule, HRSRC hRsrc )
254 {
255     return RES_AccessResource( hModule, hRsrc );
256 }
257 /**********************************************************************
258  *          SizeofResource   (KERNEL32.522)
259  */
260 DWORD WINAPI SizeofResource( HINSTANCE hModule, HRSRC hRsrc )
261 {
262     return RES_SizeofResource( hModule, hRsrc );
263 }
264
265
266 INT WINAPI LoadStringW( HINSTANCE instance, UINT resource_id,
267                             LPWSTR buffer, INT buflen );
268
269 /**********************************************************************
270  *      LoadStringA     (USER32.375)
271  */
272 INT WINAPI LoadStringA( HINSTANCE instance, UINT resource_id,
273                             LPSTR buffer, INT buflen )
274 {
275     INT    retval;
276     INT    wbuflen;
277     INT    abuflen;
278     LPWSTR wbuf = NULL;
279     LPSTR  abuf = NULL;
280
281     if ( buffer != NULL && buflen > 0 )
282         *buffer = 0;
283
284     wbuflen = LoadStringW(instance,resource_id,NULL,0);
285     if ( !wbuflen )
286         return 0;
287     wbuflen ++;
288
289     retval = 0;
290     wbuf = (LPWSTR) HeapAlloc( GetProcessHeap(), 0, wbuflen * sizeof(WCHAR) );
291     wbuflen = LoadStringW(instance,resource_id,wbuf,wbuflen);
292     if ( wbuflen > 0 )
293     {
294         abuflen = WideCharToMultiByte(CP_ACP,0,wbuf,wbuflen,NULL,0,NULL,NULL);
295         if ( abuflen > 0 )
296         {
297             if ( buffer == NULL || buflen == 0 )
298                 retval = abuflen;
299             else
300             {
301                 abuf = (LPSTR) HeapAlloc( GetProcessHeap(), 0, abuflen * sizeof(CHAR) );
302                 abuflen = WideCharToMultiByte(CP_ACP,0,wbuf,wbuflen,abuf,abuflen,NULL,NULL);
303                 if ( abuflen > 0 )
304                 {
305                     abuflen = min(abuflen,buflen - 1);
306                     memcpy( buffer, abuf, abuflen );
307                     buffer[abuflen] = 0;
308                     retval = abuflen;
309                 }
310                 HeapFree( GetProcessHeap(), 0, abuf );
311             }
312         }
313     }
314     HeapFree( GetProcessHeap(), 0, wbuf );
315
316     return retval;
317 }
318
319 /**********************************************************************
320  *      LoadStringW             (USER32.376)
321  */
322 INT WINAPI LoadStringW( HINSTANCE instance, UINT resource_id,
323                             LPWSTR buffer, INT buflen )
324 {
325     HGLOBAL hmem;
326     HRSRC hrsrc;
327     WCHAR *p;
328     int string_num;
329     int i;
330
331     if (HIWORD(resource_id)==0xFFFF) /* netscape 3 passes this */
332         resource_id = (UINT)(-((INT)resource_id));
333     TRACE("instance = %04x, id = %04x, buffer = %08x, "
334           "length = %d\n", instance, (int)resource_id, (int) buffer, buflen);
335
336     /* Use bits 4 - 19 (incremented by 1) as resourceid, mask out 
337      * 20 - 31. */
338     hrsrc = FindResourceW( instance, (LPCWSTR)(((resource_id>>4)&0xffff)+1),
339                              RT_STRINGW );
340     if (!hrsrc) return 0;
341     hmem = LoadResource( instance, hrsrc );
342     if (!hmem) return 0;
343     
344     p = (WCHAR*) LockResource(hmem);
345     string_num = resource_id & 0x000f;
346     for (i = 0; i < string_num; i++)
347         p += *p + 1;
348     
349     TRACE("strlen = %d\n", (int)*p );
350     
351     if (buffer == NULL) return *p;
352     i = min(buflen - 1, *p);
353     if (i > 0) {
354         memcpy(buffer, p + 1, i * sizeof (WCHAR));
355         buffer[i] = (WCHAR) 0;
356     } else {
357         if (buflen > 1) {
358             buffer[0] = (WCHAR) 0;
359             return 0;
360         }
361 #if 0
362         WARN("Don't know why caller give buflen=%d *p=%d trying to obtain string '%s'\n", buflen, *p, p + 1);
363 #endif
364     }
365
366     TRACE("String loaded !\n");
367     return i;
368 }
369
370 /* Messages...used by FormatMessage32* (KERNEL32.something)
371  * 
372  * They can be specified either directly or using a message ID and
373  * loading them from the resource.
374  * 
375  * The resourcedata has following format:
376  * start:
377  * 0: DWORD nrofentries
378  * nrofentries * subentry:
379  *      0: DWORD firstentry
380  *      4: DWORD lastentry
381  *      8: DWORD offset from start to the stringentries
382  *
383  * (lastentry-firstentry) * stringentry:
384  * 0: WORD len (0 marks end)
385  * 2: WORD flags
386  * 4: CHAR[len-4]
387  *      (stringentry i of a subentry refers to the ID 'firstentry+i')
388  *
389  * Yes, ANSI strings in win32 resources. Go figure.
390  */
391
392 /**********************************************************************
393  *      LoadMessageA            (internal)
394  */
395 INT WINAPI LoadMessageA( HMODULE instance, UINT id, WORD lang,
396                       LPSTR buffer, INT buflen )
397 {
398     HGLOBAL     hmem;
399     HRSRC       hrsrc;
400     PMESSAGE_RESOURCE_DATA      mrd;
401     PMESSAGE_RESOURCE_BLOCK     mrb;
402     PMESSAGE_RESOURCE_ENTRY     mre;
403     int         i,slen;
404
405     TRACE("instance = %08lx, id = %08lx, buffer = %p, length = %ld\n", (DWORD)instance, (DWORD)id, buffer, (DWORD)buflen);
406
407     /*FIXME: I am not sure about the '1' ... But I've only seen those entries*/
408     hrsrc = FindResourceExW(instance,RT_MESSAGELISTW,(LPWSTR)1,lang);
409     if (!hrsrc) return 0;
410     hmem = LoadResource( instance, hrsrc );
411     if (!hmem) return 0;
412     
413     mrd = (PMESSAGE_RESOURCE_DATA)LockResource(hmem);
414     mre = NULL;
415     mrb = &(mrd->Blocks[0]);
416     for (i=mrd->NumberOfBlocks;i--;) {
417         if ((id>=mrb->LowId) && (id<=mrb->HighId)) {
418             mre = (PMESSAGE_RESOURCE_ENTRY)(((char*)mrd)+mrb->OffsetToEntries);
419             id  -= mrb->LowId;
420             break;
421         }
422         mrb++;
423     }
424     if (!mre)
425         return 0;
426     for (i=id;i--;) {
427         if (!mre->Length)
428                 return 0;
429         mre = (PMESSAGE_RESOURCE_ENTRY)(((char*)mre)+(mre->Length));
430     }
431     slen=mre->Length;
432     TRACE("     - strlen=%d\n",slen);
433     i = min(buflen - 1, slen);
434     if (buffer == NULL)
435         return slen;
436     if (i>0) {
437         lstrcpynA(buffer,(char*)mre->Text,i);
438         buffer[i]=0;
439     } else {
440         if (buflen>1) {
441             buffer[0]=0;
442             return 0;
443         }
444     }
445     if (buffer)
446             TRACE("'%s' copied !\n", buffer);
447     return i;
448 }
449
450
451
452 /**********************************************************************
453  *      EnumResourceTypesA      (KERNEL32.90)
454  */
455 WIN_BOOL WINAPI EnumResourceTypesA( HMODULE hmodule,ENUMRESTYPEPROCA lpfun,
456                                     LONG lParam)
457 {
458         /* FIXME: move WINE_MODREF stuff here */
459     return PE_EnumResourceTypesA(hmodule,lpfun,lParam);
460 }
461
462 /**********************************************************************
463  *      EnumResourceNamesA      (KERNEL32.88)
464  */
465 WIN_BOOL WINAPI EnumResourceNamesA( HMODULE hmodule, LPCSTR type,
466                                     ENUMRESNAMEPROCA lpfun, LONG lParam )
467 {
468         /* FIXME: move WINE_MODREF stuff here */
469     return PE_EnumResourceNamesA(hmodule,type,lpfun,lParam);
470 }
471 /**********************************************************************
472  *      EnumResourceLanguagesA  (KERNEL32.86)
473  */
474 WIN_BOOL WINAPI EnumResourceLanguagesA( HMODULE hmodule, LPCSTR type,
475                                         LPCSTR name, ENUMRESLANGPROCA lpfun,
476                                         LONG lParam)
477 {
478         /* FIXME: move WINE_MODREF stuff here */
479     return PE_EnumResourceLanguagesA(hmodule,type,name,lpfun,lParam);
480 }
481 /**********************************************************************
482  *          LoadResource     (KERNEL32.370)
483  */
484 HGLOBAL WINAPI LoadResource( HINSTANCE hModule, HRSRC hRsrc )
485 {
486     return RES_LoadResource( hModule, hRsrc);
487 }