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