DUMMYSTRUCTNAME2 creates a conflict when using anonymous union names.
[wine] / dlls / version / resource.c
1 /* 
2  * Implementation of VERSION.DLL - Resource Access routines
3  * 
4  * Copyright 1996,1997 Marcus Meissner
5  * Copyright 1997 David Cuthbert
6  * Copyright 1999 Ulrich Weigand
7  */
8
9 #include <stdlib.h>
10 #include <string.h>
11 #include <sys/types.h>
12 #include <unistd.h>
13
14 #include "winbase.h"
15 #include "wine/winbase16.h"
16 #include "winnls.h"
17 #include "wine/unicode.h"
18
19 #include "winver.h"
20 #include "lzexpand.h"
21 #include "debugtools.h"
22
23 DEFAULT_DEBUG_CHANNEL(ver);
24
25
26 /**********************************************************************
27  *  find_entry_by_id
28  *
29  * Find an entry by id in a resource directory
30  * Copied from loader/pe_resource.c
31  */
32 static const IMAGE_RESOURCE_DIRECTORY *find_entry_by_id( const IMAGE_RESOURCE_DIRECTORY *dir,
33                                                          WORD id, const void *root )
34 {
35     const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry;
36     int min, max, pos;
37
38     entry = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1);
39     min = dir->NumberOfNamedEntries;
40     max = min + dir->NumberOfIdEntries - 1;
41     while (min <= max)
42     {
43         pos = (min + max) / 2;
44         if (entry[pos].u1.s2.Id == id)
45             return (IMAGE_RESOURCE_DIRECTORY *)((char *)root + entry[pos].u2.s3.OffsetToDirectory);
46         if (entry[pos].u1.s2.Id > id) max = pos - 1;
47         else min = pos + 1;
48     }
49     return NULL;
50 }
51
52
53 /**********************************************************************
54  *  find_entry_default
55  *
56  * Find a default entry in a resource directory
57  * Copied from loader/pe_resource.c
58  */
59 static const IMAGE_RESOURCE_DIRECTORY *find_entry_default( const IMAGE_RESOURCE_DIRECTORY *dir,
60                                                            const void *root )
61 {
62     const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry;
63
64     entry = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1);
65     return (IMAGE_RESOURCE_DIRECTORY *)((char *)root + entry->u2.s3.OffsetToDirectory);
66 }
67
68
69 /**********************************************************************
70  *  find_entry_by_name
71  *
72  * Find an entry by name in a resource directory
73  * Copied from loader/pe_resource.c
74  */
75 static const IMAGE_RESOURCE_DIRECTORY *find_entry_by_name( const IMAGE_RESOURCE_DIRECTORY *dir,
76                                                            LPCSTR name, const void *root )
77 {
78     const IMAGE_RESOURCE_DIRECTORY *ret = NULL;
79     LPWSTR nameW;
80     DWORD namelen;
81
82     if (!HIWORD(name)) return find_entry_by_id( dir, LOWORD(name), root );
83     if (name[0] == '#')
84     {
85         return find_entry_by_id( dir, atoi(name+1), root );
86     }
87
88     namelen = MultiByteToWideChar( CP_ACP, 0, name, -1, NULL, 0 );
89     if ((nameW = HeapAlloc( GetProcessHeap(), 0, namelen * sizeof(WCHAR) )))
90     {
91         const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry;
92         const IMAGE_RESOURCE_DIR_STRING_U *str;
93         int min, max, res, pos;
94
95         MultiByteToWideChar( CP_ACP, 0, name, -1, nameW, namelen );
96         namelen--;  /* remove terminating null */
97         entry = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1);
98         min = 0;
99         max = dir->NumberOfNamedEntries - 1;
100         while (min <= max)
101         {
102             pos = (min + max) / 2;
103             str = (IMAGE_RESOURCE_DIR_STRING_U *)((char *)root + entry[pos].u1.s1.NameOffset);
104             res = strncmpiW( nameW, str->NameString, str->Length );
105             if (!res && namelen == str->Length)
106             {
107                 ret = (IMAGE_RESOURCE_DIRECTORY *)((char *)root + entry[pos].u2.s3.OffsetToDirectory);
108                 break;
109             }
110             if (res < 0) max = pos - 1;
111             else min = pos + 1;
112         }
113         HeapFree( GetProcessHeap(), 0, nameW );
114     }
115     return ret;
116 }
117
118
119 /***********************************************************************
120  *           read_xx_header         [internal]
121  */
122 static int read_xx_header( HFILE lzfd )
123 {
124     IMAGE_DOS_HEADER mzh;
125     char magic[3];
126
127     LZSeek( lzfd, 0, SEEK_SET );
128     if ( sizeof(mzh) != LZRead( lzfd, &mzh, sizeof(mzh) ) )
129         return 0;
130     if ( mzh.e_magic != IMAGE_DOS_SIGNATURE )
131         return 0;
132
133     LZSeek( lzfd, mzh.e_lfanew, SEEK_SET );
134     if ( 2 != LZRead( lzfd, magic, 2 ) )
135         return 0;
136
137     LZSeek( lzfd, mzh.e_lfanew, SEEK_SET );
138
139     if ( magic[0] == 'N' && magic[1] == 'E' )
140         return IMAGE_OS2_SIGNATURE;
141     if ( magic[0] == 'P' && magic[1] == 'E' )
142         return IMAGE_NT_SIGNATURE;
143
144     magic[2] = '\0';
145     WARN("Can't handle %s files.\n", magic );
146     return 0;
147 }
148
149 /***********************************************************************
150  *           load_ne_resource         [internal]
151  */
152 static BOOL find_ne_resource( HFILE lzfd, LPCSTR typeid, LPCSTR resid,
153                                 DWORD *resLen, DWORD *resOff )
154 {
155     IMAGE_OS2_HEADER nehd;
156     NE_TYPEINFO *typeInfo;
157     NE_NAMEINFO *nameInfo;
158     DWORD nehdoffset;
159     LPBYTE resTab;
160     DWORD resTabSize;
161     int count;
162
163     /* Read in NE header */ 
164     nehdoffset = LZSeek( lzfd, 0, SEEK_CUR );
165     if ( sizeof(nehd) != LZRead( lzfd, &nehd, sizeof(nehd) ) ) return 0;
166
167     resTabSize = nehd.ne_restab - nehd.ne_rsrctab; 
168     if ( !resTabSize )
169     {
170         TRACE("No resources in NE dll\n" );
171         return FALSE;
172     }
173
174     /* Read in resource table */ 
175     resTab = HeapAlloc( GetProcessHeap(), 0, resTabSize );
176     if ( !resTab ) return FALSE;
177
178     LZSeek( lzfd, nehd.ne_rsrctab + nehdoffset, SEEK_SET );
179     if ( resTabSize != LZRead( lzfd, resTab, resTabSize ) )
180     {
181         HeapFree( GetProcessHeap(), 0, resTab );
182         return FALSE;
183     }
184
185     /* Find resource */
186     typeInfo = (NE_TYPEINFO *)(resTab + 2);
187
188     if (HIWORD(typeid) != 0)  /* named type */
189     {
190         BYTE len = strlen( typeid );
191         while (typeInfo->type_id)
192         {
193             if (!(typeInfo->type_id & 0x8000))
194             {
195                 BYTE *p = resTab + typeInfo->type_id;
196                 if ((*p == len) && !strncasecmp( p+1, typeid, len )) goto found_type;
197             }
198             typeInfo = (NE_TYPEINFO *)((char *)(typeInfo + 1) +
199                                        typeInfo->count * sizeof(NE_NAMEINFO));
200         }
201     }
202     else  /* numeric type id */
203     {
204         WORD id = LOWORD(typeid) | 0x8000;
205         while (typeInfo->type_id)
206         {
207             if (typeInfo->type_id == id) goto found_type;
208             typeInfo = (NE_TYPEINFO *)((char *)(typeInfo + 1) +
209                                        typeInfo->count * sizeof(NE_NAMEINFO));
210         }
211     }
212     TRACE("No typeid entry found for %p\n", typeid );
213     HeapFree( GetProcessHeap(), 0, resTab );
214     return FALSE;
215
216  found_type:
217     nameInfo = (NE_NAMEINFO *)(typeInfo + 1);
218
219     if (HIWORD(resid) != 0)  /* named resource */
220     {
221         BYTE len = strlen( resid );
222         for (count = typeInfo->count; count > 0; count--, nameInfo++)
223         {
224             BYTE *p = resTab + nameInfo->id;
225             if (nameInfo->id & 0x8000) continue;
226             if ((*p == len) && !strncasecmp( p+1, resid, len )) goto found_name;
227         }
228     }
229     else  /* numeric resource id */
230     {
231         WORD id = LOWORD(resid) | 0x8000;
232         for (count = typeInfo->count; count > 0; count--, nameInfo++)
233             if (nameInfo->id == id) goto found_name;
234     }
235     TRACE("No resid entry found for %p\n", typeid );
236     HeapFree( GetProcessHeap(), 0, resTab );
237     return FALSE;
238
239  found_name:
240     /* Return resource data */
241     if ( resLen ) *resLen = nameInfo->length << *(WORD *)resTab;
242     if ( resOff ) *resOff = nameInfo->offset << *(WORD *)resTab;
243
244     HeapFree( GetProcessHeap(), 0, resTab );
245     return TRUE;
246 }
247
248 /***********************************************************************
249  *           load_pe_resource         [internal]
250  */
251 static BOOL find_pe_resource( HFILE lzfd, LPCSTR typeid, LPCSTR resid,
252                                 DWORD *resLen, DWORD *resOff )
253 {
254     IMAGE_NT_HEADERS pehd;
255     DWORD pehdoffset;
256     PIMAGE_DATA_DIRECTORY resDataDir;
257     PIMAGE_SECTION_HEADER sections;
258     LPBYTE resSection;
259     DWORD resSectionSize;
260     const void *resDir;
261     const IMAGE_RESOURCE_DIRECTORY *resPtr;
262     const IMAGE_RESOURCE_DATA_ENTRY *resData;
263     int i, nSections;
264     BOOL ret = FALSE;
265
266     /* Read in PE header */
267     pehdoffset = LZSeek( lzfd, 0, SEEK_CUR );
268     if ( sizeof(pehd) != LZRead( lzfd, &pehd, sizeof(pehd) ) ) return 0;
269
270     resDataDir = pehd.OptionalHeader.DataDirectory+IMAGE_FILE_RESOURCE_DIRECTORY;
271     if ( !resDataDir->Size )
272     {
273         TRACE("No resources in PE dll\n" );
274         return FALSE;
275     }
276
277     /* Read in section table */
278     nSections = pehd.FileHeader.NumberOfSections; 
279     sections = HeapAlloc( GetProcessHeap(), 0, 
280                           nSections * sizeof(IMAGE_SECTION_HEADER) );
281     if ( !sections ) return FALSE;
282
283     LZSeek( lzfd, pehdoffset +
284                     sizeof(DWORD) + /* Signature */
285                     sizeof(IMAGE_FILE_HEADER) +
286                     pehd.FileHeader.SizeOfOptionalHeader, SEEK_SET );
287
288     if ( nSections * sizeof(IMAGE_SECTION_HEADER) !=
289          LZRead( lzfd, sections, nSections * sizeof(IMAGE_SECTION_HEADER) ) )
290     {
291         HeapFree( GetProcessHeap(), 0, sections );
292         return FALSE;
293     }
294
295     /* Find resource section */
296     for ( i = 0; i < nSections; i++ )
297         if (    resDataDir->VirtualAddress >= sections[i].VirtualAddress
298              && resDataDir->VirtualAddress <  sections[i].VirtualAddress +
299                                               sections[i].SizeOfRawData )
300             break;
301
302     if ( i == nSections )
303     {
304         HeapFree( GetProcessHeap(), 0, sections );
305         TRACE("Couldn't find resource section\n" );
306         return FALSE;
307     }
308
309     /* Read in resource section */
310     resSectionSize = sections[i].SizeOfRawData; 
311     resSection = HeapAlloc( GetProcessHeap(), 0, resSectionSize );
312     if ( !resSection ) 
313     {
314         HeapFree( GetProcessHeap(), 0, sections );
315         return FALSE;
316     }
317
318     LZSeek( lzfd, sections[i].PointerToRawData, SEEK_SET );
319     if ( resSectionSize != LZRead( lzfd, resSection, resSectionSize ) ) goto done;
320
321     /* Find resource */
322     resDir = resSection + (resDataDir->VirtualAddress - sections[i].VirtualAddress);
323
324     resPtr = (PIMAGE_RESOURCE_DIRECTORY)resDir;
325     resPtr = find_entry_by_name( resPtr, typeid, resDir );
326     if ( !resPtr )
327     {
328         TRACE("No typeid entry found for %p\n", typeid );
329         goto done;
330     }
331     resPtr = find_entry_by_name( resPtr, resid, resDir );
332     if ( !resPtr )
333     {
334         TRACE("No resid entry found for %p\n", resid );
335         goto done;
336     }
337     resPtr = find_entry_default( resPtr, resDir );
338     if ( !resPtr )
339     {
340         TRACE("No default language entry found for %p\n", resid );
341         goto done;
342     }
343
344     /* Find resource data section */
345     resData = (PIMAGE_RESOURCE_DATA_ENTRY)resPtr;
346     for ( i = 0; i < nSections; i++ )
347         if (    resData->OffsetToData >= sections[i].VirtualAddress
348              && resData->OffsetToData <  sections[i].VirtualAddress +
349                                          sections[i].SizeOfRawData )
350             break;
351
352     if ( i == nSections )
353     {
354         TRACE("Couldn't find resource data section\n" );
355         goto done;
356     }
357
358     /* Return resource data */
359     if ( resLen ) *resLen = resData->Size;
360     if ( resOff ) *resOff = resData->OffsetToData - sections[i].VirtualAddress
361                             + sections[i].PointerToRawData;
362     ret = TRUE;
363
364  done:
365     HeapFree( GetProcessHeap(), 0, resSection );
366     HeapFree( GetProcessHeap(), 0, sections );
367     return ret;
368 }
369
370
371 /*************************************************************************
372  * GetFileResourceSize16                     [VER.2]
373  */
374 DWORD WINAPI GetFileResourceSize16( LPCSTR lpszFileName, LPCSTR lpszResType,
375                                     LPCSTR lpszResId, LPDWORD lpdwFileOffset )
376 {
377     BOOL retv = FALSE;
378     HFILE lzfd;
379     OFSTRUCT ofs;
380     DWORD reslen;
381
382     TRACE("(%s,type=0x%lx,id=0x%lx,off=%p)\n",
383                 debugstr_a(lpszFileName), (LONG)lpszResType, (LONG)lpszResId, 
384                 lpszResId );
385
386     lzfd = LZOpenFileA( lpszFileName, &ofs, OF_READ );
387     if ( !lzfd ) return 0;
388
389     switch ( read_xx_header( lzfd ) )
390     {
391     case IMAGE_OS2_SIGNATURE:
392         retv = find_ne_resource( lzfd, lpszResType, lpszResId, 
393                                  &reslen, lpdwFileOffset );
394         break;
395
396     case IMAGE_NT_SIGNATURE:
397         retv = find_pe_resource( lzfd, lpszResType, lpszResId, 
398                                  &reslen, lpdwFileOffset );
399         break;
400     }
401
402     LZClose( lzfd );
403     return retv? reslen : 0;
404 }
405
406
407 /*************************************************************************
408  * GetFileResource16                         [VER.3]
409  */
410 DWORD WINAPI GetFileResource16( LPCSTR lpszFileName, LPCSTR lpszResType,
411                                 LPCSTR lpszResId, DWORD dwFileOffset,
412                                 DWORD dwResLen, LPVOID lpvData )
413 {
414     BOOL retv = FALSE;
415     HFILE lzfd;
416     OFSTRUCT ofs;
417     DWORD reslen = dwResLen;
418
419     TRACE("(%s,type=0x%lx,id=0x%lx,off=%ld,len=%ld,data=%p)\n",
420                 debugstr_a(lpszFileName), (LONG)lpszResType, (LONG)lpszResId, 
421                 dwFileOffset, dwResLen, lpvData );
422
423     lzfd = LZOpenFileA( lpszFileName, &ofs, OF_READ );
424     if ( lzfd == 0 ) return 0;
425
426     if ( !dwFileOffset )
427     {
428         switch ( read_xx_header( lzfd ) ) 
429         {
430         case IMAGE_OS2_SIGNATURE:
431             retv = find_ne_resource( lzfd, lpszResType, lpszResId, 
432                                      &reslen, &dwFileOffset );
433             break;
434
435         case IMAGE_NT_SIGNATURE:
436             retv = find_pe_resource( lzfd, lpszResType, lpszResId, 
437                                      &reslen, &dwFileOffset );
438             break;
439         }
440
441         if ( !retv ) 
442         {
443             LZClose( lzfd );
444             return 0;
445         }
446     }
447
448     LZSeek( lzfd, dwFileOffset, SEEK_SET );
449     reslen = LZRead( lzfd, lpvData, min( reslen, dwResLen ) );
450     LZClose( lzfd );
451
452     return reslen;
453 }
454