?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Introduce WINED3DFMT_INST and use it in CheckTextureCapability().
[wine/testsucceed.git] / dlls / kernel32 / resource.c
blobd3647394085b30f0dfffc333e28905a2c1da570a
1 /*
2 * Resources
3 *
4 * Copyright 1993 Robert J. Amstadt
5 * Copyright 1995, 2003 Alexandre Julliard
6 * Copyright 2006 Mike McCormack
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 #include "wine/port.h"
25
26 #include <stdarg.h>
27
28 #define NONAMELESSUNION
29 #define NONAMELESSSTRUCT
30 #include "ntstatus.h"
31 #define WIN32_NO_STATUS
32 #include "windef.h"
33 #include "winbase.h"
34 #include "winternl.h"
35 #include "wine/debug.h"
36 #include "wine/exception.h"
37 #include "wine/unicode.h"
38 #include "wine/list.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(resource);
41
42 /* retrieve the resource name to pass to the ntdll functions */
43 static NTSTATUS get_res_nameA( LPCSTR name, UNICODE_STRING *str )
44 {
45 if (!HIWORD(name))
46 {
47 str->Buffer = ULongToPtr(LOWORD(name));
48 return STATUS_SUCCESS;
49 }
50 if (name[0] == '#')
51 {
52 ULONG value;
53 if (RtlCharToInteger( name + 1, 10, &value ) != STATUS_SUCCESS || HIWORD(value))
54 return STATUS_INVALID_PARAMETER;
55 str->Buffer = ULongToPtr(value);
56 return STATUS_SUCCESS;
57 }
58 RtlCreateUnicodeStringFromAsciiz( str, name );
59 RtlUpcaseUnicodeString( str, str, FALSE );
60 return STATUS_SUCCESS;
61 }
62
63 /* retrieve the resource name to pass to the ntdll functions */
64 static NTSTATUS get_res_nameW( LPCWSTR name, UNICODE_STRING *str )
65 {
66 if (!HIWORD(name))
67 {
68 str->Buffer = ULongToPtr(LOWORD(name));
69 return STATUS_SUCCESS;
70 }
71 if (name[0] == '#')
72 {
73 ULONG value;
74 RtlInitUnicodeString( str, name + 1 );
75 if (RtlUnicodeStringToInteger( str, 10, &value ) != STATUS_SUCCESS || HIWORD(value))
76 return STATUS_INVALID_PARAMETER;
77 str->Buffer = ULongToPtr(value);
78 return STATUS_SUCCESS;
79 }
80 RtlCreateUnicodeString( str, name );
81 RtlUpcaseUnicodeString( str, str, FALSE );
82 return STATUS_SUCCESS;
83 }
84
85 /* implementation of FindResourceExA */
86 static HRSRC find_resourceA( HMODULE hModule, LPCSTR type, LPCSTR name, WORD lang )
87 {
88 NTSTATUS status;
89 UNICODE_STRING nameW, typeW;
90 LDR_RESOURCE_INFO info;
91 const IMAGE_RESOURCE_DATA_ENTRY *entry = NULL;
92
93 nameW.Buffer = NULL;
94 typeW.Buffer = NULL;
95
96 __TRY
97 {
98 if ((status = get_res_nameA( name, &nameW )) != STATUS_SUCCESS) goto done;
99 if ((status = get_res_nameA( type, &typeW )) != STATUS_SUCCESS) goto done;
100 info.Type = (ULONG_PTR)typeW.Buffer;
101 info.Name = (ULONG_PTR)nameW.Buffer;
102 info.Language = lang;
103 status = LdrFindResource_U( hModule, &info, 3, &entry );
104 done:
105 if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
106 }
107 __EXCEPT_PAGE_FAULT
108 {
109 SetLastError( ERROR_INVALID_PARAMETER );
110 }
111 __ENDTRY
112
113 if (HIWORD(nameW.Buffer)) HeapFree( GetProcessHeap(), 0, nameW.Buffer );
114 if (HIWORD(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
115 return (HRSRC)entry;
116 }
117
118
119 /* implementation of FindResourceExW */
120 static HRSRC find_resourceW( HMODULE hModule, LPCWSTR type, LPCWSTR name, WORD lang )
121 {
122 NTSTATUS status;
123 UNICODE_STRING nameW, typeW;
124 LDR_RESOURCE_INFO info;
125 const IMAGE_RESOURCE_DATA_ENTRY *entry = NULL;
126
127 nameW.Buffer = typeW.Buffer = NULL;
128
129 __TRY
130 {
131 if ((status = get_res_nameW( name, &nameW )) != STATUS_SUCCESS) goto done;
132 if ((status = get_res_nameW( type, &typeW )) != STATUS_SUCCESS) goto done;
133 info.Type = (ULONG_PTR)typeW.Buffer;
134 info.Name = (ULONG_PTR)nameW.Buffer;
135 info.Language = lang;
136 status = LdrFindResource_U( hModule, &info, 3, &entry );
137 done:
138 if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
139 }
140 __EXCEPT_PAGE_FAULT
141 {
142 SetLastError( ERROR_INVALID_PARAMETER );
143 }
144 __ENDTRY
145
146 if (HIWORD(nameW.Buffer)) HeapFree( GetProcessHeap(), 0, nameW.Buffer );
147 if (HIWORD(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
148 return (HRSRC)entry;
149 }
150
151 /**********************************************************************
152 * FindResourceExA (KERNEL32.@)
153 */
154 HRSRC WINAPI FindResourceExA( HMODULE hModule, LPCSTR type, LPCSTR name, WORD lang )
155 {
156 TRACE( "%p %s %s %04x\n", hModule, debugstr_a(type), debugstr_a(name), lang );
157
158 if (!hModule) hModule = GetModuleHandleW(0);
159 return find_resourceA( hModule, type, name, lang );
160 }
161
162
163 /**********************************************************************
164 * FindResourceA (KERNEL32.@)
165 */
166 HRSRC WINAPI FindResourceA( HMODULE hModule, LPCSTR name, LPCSTR type )
167 {
168 return FindResourceExA( hModule, type, name, MAKELANGID( LANG_NEUTRAL, SUBLANG_NEUTRAL ) );
169 }
170
171
172 /**********************************************************************
173 * FindResourceExW (KERNEL32.@)
174 */
175 HRSRC WINAPI FindResourceExW( HMODULE hModule, LPCWSTR type, LPCWSTR name, WORD lang )
176 {
177 TRACE( "%p %s %s %04x\n", hModule, debugstr_w(type), debugstr_w(name), lang );
178
179 if (!hModule) hModule = GetModuleHandleW(0);
180 return find_resourceW( hModule, type, name, lang );
181 }
182
183
184 /**********************************************************************
185 * FindResourceW (KERNEL32.@)
186 */
187 HRSRC WINAPI FindResourceW( HINSTANCE hModule, LPCWSTR name, LPCWSTR type )
188 {
189 return FindResourceExW( hModule, type, name, MAKELANGID( LANG_NEUTRAL, SUBLANG_NEUTRAL ) );
190 }
191
192
193 /**********************************************************************
194 * EnumResourceTypesA (KERNEL32.@)
195 */
196 BOOL WINAPI EnumResourceTypesA( HMODULE hmod, ENUMRESTYPEPROCA lpfun, LONG_PTR lparam )
197 {
198 int i;
199 BOOL ret = FALSE;
200 LPSTR type = NULL;
201 DWORD len = 0, newlen;
202 NTSTATUS status;
203 const IMAGE_RESOURCE_DIRECTORY *resdir;
204 const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
205 const IMAGE_RESOURCE_DIR_STRING_U *str;
206
207 TRACE( "%p %p %lx\n", hmod, lpfun, lparam );
208
209 if (!hmod) hmod = GetModuleHandleA( NULL );
210
211 if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &resdir )) != STATUS_SUCCESS)
212 {
213 SetLastError( RtlNtStatusToDosError(status) );
214 return FALSE;
215 }
216 et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
217 for (i = 0; i < resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries; i++)
218 {
219 if (et[i].u1.s1.NameIsString)
220 {
221 str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)resdir + et[i].u1.s1.NameOffset);
222 newlen = WideCharToMultiByte( CP_ACP, 0, str->NameString, str->Length, NULL, 0, NULL, NULL);
223 if (newlen + 1 > len)
224 {
225 len = newlen + 1;
226 HeapFree( GetProcessHeap(), 0, type );
227 if (!(type = HeapAlloc( GetProcessHeap(), 0, len ))) return FALSE;
228 }
229 WideCharToMultiByte( CP_ACP, 0, str->NameString, str->Length, type, len, NULL, NULL);
230 type[newlen] = 0;
231 ret = lpfun(hmod,type,lparam);
232 }
233 else
234 {
235 ret = lpfun( hmod, UIntToPtr(et[i].u1.s2.Id), lparam );
236 }
237 if (!ret) break;
238 }
239 HeapFree( GetProcessHeap(), 0, type );
240 return ret;
241 }
242
243
244 /**********************************************************************
245 * EnumResourceTypesW (KERNEL32.@)
246 */
247 BOOL WINAPI EnumResourceTypesW( HMODULE hmod, ENUMRESTYPEPROCW lpfun, LONG_PTR lparam )
248 {
249 int i, len = 0;
250 BOOL ret = FALSE;
251 LPWSTR type = NULL;
252 NTSTATUS status;
253 const IMAGE_RESOURCE_DIRECTORY *resdir;
254 const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
255 const IMAGE_RESOURCE_DIR_STRING_U *str;
256
257 TRACE( "%p %p %lx\n", hmod, lpfun, lparam );
258
259 if (!hmod) hmod = GetModuleHandleW( NULL );
260
261 if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &resdir )) != STATUS_SUCCESS)
262 {
263 SetLastError( RtlNtStatusToDosError(status) );
264 return FALSE;
265 }
266 et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
267 for (i = 0; i < resdir->NumberOfNamedEntries + resdir->NumberOfIdEntries; i++)
268 {
269 if (et[i].u1.s1.NameIsString)
270 {
271 str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)resdir + et[i].u1.s1.NameOffset);
272 if (str->Length + 1 > len)
273 {
274 len = str->Length + 1;
275 HeapFree( GetProcessHeap(), 0, type );
276 if (!(type = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return FALSE;
277 }
278 memcpy(type, str->NameString, str->Length * sizeof (WCHAR));
279 type[str->Length] = 0;
280 ret = lpfun(hmod,type,lparam);
281 }
282 else
283 {
284 ret = lpfun( hmod, UIntToPtr(et[i].u1.s2.Id), lparam );
285 }
286 if (!ret) break;
287 }
288 HeapFree( GetProcessHeap(), 0, type );
289 return ret;
290 }
291
292
293 /**********************************************************************
294 * EnumResourceNamesA (KERNEL32.@)
295 */
296 BOOL WINAPI EnumResourceNamesA( HMODULE hmod, LPCSTR type, ENUMRESNAMEPROCA lpfun, LONG_PTR lparam )
297 {
298 int i;
299 BOOL ret = FALSE;
300 DWORD len = 0, newlen;
301 LPSTR name = NULL;
302 NTSTATUS status;
303 UNICODE_STRING typeW;
304 LDR_RESOURCE_INFO info;
305 const IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
306 const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
307 const IMAGE_RESOURCE_DIR_STRING_U *str;
308
309 TRACE( "%p %s %p %lx\n", hmod, debugstr_a(type), lpfun, lparam );
310
311 if (!hmod) hmod = GetModuleHandleA( NULL );
312 typeW.Buffer = NULL;
313 if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &basedir )) != STATUS_SUCCESS)
314 goto done;
315 if ((status = get_res_nameA( type, &typeW )) != STATUS_SUCCESS)
316 goto done;
317 info.Type = (ULONG_PTR)typeW.Buffer;
318 if ((status = LdrFindResourceDirectory_U( hmod, &info, 1, &resdir )) != STATUS_SUCCESS)
319 goto done;
320
321 et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
322 __TRY
323 {
324 for (i = 0; i < resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries; i++)
325 {
326 if (et[i].u1.s1.NameIsString)
327 {
328 str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)basedir + et[i].u1.s1.NameOffset);
329 newlen = WideCharToMultiByte(CP_ACP, 0, str->NameString, str->Length, NULL, 0, NULL, NULL);
330 if (newlen + 1 > len)
331 {
332 len = newlen + 1;
333 HeapFree( GetProcessHeap(), 0, name );
334 if (!(name = HeapAlloc(GetProcessHeap(), 0, len + 1 )))
335 {
336 ret = FALSE;
337 break;
338 }
339 }
340 WideCharToMultiByte( CP_ACP, 0, str->NameString, str->Length, name, len, NULL, NULL );
341 name[newlen] = 0;
342 ret = lpfun(hmod,type,name,lparam);
343 }
344 else
345 {
346 ret = lpfun( hmod, type, UIntToPtr(et[i].u1.s2.Id), lparam );
347 }
348 if (!ret) break;
349 }
350 }
351 __EXCEPT_PAGE_FAULT
352 {
353 ret = FALSE;
354 status = STATUS_ACCESS_VIOLATION;
355 }
356 __ENDTRY
357
358 done:
359 HeapFree( GetProcessHeap(), 0, name );
360 if (HIWORD(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
361 if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
362 return ret;
363 }
364
365
366 /**********************************************************************
367 * EnumResourceNamesW (KERNEL32.@)
368 */
369 BOOL WINAPI EnumResourceNamesW( HMODULE hmod, LPCWSTR type, ENUMRESNAMEPROCW lpfun, LONG_PTR lparam )
370 {
371 int i, len = 0;
372 BOOL ret = FALSE;
373 LPWSTR name = NULL;
374 NTSTATUS status;
375 UNICODE_STRING typeW;
376 LDR_RESOURCE_INFO info;
377 const IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
378 const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
379 const IMAGE_RESOURCE_DIR_STRING_U *str;
380
381 TRACE( "%p %s %p %lx\n", hmod, debugstr_w(type), lpfun, lparam );
382
383 if (!hmod) hmod = GetModuleHandleW( NULL );
384 typeW.Buffer = NULL;
385 if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &basedir )) != STATUS_SUCCESS)
386 goto done;
387 if ((status = get_res_nameW( type, &typeW )) != STATUS_SUCCESS)
388 goto done;
389 info.Type = (ULONG_PTR)typeW.Buffer;
390 if ((status = LdrFindResourceDirectory_U( hmod, &info, 1, &resdir )) != STATUS_SUCCESS)
391 goto done;
392
393 et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
394 __TRY
395 {
396 for (i = 0; i < resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries; i++)
397 {
398 if (et[i].u1.s1.NameIsString)
399 {
400 str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)basedir + et[i].u1.s1.NameOffset);
401 if (str->Length + 1 > len)
402 {
403 len = str->Length + 1;
404 HeapFree( GetProcessHeap(), 0, name );
405 if (!(name = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
406 {
407 ret = FALSE;
408 break;
409 }
410 }
411 memcpy(name, str->NameString, str->Length * sizeof (WCHAR));
412 name[str->Length] = 0;
413 ret = lpfun(hmod,type,name,lparam);
414 }
415 else
416 {
417 ret = lpfun( hmod, type, UIntToPtr(et[i].u1.s2.Id), lparam );
418 }
419 if (!ret) break;
420 }
421 }
422 __EXCEPT_PAGE_FAULT
423 {
424 ret = FALSE;
425 status = STATUS_ACCESS_VIOLATION;
426 }
427 __ENDTRY
428 done:
429 HeapFree( GetProcessHeap(), 0, name );
430 if (HIWORD(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
431 if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
432 return ret;
433 }
434
435
436 /**********************************************************************
437 * EnumResourceLanguagesA (KERNEL32.@)
438 */
439 BOOL WINAPI EnumResourceLanguagesA( HMODULE hmod, LPCSTR type, LPCSTR name,
440 ENUMRESLANGPROCA lpfun, LONG_PTR lparam )
441 {
442 int i;
443 BOOL ret = FALSE;
444 NTSTATUS status;
445 UNICODE_STRING typeW, nameW;
446 LDR_RESOURCE_INFO info;
447 const IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
448 const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
449
450 TRACE( "%p %s %s %p %lx\n", hmod, debugstr_a(type), debugstr_a(name), lpfun, lparam );
451
452 if (!hmod) hmod = GetModuleHandleA( NULL );
453 typeW.Buffer = nameW.Buffer = NULL;
454 if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &basedir )) != STATUS_SUCCESS)
455 goto done;
456 if ((status = get_res_nameA( type, &typeW )) != STATUS_SUCCESS)
457 goto done;
458 if ((status = get_res_nameA( name, &nameW )) != STATUS_SUCCESS)
459 goto done;
460 info.Type = (ULONG_PTR)typeW.Buffer;
461 info.Name = (ULONG_PTR)nameW.Buffer;
462 if ((status = LdrFindResourceDirectory_U( hmod, &info, 2, &resdir )) != STATUS_SUCCESS)
463 goto done;
464
465 et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
466 __TRY
467 {
468 for (i = 0; i < resdir->NumberOfNamedEntries + resdir->NumberOfIdEntries; i++)
469 {
470 ret = lpfun( hmod, type, name, et[i].u1.s2.Id, lparam );
471 if (!ret) break;
472 }
473 }
474 __EXCEPT_PAGE_FAULT
475 {
476 ret = FALSE;
477 status = STATUS_ACCESS_VIOLATION;
478 }
479 __ENDTRY
480 done:
481 if (HIWORD(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
482 if (HIWORD(nameW.Buffer)) HeapFree( GetProcessHeap(), 0, nameW.Buffer );
483 if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
484 return ret;
485 }
486
487
488 /**********************************************************************
489 * EnumResourceLanguagesW (KERNEL32.@)
490 */
491 BOOL WINAPI EnumResourceLanguagesW( HMODULE hmod, LPCWSTR type, LPCWSTR name,
492 ENUMRESLANGPROCW lpfun, LONG_PTR lparam )
493 {
494 int i;
495 BOOL ret = FALSE;
496 NTSTATUS status;
497 UNICODE_STRING typeW, nameW;
498 LDR_RESOURCE_INFO info;
499 const IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
500 const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
501
502 TRACE( "%p %s %s %p %lx\n", hmod, debugstr_w(type), debugstr_w(name), lpfun, lparam );
503
504 if (!hmod) hmod = GetModuleHandleW( NULL );
505 typeW.Buffer = nameW.Buffer = NULL;
506 if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &basedir )) != STATUS_SUCCESS)
507 goto done;
508 if ((status = get_res_nameW( type, &typeW )) != STATUS_SUCCESS)
509 goto done;
510 if ((status = get_res_nameW( name, &nameW )) != STATUS_SUCCESS)
511 goto done;
512 info.Type = (ULONG_PTR)typeW.Buffer;
513 info.Name = (ULONG_PTR)nameW.Buffer;
514 if ((status = LdrFindResourceDirectory_U( hmod, &info, 2, &resdir )) != STATUS_SUCCESS)
515 goto done;
516
517 et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
518 __TRY
519 {
520 for (i = 0; i < resdir->NumberOfNamedEntries + resdir->NumberOfIdEntries; i++)
521 {
522 ret = lpfun( hmod, type, name, et[i].u1.s2.Id, lparam );
523 if (!ret) break;
524 }
525 }
526 __EXCEPT_PAGE_FAULT
527 {
528 ret = FALSE;
529 status = STATUS_ACCESS_VIOLATION;
530 }
531 __ENDTRY
532 done:
533 if (HIWORD(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
534 if (HIWORD(nameW.Buffer)) HeapFree( GetProcessHeap(), 0, nameW.Buffer );
535 if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
536 return ret;
537 }
538
539
540 /**********************************************************************
541 * LoadResource (KERNEL32.@)
542 */
543 HGLOBAL WINAPI LoadResource( HINSTANCE hModule, HRSRC hRsrc )
544 {
545 NTSTATUS status;
546 void *ret = NULL;
547
548 TRACE( "%p %p\n", hModule, hRsrc );
549
550 if (!hRsrc) return 0;
551 if (!hModule) hModule = GetModuleHandleA( NULL );
552 status = LdrAccessResource( hModule, (IMAGE_RESOURCE_DATA_ENTRY *)hRsrc, &ret, NULL );
553 if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
554 return ret;
555 }
556
557
558 /**********************************************************************
559 * LockResource (KERNEL32.@)
560 */
561 LPVOID WINAPI LockResource( HGLOBAL handle )
562 {
563 return handle;
564 }
565
566
567 /**********************************************************************
568 * FreeResource (KERNEL32.@)
569 */
570 BOOL WINAPI FreeResource( HGLOBAL handle )
571 {
572 return 0;
573 }
574
575
576 /**********************************************************************
577 * SizeofResource (KERNEL32.@)
578 */
579 DWORD WINAPI SizeofResource( HINSTANCE hModule, HRSRC hRsrc )
580 {
581 if (!hRsrc) return 0;
582 return ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->Size;
583 }
584
585 /*
586 * Data structure for updating resources.
587 * Type/Name/Language is a keyset for accessing resource data.
588 *
589 * QUEUEDUPDATES (root) ->
590 * list of struct resource_dir_entry (Type) ->
591 * list of struct resource_dir_entry (Name) ->
592 * list of struct resource_data Language + Data
593 */
594
595 typedef struct
596 {
597 LPWSTR pFileName;
598 BOOL bDeleteExistingResources;
599 struct list root;
600 } QUEUEDUPDATES;
601
602 /* this structure is shared for types and names */
603 struct resource_dir_entry {
604 struct list entry;
605 LPWSTR id;
606 struct list children;
607 };
608
609 /* this structure is the leaf */
610 struct resource_data {
611 struct list entry;
612 LANGID lang;
613 DWORD codepage;
614 DWORD cbData;
615 void *lpData;
616 };
617
618 static int resource_strcmp( LPCWSTR a, LPCWSTR b )
619 {
620 if ( a == b )
621 return 0;
622 if (HIWORD( a ) && HIWORD( b ) )
623 return lstrcmpW( a, b );
624 /* strings come before ids */
625 if (HIWORD( a ) && !HIWORD( b ))
626 return -1;
627 if (HIWORD( b ) && !HIWORD( a ))
628 return 1;
629 return ( a < b ) ? -1 : 1;
630 }
631
632 static struct resource_dir_entry *find_resource_dir_entry( struct list *dir, LPCWSTR id )
633 {
634 struct resource_dir_entry *ent;
635
636 /* match either IDs or strings */
637 LIST_FOR_EACH_ENTRY( ent, dir, struct resource_dir_entry, entry )
638 if (!resource_strcmp( id, ent->id ))
639 return ent;
640
641 return NULL;
642 }
643
644 static struct resource_data *find_resource_data( struct list *dir, LANGID lang )
645 {
646 struct resource_data *res_data;
647
648 /* match only languages here */
649 LIST_FOR_EACH_ENTRY( res_data, dir, struct resource_data, entry )
650 if ( lang == res_data->lang )
651 return res_data;
652
653 return NULL;
654 }
655
656 static void add_resource_dir_entry( struct list *dir, struct resource_dir_entry *resdir )
657 {
658 struct resource_dir_entry *ent;
659
660 LIST_FOR_EACH_ENTRY( ent, dir, struct resource_dir_entry, entry )
661 {
662 if (0>resource_strcmp( ent->id, resdir->id ))
663 continue;
664
665 list_add_before( &ent->entry, &resdir->entry );
666 return;
667 }
668 list_add_tail( dir, &resdir->entry );
669 }
670
671 static void add_resource_data_entry( struct list *dir, struct resource_data *resdata )
672 {
673 struct resource_data *ent;
674
675 LIST_FOR_EACH_ENTRY( ent, dir, struct resource_data, entry )
676 {
677 if (ent->lang < resdata->lang)
678 continue;
679
680 list_add_before( &ent->entry, &resdata->entry );
681 return;
682 }
683 list_add_tail( dir, &resdata->entry );
684 }
685
686 static LPWSTR res_strdupW( LPCWSTR str )
687 {
688 LPWSTR ret;
689 UINT len;
690
691 if (HIWORD(str) == 0)
692 return (LPWSTR) (UINT_PTR) LOWORD(str);
693 len = (lstrlenW( str ) + 1) * sizeof (WCHAR);
694 ret = HeapAlloc( GetProcessHeap(), 0, len );
695 memcpy( ret, str, len );
696 return ret;
697 }
698
699 static void res_free_str( LPWSTR str )
700 {
701 if (HIWORD(str))
702 HeapFree( GetProcessHeap(), 0, str );
703 }
704
705 static BOOL update_add_resource( QUEUEDUPDATES *updates, LPCWSTR Type, LPCWSTR Name,
706 struct resource_data *resdata, BOOL overwrite_existing )
707 {
708 struct resource_dir_entry *restype, *resname;
709 struct resource_data *existing;
710
711 TRACE("%p %s %s %p %d\n", updates,
712 debugstr_w(Type), debugstr_w(Name), resdata, overwrite_existing );
713
714 restype = find_resource_dir_entry( &updates->root, Type );
715 if (!restype)
716 {
717 restype = HeapAlloc( GetProcessHeap(), 0, sizeof *restype );
718 restype->id = res_strdupW( Type );
719 list_init( &restype->children );
720 add_resource_dir_entry( &updates->root, restype );
721 }
722
723 resname = find_resource_dir_entry( &restype->children, Name );
724 if (!resname)
725 {
726 resname = HeapAlloc( GetProcessHeap(), 0, sizeof *resname );
727 resname->id = res_strdupW( Name );
728 list_init( &resname->children );
729 add_resource_dir_entry( &restype->children, resname );
730 }
731
732 /*
733 * If there's an existing resource entry with matching (Type,Name,Language)
734 * it needs to be removed before adding the new data.
735 */
736 existing = find_resource_data( &resname->children, resdata->lang );
737 if (existing)
738 {
739 if (!overwrite_existing)
740 return FALSE;
741 list_remove( &existing->entry );
742 HeapFree( GetProcessHeap(), 0, existing );
743 }
744
745 add_resource_data_entry( &resname->children, resdata );
746
747 return TRUE;
748 }
749
750 static struct resource_data *allocate_resource_data( WORD Language, DWORD codepage,
751 LPVOID lpData, DWORD cbData, BOOL copy_data )
752 {
753 struct resource_data *resdata;
754
755 if (!lpData || !cbData)
756 return NULL;
757
758 resdata = HeapAlloc( GetProcessHeap(), 0, sizeof *resdata + (copy_data ? cbData : 0) );
759 if (resdata)
760 {
761 resdata->lang = Language;
762 resdata->codepage = codepage;
763 resdata->cbData = cbData;
764 if (copy_data)
765 {
766 resdata->lpData = &resdata[1];
767 memcpy( resdata->lpData, lpData, cbData );
768 }
769 else
770 resdata->lpData = lpData;
771 }
772
773 return resdata;
774 }
775
776 static void free_resource_directory( struct list *head, int level )
777 {
778 struct list *ptr = NULL;
779
780 while ((ptr = list_head( head )))
781 {
782 list_remove( ptr );
783 if (level)
784 {
785 struct resource_dir_entry *ent;
786
787 ent = LIST_ENTRY( ptr, struct resource_dir_entry, entry );
788 res_free_str( ent->id );
789 free_resource_directory( &ent->children, level - 1 );
790 HeapFree(GetProcessHeap(), 0, ent);
791 }
792 else
793 {
794 struct resource_data *data;
795
796 data = LIST_ENTRY( ptr, struct resource_data, entry );
797 HeapFree( GetProcessHeap(), 0, data );
798 }
799 }
800 }
801
802 static IMAGE_NT_HEADERS *get_nt_header( void *base, DWORD mapping_size )
803 {
804 IMAGE_NT_HEADERS *nt;
805 IMAGE_DOS_HEADER *dos;
806
807 if (mapping_size<sizeof (*dos))
808 return NULL;
809
810 dos = base;
811 if (dos->e_magic != IMAGE_DOS_SIGNATURE)
812 return NULL;
813
814 if ((dos->e_lfanew + sizeof (*nt)) > mapping_size)
815 return NULL;
816
817 nt = (void*) ((BYTE*)base + dos->e_lfanew);
818
819 if (nt->Signature != IMAGE_NT_SIGNATURE)
820 return NULL;
821
822 return nt;
823 }
824
825 static IMAGE_SECTION_HEADER *get_section_header( void *base, DWORD mapping_size, DWORD *num_sections )
826 {
827 IMAGE_NT_HEADERS *nt;
828 IMAGE_SECTION_HEADER *sec;
829 DWORD section_ofs;
830
831 nt = get_nt_header( base, mapping_size );
832 if (!nt)
833 return NULL;
834
835 /* check that we don't go over the end of the file accessing the sections */
836 section_ofs = FIELD_OFFSET(IMAGE_NT_HEADERS, OptionalHeader) + nt->FileHeader.SizeOfOptionalHeader;
837 if ((nt->FileHeader.NumberOfSections * sizeof (*sec) + section_ofs) > mapping_size)
838 return NULL;
839
840 if (num_sections)
841 *num_sections = nt->FileHeader.NumberOfSections;
842
843 /* from here we have a valid PE exe to update */
844 return (void*) ((BYTE*)nt + section_ofs);
845 }
846
847 static BOOL check_pe_exe( HANDLE file, QUEUEDUPDATES *updates )
848 {
849 const IMAGE_NT_HEADERS *nt;
850 const IMAGE_SECTION_HEADER *sec;
851 BOOL ret = FALSE;
852 HANDLE mapping;
853 DWORD mapping_size, num_sections = 0;
854 void *base = NULL;
855
856 mapping_size = GetFileSize( file, NULL );
857
858 mapping = CreateFileMappingW( file, NULL, PAGE_READONLY, 0, 0, NULL );
859 if (!mapping)
860 goto done;
861
862 base = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, mapping_size );
863 if (!base)
864 goto done;
865
866 nt = get_nt_header( base, mapping_size );
867 if (!nt)
868 goto done;
869
870 TRACE("resources: %08x %08x\n",
871 nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress,
872 nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].Size);
873
874 sec = get_section_header( base, mapping_size, &num_sections );
875 if (!sec)
876 goto done;
877
878 ret = TRUE;
879
880 done:
881 if (base)
882 UnmapViewOfFile( base );
883 if (mapping)
884 CloseHandle( mapping );
885
886 return ret;
887 }
888
889 struct resource_size_info {
890 DWORD types_ofs;
891 DWORD names_ofs;
892 DWORD langs_ofs;
893 DWORD data_entry_ofs;
894 DWORD strings_ofs;
895 DWORD data_ofs;
896 DWORD total_size;
897 };
898
899 struct mapping_info {
900 HANDLE file;
901 HANDLE mapping;
902 void *base;
903 DWORD size;
904 BOOL read_write;
905 };
906
907 static const IMAGE_SECTION_HEADER *section_from_rva( void *base, DWORD mapping_size, DWORD rva )
908 {
909 const IMAGE_SECTION_HEADER *sec;
910 DWORD num_sections = 0;
911 int i;
912
913 sec = get_section_header( base, mapping_size, &num_sections );
914 if (!sec)
915 return NULL;
916
917 for (i=num_sections-1; i>=0; i--)
918 {
919 if (sec[i].VirtualAddress <= rva &&
920 rva <= (DWORD)sec[i].VirtualAddress + sec[i].SizeOfRawData)
921 {
922 return &sec[i];
923 }
924 }
925
926 return NULL;
927 }
928
929 static void *address_from_rva( void *base, DWORD mapping_size, DWORD rva, DWORD len )
930 {
931 const IMAGE_SECTION_HEADER *sec;
932
933 sec = section_from_rva( base, mapping_size, rva );
934 if (!sec)
935 return NULL;
936
937 if (rva + len <= (DWORD)sec->VirtualAddress + sec->SizeOfRawData)
938 return (void*)((LPBYTE) base + (sec->PointerToRawData + rva - sec->VirtualAddress));
939
940 return NULL;
941 }
942
943 static LPWSTR resource_dup_string( const IMAGE_RESOURCE_DIRECTORY *root, const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry )
944 {
945 const IMAGE_RESOURCE_DIR_STRING_U* string;
946 LPWSTR s;
947
948 if (!entry->u1.s1.NameIsString)
949 return UIntToPtr(entry->u1.s2.Id);
950
951 string = (const IMAGE_RESOURCE_DIR_STRING_U*) (((const char *)root) + entry->u1.s1.NameOffset);
952 s = HeapAlloc(GetProcessHeap(), 0, (string->Length + 1)*sizeof (WCHAR) );
953 memcpy( s, string->NameString, (string->Length + 1)*sizeof (WCHAR) );
954 s[string->Length] = 0;
955
956 return s;
957 }
958
959 /* this function is based on the code in winedump's pe.c */
960 static BOOL enumerate_mapped_resources( QUEUEDUPDATES *updates,
961 void *base, DWORD mapping_size,
962 const IMAGE_RESOURCE_DIRECTORY *root )
963 {
964 const IMAGE_RESOURCE_DIRECTORY *namedir, *langdir;
965 const IMAGE_RESOURCE_DIRECTORY_ENTRY *e1, *e2, *e3;
966 const IMAGE_RESOURCE_DATA_ENTRY *data;
967 DWORD i, j, k;
968
969 TRACE("version (%d.%d) %d named %d id entries\n",
970 root->MajorVersion, root->MinorVersion, root->NumberOfNamedEntries, root->NumberOfIdEntries);
971
972 for (i = 0; i< root->NumberOfNamedEntries + root->NumberOfIdEntries; i++)
973 {
974 LPWSTR Type;
975
976 e1 = (const IMAGE_RESOURCE_DIRECTORY_ENTRY*)(root + 1) + i;
977
978 Type = resource_dup_string( root, e1 );
979
980 namedir = (const IMAGE_RESOURCE_DIRECTORY *)((const char *)root + e1->u2.s3.OffsetToDirectory);
981 for (j = 0; j < namedir->NumberOfNamedEntries + namedir->NumberOfIdEntries; j++)
982 {
983 LPWSTR Name;
984
985 e2 = (const IMAGE_RESOURCE_DIRECTORY_ENTRY*)(namedir + 1) + j;
986
987 Name = resource_dup_string( root, e2 );
988
989 langdir = (const IMAGE_RESOURCE_DIRECTORY *)((const char *)root + e2->u2.s3.OffsetToDirectory);
990 for (k = 0; k < langdir->NumberOfNamedEntries + langdir->NumberOfIdEntries; k++)
991 {
992 LANGID Lang;
993 void *p;
994 struct resource_data *resdata;
995
996 e3 = (const IMAGE_RESOURCE_DIRECTORY_ENTRY*)(langdir + 1) + k;
997
998 Lang = e3->u1.s2.Id;
999
1000 data = (const IMAGE_RESOURCE_DATA_ENTRY *)((const char *)root + e3->u2.OffsetToData);
1001
1002 p = address_from_rva( base, mapping_size, data->OffsetToData, data->Size );
1003
1004 resdata = allocate_resource_data( Lang, data->CodePage, p, data->Size, FALSE );
1005 if (resdata)
1006 {
1007 if (!update_add_resource( updates, Type, Name, resdata, FALSE ))
1008 HeapFree( GetProcessHeap(), 0, resdata );
1009 }
1010 }
1011 res_free_str( Name );
1012 }
1013 res_free_str( Type );
1014 }
1015
1016 return TRUE;
1017 }
1018
1019 static BOOL read_mapped_resources( QUEUEDUPDATES *updates, void *base, DWORD mapping_size )
1020 {
1021 const IMAGE_RESOURCE_DIRECTORY *root;
1022 const IMAGE_NT_HEADERS *nt;
1023 const IMAGE_SECTION_HEADER *sec;
1024 DWORD num_sections = 0, i;
1025
1026 nt = get_nt_header( base, mapping_size );
1027 if (!nt)
1028 return FALSE;
1029
1030 sec = get_section_header( base, mapping_size, &num_sections );
1031 if (!sec)
1032 return FALSE;
1033
1034 for (i=0; i<num_sections; i++)
1035 if (!memcmp(sec[i].Name, ".rsrc", 6))
1036 break;
1037
1038 if (i == num_sections)
1039 return TRUE;
1040
1041 /* check the resource data is inside the mapping */
1042 if (sec[i].PointerToRawData > mapping_size ||
1043 (sec[i].PointerToRawData + sec[i].SizeOfRawData) > mapping_size)
1044 return TRUE;
1045
1046 TRACE("found .rsrc at %08x, size %08x\n", sec[i].PointerToRawData, sec[i].SizeOfRawData);
1047
1048 if (!sec[i].PointerToRawData || sec[i].SizeOfRawData < sizeof(IMAGE_RESOURCE_DIRECTORY))
1049 return TRUE;
1050
1051 root = (void*) ((BYTE*)base + sec[i].PointerToRawData);
1052 enumerate_mapped_resources( updates, base, mapping_size, root );
1053
1054 return TRUE;
1055 }
1056
1057 static BOOL map_file_into_memory( struct mapping_info *mi )
1058 {
1059 DWORD page_attr, perm;
1060
1061 if (mi->read_write)
1062 {
1063 page_attr = PAGE_READWRITE;
1064 perm = FILE_MAP_WRITE | FILE_MAP_READ;
1065 }
1066 else
1067 {
1068 page_attr = PAGE_READONLY;
1069 perm = FILE_MAP_READ;
1070 }
1071
1072 mi->mapping = CreateFileMappingW( mi->file, NULL, page_attr, 0, 0, NULL );
1073 if (!mi->mapping)
1074 return FALSE;
1075
1076 mi->base = MapViewOfFile( mi->mapping, perm, 0, 0, mi->size );
1077 if (!mi->base)
1078 return FALSE;
1079
1080 return TRUE;
1081 }
1082
1083 static BOOL unmap_file_from_memory( struct mapping_info *mi )
1084 {
1085 if (mi->base)
1086 UnmapViewOfFile( mi->base );
1087 mi->base = NULL;
1088 if (mi->mapping)
1089 CloseHandle( mi->mapping );
1090 mi->mapping = NULL;
1091 return TRUE;
1092 }
1093
1094 static void destroy_mapping( struct mapping_info *mi )
1095 {
1096 if (!mi)
1097 return;
1098 unmap_file_from_memory( mi );
1099 if (mi->file)
1100 CloseHandle( mi->file );
1101 HeapFree( GetProcessHeap(), 0, mi );
1102 }
1103
1104 static struct mapping_info *create_mapping( LPCWSTR name, BOOL rw )
1105 {
1106 struct mapping_info *mi;
1107
1108 mi = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof *mi );
1109 if (!mi)
1110 return NULL;
1111
1112 mi->read_write = rw;
1113
1114 mi->file = CreateFileW( name, GENERIC_READ | (rw ? GENERIC_WRITE : 0),
1115 0, NULL, OPEN_EXISTING, 0, 0 );
1116
1117 if (mi->file != INVALID_HANDLE_VALUE)
1118 {
1119 mi->size = GetFileSize( mi->file, NULL );
1120
1121 if (map_file_into_memory( mi ))
1122 return mi;
1123 }
1124
1125 unmap_file_from_memory( mi );
1126 HeapFree( GetProcessHeap(), 0, mi );
1127
1128 return NULL;
1129 }
1130
1131 static BOOL resize_mapping( struct mapping_info *mi, DWORD new_size )
1132 {
1133 if (!unmap_file_from_memory( mi ))
1134 return FALSE;
1135
1136 /* change the file size */
1137 SetFilePointer( mi->file, new_size, NULL, FILE_BEGIN );
1138 if (!SetEndOfFile( mi->file ))
1139 {
1140 ERR("failed to set file size to %08x\n", new_size );
1141 return FALSE;
1142 }
1143
1144 mi->size = new_size;
1145
1146 return map_file_into_memory( mi );
1147 }
1148
1149 static void get_resource_sizes( QUEUEDUPDATES *updates, struct resource_size_info *si )
1150 {
1151 struct resource_dir_entry *types, *names;
1152 struct resource_data *data;
1153 DWORD num_types = 0, num_names = 0, num_langs = 0, strings_size = 0, data_size = 0;
1154
1155 memset( si, 0, sizeof *si );
1156
1157 LIST_FOR_EACH_ENTRY( types, &updates->root, struct resource_dir_entry, entry )
1158 {
1159 num_types++;
1160 if (HIWORD( types->id ))
1161 strings_size += sizeof (WORD) + lstrlenW( types->id )*sizeof (WCHAR);
1162
1163 LIST_FOR_EACH_ENTRY( names, &types->children, struct resource_dir_entry, entry )
1164 {
1165 num_names++;
1166
1167 if (HIWORD( names->id ))
1168 strings_size += sizeof (WORD) + lstrlenW( names->id )*sizeof (WCHAR);
1169
1170 LIST_FOR_EACH_ENTRY( data, &names->children, struct resource_data, entry )
1171 {
1172 num_langs++;
1173 data_size += (data->cbData + 3) & ~3;
1174 }
1175 }
1176 }
1177
1178 /* names are at the end of the types */
1179 si->names_ofs = sizeof (IMAGE_RESOURCE_DIRECTORY) +
1180 num_types * sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
1181
1182 /* language directories are at the end of the names */
1183 si->langs_ofs = si->names_ofs +
1184 num_types * sizeof (IMAGE_RESOURCE_DIRECTORY) +
1185 num_names * sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
1186
1187 si->data_entry_ofs = si->langs_ofs +
1188 num_names * sizeof (IMAGE_RESOURCE_DIRECTORY) +
1189 num_langs * sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
1190
1191 si->strings_ofs = si->data_entry_ofs +
1192 num_langs * sizeof (IMAGE_RESOURCE_DATA_ENTRY);
1193
1194 si->data_ofs = si->strings_ofs + ((strings_size + 3) & ~3);
1195
1196 si->total_size = si->data_ofs + data_size;
1197
1198 TRACE("names %08x langs %08x data entries %08x strings %08x data %08x total %08x\n",
1199 si->names_ofs, si->langs_ofs, si->data_entry_ofs,
1200 si->strings_ofs, si->data_ofs, si->total_size);
1201 }
1202
1203 static void res_write_padding( BYTE *res_base, DWORD size )
1204 {
1205 static const BYTE pad[] = {
1206 'P','A','D','D','I','N','G','X','X','P','A','D','D','I','N','G' };
1207 DWORD i;
1208
1209 for ( i = 0; i < size / sizeof pad; i++ )
1210 memcpy( &res_base[i*sizeof pad], pad, sizeof pad );
1211 memcpy( &res_base[i*sizeof pad], pad, size%sizeof pad );
1212 }
1213
1214 static BOOL write_resources( QUEUEDUPDATES *updates, LPBYTE base, struct resource_size_info *si, DWORD rva )
1215 {
1216 struct resource_dir_entry *types, *names;
1217 struct resource_data *data;
1218 IMAGE_RESOURCE_DIRECTORY *root;
1219
1220 TRACE("%p %p %p %08x\n", updates, base, si, rva );
1221
1222 memset( base, 0, si->total_size );
1223
1224 /* the root entry always exists */
1225 root = (IMAGE_RESOURCE_DIRECTORY*) base;
1226 memset( root, 0, sizeof *root );
1227 root->MajorVersion = 4;
1228 si->types_ofs = sizeof *root;
1229 LIST_FOR_EACH_ENTRY( types, &updates->root, struct resource_dir_entry, entry )
1230 {
1231 IMAGE_RESOURCE_DIRECTORY_ENTRY *e1;
1232 IMAGE_RESOURCE_DIRECTORY *namedir;
1233
1234 e1 = (IMAGE_RESOURCE_DIRECTORY_ENTRY*) &base[si->types_ofs];
1235 memset( e1, 0, sizeof *e1 );
1236 if (HIWORD( types->id ))
1237 {
1238 WCHAR *strings;
1239 DWORD len;
1240
1241 root->NumberOfNamedEntries++;
1242 e1->u1.s1.NameIsString = 1;
1243 e1->u1.s1.NameOffset = si->strings_ofs;
1244
1245 strings = (WCHAR*) &base[si->strings_ofs];
1246 len = lstrlenW( types->id );
1247 strings[0] = len;
1248 memcpy( &strings[1], types->id, len * sizeof (WCHAR) );
1249 si->strings_ofs += (len + 1) * sizeof (WCHAR);
1250 }
1251 else
1252 {
1253 root->NumberOfIdEntries++;
1254 e1->u1.s2.Id = LOWORD( types->id );
1255 }
1256 e1->u2.s3.OffsetToDirectory = si->names_ofs;
1257 e1->u2.s3.DataIsDirectory = TRUE;
1258 si->types_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
1259
1260 namedir = (IMAGE_RESOURCE_DIRECTORY*) &base[si->names_ofs];
1261 memset( namedir, 0, sizeof *namedir );
1262 namedir->MajorVersion = 4;
1263 si->names_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY);
1264
1265 LIST_FOR_EACH_ENTRY( names, &types->children, struct resource_dir_entry, entry )
1266 {
1267 IMAGE_RESOURCE_DIRECTORY_ENTRY *e2;
1268 IMAGE_RESOURCE_DIRECTORY *langdir;
1269
1270 e2 = (IMAGE_RESOURCE_DIRECTORY_ENTRY*) &base[si->names_ofs];
1271 memset( e2, 0, sizeof *e2 );
1272 if (HIWORD( names->id ))
1273 {
1274 WCHAR *strings;
1275 DWORD len;
1276
1277 namedir->NumberOfNamedEntries++;
1278 e2->u1.s1.NameIsString = 1;
1279 e2->u1.s1.NameOffset = si->strings_ofs;
1280
1281 strings = (WCHAR*) &base[si->strings_ofs];
1282 len = lstrlenW( names->id );
1283 strings[0] = len;
1284 memcpy( &strings[1], names->id, len * sizeof (WCHAR) );
1285 si->strings_ofs += (len + 1) * sizeof (WCHAR);
1286 }
1287 else
1288 {
1289 namedir->NumberOfIdEntries++;
1290 e2->u1.s2.Id = LOWORD( names->id );
1291 }
1292 e2->u2.s3.OffsetToDirectory = si->langs_ofs;
1293 e2->u2.s3.DataIsDirectory = TRUE;
1294 si->names_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
1295
1296 langdir = (IMAGE_RESOURCE_DIRECTORY*) &base[si->langs_ofs];
1297 memset( langdir, 0, sizeof *langdir );
1298 langdir->MajorVersion = 4;
1299 si->langs_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY);
1300
1301 LIST_FOR_EACH_ENTRY( data, &names->children, struct resource_data, entry )
1302 {
1303 IMAGE_RESOURCE_DIRECTORY_ENTRY *e3;
1304 IMAGE_RESOURCE_DATA_ENTRY *de;
1305 int pad_size;
1306
1307 e3 = (IMAGE_RESOURCE_DIRECTORY_ENTRY*) &base[si->langs_ofs];
1308 memset( e3, 0, sizeof *e3 );
1309 langdir->NumberOfIdEntries++;
1310 e3->u1.s2.Id = LOWORD( data->lang );
1311 e3->u2.OffsetToData = si->data_entry_ofs;
1312
1313 si->langs_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
1314
1315 /* write out all the data entries */
1316 de = (IMAGE_RESOURCE_DATA_ENTRY*) &base[si->data_entry_ofs];
1317 memset( de, 0, sizeof *de );
1318 de->OffsetToData = si->data_ofs + rva;
1319 de->Size = data->cbData;
1320 de->CodePage = data->codepage;
1321 si->data_entry_ofs += sizeof (IMAGE_RESOURCE_DATA_ENTRY);
1322
1323 /* write out the resource data */
1324 memcpy( &base[si->data_ofs], data->lpData, data->cbData );
1325 si->data_ofs += data->cbData;
1326
1327 pad_size = (-si->data_ofs)&3;
1328 res_write_padding( &base[si->data_ofs], pad_size );
1329 si->data_ofs += pad_size;
1330 }
1331 }
1332 }
1333
1334 return TRUE;
1335 }
1336
1337 /*
1338 * FIXME:
1339 * Assumes that the resources are in .rsrc
1340 * and .rsrc is the last section in the file.
1341 * Not sure whether updating resources will other cases on Windows.
1342 * If the resources lie in a section containing other data,
1343 * resizing that section could possibly cause trouble.
1344 * If the section with the resources isn't last, the remaining
1345 * sections need to be moved down in the file, and the section header
1346 * would need to be adjusted.
1347 * If we needed to add a section, what would we name it?
1348 * If we needed to add a section and there wasn't space in the file
1349 * header, how would that work?
1350 * Seems that at least some of these cases can't be handled properly.
1351 */
1352 static IMAGE_SECTION_HEADER *get_resource_section( void *base, DWORD mapping_size )
1353 {
1354 IMAGE_SECTION_HEADER *sec;
1355 IMAGE_NT_HEADERS *nt;
1356 DWORD i, num_sections = 0;
1357
1358 nt = get_nt_header( base, mapping_size );
1359 if (!nt)
1360 return NULL;
1361
1362 sec = get_section_header( base, mapping_size, &num_sections );
1363 if (!sec)
1364 return NULL;
1365
1366 /* find the resources section */
1367 for (i=0; i<num_sections; i++)
1368 if (!memcmp(sec[i].Name, ".rsrc", 6))
1369 break;
1370
1371 if (i == num_sections)
1372 {
1373 FIXME(".rsrc doesn't exist\n");
1374 return NULL;
1375 }
1376
1377 return &sec[i];
1378 }
1379
1380 static DWORD get_init_data_size( void *base, DWORD mapping_size )
1381 {
1382 DWORD i, sz = 0, num_sections = 0;
1383 IMAGE_SECTION_HEADER *s;
1384
1385 s = get_section_header( base, mapping_size, &num_sections );
1386
1387 for (i=0; i<num_sections; i++)
1388 if (s[i].Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
1389 sz += s[i].SizeOfRawData;
1390
1391 TRACE("size = %08x\n", sz);
1392
1393 return sz;
1394 }
1395
1396 static BOOL write_raw_resources( QUEUEDUPDATES *updates )
1397 {
1398 static const WCHAR prefix[] = { 'r','e','s','u',0 };
1399 WCHAR tempdir[MAX_PATH], tempfile[MAX_PATH];
1400 DWORD mapping_size, section_size, old_size;
1401 BOOL ret = FALSE;
1402 IMAGE_SECTION_HEADER *sec;
1403 IMAGE_NT_HEADERS *nt;
1404 struct resource_size_info res_size;
1405 BYTE *res_base;
1406 struct mapping_info *read_map = NULL, *write_map = NULL;
1407
1408 /* copy the exe to a temp file then update the temp file... */
1409 tempdir[0] = 0;
1410 if (!GetTempPathW( MAX_PATH, tempdir ))
1411 return ret;
1412
1413 if (!GetTempFileNameW( tempdir, prefix, 0, tempfile ))
1414 return ret;
1415
1416 if (!CopyFileW( updates->pFileName, tempfile, FALSE ))
1417 goto done;
1418
1419 TRACE("tempfile %s\n", debugstr_w(tempfile));
1420
1421 if (!updates->bDeleteExistingResources)
1422 {
1423 read_map = create_mapping( updates->pFileName, FALSE );
1424 if (!read_map)
1425 goto done;
1426
1427 ret = read_mapped_resources( updates, read_map->base, read_map->size );
1428 if (!ret)
1429 {
1430 ERR("failed to read existing resources\n");
1431 goto done;
1432 }
1433 }
1434
1435 write_map = create_mapping( tempfile, TRUE );
1436 if (!write_map)
1437 goto done;
1438
1439 nt = get_nt_header( write_map->base, write_map->size );
1440 if (!nt)
1441 goto done;
1442
1443 if (nt->OptionalHeader.SectionAlignment <= 0)
1444 {
1445 ERR("invalid section alignment %04x\n", nt->OptionalHeader.SectionAlignment);
1446 goto done;
1447 }
1448
1449 sec = get_resource_section( write_map->base, write_map->size );
1450 if (!sec)
1451 goto done;
1452
1453 if (!sec->PointerToRawData) /* empty section */
1454 {
1455 sec->PointerToRawData = write_map->size;
1456 sec->SizeOfRawData = 0;
1457 }
1458 else if ((sec->SizeOfRawData + sec->PointerToRawData) != write_map->size)
1459 {
1460 FIXME(".rsrc isn't at the end of the image %08x + %08x != %08x for %s\n",
1461 sec->SizeOfRawData, sec->PointerToRawData, write_map->size, debugstr_w(updates->pFileName));
1462 goto done;
1463 }
1464
1465 TRACE("before .rsrc at %08x, size %08x\n", sec->PointerToRawData, sec->SizeOfRawData);
1466
1467 get_resource_sizes( updates, &res_size );
1468
1469 /* round up the section size */
1470 section_size = res_size.total_size;
1471 section_size += (-section_size) % nt->OptionalHeader.SectionAlignment;
1472
1473 mapping_size = sec->PointerToRawData + section_size;
1474
1475 TRACE("requires %08x (%08x) bytes\n", res_size.total_size, section_size );
1476
1477 /* check if the file size needs to be changed */
1478 if (section_size != sec->SizeOfRawData)
1479 {
1480 old_size = write_map->size;
1481
1482 TRACE("file size %08x -> %08x\n", old_size, mapping_size);
1483
1484 /* unmap the file before changing the file size */
1485 ret = resize_mapping( write_map, mapping_size );
1486
1487 /* get the pointers again - they might be different after remapping */
1488 nt = get_nt_header( write_map->base, mapping_size );
1489 if (!nt)
1490 {
1491 ERR("couldn't get NT header\n");
1492 goto done;
1493 }
1494
1495 sec = get_resource_section( write_map->base, mapping_size );
1496 if (!sec)
1497 goto done;
1498
1499 /* adjust the PE header information */
1500 nt->OptionalHeader.SizeOfImage += (mapping_size - old_size);
1501 sec->SizeOfRawData = section_size;
1502 sec->Misc.VirtualSize = section_size;
1503 nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].Size = res_size.total_size;
1504 nt->OptionalHeader.SizeOfInitializedData = get_init_data_size( write_map->base, mapping_size );
1505 }
1506
1507 res_base = (LPBYTE) write_map->base + sec->PointerToRawData;
1508
1509 TRACE("base = %p offset = %08x\n", write_map->base, sec->PointerToRawData);
1510
1511 ret = write_resources( updates, res_base, &res_size, sec->VirtualAddress );
1512
1513 res_write_padding( res_base + res_size.total_size, section_size - res_size.total_size );
1514
1515 TRACE("after .rsrc at %08x, size %08x\n", sec->PointerToRawData, sec->SizeOfRawData);
1516
1517 done:
1518 destroy_mapping( read_map );
1519 destroy_mapping( write_map );
1520
1521 if (ret)
1522 ret = CopyFileW( tempfile, updates->pFileName, FALSE );
1523
1524 DeleteFileW( tempfile );
1525
1526 return ret;
1527 }
1528
1529 /***********************************************************************
1530 * BeginUpdateResourceW (KERNEL32.@)
1531 */
1532 HANDLE WINAPI BeginUpdateResourceW( LPCWSTR pFileName, BOOL bDeleteExistingResources )
1533 {
1534 QUEUEDUPDATES *updates = NULL;
1535 HANDLE hUpdate, file, ret = NULL;
1536
1537 TRACE("%s, %d\n", debugstr_w(pFileName), bDeleteExistingResources);
1538
1539 hUpdate = GlobalAlloc(GHND, sizeof(QUEUEDUPDATES));
1540 if (!hUpdate)
1541 return ret;
1542
1543 updates = GlobalLock(hUpdate);
1544 if (updates)
1545 {
1546 list_init( &updates->root );
1547 updates->bDeleteExistingResources = bDeleteExistingResources;
1548 updates->pFileName = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(pFileName)+1)*sizeof(WCHAR));
1549 if (updates->pFileName)
1550 {
1551 lstrcpyW(updates->pFileName, pFileName);
1552
1553 file = CreateFileW( pFileName, GENERIC_READ | GENERIC_WRITE,
1554 0, NULL, OPEN_EXISTING, 0, 0 );
1555
1556 /* if resources are deleted, only the file's presence is checked */
1557 if (file != INVALID_HANDLE_VALUE &&
1558 (bDeleteExistingResources || check_pe_exe( file, updates )))
1559 ret = hUpdate;
1560 else
1561 HeapFree( GetProcessHeap(), 0, updates->pFileName );
1562
1563 CloseHandle( file );
1564 }
1565 GlobalUnlock(hUpdate);
1566 }
1567
1568 if (!ret)
1569 GlobalFree(hUpdate);
1570
1571 return ret;
1572 }
1573
1574
1575 /***********************************************************************
1576 * BeginUpdateResourceA (KERNEL32.@)
1577 */
1578 HANDLE WINAPI BeginUpdateResourceA( LPCSTR pFileName, BOOL bDeleteExistingResources )
1579 {
1580 UNICODE_STRING FileNameW;
1581 HANDLE ret;
1582 RtlCreateUnicodeStringFromAsciiz(&FileNameW, pFileName);
1583 ret = BeginUpdateResourceW(FileNameW.Buffer, bDeleteExistingResources);
1584 RtlFreeUnicodeString(&FileNameW);
1585 return ret;
1586 }
1587
1588
1589 /***********************************************************************
1590 * EndUpdateResourceW (KERNEL32.@)
1591 */
1592 BOOL WINAPI EndUpdateResourceW( HANDLE hUpdate, BOOL fDiscard )
1593 {
1594 QUEUEDUPDATES *updates;
1595 BOOL ret;
1596
1597 TRACE("%p %d\n", hUpdate, fDiscard);
1598
1599 updates = GlobalLock(hUpdate);
1600 if (!updates)
1601 return FALSE;
1602
1603 ret = fDiscard || write_raw_resources( updates );
1604
1605 free_resource_directory( &updates->root, 2 );
1606
1607 HeapFree( GetProcessHeap(), 0, updates->pFileName );
1608 GlobalUnlock( hUpdate );
1609 GlobalFree( hUpdate );
1610
1611 return ret;
1612 }
1613
1614
1615 /***********************************************************************
1616 * EndUpdateResourceA (KERNEL32.@)
1617 */
1618 BOOL WINAPI EndUpdateResourceA( HANDLE hUpdate, BOOL fDiscard )
1619 {
1620 return EndUpdateResourceW(hUpdate, fDiscard);
1621 }
1622
1623
1624 /***********************************************************************
1625 * UpdateResourceW (KERNEL32.@)
1626 */
1627 BOOL WINAPI UpdateResourceW( HANDLE hUpdate, LPCWSTR lpType, LPCWSTR lpName,
1628 WORD wLanguage, LPVOID lpData, DWORD cbData)
1629 {
1630 QUEUEDUPDATES *updates;
1631 BOOL ret = FALSE;
1632
1633 TRACE("%p %s %s %08x %p %d\n", hUpdate,
1634 debugstr_w(lpType), debugstr_w(lpName), wLanguage, lpData, cbData);
1635
1636 updates = GlobalLock(hUpdate);
1637 if (updates)
1638 {
1639 struct resource_data *data;
1640 data = allocate_resource_data( wLanguage, 0, lpData, cbData, TRUE );
1641 if (data)
1642 ret = update_add_resource( updates, lpType, lpName, data, TRUE );
1643 GlobalUnlock(hUpdate);
1644 }
1645 return ret;
1646 }
1647
1648
1649 /***********************************************************************
1650 * UpdateResourceA (KERNEL32.@)
1651 */
1652 BOOL WINAPI UpdateResourceA( HANDLE hUpdate, LPCSTR lpType, LPCSTR lpName,
1653 WORD wLanguage, LPVOID lpData, DWORD cbData)
1654 {
1655 BOOL ret;
1656 UNICODE_STRING TypeW;
1657 UNICODE_STRING NameW;
1658 if(!HIWORD(lpType))
1659 TypeW.Buffer = ULongToPtr(LOWORD(lpType));
1660 else
1661 RtlCreateUnicodeStringFromAsciiz(&TypeW, lpType);
1662 if(!HIWORD(lpName))
1663 NameW.Buffer = ULongToPtr(LOWORD(lpName));
1664 else
1665 RtlCreateUnicodeStringFromAsciiz(&NameW, lpName);
1666 ret = UpdateResourceW(hUpdate, TypeW.Buffer, NameW.Buffer, wLanguage, lpData, cbData);
1667 if(HIWORD(lpType)) RtlFreeUnicodeString(&TypeW);
1668 if(HIWORD(lpName)) RtlFreeUnicodeString(&NameW);
1669 return ret;
1670 }
Quick hack tree for wine patches julliard doesn't want to commit