oleaut32/tests: COM cleanup for usrmarshal.c.
[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  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  */
22
23 #include "config.h"
24
25 #include <stdarg.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <sys/types.h>
30 #ifdef HAVE_UNISTD_H
31 # include <unistd.h>
32 #endif
33
34 #define NONAMELESSUNION
35 #define NONAMELESSSTRUCT
36 #include "windef.h"
37 #include "winbase.h"
38 #include "lzexpand.h"
39 #include "winver.h"
40
41 #include "wine/unicode.h"
42 #include "wine/debug.h"
43
44 typedef struct
45 {
46     WORD offset;
47     WORD length;
48     WORD flags;
49     WORD id;
50     WORD handle;
51     WORD usage;
52 } NE_NAMEINFO;
53
54 typedef struct
55 {
56     WORD  type_id;
57     WORD  count;
58     DWORD resloader;
59 } NE_TYPEINFO;
60
61 WINE_DEFAULT_DEBUG_CHANNEL(ver);
62
63
64 /**********************************************************************
65  *  find_entry_by_id
66  *
67  * Find an entry by id in a resource directory
68  * Copied from loader/pe_resource.c
69  */
70 static const IMAGE_RESOURCE_DIRECTORY *find_entry_by_id( const IMAGE_RESOURCE_DIRECTORY *dir,
71                                                          WORD id, const void *root )
72 {
73     const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry;
74     int min, max, pos;
75
76     entry = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1);
77     min = dir->NumberOfNamedEntries;
78     max = min + dir->NumberOfIdEntries - 1;
79     while (min <= max)
80     {
81         pos = (min + max) / 2;
82         if (entry[pos].u1.s2.Id == id)
83             return (const IMAGE_RESOURCE_DIRECTORY *)((const char *)root + entry[pos].u2.s3.OffsetToDirectory);
84         if (entry[pos].u1.s2.Id > id) max = pos - 1;
85         else min = pos + 1;
86     }
87     return NULL;
88 }
89
90
91 /**********************************************************************
92  *  find_entry_default
93  *
94  * Find a default entry in a resource directory
95  * Copied from loader/pe_resource.c
96  */
97 static const IMAGE_RESOURCE_DIRECTORY *find_entry_default( const IMAGE_RESOURCE_DIRECTORY *dir,
98                                                            const void *root )
99 {
100     const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry;
101
102     entry = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1);
103     return (const IMAGE_RESOURCE_DIRECTORY *)((const char *)root + entry->u2.s3.OffsetToDirectory);
104 }
105
106
107 /***********************************************************************
108  *           read_xx_header         [internal]
109  */
110 static int read_xx_header( HFILE lzfd )
111 {
112     IMAGE_DOS_HEADER mzh;
113     char magic[3];
114
115     LZSeek( lzfd, 0, SEEK_SET );
116     if ( sizeof(mzh) != LZRead( lzfd, (LPSTR)&mzh, sizeof(mzh) ) )
117         return 0;
118     if ( mzh.e_magic != IMAGE_DOS_SIGNATURE )
119     {
120         if (!memcmp( &mzh, "\177ELF", 4 )) return 1;  /* ELF */
121         if (*(UINT *)&mzh == 0xfeedface || *(UINT *)&mzh == 0xcefaedfe) return 1;  /* Mach-O */
122         return 0;
123     }
124
125     LZSeek( lzfd, mzh.e_lfanew, SEEK_SET );
126     if ( 2 != LZRead( lzfd, magic, 2 ) )
127         return 0;
128
129     LZSeek( lzfd, mzh.e_lfanew, SEEK_SET );
130
131     if ( magic[0] == 'N' && magic[1] == 'E' )
132         return IMAGE_OS2_SIGNATURE;
133     if ( magic[0] == 'P' && magic[1] == 'E' )
134         return IMAGE_NT_SIGNATURE;
135
136     magic[2] = '\0';
137     WARN("Can't handle %s files.\n", magic );
138     return 0;
139 }
140
141 /***********************************************************************
142  *           find_ne_resource         [internal]
143  */
144 static BOOL find_ne_resource( HFILE lzfd, DWORD *resLen, DWORD *resOff )
145 {
146     const WORD typeid = VS_FILE_INFO | 0x8000;
147     const WORD resid = VS_VERSION_INFO | 0x8000;
148     IMAGE_OS2_HEADER nehd;
149     NE_TYPEINFO *typeInfo;
150     NE_NAMEINFO *nameInfo;
151     DWORD nehdoffset;
152     LPBYTE resTab;
153     DWORD resTabSize;
154     int count;
155
156     /* Read in NE header */
157     nehdoffset = LZSeek( lzfd, 0, SEEK_CUR );
158     if ( sizeof(nehd) != LZRead( lzfd, (LPSTR)&nehd, sizeof(nehd) ) ) return 0;
159
160     resTabSize = nehd.ne_restab - nehd.ne_rsrctab;
161     if ( !resTabSize )
162     {
163         TRACE("No resources in NE dll\n" );
164         return FALSE;
165     }
166
167     /* Read in resource table */
168     resTab = HeapAlloc( GetProcessHeap(), 0, resTabSize );
169     if ( !resTab ) return FALSE;
170
171     LZSeek( lzfd, nehd.ne_rsrctab + nehdoffset, SEEK_SET );
172     if ( resTabSize != LZRead( lzfd, (char*)resTab, resTabSize ) )
173     {
174         HeapFree( GetProcessHeap(), 0, resTab );
175         return FALSE;
176     }
177
178     /* Find resource */
179     typeInfo = (NE_TYPEINFO *)(resTab + 2);
180     while (typeInfo->type_id)
181     {
182         if (typeInfo->type_id == typeid) goto found_type;
183         typeInfo = (NE_TYPEINFO *)((char *)(typeInfo + 1) +
184                                    typeInfo->count * sizeof(NE_NAMEINFO));
185     }
186     TRACE("No typeid entry found\n" );
187     HeapFree( GetProcessHeap(), 0, resTab );
188     return FALSE;
189
190  found_type:
191     nameInfo = (NE_NAMEINFO *)(typeInfo + 1);
192
193     for (count = typeInfo->count; count > 0; count--, nameInfo++)
194         if (nameInfo->id == resid) goto found_name;
195
196     TRACE("No resid entry found\n" );
197     HeapFree( GetProcessHeap(), 0, resTab );
198     return FALSE;
199
200  found_name:
201     /* Return resource data */
202     if ( resLen ) *resLen = nameInfo->length << *(WORD *)resTab;
203     if ( resOff ) *resOff = nameInfo->offset << *(WORD *)resTab;
204
205     HeapFree( GetProcessHeap(), 0, resTab );
206     return TRUE;
207 }
208
209 /***********************************************************************
210  *           find_pe_resource         [internal]
211  */
212 static BOOL find_pe_resource( HFILE lzfd, DWORD *resLen, DWORD *resOff )
213 {
214     union
215     {
216         IMAGE_NT_HEADERS32 nt32;
217         IMAGE_NT_HEADERS64 nt64;
218     } pehd;
219     DWORD pehdoffset;
220     PIMAGE_DATA_DIRECTORY resDataDir;
221     PIMAGE_SECTION_HEADER sections;
222     LPBYTE resSection;
223     DWORD resSectionSize;
224     const void *resDir;
225     const IMAGE_RESOURCE_DIRECTORY *resPtr;
226     const IMAGE_RESOURCE_DATA_ENTRY *resData;
227     int i, len, nSections;
228     BOOL ret = FALSE;
229
230     /* Read in PE header */
231     pehdoffset = LZSeek( lzfd, 0, SEEK_CUR );
232     len = LZRead( lzfd, (LPSTR)&pehd, sizeof(pehd) );
233     if (len < sizeof(pehd.nt32.FileHeader)) return 0;
234     if (len < sizeof(pehd)) memset( (char *)&pehd + len, 0, sizeof(pehd) - len );
235
236     switch (pehd.nt32.OptionalHeader.Magic)
237     {
238     case IMAGE_NT_OPTIONAL_HDR32_MAGIC:
239         resDataDir = pehd.nt32.OptionalHeader.DataDirectory + IMAGE_DIRECTORY_ENTRY_RESOURCE;
240         break;
241     case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
242         resDataDir = pehd.nt64.OptionalHeader.DataDirectory + IMAGE_DIRECTORY_ENTRY_RESOURCE;
243         break;
244     default:
245         return 0;
246     }
247
248     if ( !resDataDir->Size )
249     {
250         TRACE("No resources in PE dll\n" );
251         return FALSE;
252     }
253
254     /* Read in section table */
255     nSections = pehd.nt32.FileHeader.NumberOfSections;
256     sections = HeapAlloc( GetProcessHeap(), 0,
257                           nSections * sizeof(IMAGE_SECTION_HEADER) );
258     if ( !sections ) return FALSE;
259
260     len = FIELD_OFFSET( IMAGE_NT_HEADERS32, OptionalHeader ) + pehd.nt32.FileHeader.SizeOfOptionalHeader;
261     LZSeek( lzfd, pehdoffset + len, SEEK_SET );
262
263     if ( nSections * sizeof(IMAGE_SECTION_HEADER) !=
264          LZRead( lzfd, (LPSTR)sections, nSections * sizeof(IMAGE_SECTION_HEADER) ) )
265     {
266         HeapFree( GetProcessHeap(), 0, sections );
267         return FALSE;
268     }
269
270     /* Find resource section */
271     for ( i = 0; i < nSections; i++ )
272         if (    resDataDir->VirtualAddress >= sections[i].VirtualAddress
273              && resDataDir->VirtualAddress <  sections[i].VirtualAddress +
274                                               sections[i].SizeOfRawData )
275             break;
276
277     if ( i == nSections )
278     {
279         HeapFree( GetProcessHeap(), 0, sections );
280         TRACE("Couldn't find resource section\n" );
281         return FALSE;
282     }
283
284     /* Read in resource section */
285     resSectionSize = sections[i].SizeOfRawData;
286     resSection = HeapAlloc( GetProcessHeap(), 0, resSectionSize );
287     if ( !resSection )
288     {
289         HeapFree( GetProcessHeap(), 0, sections );
290         return FALSE;
291     }
292
293     LZSeek( lzfd, sections[i].PointerToRawData, SEEK_SET );
294     if ( resSectionSize != LZRead( lzfd, (char*)resSection, resSectionSize ) ) goto done;
295
296     /* Find resource */
297     resDir = resSection + (resDataDir->VirtualAddress - sections[i].VirtualAddress);
298
299     resPtr = resDir;
300     resPtr = find_entry_by_id( resPtr, VS_FILE_INFO, resDir );
301     if ( !resPtr )
302     {
303         TRACE("No typeid entry found\n" );
304         goto done;
305     }
306     resPtr = find_entry_by_id( resPtr, VS_VERSION_INFO, resDir );
307     if ( !resPtr )
308     {
309         TRACE("No resid entry found\n" );
310         goto done;
311     }
312     resPtr = find_entry_default( resPtr, resDir );
313     if ( !resPtr )
314     {
315         TRACE("No default language entry found\n" );
316         goto done;
317     }
318
319     /* Find resource data section */
320     resData = (const IMAGE_RESOURCE_DATA_ENTRY*)resPtr;
321     for ( i = 0; i < nSections; i++ )
322         if (    resData->OffsetToData >= sections[i].VirtualAddress
323              && resData->OffsetToData <  sections[i].VirtualAddress +
324                                          sections[i].SizeOfRawData )
325             break;
326
327     if ( i == nSections )
328     {
329         TRACE("Couldn't find resource data section\n" );
330         goto done;
331     }
332
333     /* Return resource data */
334     if ( resLen ) *resLen = resData->Size;
335     if ( resOff ) *resOff = resData->OffsetToData - sections[i].VirtualAddress
336                             + sections[i].PointerToRawData;
337     ret = TRUE;
338
339  done:
340     HeapFree( GetProcessHeap(), 0, resSection );
341     HeapFree( GetProcessHeap(), 0, sections );
342     return ret;
343 }
344
345
346 /***********************************************************************
347  *           find_version_resource         [internal]
348  */
349 DWORD find_version_resource( HFILE lzfd, DWORD *reslen, DWORD *offset )
350 {
351     DWORD magic = read_xx_header( lzfd );
352
353     switch (magic)
354     {
355     case IMAGE_OS2_SIGNATURE:
356         if (!find_ne_resource( lzfd, reslen, offset )) magic = 0;
357         break;
358     case IMAGE_NT_SIGNATURE:
359         if (!find_pe_resource( lzfd, reslen, offset )) magic = 0;
360         break;
361     }
362     return magic;
363 }