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