?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32: Consider whether the logical font face is vertical when selecting.
[wine/multimedia.git] / dlls / kernel32 / resource.c
blobb9a93c41b3784c8ee950949ce9ebad259f4525d2
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].u1.s1.NameIsString)
223 {
224 str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)resdir + et[i].u1.s1.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].u1.s2.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].u1.s1.NameIsString)
273 {
274 str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)resdir + et[i].u1.s1.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].u1.s2.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].u1.s1.NameIsString)
330 {
331 str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)basedir + et[i].u1.s1.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].u1.s2.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].u1.s1.NameIsString)
402 {
403 str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)basedir + et[i].u1.s1.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].u1.s2.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 * EnumResourceLanguagesA (KERNEL32.@)
441 */
442 BOOL WINAPI EnumResourceLanguagesA( HMODULE hmod, LPCSTR type, LPCSTR name,
443 ENUMRESLANGPROCA lpfun, LONG_PTR lparam )
444 {
445 int i;
446 BOOL ret = FALSE;
447 NTSTATUS status;
448 UNICODE_STRING typeW, nameW;
449 LDR_RESOURCE_INFO info;
450 const IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
451 const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
452
453 TRACE( "%p %s %s %p %lx\n", hmod, debugstr_a(type), debugstr_a(name), lpfun, lparam );
454
455 if (!hmod) hmod = GetModuleHandleA( NULL );
456 typeW.Buffer = nameW.Buffer = NULL;
457 if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &basedir )) != STATUS_SUCCESS)
458 goto done;
459 if ((status = get_res_nameA( type, &typeW )) != STATUS_SUCCESS)
460 goto done;
461 if ((status = get_res_nameA( name, &nameW )) != STATUS_SUCCESS)
462 goto done;
463 info.Type = (ULONG_PTR)typeW.Buffer;
464 info.Name = (ULONG_PTR)nameW.Buffer;
465 if ((status = LdrFindResourceDirectory_U( hmod, &info, 2, &resdir )) != STATUS_SUCCESS)
466 goto done;
467
468 et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
469 __TRY
470 {
471 for (i = 0; i < resdir->NumberOfNamedEntries + resdir->NumberOfIdEntries; i++)
472 {
473 ret = lpfun( hmod, type, name, et[i].u1.s2.Id, lparam );
474 if (!ret) break;
475 }
476 }
477 __EXCEPT_PAGE_FAULT
478 {
479 ret = FALSE;
480 status = STATUS_ACCESS_VIOLATION;
481 }
482 __ENDTRY
483 done:
484 if (!IS_INTRESOURCE(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
485 if (!IS_INTRESOURCE(nameW.Buffer)) HeapFree( GetProcessHeap(), 0, nameW.Buffer );
486 if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
487 return ret;
488 }
489
490
491 /**********************************************************************
492 * EnumResourceLanguagesW (KERNEL32.@)
493 */
494 BOOL WINAPI EnumResourceLanguagesW( HMODULE hmod, LPCWSTR type, LPCWSTR name,
495 ENUMRESLANGPROCW lpfun, LONG_PTR lparam )
496 {
497 int i;
498 BOOL ret = FALSE;
499 NTSTATUS status;
500 UNICODE_STRING typeW, nameW;
501 LDR_RESOURCE_INFO info;
502 const IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
503 const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
504
505 TRACE( "%p %s %s %p %lx\n", hmod, debugstr_w(type), debugstr_w(name), lpfun, lparam );
506
507 if (!hmod) hmod = GetModuleHandleW( NULL );
508 typeW.Buffer = nameW.Buffer = NULL;
509 if ((status = LdrFindResourceDirectory_U( hmod, NULL, 0, &basedir )) != STATUS_SUCCESS)
510 goto done;
511 if ((status = get_res_nameW( type, &typeW )) != STATUS_SUCCESS)
512 goto done;
513 if ((status = get_res_nameW( name, &nameW )) != STATUS_SUCCESS)
514 goto done;
515 info.Type = (ULONG_PTR)typeW.Buffer;
516 info.Name = (ULONG_PTR)nameW.Buffer;
517 if ((status = LdrFindResourceDirectory_U( hmod, &info, 2, &resdir )) != STATUS_SUCCESS)
518 goto done;
519
520 et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
521 __TRY
522 {
523 for (i = 0; i < resdir->NumberOfNamedEntries + resdir->NumberOfIdEntries; i++)
524 {
525 ret = lpfun( hmod, type, name, et[i].u1.s2.Id, lparam );
526 if (!ret) break;
527 }
528 }
529 __EXCEPT_PAGE_FAULT
530 {
531 ret = FALSE;
532 status = STATUS_ACCESS_VIOLATION;
533 }
534 __ENDTRY
535 done:
536 if (!IS_INTRESOURCE(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
537 if (!IS_INTRESOURCE(nameW.Buffer)) HeapFree( GetProcessHeap(), 0, nameW.Buffer );
538 if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
539 return ret;
540 }
541
542
543 /**********************************************************************
544 * LoadResource (KERNEL32.@)
545 */
546 HGLOBAL WINAPI LoadResource( HINSTANCE hModule, HRSRC hRsrc )
547 {
548 NTSTATUS status;
549 void *ret = NULL;
550
551 TRACE( "%p %p\n", hModule, hRsrc );
552
553 if (!hRsrc) return 0;
554 if (!hModule) hModule = GetModuleHandleA( NULL );
555 status = LdrAccessResource( hModule, (IMAGE_RESOURCE_DATA_ENTRY *)hRsrc, &ret, NULL );
556 if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
557 return ret;
558 }
559
560
561 /**********************************************************************
562 * LockResource (KERNEL32.@)
563 */
564 LPVOID WINAPI LockResource( HGLOBAL handle )
565 {
566 return handle;
567 }
568
569
570 /**********************************************************************
571 * FreeResource (KERNEL32.@)
572 */
573 BOOL WINAPI FreeResource( HGLOBAL handle )
574 {
575 return 0;
576 }
577
578
579 /**********************************************************************
580 * SizeofResource (KERNEL32.@)
581 */
582 DWORD WINAPI SizeofResource( HINSTANCE hModule, HRSRC hRsrc )
583 {
584 if (!hRsrc) return 0;
585 return ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->Size;
586 }
587
588 /*
589 * Data structure for updating resources.
590 * Type/Name/Language is a keyset for accessing resource data.
591 *
592 * QUEUEDUPDATES (root) ->
593 * list of struct resource_dir_entry (Type) ->
594 * list of struct resource_dir_entry (Name) ->
595 * list of struct resource_data Language + Data
596 */
597
598 typedef struct
599 {
600 LPWSTR pFileName;
601 BOOL bDeleteExistingResources;
602 struct list root;
603 } QUEUEDUPDATES;
604
605 /* this structure is shared for types and names */
606 struct resource_dir_entry {
607 struct list entry;
608 LPWSTR id;
609 struct list children;
610 };
611
612 /* this structure is the leaf */
613 struct resource_data {
614 struct list entry;
615 LANGID lang;
616 DWORD codepage;
617 DWORD cbData;
618 void *lpData;
619 };
620
621 static int resource_strcmp( LPCWSTR a, LPCWSTR b )
622 {
623 if ( a == b )
624 return 0;
625 if (!IS_INTRESOURCE( a ) && !IS_INTRESOURCE( b ) )
626 return lstrcmpW( a, b );
627 /* strings come before ids */
628 if (!IS_INTRESOURCE( a ) && IS_INTRESOURCE( b ))
629 return -1;
630 if (!IS_INTRESOURCE( b ) && IS_INTRESOURCE( a ))
631 return 1;
632 return ( a < b ) ? -1 : 1;
633 }
634
635 static struct resource_dir_entry *find_resource_dir_entry( struct list *dir, LPCWSTR id )
636 {
637 struct resource_dir_entry *ent;
638
639 /* match either IDs or strings */
640 LIST_FOR_EACH_ENTRY( ent, dir, struct resource_dir_entry, entry )
641 if (!resource_strcmp( id, ent->id ))
642 return ent;
643
644 return NULL;
645 }
646
647 static struct resource_data *find_resource_data( struct list *dir, LANGID lang )
648 {
649 struct resource_data *res_data;
650
651 /* match only languages here */
652 LIST_FOR_EACH_ENTRY( res_data, dir, struct resource_data, entry )
653 if ( lang == res_data->lang )
654 return res_data;
655
656 return NULL;
657 }
658
659 static void add_resource_dir_entry( struct list *dir, struct resource_dir_entry *resdir )
660 {
661 struct resource_dir_entry *ent;
662
663 LIST_FOR_EACH_ENTRY( ent, dir, struct resource_dir_entry, entry )
664 {
665 if (0>resource_strcmp( ent->id, resdir->id ))
666 continue;
667
668 list_add_before( &ent->entry, &resdir->entry );
669 return;
670 }
671 list_add_tail( dir, &resdir->entry );
672 }
673
674 static void add_resource_data_entry( struct list *dir, struct resource_data *resdata )
675 {
676 struct resource_data *ent;
677
678 LIST_FOR_EACH_ENTRY( ent, dir, struct resource_data, entry )
679 {
680 if (ent->lang < resdata->lang)
681 continue;
682
683 list_add_before( &ent->entry, &resdata->entry );
684 return;
685 }
686 list_add_tail( dir, &resdata->entry );
687 }
688
689 static LPWSTR res_strdupW( LPCWSTR str )
690 {
691 LPWSTR ret;
692 UINT len;
693
694 if (IS_INTRESOURCE(str))
695 return (LPWSTR) (UINT_PTR) LOWORD(str);
696 len = (lstrlenW( str ) + 1) * sizeof (WCHAR);
697 ret = HeapAlloc( GetProcessHeap(), 0, len );
698 memcpy( ret, str, len );
699 return ret;
700 }
701
702 static void res_free_str( LPWSTR str )
703 {
704 if (!IS_INTRESOURCE(str))
705 HeapFree( GetProcessHeap(), 0, str );
706 }
707
708 static BOOL update_add_resource( QUEUEDUPDATES *updates, LPCWSTR Type, LPCWSTR Name,
709 LANGID Lang, struct resource_data *resdata,
710 BOOL overwrite_existing )
711 {
712 struct resource_dir_entry *restype, *resname;
713 struct resource_data *existing;
714
715 TRACE("%p %s %s %p %d\n", updates,
716 debugstr_w(Type), debugstr_w(Name), resdata, overwrite_existing );
717
718 restype = find_resource_dir_entry( &updates->root, Type );
719 if (!restype)
720 {
721 restype = HeapAlloc( GetProcessHeap(), 0, sizeof *restype );
722 restype->id = res_strdupW( Type );
723 list_init( &restype->children );
724 add_resource_dir_entry( &updates->root, restype );
725 }
726
727 resname = find_resource_dir_entry( &restype->children, Name );
728 if (!resname)
729 {
730 resname = HeapAlloc( GetProcessHeap(), 0, sizeof *resname );
731 resname->id = res_strdupW( Name );
732 list_init( &resname->children );
733 add_resource_dir_entry( &restype->children, resname );
734 }
735
736 /*
737 * If there's an existing resource entry with matching (Type,Name,Language)
738 * it needs to be removed before adding the new data.
739 */
740 existing = find_resource_data( &resname->children, Lang );
741 if (existing)
742 {
743 if (!overwrite_existing)
744 return FALSE;
745 list_remove( &existing->entry );
746 HeapFree( GetProcessHeap(), 0, existing );
747 }
748
749 if (resdata)
750 add_resource_data_entry( &resname->children, resdata );
751
752 return TRUE;
753 }
754
755 static struct resource_data *allocate_resource_data( WORD Language, DWORD codepage,
756 LPVOID lpData, DWORD cbData, BOOL copy_data )
757 {
758 struct resource_data *resdata;
759
760 if (!lpData || !cbData)
761 return NULL;
762
763 resdata = HeapAlloc( GetProcessHeap(), 0, sizeof *resdata + (copy_data ? cbData : 0) );
764 if (resdata)
765 {
766 resdata->lang = Language;
767 resdata->codepage = codepage;
768 resdata->cbData = cbData;
769 if (copy_data)
770 {
771 resdata->lpData = &resdata[1];
772 memcpy( resdata->lpData, lpData, cbData );
773 }
774 else
775 resdata->lpData = lpData;
776 }
777
778 return resdata;
779 }
780
781 static void free_resource_directory( struct list *head, int level )
782 {
783 struct list *ptr = NULL;
784
785 while ((ptr = list_head( head )))
786 {
787 list_remove( ptr );
788 if (level)
789 {
790 struct resource_dir_entry *ent;
791
792 ent = LIST_ENTRY( ptr, struct resource_dir_entry, entry );
793 res_free_str( ent->id );
794 free_resource_directory( &ent->children, level - 1 );
795 HeapFree(GetProcessHeap(), 0, ent);
796 }
797 else
798 {
799 struct resource_data *data;
800
801 data = LIST_ENTRY( ptr, struct resource_data, entry );
802 HeapFree( GetProcessHeap(), 0, data );
803 }
804 }
805 }
806
807 static IMAGE_NT_HEADERS *get_nt_header( void *base, DWORD mapping_size )
808 {
809 IMAGE_NT_HEADERS *nt;
810 IMAGE_DOS_HEADER *dos;
811
812 if (mapping_size<sizeof (*dos))
813 return NULL;
814
815 dos = base;
816 if (dos->e_magic != IMAGE_DOS_SIGNATURE)
817 return NULL;
818
819 if ((dos->e_lfanew + sizeof (*nt)) > mapping_size)
820 return NULL;
821
822 nt = (void*) ((BYTE*)base + dos->e_lfanew);
823
824 if (nt->Signature != IMAGE_NT_SIGNATURE)
825 return NULL;
826
827 return nt;
828 }
829
830 static IMAGE_SECTION_HEADER *get_section_header( void *base, DWORD mapping_size, DWORD *num_sections )
831 {
832 IMAGE_NT_HEADERS *nt;
833 IMAGE_SECTION_HEADER *sec;
834 DWORD section_ofs;
835
836 nt = get_nt_header( base, mapping_size );
837 if (!nt)
838 return NULL;
839
840 /* check that we don't go over the end of the file accessing the sections */
841 section_ofs = FIELD_OFFSET(IMAGE_NT_HEADERS, OptionalHeader) + nt->FileHeader.SizeOfOptionalHeader;
842 if ((nt->FileHeader.NumberOfSections * sizeof (*sec) + section_ofs) > mapping_size)
843 return NULL;
844
845 if (num_sections)
846 *num_sections = nt->FileHeader.NumberOfSections;
847
848 /* from here we have a valid PE exe to update */
849 return (void*) ((BYTE*)nt + section_ofs);
850 }
851
852 static BOOL check_pe_exe( HANDLE file, QUEUEDUPDATES *updates )
853 {
854 const IMAGE_NT_HEADERS *nt;
855 const IMAGE_SECTION_HEADER *sec;
856 BOOL ret = FALSE;
857 HANDLE mapping;
858 DWORD mapping_size, num_sections = 0;
859 void *base = NULL;
860
861 mapping_size = GetFileSize( file, NULL );
862
863 mapping = CreateFileMappingW( file, NULL, PAGE_READONLY, 0, 0, NULL );
864 if (!mapping)
865 goto done;
866
867 base = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, mapping_size );
868 if (!base)
869 goto done;
870
871 nt = get_nt_header( base, mapping_size );
872 if (!nt)
873 goto done;
874
875 TRACE("resources: %08x %08x\n",
876 nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress,
877 nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].Size);
878
879 sec = get_section_header( base, mapping_size, &num_sections );
880 if (!sec)
881 goto done;
882
883 ret = TRUE;
884
885 done:
886 if (base)
887 UnmapViewOfFile( base );
888 if (mapping)
889 CloseHandle( mapping );
890
891 return ret;
892 }
893
894 struct resource_size_info {
895 DWORD types_ofs;
896 DWORD names_ofs;
897 DWORD langs_ofs;
898 DWORD data_entry_ofs;
899 DWORD strings_ofs;
900 DWORD data_ofs;
901 DWORD total_size;
902 };
903
904 struct mapping_info {
905 HANDLE file;
906 void *base;
907 DWORD size;
908 BOOL read_write;
909 };
910
911 static const IMAGE_SECTION_HEADER *section_from_rva( void *base, DWORD mapping_size, DWORD rva )
912 {
913 const IMAGE_SECTION_HEADER *sec;
914 DWORD num_sections = 0;
915 int i;
916
917 sec = get_section_header( base, mapping_size, &num_sections );
918 if (!sec)
919 return NULL;
920
921 for (i=num_sections-1; i>=0; i--)
922 {
923 if (sec[i].VirtualAddress <= rva &&
924 rva <= (DWORD)sec[i].VirtualAddress + sec[i].SizeOfRawData)
925 {
926 return &sec[i];
927 }
928 }
929
930 return NULL;
931 }
932
933 static void *address_from_rva( void *base, DWORD mapping_size, DWORD rva, DWORD len )
934 {
935 const IMAGE_SECTION_HEADER *sec;
936
937 sec = section_from_rva( base, mapping_size, rva );
938 if (!sec)
939 return NULL;
940
941 if (rva + len <= (DWORD)sec->VirtualAddress + sec->SizeOfRawData)
942 return (void*)((LPBYTE) base + (sec->PointerToRawData + rva - sec->VirtualAddress));
943
944 return NULL;
945 }
946
947 static LPWSTR resource_dup_string( const IMAGE_RESOURCE_DIRECTORY *root, const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry )
948 {
949 const IMAGE_RESOURCE_DIR_STRING_U* string;
950 LPWSTR s;
951
952 if (!entry->u1.s1.NameIsString)
953 return UIntToPtr(entry->u1.s2.Id);
954
955 string = (const IMAGE_RESOURCE_DIR_STRING_U*) (((const char *)root) + entry->u1.s1.NameOffset);
956 s = HeapAlloc(GetProcessHeap(), 0, (string->Length + 1)*sizeof (WCHAR) );
957 memcpy( s, string->NameString, (string->Length + 1)*sizeof (WCHAR) );
958 s[string->Length] = 0;
959
960 return s;
961 }
962
963 /* this function is based on the code in winedump's pe.c */
964 static BOOL enumerate_mapped_resources( QUEUEDUPDATES *updates,
965 void *base, DWORD mapping_size,
966 const IMAGE_RESOURCE_DIRECTORY *root )
967 {
968 const IMAGE_RESOURCE_DIRECTORY *namedir, *langdir;
969 const IMAGE_RESOURCE_DIRECTORY_ENTRY *e1, *e2, *e3;
970 const IMAGE_RESOURCE_DATA_ENTRY *data;
971 DWORD i, j, k;
972
973 TRACE("version (%d.%d) %d named %d id entries\n",
974 root->MajorVersion, root->MinorVersion, root->NumberOfNamedEntries, root->NumberOfIdEntries);
975
976 for (i = 0; i< root->NumberOfNamedEntries + root->NumberOfIdEntries; i++)
977 {
978 LPWSTR Type;
979
980 e1 = (const IMAGE_RESOURCE_DIRECTORY_ENTRY*)(root + 1) + i;
981
982 Type = resource_dup_string( root, e1 );
983
984 namedir = (const IMAGE_RESOURCE_DIRECTORY *)((const char *)root + e1->u2.s3.OffsetToDirectory);
985 for (j = 0; j < namedir->NumberOfNamedEntries + namedir->NumberOfIdEntries; j++)
986 {
987 LPWSTR Name;
988
989 e2 = (const IMAGE_RESOURCE_DIRECTORY_ENTRY*)(namedir + 1) + j;
990
991 Name = resource_dup_string( root, e2 );
992
993 langdir = (const IMAGE_RESOURCE_DIRECTORY *)((const char *)root + e2->u2.s3.OffsetToDirectory);
994 for (k = 0; k < langdir->NumberOfNamedEntries + langdir->NumberOfIdEntries; k++)
995 {
996 LANGID Lang;
997 void *p;
998 struct resource_data *resdata;
999
1000 e3 = (const IMAGE_RESOURCE_DIRECTORY_ENTRY*)(langdir + 1) + k;
1001
1002 Lang = e3->u1.s2.Id;
1003
1004 data = (const IMAGE_RESOURCE_DATA_ENTRY *)((const char *)root + e3->u2.OffsetToData);
1005
1006 p = address_from_rva( base, mapping_size, data->OffsetToData, data->Size );
1007
1008 resdata = allocate_resource_data( Lang, data->CodePage, p, data->Size, FALSE );
1009 if (resdata)
1010 {
1011 if (!update_add_resource( updates, Type, Name, Lang, resdata, FALSE ))
1012 HeapFree( GetProcessHeap(), 0, resdata );
1013 }
1014 }
1015 res_free_str( Name );
1016 }
1017 res_free_str( Type );
1018 }
1019
1020 return TRUE;
1021 }
1022
1023 static BOOL read_mapped_resources( QUEUEDUPDATES *updates, void *base, DWORD mapping_size )
1024 {
1025 const IMAGE_RESOURCE_DIRECTORY *root;
1026 const IMAGE_NT_HEADERS *nt;
1027 const IMAGE_SECTION_HEADER *sec;
1028 DWORD num_sections = 0, i;
1029
1030 nt = get_nt_header( base, mapping_size );
1031 if (!nt)
1032 return FALSE;
1033
1034 sec = get_section_header( base, mapping_size, &num_sections );
1035 if (!sec)
1036 return FALSE;
1037
1038 for (i=0; i<num_sections; i++)
1039 if (!memcmp(sec[i].Name, ".rsrc", 6))
1040 break;
1041
1042 if (i == num_sections)
1043 return TRUE;
1044
1045 /* check the resource data is inside the mapping */
1046 if (sec[i].PointerToRawData > mapping_size ||
1047 (sec[i].PointerToRawData + sec[i].SizeOfRawData) > mapping_size)
1048 return TRUE;
1049
1050 TRACE("found .rsrc at %08x, size %08x\n", sec[i].PointerToRawData, sec[i].SizeOfRawData);
1051
1052 if (!sec[i].PointerToRawData || sec[i].SizeOfRawData < sizeof(IMAGE_RESOURCE_DIRECTORY))
1053 return TRUE;
1054
1055 root = (void*) ((BYTE*)base + sec[i].PointerToRawData);
1056 enumerate_mapped_resources( updates, base, mapping_size, root );
1057
1058 return TRUE;
1059 }
1060
1061 static BOOL map_file_into_memory( struct mapping_info *mi )
1062 {
1063 DWORD page_attr, perm;
1064 HANDLE mapping;
1065
1066 if (mi->read_write)
1067 {
1068 page_attr = PAGE_READWRITE;
1069 perm = FILE_MAP_WRITE | FILE_MAP_READ;
1070 }
1071 else
1072 {
1073 page_attr = PAGE_READONLY;
1074 perm = FILE_MAP_READ;
1075 }
1076
1077 mapping = CreateFileMappingW( mi->file, NULL, page_attr, 0, 0, NULL );
1078 if (!mapping) return FALSE;
1079
1080 mi->base = MapViewOfFile( mapping, perm, 0, 0, mi->size );
1081 CloseHandle( mapping );
1082
1083 return mi->base != NULL;
1084 }
1085
1086 static BOOL unmap_file_from_memory( struct mapping_info *mi )
1087 {
1088 if (mi->base)
1089 UnmapViewOfFile( mi->base );
1090 mi->base = NULL;
1091 return TRUE;
1092 }
1093
1094 static void destroy_mapping( struct mapping_info *mi )
1095 {
1096 if (!mi)
1097 return;
1098 unmap_file_from_memory( mi );
1099 if (mi->file)
1100 CloseHandle( mi->file );
1101 HeapFree( GetProcessHeap(), 0, mi );
1102 }
1103
1104 static struct mapping_info *create_mapping( LPCWSTR name, BOOL rw )
1105 {
1106 struct mapping_info *mi;
1107
1108 mi = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof *mi );
1109 if (!mi)
1110 return NULL;
1111
1112 mi->read_write = rw;
1113
1114 mi->file = CreateFileW( name, GENERIC_READ | (rw ? GENERIC_WRITE : 0),
1115 0, NULL, OPEN_EXISTING, 0, 0 );
1116
1117 if (mi->file != INVALID_HANDLE_VALUE)
1118 {
1119 mi->size = GetFileSize( mi->file, NULL );
1120
1121 if (map_file_into_memory( mi ))
1122 return mi;
1123 }
1124 destroy_mapping( mi );
1125 return NULL;
1126 }
1127
1128 static BOOL resize_mapping( struct mapping_info *mi, DWORD new_size )
1129 {
1130 if (!unmap_file_from_memory( mi ))
1131 return FALSE;
1132
1133 /* change the file size */
1134 SetFilePointer( mi->file, new_size, NULL, FILE_BEGIN );
1135 if (!SetEndOfFile( mi->file ))
1136 {
1137 ERR("failed to set file size to %08x\n", new_size );
1138 return FALSE;
1139 }
1140
1141 mi->size = new_size;
1142
1143 return map_file_into_memory( mi );
1144 }
1145
1146 static void get_resource_sizes( QUEUEDUPDATES *updates, struct resource_size_info *si )
1147 {
1148 struct resource_dir_entry *types, *names;
1149 struct resource_data *data;
1150 DWORD num_types = 0, num_names = 0, num_langs = 0, strings_size = 0, data_size = 0;
1151
1152 memset( si, 0, sizeof *si );
1153
1154 LIST_FOR_EACH_ENTRY( types, &updates->root, struct resource_dir_entry, entry )
1155 {
1156 num_types++;
1157 if (!IS_INTRESOURCE( types->id ))
1158 strings_size += sizeof (WORD) + lstrlenW( types->id )*sizeof (WCHAR);
1159
1160 LIST_FOR_EACH_ENTRY( names, &types->children, struct resource_dir_entry, entry )
1161 {
1162 num_names++;
1163
1164 if (!IS_INTRESOURCE( names->id ))
1165 strings_size += sizeof (WORD) + lstrlenW( names->id )*sizeof (WCHAR);
1166
1167 LIST_FOR_EACH_ENTRY( data, &names->children, struct resource_data, entry )
1168 {
1169 num_langs++;
1170 data_size += (data->cbData + 3) & ~3;
1171 }
1172 }
1173 }
1174
1175 /* names are at the end of the types */
1176 si->names_ofs = sizeof (IMAGE_RESOURCE_DIRECTORY) +
1177 num_types * sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
1178
1179 /* language directories are at the end of the names */
1180 si->langs_ofs = si->names_ofs +
1181 num_types * sizeof (IMAGE_RESOURCE_DIRECTORY) +
1182 num_names * sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
1183
1184 si->data_entry_ofs = si->langs_ofs +
1185 num_names * sizeof (IMAGE_RESOURCE_DIRECTORY) +
1186 num_langs * sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
1187
1188 si->strings_ofs = si->data_entry_ofs +
1189 num_langs * sizeof (IMAGE_RESOURCE_DATA_ENTRY);
1190
1191 si->data_ofs = si->strings_ofs + ((strings_size + 3) & ~3);
1192
1193 si->total_size = si->data_ofs + data_size;
1194
1195 TRACE("names %08x langs %08x data entries %08x strings %08x data %08x total %08x\n",
1196 si->names_ofs, si->langs_ofs, si->data_entry_ofs,
1197 si->strings_ofs, si->data_ofs, si->total_size);
1198 }
1199
1200 static void res_write_padding( BYTE *res_base, DWORD size )
1201 {
1202 static const BYTE pad[] = {
1203 'P','A','D','D','I','N','G','X','X','P','A','D','D','I','N','G' };
1204 DWORD i;
1205
1206 for ( i = 0; i < size / sizeof pad; i++ )
1207 memcpy( &res_base[i*sizeof pad], pad, sizeof pad );
1208 memcpy( &res_base[i*sizeof pad], pad, size%sizeof pad );
1209 }
1210
1211 static BOOL write_resources( QUEUEDUPDATES *updates, LPBYTE base, struct resource_size_info *si, DWORD rva )
1212 {
1213 struct resource_dir_entry *types, *names;
1214 struct resource_data *data;
1215 IMAGE_RESOURCE_DIRECTORY *root;
1216
1217 TRACE("%p %p %p %08x\n", updates, base, si, rva );
1218
1219 memset( base, 0, si->total_size );
1220
1221 /* the root entry always exists */
1222 root = (IMAGE_RESOURCE_DIRECTORY*) base;
1223 memset( root, 0, sizeof *root );
1224 root->MajorVersion = 4;
1225 si->types_ofs = sizeof *root;
1226 LIST_FOR_EACH_ENTRY( types, &updates->root, struct resource_dir_entry, entry )
1227 {
1228 IMAGE_RESOURCE_DIRECTORY_ENTRY *e1;
1229 IMAGE_RESOURCE_DIRECTORY *namedir;
1230
1231 e1 = (IMAGE_RESOURCE_DIRECTORY_ENTRY*) &base[si->types_ofs];
1232 memset( e1, 0, sizeof *e1 );
1233 if (!IS_INTRESOURCE( types->id ))
1234 {
1235 WCHAR *strings;
1236 DWORD len;
1237
1238 root->NumberOfNamedEntries++;
1239 e1->u1.s1.NameIsString = 1;
1240 e1->u1.s1.NameOffset = si->strings_ofs;
1241
1242 strings = (WCHAR*) &base[si->strings_ofs];
1243 len = lstrlenW( types->id );
1244 strings[0] = len;
1245 memcpy( &strings[1], types->id, len * sizeof (WCHAR) );
1246 si->strings_ofs += (len + 1) * sizeof (WCHAR);
1247 }
1248 else
1249 {
1250 root->NumberOfIdEntries++;
1251 e1->u1.s2.Id = LOWORD( types->id );
1252 }
1253 e1->u2.s3.OffsetToDirectory = si->names_ofs;
1254 e1->u2.s3.DataIsDirectory = TRUE;
1255 si->types_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
1256
1257 namedir = (IMAGE_RESOURCE_DIRECTORY*) &base[si->names_ofs];
1258 memset( namedir, 0, sizeof *namedir );
1259 namedir->MajorVersion = 4;
1260 si->names_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY);
1261
1262 LIST_FOR_EACH_ENTRY( names, &types->children, struct resource_dir_entry, entry )
1263 {
1264 IMAGE_RESOURCE_DIRECTORY_ENTRY *e2;
1265 IMAGE_RESOURCE_DIRECTORY *langdir;
1266
1267 e2 = (IMAGE_RESOURCE_DIRECTORY_ENTRY*) &base[si->names_ofs];
1268 memset( e2, 0, sizeof *e2 );
1269 if (!IS_INTRESOURCE( names->id ))
1270 {
1271 WCHAR *strings;
1272 DWORD len;
1273
1274 namedir->NumberOfNamedEntries++;
1275 e2->u1.s1.NameIsString = 1;
1276 e2->u1.s1.NameOffset = si->strings_ofs;
1277
1278 strings = (WCHAR*) &base[si->strings_ofs];
1279 len = lstrlenW( names->id );
1280 strings[0] = len;
1281 memcpy( &strings[1], names->id, len * sizeof (WCHAR) );
1282 si->strings_ofs += (len + 1) * sizeof (WCHAR);
1283 }
1284 else
1285 {
1286 namedir->NumberOfIdEntries++;
1287 e2->u1.s2.Id = LOWORD( names->id );
1288 }
1289 e2->u2.s3.OffsetToDirectory = si->langs_ofs;
1290 e2->u2.s3.DataIsDirectory = TRUE;
1291 si->names_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
1292
1293 langdir = (IMAGE_RESOURCE_DIRECTORY*) &base[si->langs_ofs];
1294 memset( langdir, 0, sizeof *langdir );
1295 langdir->MajorVersion = 4;
1296 si->langs_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY);
1297
1298 LIST_FOR_EACH_ENTRY( data, &names->children, struct resource_data, entry )
1299 {
1300 IMAGE_RESOURCE_DIRECTORY_ENTRY *e3;
1301 IMAGE_RESOURCE_DATA_ENTRY *de;
1302 int pad_size;
1303
1304 e3 = (IMAGE_RESOURCE_DIRECTORY_ENTRY*) &base[si->langs_ofs];
1305 memset( e3, 0, sizeof *e3 );
1306 langdir->NumberOfIdEntries++;
1307 e3->u1.s2.Id = LOWORD( data->lang );
1308 e3->u2.OffsetToData = si->data_entry_ofs;
1309
1310 si->langs_ofs += sizeof (IMAGE_RESOURCE_DIRECTORY_ENTRY);
1311
1312 /* write out all the data entries */
1313 de = (IMAGE_RESOURCE_DATA_ENTRY*) &base[si->data_entry_ofs];
1314 memset( de, 0, sizeof *de );
1315 de->OffsetToData = si->data_ofs + rva;
1316 de->Size = data->cbData;
1317 de->CodePage = data->codepage;
1318 si->data_entry_ofs += sizeof (IMAGE_RESOURCE_DATA_ENTRY);
1319
1320 /* write out the resource data */
1321 memcpy( &base[si->data_ofs], data->lpData, data->cbData );
1322 si->data_ofs += data->cbData;
1323
1324 pad_size = (-si->data_ofs)&3;
1325 res_write_padding( &base[si->data_ofs], pad_size );
1326 si->data_ofs += pad_size;
1327 }
1328 }
1329 }
1330
1331 return TRUE;
1332 }
1333
1334 /*
1335 * FIXME:
1336 * Assumes that the resources are in .rsrc
1337 * and .rsrc is the last section in the file.
1338 * Not sure whether updating resources will other cases on Windows.
1339 * If the resources lie in a section containing other data,
1340 * resizing that section could possibly cause trouble.
1341 * If the section with the resources isn't last, the remaining
1342 * sections need to be moved down in the file, and the section header
1343 * would need to be adjusted.
1344 * If we needed to add a section, what would we name it?
1345 * If we needed to add a section and there wasn't space in the file
1346 * header, how would that work?
1347 * Seems that at least some of these cases can't be handled properly.
1348 */
1349 static IMAGE_SECTION_HEADER *get_resource_section( void *base, DWORD mapping_size )
1350 {
1351 IMAGE_SECTION_HEADER *sec;
1352 IMAGE_NT_HEADERS *nt;
1353 DWORD i, num_sections = 0;
1354
1355 nt = get_nt_header( base, mapping_size );
1356 if (!nt)
1357 return NULL;
1358
1359 sec = get_section_header( base, mapping_size, &num_sections );
1360 if (!sec)
1361 return NULL;
1362
1363 /* find the resources section */
1364 for (i=0; i<num_sections; i++)
1365 if (!memcmp(sec[i].Name, ".rsrc", 6))
1366 break;
1367
1368 if (i == num_sections)
1369 return NULL;
1370
1371 return &sec[i];
1372 }
1373
1374 static DWORD get_init_data_size( void *base, DWORD mapping_size )
1375 {
1376 DWORD i, sz = 0, num_sections = 0;
1377 IMAGE_SECTION_HEADER *s;
1378
1379 s = get_section_header( base, mapping_size, &num_sections );
1380
1381 for (i=0; i<num_sections; i++)
1382 if (s[i].Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
1383 sz += s[i].SizeOfRawData;
1384
1385 TRACE("size = %08x\n", sz);
1386
1387 return sz;
1388 }
1389
1390 static BOOL write_raw_resources( QUEUEDUPDATES *updates )
1391 {
1392 static const WCHAR prefix[] = { 'r','e','s','u',0 };
1393 WCHAR tempdir[MAX_PATH], tempfile[MAX_PATH];
1394 DWORD section_size;
1395 BOOL ret = FALSE;
1396 IMAGE_SECTION_HEADER *sec;
1397 IMAGE_NT_HEADERS *nt;
1398 struct resource_size_info res_size;
1399 BYTE *res_base;
1400 struct mapping_info *read_map = NULL, *write_map = NULL;
1401
1402 /* copy the exe to a temp file then update the temp file... */
1403 tempdir[0] = 0;
1404 if (!GetTempPathW( MAX_PATH, tempdir ))
1405 return ret;
1406
1407 if (!GetTempFileNameW( tempdir, prefix, 0, tempfile ))
1408 return ret;
1409
1410 if (!CopyFileW( updates->pFileName, tempfile, FALSE ))
1411 goto done;
1412
1413 TRACE("tempfile %s\n", debugstr_w(tempfile));
1414
1415 if (!updates->bDeleteExistingResources)
1416 {
1417 read_map = create_mapping( updates->pFileName, FALSE );
1418 if (!read_map)
1419 goto done;
1420
1421 ret = read_mapped_resources( updates, read_map->base, read_map->size );
1422 if (!ret)
1423 {
1424 ERR("failed to read existing resources\n");
1425 goto done;
1426 }
1427 }
1428
1429 write_map = create_mapping( tempfile, TRUE );
1430 if (!write_map)
1431 goto done;
1432
1433 nt = get_nt_header( write_map->base, write_map->size );
1434 if (!nt)
1435 goto done;
1436
1437 if (nt->OptionalHeader.SectionAlignment <= 0)
1438 {
1439 ERR("invalid section alignment %04x\n", nt->OptionalHeader.SectionAlignment);
1440 goto done;
1441 }
1442
1443 if (nt->OptionalHeader.FileAlignment <= 0)
1444 {
1445 ERR("invalid file alignment %04x\n", nt->OptionalHeader.FileAlignment);
1446 goto done;
1447 }
1448
1449 sec = get_resource_section( write_map->base, write_map->size );
1450 if (!sec) /* no section, add one */
1451 {
1452 DWORD num_sections;
1453
1454 sec = get_section_header( write_map->base, write_map->size, &num_sections );
1455 if (!sec)
1456 goto done;
1457
1458 sec += num_sections;
1459 nt->FileHeader.NumberOfSections++;
1460
1461 memset( sec, 0, sizeof *sec );
1462 memcpy( sec->Name, ".rsrc", 5 );
1463 sec->Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
1464 sec->VirtualAddress = nt->OptionalHeader.SizeOfImage;
1465 }
1466
1467 if (!sec->PointerToRawData) /* empty section */
1468 {
1469 sec->PointerToRawData = write_map->size + (-write_map->size) % nt->OptionalHeader.FileAlignment;
1470 sec->SizeOfRawData = 0;
1471 }
1472
1473 TRACE("before .rsrc at %08x, size %08x\n", sec->PointerToRawData, sec->SizeOfRawData);
1474
1475 get_resource_sizes( updates, &res_size );
1476
1477 /* round up the section size */
1478 section_size = res_size.total_size;
1479 section_size += (-section_size) % nt->OptionalHeader.FileAlignment;
1480
1481 TRACE("requires %08x (%08x) bytes\n", res_size.total_size, section_size );
1482
1483 /* check if the file size needs to be changed */
1484 if (section_size != sec->SizeOfRawData)
1485 {
1486 DWORD old_size = write_map->size;
1487 DWORD virtual_section_size = res_size.total_size + (-res_size.total_size) % nt->OptionalHeader.SectionAlignment;
1488 int delta = section_size - (sec->SizeOfRawData + (-sec->SizeOfRawData) % nt->OptionalHeader.FileAlignment);
1489 int rva_delta = virtual_section_size -
1490 (sec->Misc.VirtualSize + (-sec->Misc.VirtualSize) % nt->OptionalHeader.SectionAlignment);
1491 BOOL rsrc_is_last = sec->PointerToRawData + sec->SizeOfRawData == old_size;
1492 /* align .rsrc size when possible */
1493 DWORD mapping_size = rsrc_is_last ? sec->PointerToRawData + section_size : old_size + delta;
1494
1495 /* postpone file truncation if there are some data to be moved down from file end */
1496 BOOL resize_after = mapping_size < old_size && !rsrc_is_last;
1497
1498 TRACE("file size %08x -> %08x\n", old_size, mapping_size);
1499
1500 if (!resize_after)
1501 {
1502 /* unmap the file before changing the file size */
1503 ret = resize_mapping( write_map, mapping_size );
1504
1505 /* get the pointers again - they might be different after remapping */
1506 nt = get_nt_header( write_map->base, mapping_size );
1507 if (!nt)
1508 {
1509 ERR("couldn't get NT header\n");
1510 goto done;
1511 }
1512
1513 sec = get_resource_section( write_map->base, mapping_size );
1514 if (!sec)
1515 goto done;
1516 }
1517
1518 if (!rsrc_is_last) /* not last section, relocate trailing sections */
1519 {
1520 IMAGE_SECTION_HEADER *s;
1521 DWORD tail_start = sec->PointerToRawData + sec->SizeOfRawData;
1522 DWORD i, num_sections = 0;
1523
1524 memmove( (char*)write_map->base + tail_start + delta, (char*)write_map->base + tail_start, old_size - tail_start );
1525
1526 s = get_section_header( write_map->base, mapping_size, &num_sections );
1527
1528 for (i=0; i<num_sections; i++)
1529 {
1530 if (s[i].PointerToRawData > sec->PointerToRawData)
1531 {
1532 s[i].PointerToRawData += delta;
1533 s[i].VirtualAddress += rva_delta;
1534 }
1535 }
1536 }
1537
1538 if (resize_after)
1539 {
1540 ret = resize_mapping( write_map, mapping_size );
1541
1542 nt = get_nt_header( write_map->base, mapping_size );
1543 if (!nt)
1544 {
1545 ERR("couldn't get NT header\n");
1546 goto done;
1547 }
1548
1549 sec = get_resource_section( write_map->base, mapping_size );
1550 if (!sec)
1551 goto done;
1552 }
1553
1554 /* adjust the PE header information */
1555 sec->SizeOfRawData = section_size;
1556 sec->Misc.VirtualSize = virtual_section_size;
1557 nt->OptionalHeader.SizeOfImage += rva_delta;
1558 nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].Size = res_size.total_size;
1559 nt->OptionalHeader.SizeOfInitializedData = get_init_data_size( write_map->base, mapping_size );
1560 }
1561
1562 res_base = (LPBYTE) write_map->base + sec->PointerToRawData;
1563
1564 TRACE("base = %p offset = %08x\n", write_map->base, sec->PointerToRawData);
1565
1566 ret = write_resources( updates, res_base, &res_size, sec->VirtualAddress );
1567
1568 res_write_padding( res_base + res_size.total_size, section_size - res_size.total_size );
1569
1570 TRACE("after .rsrc at %08x, size %08x\n", sec->PointerToRawData, sec->SizeOfRawData);
1571
1572 done:
1573 destroy_mapping( read_map );
1574 destroy_mapping( write_map );
1575
1576 if (ret)
1577 ret = CopyFileW( tempfile, updates->pFileName, FALSE );
1578
1579 DeleteFileW( tempfile );
1580
1581 return ret;
1582 }
1583
1584 /***********************************************************************
1585 * BeginUpdateResourceW (KERNEL32.@)
1586 */
1587 HANDLE WINAPI BeginUpdateResourceW( LPCWSTR pFileName, BOOL bDeleteExistingResources )
1588 {
1589 QUEUEDUPDATES *updates = NULL;
1590 HANDLE hUpdate, file, ret = NULL;
1591
1592 TRACE("%s, %d\n", debugstr_w(pFileName), bDeleteExistingResources);
1593
1594 hUpdate = GlobalAlloc(GHND, sizeof(QUEUEDUPDATES));
1595 if (!hUpdate)
1596 return ret;
1597
1598 updates = GlobalLock(hUpdate);
1599 if (updates)
1600 {
1601 list_init( &updates->root );
1602 updates->bDeleteExistingResources = bDeleteExistingResources;
1603 updates->pFileName = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(pFileName)+1)*sizeof(WCHAR));
1604 if (updates->pFileName)
1605 {
1606 lstrcpyW(updates->pFileName, pFileName);
1607
1608 file = CreateFileW( pFileName, GENERIC_READ | GENERIC_WRITE,
1609 0, NULL, OPEN_EXISTING, 0, 0 );
1610
1611 /* if resources are deleted, only the file's presence is checked */
1612 if (file != INVALID_HANDLE_VALUE &&
1613 (bDeleteExistingResources || check_pe_exe( file, updates )))
1614 ret = hUpdate;
1615 else
1616 HeapFree( GetProcessHeap(), 0, updates->pFileName );
1617
1618 CloseHandle( file );
1619 }
1620 GlobalUnlock(hUpdate);
1621 }
1622
1623 if (!ret)
1624 GlobalFree(hUpdate);
1625
1626 return ret;
1627 }
1628
1629
1630 /***********************************************************************
1631 * BeginUpdateResourceA (KERNEL32.@)
1632 */
1633 HANDLE WINAPI BeginUpdateResourceA( LPCSTR pFileName, BOOL bDeleteExistingResources )
1634 {
1635 UNICODE_STRING FileNameW;
1636 HANDLE ret;
1637 RtlCreateUnicodeStringFromAsciiz(&FileNameW, pFileName);
1638 ret = BeginUpdateResourceW(FileNameW.Buffer, bDeleteExistingResources);
1639 RtlFreeUnicodeString(&FileNameW);
1640 return ret;
1641 }
1642
1643
1644 /***********************************************************************
1645 * EndUpdateResourceW (KERNEL32.@)
1646 */
1647 BOOL WINAPI EndUpdateResourceW( HANDLE hUpdate, BOOL fDiscard )
1648 {
1649 QUEUEDUPDATES *updates;
1650 BOOL ret;
1651
1652 TRACE("%p %d\n", hUpdate, fDiscard);
1653
1654 updates = GlobalLock(hUpdate);
1655 if (!updates)
1656 return FALSE;
1657
1658 ret = fDiscard || write_raw_resources( updates );
1659
1660 free_resource_directory( &updates->root, 2 );
1661
1662 HeapFree( GetProcessHeap(), 0, updates->pFileName );
1663 GlobalUnlock( hUpdate );
1664 GlobalFree( hUpdate );
1665
1666 return ret;
1667 }
1668
1669
1670 /***********************************************************************
1671 * EndUpdateResourceA (KERNEL32.@)
1672 */
1673 BOOL WINAPI EndUpdateResourceA( HANDLE hUpdate, BOOL fDiscard )
1674 {
1675 return EndUpdateResourceW(hUpdate, fDiscard);
1676 }
1677
1678
1679 /***********************************************************************
1680 * UpdateResourceW (KERNEL32.@)
1681 */
1682 BOOL WINAPI UpdateResourceW( HANDLE hUpdate, LPCWSTR lpType, LPCWSTR lpName,
1683 WORD wLanguage, LPVOID lpData, DWORD cbData)
1684 {
1685 QUEUEDUPDATES *updates;
1686 BOOL ret = FALSE;
1687
1688 TRACE("%p %s %s %08x %p %d\n", hUpdate,
1689 debugstr_w(lpType), debugstr_w(lpName), wLanguage, lpData, cbData);
1690
1691 updates = GlobalLock(hUpdate);
1692 if (updates)
1693 {
1694 if (lpData == NULL && cbData == 0) /* remove resource */
1695 {
1696 ret = update_add_resource( updates, lpType, lpName, wLanguage, NULL, TRUE );
1697 }
1698 else
1699 {
1700 struct resource_data *data;
1701 data = allocate_resource_data( wLanguage, 0, lpData, cbData, TRUE );
1702 if (data)
1703 ret = update_add_resource( updates, lpType, lpName, wLanguage, data, TRUE );
1704 }
1705 GlobalUnlock(hUpdate);
1706 }
1707 return ret;
1708 }
1709
1710
1711 /***********************************************************************
1712 * UpdateResourceA (KERNEL32.@)
1713 */
1714 BOOL WINAPI UpdateResourceA( HANDLE hUpdate, LPCSTR lpType, LPCSTR lpName,
1715 WORD wLanguage, LPVOID lpData, DWORD cbData)
1716 {
1717 BOOL ret;
1718 UNICODE_STRING TypeW;
1719 UNICODE_STRING NameW;
1720 if(IS_INTRESOURCE(lpType))
1721 TypeW.Buffer = ULongToPtr(LOWORD(lpType));
1722 else
1723 RtlCreateUnicodeStringFromAsciiz(&TypeW, lpType);
1724 if(IS_INTRESOURCE(lpName))
1725 NameW.Buffer = ULongToPtr(LOWORD(lpName));
1726 else
1727 RtlCreateUnicodeStringFromAsciiz(&NameW, lpName);
1728 ret = UpdateResourceW(hUpdate, TypeW.Buffer, NameW.Buffer, wLanguage, lpData, cbData);
1729 if(!IS_INTRESOURCE(lpType)) RtlFreeUnicodeString(&TypeW);
1730 if(!IS_INTRESOURCE(lpName)) RtlFreeUnicodeString(&NameW);
1731 return ret;
1732 }
Maarten's multimedia branch