ws2_32: Delete the static critical section when unloading the dll.
[wine] / dlls / kernel32 / resource.c
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 }