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