wshom.ocx: Added beginning WshShell object tests.
[wine] / dlls / setupapi / fakedll.c
1 /*
2  * Creation of Wine fake dlls for apps that access the dll file directly.
3  *
4  * Copyright 2006, 2011 Alexandre Julliard
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <stdarg.h>
25 #include <fcntl.h>
26 #ifdef HAVE_DIRENT_H
27 # include <dirent.h>
28 #endif
29 #ifdef HAVE_SYS_STAT_H
30 # include <sys/stat.h>
31 #endif
32 #ifdef HAVE_UNISTD_H
33 # include <unistd.h>
34 #endif
35
36 #define COBJMACROS
37 #define ATL_INITGUID
38 #define NONAMELESSSTRUCT
39 #define NONAMELESSUNION
40 #include "ntstatus.h"
41 #define WIN32_NO_STATUS
42 #include "windef.h"
43 #include "winbase.h"
44 #include "winuser.h"
45 #include "winnt.h"
46 #include "winternl.h"
47 #include "wine/unicode.h"
48 #include "wine/library.h"
49 #include "wine/debug.h"
50 #include "ole2.h"
51 #include "atliface.h"
52
53 WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
54
55 static const char fakedll_signature[] = "Wine placeholder DLL";
56
57 static const unsigned int file_alignment = 512;
58 static const unsigned int section_alignment = 4096;
59 static const unsigned int max_dll_name_len = 64;
60
61 static void *file_buffer;
62 static SIZE_T file_buffer_size;
63 static unsigned int handled_count;
64 static unsigned int handled_total;
65 static char **handled_dlls;
66 static IRegistrar *registrar;
67
68 struct dll_info
69 {
70     HANDLE            handle;
71     IMAGE_NT_HEADERS *nt;
72     DWORD             file_pos;
73     DWORD             mem_pos;
74 };
75
76 #define ALIGN(size,align) (((size) + (align) - 1) & ~((align) - 1))
77
78 /* contents of the dll sections */
79
80 static const BYTE dll_code_section[] = { 0x31, 0xc0,          /* xor %eax,%eax */
81                                          0xc2, 0x0c, 0x00 };  /* ret $12 */
82
83 static const BYTE exe_code_section[] = { 0xb8, 0x01, 0x00, 0x00, 0x00,  /* movl $1,%eax */
84                                          0xc2, 0x04, 0x00 };            /* ret $4 */
85
86 static const IMAGE_BASE_RELOCATION reloc_section;  /* empty relocs */
87
88
89 /* wrapper for WriteFile */
90 static inline BOOL xwrite( struct dll_info *info, const void *data, DWORD size, DWORD offset )
91 {
92     DWORD res;
93
94     return (SetFilePointer( info->handle, offset, NULL, FILE_BEGIN ) != INVALID_SET_FILE_POINTER &&
95             WriteFile( info->handle, data, size, &res, NULL ) &&
96             res == size);
97 }
98
99 /* add a new section to the dll NT header */
100 static void add_section( struct dll_info *info, const char *name, DWORD size, DWORD flags )
101 {
102     IMAGE_SECTION_HEADER *sec = (IMAGE_SECTION_HEADER *)(info->nt + 1);
103
104     sec += info->nt->FileHeader.NumberOfSections;
105     memcpy( sec->Name, name, min( strlen(name), sizeof(sec->Name)) );
106     sec->Misc.VirtualSize = ALIGN( size, section_alignment );
107     sec->VirtualAddress   = info->mem_pos;
108     sec->SizeOfRawData    = size;
109     sec->PointerToRawData = info->file_pos;
110     sec->Characteristics  = flags;
111     info->file_pos += ALIGN( size, file_alignment );
112     info->mem_pos  += ALIGN( size, section_alignment );
113     info->nt->FileHeader.NumberOfSections++;
114 }
115
116 /* add a data directory to the dll NT header */
117 static inline void add_directory( struct dll_info *info, unsigned int idx, DWORD rva, DWORD size )
118 {
119     info->nt->OptionalHeader.DataDirectory[idx].VirtualAddress = rva;
120     info->nt->OptionalHeader.DataDirectory[idx].Size = size;
121 }
122
123 /* convert a dll name W->A without depending on the current codepage */
124 static char *dll_name_WtoA( char *nameA, const WCHAR *nameW, unsigned int len )
125 {
126     unsigned int i;
127
128     for (i = 0; i < len; i++)
129     {
130         char c = nameW[i];
131         if (nameW[i] > 127) return NULL;
132         if (c >= 'A' && c <= 'Z') c += 'a' - 'A';
133         nameA[i] = c;
134     }
135     nameA[i] = 0;
136     return nameA;
137 }
138
139 /* convert a dll name A->W without depending on the current codepage */
140 static WCHAR *dll_name_AtoW( WCHAR *nameW, const char *nameA, unsigned int len )
141 {
142     unsigned int i;
143
144     for (i = 0; i < len; i++) nameW[i] = nameA[i];
145     nameW[i] = 0;
146     return nameW;
147 }
148
149 /* add a dll to the list of dll that have been taken care of */
150 static BOOL add_handled_dll( const WCHAR *name )
151 {
152     unsigned int len = strlenW( name );
153     int i, min, max, pos, res;
154     char *nameA;
155
156     if (!(nameA = HeapAlloc( GetProcessHeap(), 0, len + 1 ))) return FALSE;
157     if (!dll_name_WtoA( nameA, name, len )) goto failed;
158
159     min = 0;
160     max = handled_count - 1;
161     while (min <= max)
162     {
163         pos = (min + max) / 2;
164         res = strcmp( handled_dlls[pos], nameA );
165         if (!res) goto failed;  /* already in the list */
166         if (res < 0) min = pos + 1;
167         else max = pos - 1;
168     }
169
170     if (handled_count >= handled_total)
171     {
172         char **new_dlls;
173         unsigned int new_count = max( 64, handled_total * 2 );
174
175         if (handled_dlls) new_dlls = HeapReAlloc( GetProcessHeap(), 0, handled_dlls,
176                                                   new_count * sizeof(*handled_dlls) );
177         else new_dlls = HeapAlloc( GetProcessHeap(), 0, new_count * sizeof(*handled_dlls) );
178         if (!new_dlls) goto failed;
179         handled_dlls = new_dlls;
180         handled_total = new_count;
181     }
182
183     for (i = handled_count; i > min; i--) handled_dlls[i] = handled_dlls[i - 1];
184     handled_dlls[i] = nameA;
185     handled_count++;
186     return TRUE;
187
188 failed:
189     HeapFree( GetProcessHeap(), 0, nameA );
190     return FALSE;
191 }
192
193 /* read in the contents of a file into the global file buffer */
194 /* return 1 on success, 0 on nonexistent file, -1 on other error */
195 static int read_file( const char *name, void **data, SIZE_T *size )
196 {
197     struct stat st;
198     int fd, ret = -1;
199     size_t header_size;
200     IMAGE_DOS_HEADER *dos;
201     IMAGE_NT_HEADERS *nt;
202     const size_t min_size = sizeof(*dos) + sizeof(fakedll_signature) +
203         FIELD_OFFSET( IMAGE_NT_HEADERS, OptionalHeader.MajorLinkerVersion );
204
205     if ((fd = open( name, O_RDONLY | O_BINARY )) == -1) return 0;
206     if (fstat( fd, &st ) == -1) goto done;
207     *size = st.st_size;
208     if (!file_buffer || st.st_size > file_buffer_size)
209     {
210         VirtualFree( file_buffer, 0, MEM_RELEASE );
211         file_buffer = NULL;
212         file_buffer_size = st.st_size;
213         if (NtAllocateVirtualMemory( GetCurrentProcess(), &file_buffer, 0, &file_buffer_size,
214                                      MEM_COMMIT, PAGE_READWRITE )) goto done;
215     }
216
217     /* check for valid fake dll file */
218
219     if (st.st_size < min_size) goto done;
220     header_size = min( st.st_size, 4096 );
221     if (pread( fd, file_buffer, header_size, 0 ) != header_size) goto done;
222     dos = file_buffer;
223     if (dos->e_magic != IMAGE_DOS_SIGNATURE) goto done;
224     if (dos->e_lfanew < sizeof(fakedll_signature)) goto done;
225     if (memcmp( dos + 1, fakedll_signature, sizeof(fakedll_signature) )) goto done;
226     if (dos->e_lfanew + FIELD_OFFSET(IMAGE_NT_HEADERS,OptionalHeader.MajorLinkerVersion) > header_size)
227         goto done;
228     nt = (IMAGE_NT_HEADERS *)((char *)file_buffer + dos->e_lfanew);
229     if (nt->Signature == IMAGE_NT_SIGNATURE && nt->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)
230     {
231         /* wrong 32/64 type, pretend it doesn't exist */
232         ret = 0;
233         goto done;
234     }
235     if (st.st_size == header_size ||
236         pread( fd, (char *)file_buffer + header_size,
237                st.st_size - header_size, header_size ) == st.st_size - header_size)
238     {
239         *data = file_buffer;
240         ret = 1;
241     }
242 done:
243     close( fd );
244     return ret;
245 }
246
247 /* build a complete fake dll from scratch */
248 static BOOL build_fake_dll( HANDLE file )
249 {
250     IMAGE_DOS_HEADER *dos;
251     IMAGE_NT_HEADERS *nt;
252     struct dll_info info;
253     BYTE *buffer;
254     BOOL ret = FALSE;
255     DWORD lfanew = (sizeof(*dos) + sizeof(fakedll_signature) + 15) & ~15;
256     DWORD size, header_size = lfanew + sizeof(*nt);
257
258     info.handle = file;
259     buffer = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, header_size + 8 * sizeof(IMAGE_SECTION_HEADER) );
260
261     dos = (IMAGE_DOS_HEADER *)buffer;
262     dos->e_magic    = IMAGE_DOS_SIGNATURE;
263     dos->e_cblp     = sizeof(*dos);
264     dos->e_cp       = 1;
265     dos->e_cparhdr  = lfanew / 16;
266     dos->e_minalloc = 0;
267     dos->e_maxalloc = 0xffff;
268     dos->e_ss       = 0x0000;
269     dos->e_sp       = 0x00b8;
270     dos->e_lfarlc   = lfanew;
271     dos->e_lfanew   = lfanew;
272     memcpy( dos + 1, fakedll_signature, sizeof(fakedll_signature) );
273
274     nt = info.nt = (IMAGE_NT_HEADERS *)(buffer + lfanew);
275     /* some fields are copied from the source dll */
276 #ifdef _WIN64
277     nt->FileHeader.Machine = IMAGE_FILE_MACHINE_AMD64;
278 #else
279     nt->FileHeader.Machine = IMAGE_FILE_MACHINE_I386;
280 #endif
281     nt->FileHeader.TimeDateStamp = 0;
282     nt->FileHeader.Characteristics = IMAGE_FILE_DLL;
283     nt->OptionalHeader.MajorLinkerVersion = 1;
284     nt->OptionalHeader.MinorLinkerVersion = 0;
285     nt->OptionalHeader.MajorOperatingSystemVersion = 1;
286     nt->OptionalHeader.MinorOperatingSystemVersion = 0;
287     nt->OptionalHeader.MajorImageVersion = 1;
288     nt->OptionalHeader.MinorImageVersion = 0;
289     nt->OptionalHeader.MajorSubsystemVersion = 4;
290     nt->OptionalHeader.MinorSubsystemVersion = 0;
291     nt->OptionalHeader.Win32VersionValue = 0;
292     nt->OptionalHeader.Subsystem = IMAGE_SUBSYSTEM_WINDOWS_GUI;
293     nt->OptionalHeader.DllCharacteristics = 0;
294     nt->OptionalHeader.SizeOfStackReserve = 0;
295     nt->OptionalHeader.SizeOfStackCommit = 0;
296     nt->OptionalHeader.SizeOfHeapReserve = 0;
297     nt->OptionalHeader.SizeOfHeapCommit = 0;
298     /* other fields have fixed values */
299     nt->Signature                              = IMAGE_NT_SIGNATURE;
300     nt->FileHeader.NumberOfSections            = 0;
301     nt->FileHeader.SizeOfOptionalHeader        = IMAGE_SIZEOF_NT_OPTIONAL_HEADER;
302     nt->OptionalHeader.Magic                   = IMAGE_NT_OPTIONAL_HDR_MAGIC;
303     nt->OptionalHeader.ImageBase               = 0x10000000;
304     nt->OptionalHeader.SectionAlignment        = section_alignment;
305     nt->OptionalHeader.FileAlignment           = file_alignment;
306     nt->OptionalHeader.NumberOfRvaAndSizes     = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
307
308     header_size = (BYTE *)(nt + 1) - buffer;
309     info.mem_pos  = ALIGN( header_size, section_alignment );
310     info.file_pos = ALIGN( header_size, file_alignment );
311
312     nt->OptionalHeader.AddressOfEntryPoint = info.mem_pos;
313     nt->OptionalHeader.BaseOfCode          = info.mem_pos;
314
315     if (nt->FileHeader.Characteristics & IMAGE_FILE_DLL)
316     {
317         size = sizeof(dll_code_section);
318         if (!xwrite( &info, dll_code_section, size, info.file_pos )) goto done;
319     }
320     else
321     {
322         size = sizeof(exe_code_section);
323         if (!xwrite( &info, exe_code_section, size, info.file_pos )) goto done;
324     }
325     nt->OptionalHeader.SizeOfCode = size;
326     add_section( &info, ".text", size, IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ );
327
328     if (!xwrite( &info, &reloc_section, sizeof(reloc_section), info.file_pos )) goto done;
329     add_directory( &info, IMAGE_DIRECTORY_ENTRY_BASERELOC, info.mem_pos, sizeof(reloc_section) );
330     add_section( &info, ".reloc", sizeof(reloc_section),
331                  IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_MEM_READ );
332
333     header_size += nt->FileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER);
334     nt->OptionalHeader.SizeOfHeaders = ALIGN( header_size, file_alignment );
335     nt->OptionalHeader.SizeOfImage   = ALIGN( info.mem_pos, section_alignment );
336     ret = xwrite( &info, buffer, header_size, 0 );
337 done:
338     HeapFree( GetProcessHeap(), 0, buffer );
339     return ret;
340 }
341
342 /* check if an existing file is a fake dll so that we can overwrite it */
343 static BOOL is_fake_dll( HANDLE h )
344 {
345     IMAGE_DOS_HEADER *dos;
346     DWORD size;
347     BYTE buffer[sizeof(*dos) + sizeof(fakedll_signature)];
348
349     if (!ReadFile( h, buffer, sizeof(buffer), &size, NULL ) || size != sizeof(buffer))
350         return FALSE;
351     dos = (IMAGE_DOS_HEADER *)buffer;
352     if (dos->e_magic != IMAGE_DOS_SIGNATURE) return FALSE;
353     if (dos->e_lfanew < size) return FALSE;
354     return !memcmp( dos + 1, fakedll_signature, sizeof(fakedll_signature) );
355 }
356
357 /* create directories leading to a given file */
358 static void create_directories( const WCHAR *name )
359 {
360     WCHAR *path, *p;
361
362     /* create the directory/directories */
363     path = HeapAlloc(GetProcessHeap(), 0, (strlenW(name) + 1)*sizeof(WCHAR));
364     strcpyW(path, name);
365
366     p = strchrW(path, '\\');
367     while (p != NULL)
368     {
369         *p = 0;
370         if (!CreateDirectoryW(path, NULL))
371             TRACE("Couldn't create directory %s - error: %d\n", wine_dbgstr_w(path), GetLastError());
372         *p = '\\';
373         p = strchrW(p+1, '\\');
374     }
375     HeapFree(GetProcessHeap(), 0, path);
376 }
377
378 static inline char *prepend( char *buffer, const char *str, size_t len )
379 {
380     return memcpy( buffer - len, str, len );
381 }
382
383 /* try to load a pre-compiled fake dll */
384 static void *load_fake_dll( const WCHAR *name, SIZE_T *size )
385 {
386     const char *build_dir = wine_get_build_dir();
387     const char *path;
388     char *file, *ptr;
389     void *data = NULL;
390     unsigned int i, pos, len, namelen, maxlen = 0;
391     WCHAR *p;
392     int res = 0;
393
394     if ((p = strrchrW( name, '\\' ))) name = p + 1;
395
396     i = 0;
397     if (build_dir) maxlen = strlen(build_dir) + sizeof("/programs/") + strlenW(name);
398     while ((path = wine_dll_enum_load_path( i++ ))) maxlen = max( maxlen, strlen(path) );
399     maxlen += sizeof("/fakedlls") + strlenW(name) + 2;
400
401     if (!(file = HeapAlloc( GetProcessHeap(), 0, maxlen ))) return NULL;
402
403     len = strlenW( name );
404     pos = maxlen - len - sizeof(".fake");
405     if (!dll_name_WtoA( file + pos, name, len )) goto done;
406     file[--pos] = '/';
407
408     if (build_dir)
409     {
410         strcpy( file + pos + len + 1, ".fake" );
411
412         /* try as a dll */
413         ptr = file + pos;
414         namelen = len + 1;
415         if (namelen > 4 && !memcmp( ptr + namelen - 4, ".dll", 4 )) namelen -= 4;
416         ptr = prepend( ptr, ptr, namelen );
417         ptr = prepend( ptr, "/dlls", sizeof("/dlls") - 1 );
418         ptr = prepend( ptr, build_dir, strlen(build_dir) );
419         if ((res = read_file( ptr, &data, size ))) goto done;
420
421         /* now as a program */
422         ptr = file + pos;
423         namelen = len + 1;
424         if (namelen > 4 && !memcmp( ptr + namelen - 4, ".exe", 4 )) namelen -= 4;
425         ptr = prepend( ptr, ptr, namelen );
426         ptr = prepend( ptr, "/programs", sizeof("/programs") - 1 );
427         ptr = prepend( ptr, build_dir, strlen(build_dir) );
428         if ((res = read_file( ptr, &data, size ))) goto done;
429     }
430
431     file[pos + len + 1] = 0;
432     for (i = 0; (path = wine_dll_enum_load_path( i )); i++)
433     {
434         ptr = prepend( file + pos, "/fakedlls", sizeof("/fakedlls") - 1 );
435         ptr = prepend( ptr, path, strlen(path) );
436         if ((res = read_file( ptr, &data, size ))) break;
437     }
438
439 done:
440     HeapFree( GetProcessHeap(), 0, file );
441     if (res == 1) return data;
442     return NULL;
443 }
444
445 /* create the fake dll destination file */
446 static HANDLE create_dest_file( const WCHAR *name )
447 {
448     /* first check for an existing file */
449     HANDLE h = CreateFileW( name, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL );
450     if (h != INVALID_HANDLE_VALUE)
451     {
452         if (!is_fake_dll( h ))
453         {
454             TRACE( "%s is not a fake dll, not overwriting it\n", debugstr_w(name) );
455             CloseHandle( h );
456             return 0;
457         }
458         /* truncate the file */
459         SetFilePointer( h, 0, NULL, FILE_BEGIN );
460         SetEndOfFile( h );
461     }
462     else
463     {
464         if (GetLastError() == ERROR_PATH_NOT_FOUND) create_directories( name );
465
466         h = CreateFileW( name, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, NULL );
467         if (h == INVALID_HANDLE_VALUE)
468             ERR( "failed to create %s (error=%u)\n", debugstr_w(name), GetLastError() );
469     }
470     return h;
471 }
472
473 /* XML parsing code copied from ntdll */
474
475 typedef struct
476 {
477     const char  *ptr;
478     unsigned int len;
479 } xmlstr_t;
480
481 typedef struct
482 {
483     const char *ptr;
484     const char *end;
485 } xmlbuf_t;
486
487 static inline BOOL xmlstr_cmp(const xmlstr_t* xmlstr, const char *str)
488 {
489     return !strncmp(xmlstr->ptr, str, xmlstr->len) && !str[xmlstr->len];
490 }
491
492 static inline BOOL isxmlspace( char ch )
493 {
494     return (ch == ' ' || ch == '\r' || ch == '\n' || ch == '\t');
495 }
496
497 static BOOL next_xml_elem( xmlbuf_t *xmlbuf, xmlstr_t *elem )
498 {
499     const char *ptr;
500
501     for (;;)
502     {
503         ptr = memchr(xmlbuf->ptr, '<', xmlbuf->end - xmlbuf->ptr);
504         if (!ptr)
505         {
506             xmlbuf->ptr = xmlbuf->end;
507             return FALSE;
508         }
509         ptr++;
510         if (ptr + 3 < xmlbuf->end && ptr[0] == '!' && ptr[1] == '-' && ptr[2] == '-') /* skip comment */
511         {
512             for (ptr += 3; ptr + 3 <= xmlbuf->end; ptr++)
513                 if (ptr[0] == '-' && ptr[1] == '-' && ptr[2] == '>') break;
514
515             if (ptr + 3 > xmlbuf->end)
516             {
517                 xmlbuf->ptr = xmlbuf->end;
518                 return FALSE;
519             }
520             xmlbuf->ptr = ptr + 3;
521         }
522         else break;
523     }
524
525     xmlbuf->ptr = ptr;
526     while (ptr < xmlbuf->end && !isxmlspace(*ptr) && *ptr != '>' && (*ptr != '/' || ptr == xmlbuf->ptr))
527         ptr++;
528
529     elem->ptr = xmlbuf->ptr;
530     elem->len = ptr - xmlbuf->ptr;
531     xmlbuf->ptr = ptr;
532     return xmlbuf->ptr != xmlbuf->end;
533 }
534
535 static BOOL next_xml_attr(xmlbuf_t* xmlbuf, xmlstr_t* name, xmlstr_t* value,
536                           BOOL* error, BOOL* end)
537 {
538     const char *ptr;
539
540     *error = TRUE;
541
542     while (xmlbuf->ptr < xmlbuf->end && isxmlspace(*xmlbuf->ptr))
543         xmlbuf->ptr++;
544
545     if (xmlbuf->ptr == xmlbuf->end) return FALSE;
546
547     if (*xmlbuf->ptr == '/')
548     {
549         xmlbuf->ptr++;
550         if (xmlbuf->ptr == xmlbuf->end || *xmlbuf->ptr != '>')
551             return FALSE;
552
553         xmlbuf->ptr++;
554         *end = TRUE;
555         *error = FALSE;
556         return FALSE;
557     }
558
559     if (*xmlbuf->ptr == '>')
560     {
561         xmlbuf->ptr++;
562         *error = FALSE;
563         return FALSE;
564     }
565
566     ptr = xmlbuf->ptr;
567     while (ptr < xmlbuf->end && *ptr != '=' && *ptr != '>' && !isxmlspace(*ptr)) ptr++;
568
569     if (ptr == xmlbuf->end || *ptr != '=') return FALSE;
570
571     name->ptr = xmlbuf->ptr;
572     name->len = ptr-xmlbuf->ptr;
573     xmlbuf->ptr = ptr;
574
575     ptr++;
576     if (ptr == xmlbuf->end || (*ptr != '"' && *ptr != '\'')) return FALSE;
577
578     value->ptr = ++ptr;
579     if (ptr == xmlbuf->end) return FALSE;
580
581     ptr = memchr(ptr, ptr[-1], xmlbuf->end - ptr);
582     if (!ptr)
583     {
584         xmlbuf->ptr = xmlbuf->end;
585         return FALSE;
586     }
587
588     value->len = ptr - value->ptr;
589     xmlbuf->ptr = ptr + 1;
590
591     if (xmlbuf->ptr == xmlbuf->end) return FALSE;
592
593     *error = FALSE;
594     return TRUE;
595 }
596
597 static void get_manifest_filename( const xmlstr_t *arch, const xmlstr_t *name, const xmlstr_t *key,
598                                    const xmlstr_t *version, const xmlstr_t *lang, WCHAR *buffer, DWORD size )
599 {
600     static const WCHAR trailerW[] = {'_','d','e','a','d','b','e','e','f',0};
601     DWORD pos;
602
603     pos = MultiByteToWideChar( CP_UTF8, 0, arch->ptr, arch->len, buffer, size );
604     buffer[pos++] = '_';
605     pos += MultiByteToWideChar( CP_UTF8, 0, name->ptr, name->len, buffer + pos, size - pos );
606     buffer[pos++] = '_';
607     pos += MultiByteToWideChar( CP_UTF8, 0, key->ptr, key->len, buffer + pos, size - pos );
608     buffer[pos++] = '_';
609     pos += MultiByteToWideChar( CP_UTF8, 0, version->ptr, version->len, buffer + pos, size - pos );
610     buffer[pos++] = '_';
611     pos += MultiByteToWideChar( CP_UTF8, 0, lang->ptr, lang->len, buffer + pos, size - pos );
612     memcpy( buffer + pos, trailerW, sizeof(trailerW) );
613     strlwrW( buffer );
614 }
615
616 static BOOL create_winsxs_dll( const WCHAR *dll_name, const xmlstr_t *arch, const xmlstr_t *name,
617                                const xmlstr_t *key, const xmlstr_t *version, const xmlstr_t *lang,
618                                const void *dll_data, size_t dll_size )
619 {
620     static const WCHAR winsxsW[] = {'w','i','n','s','x','s','\\'};
621     WCHAR *path;
622     const WCHAR *filename;
623     DWORD pos, written, path_len;
624     HANDLE handle;
625     BOOL ret = FALSE;
626
627     if (!(filename = strrchrW( dll_name, '\\' ))) filename = dll_name;
628     else filename++;
629
630     path_len = GetWindowsDirectoryW( NULL, 0 ) + 1 + sizeof(winsxsW)/sizeof(WCHAR)
631         + arch->len + name->len + key->len + version->len + 18 + strlenW( filename ) + 1;
632
633     path = HeapAlloc( GetProcessHeap(), 0, path_len * sizeof(WCHAR) );
634     pos = GetWindowsDirectoryW( path, path_len );
635     path[pos++] = '\\';
636     memcpy( path + pos, winsxsW, sizeof(winsxsW) );
637     pos += sizeof(winsxsW) / sizeof(WCHAR);
638     get_manifest_filename( arch, name, key, version, lang, path + pos, path_len - pos );
639     pos += strlenW( path + pos );
640     path[pos++] = '\\';
641     strcpyW( path + pos, filename );
642     handle = create_dest_file( path );
643     if (handle && handle != INVALID_HANDLE_VALUE)
644     {
645         TRACE( "creating %s\n", debugstr_w(path) );
646         ret = (WriteFile( handle, dll_data, dll_size, &written, NULL ) && written == dll_size);
647         if (!ret) ERR( "failed to write to %s (error=%u)\n", debugstr_w(path), GetLastError() );
648         CloseHandle( handle );
649         if (!ret) DeleteFileW( path );
650     }
651     HeapFree( GetProcessHeap(), 0, path );
652     return ret;
653 }
654
655 static BOOL create_manifest( const xmlstr_t *arch, const xmlstr_t *name, const xmlstr_t *key,
656                              const xmlstr_t *version, const xmlstr_t *lang, const void *data, DWORD len )
657 {
658     static const WCHAR winsxsW[] = {'w','i','n','s','x','s','\\','m','a','n','i','f','e','s','t','s','\\'};
659     static const WCHAR extensionW[] = {'.','m','a','n','i','f','e','s','t',0};
660     WCHAR *path;
661     DWORD pos, written, path_len;
662     HANDLE handle;
663     BOOL ret = FALSE;
664
665     path_len = GetWindowsDirectoryW( NULL, 0 ) + 1 + sizeof(winsxsW)/sizeof(WCHAR)
666         + arch->len + name->len + key->len + version->len + 18 + sizeof(extensionW)/sizeof(WCHAR);
667
668     path = HeapAlloc( GetProcessHeap(), 0, path_len * sizeof(WCHAR) );
669     pos = GetWindowsDirectoryW( path, MAX_PATH );
670     path[pos++] = '\\';
671     memcpy( path + pos, winsxsW, sizeof(winsxsW) );
672     pos += sizeof(winsxsW) / sizeof(WCHAR);
673     get_manifest_filename( arch, name, key, version, lang, path + pos, MAX_PATH - pos );
674     strcatW( path + pos, extensionW );
675     handle = CreateFileW( path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL );
676     if (handle == INVALID_HANDLE_VALUE && GetLastError() == ERROR_PATH_NOT_FOUND)
677     {
678         create_directories( path );
679         handle = CreateFileW( path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL );
680     }
681
682     if (handle != INVALID_HANDLE_VALUE)
683     {
684         TRACE( "creating %s\n", debugstr_w(path) );
685         ret = (WriteFile( handle, data, len, &written, NULL ) && written == len);
686         if (!ret) ERR( "failed to write to %s (error=%u)\n", debugstr_w(path), GetLastError() );
687         CloseHandle( handle );
688         if (!ret) DeleteFileW( path );
689     }
690     HeapFree( GetProcessHeap(), 0, path );
691     return ret;
692 }
693
694 static void register_manifest( const WCHAR *dll_name, const char *manifest, DWORD len,
695                                const void *dll_data, size_t dll_size )
696 {
697 #ifdef __i386__
698     static const char current_arch[] = "x86";
699 #elif defined __x86_64__
700     static const char current_arch[] = "amd64";
701 #else
702     static const char current_arch[] = "none";
703 #endif
704     xmlbuf_t buffer;
705     xmlstr_t elem, attr_name, attr_value;
706     xmlstr_t name, version, arch, key, lang;
707     BOOL end = FALSE, error;
708
709     buffer.ptr = manifest;
710     buffer.end = manifest + len;
711     name.ptr = version.ptr = arch.ptr = key.ptr = lang.ptr = NULL;
712     name.len = version.len = arch.len = key.len = lang.len = 0;
713
714     while (next_xml_elem( &buffer, &elem ))
715     {
716         if (!xmlstr_cmp( &elem, "assemblyIdentity" )) continue;
717         while (next_xml_attr( &buffer, &attr_name, &attr_value, &error, &end ))
718         {
719             if (xmlstr_cmp(&attr_name, "name")) name = attr_value;
720             else if (xmlstr_cmp(&attr_name, "version")) version = attr_value;
721             else if (xmlstr_cmp(&attr_name, "processorArchitecture")) arch = attr_value;
722             else if (xmlstr_cmp(&attr_name, "publicKeyToken")) key = attr_value;
723             else if (xmlstr_cmp(&attr_name, "language")) lang = attr_value;
724         }
725         if (!error && name.ptr && version.ptr && arch.ptr && key.ptr)
726         {
727             if (!lang.ptr)
728             {
729                 lang.ptr = "none";
730                 lang.len = strlen( lang.ptr );
731             }
732             if (!arch.len)  /* fixup the architecture */
733             {
734                 char *new_buffer = HeapAlloc( GetProcessHeap(), 0, len + sizeof(current_arch) );
735                 memcpy( new_buffer, manifest, arch.ptr - manifest );
736                 strcpy( new_buffer + (arch.ptr - manifest), current_arch );
737                 memcpy( new_buffer + strlen(new_buffer), arch.ptr, len - (arch.ptr - manifest) );
738                 arch.ptr = current_arch;
739                 arch.len = strlen( current_arch );
740                 if (create_winsxs_dll( dll_name, &arch, &name, &key, &version, &lang, dll_data, dll_size ))
741                     create_manifest( &arch, &name, &key, &version, &lang, new_buffer, len + arch.len );
742                 HeapFree( GetProcessHeap(), 0, new_buffer );
743             }
744             else
745             {
746                 if (create_winsxs_dll( dll_name, &arch, &name, &key, &version, &lang, dll_data, dll_size ))
747                     create_manifest( &arch, &name, &key, &version, &lang, manifest, len );
748             }
749         }
750     }
751 }
752
753 static BOOL CALLBACK register_resource( HMODULE module, LPCWSTR type, LPWSTR name, LONG_PTR arg )
754 {
755     HRESULT *hr = (HRESULT *)arg;
756     WCHAR *buffer;
757     HRSRC rsrc = FindResourceW( module, name, type );
758     char *str = LoadResource( module, rsrc );
759     DWORD lenW, lenA = SizeofResource( module, rsrc );
760
761     if (!str) return FALSE;
762     lenW = MultiByteToWideChar( CP_UTF8, 0, str, lenA, NULL, 0 ) + 1;
763     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, lenW * sizeof(WCHAR) ))) return FALSE;
764     MultiByteToWideChar( CP_UTF8, 0, str, lenA, buffer, lenW );
765     buffer[lenW - 1] = 0;
766     *hr = IRegistrar_StringRegister( registrar, buffer );
767     HeapFree( GetProcessHeap(), 0, buffer );
768     return TRUE;
769 }
770
771 static void register_fake_dll( const WCHAR *name, const void *data, size_t size )
772 {
773     static const WCHAR atlW[] = {'a','t','l','.','d','l','l',0};
774     static const WCHAR moduleW[] = {'M','O','D','U','L','E',0};
775     static const WCHAR regtypeW[] = {'W','I','N','E','_','R','E','G','I','S','T','R','Y',0};
776     static const WCHAR manifestW[] = {'W','I','N','E','_','M','A','N','I','F','E','S','T',0};
777     const IMAGE_RESOURCE_DIRECTORY *resdir;
778     LDR_RESOURCE_INFO info;
779     HRESULT hr = S_OK;
780     HMODULE module = (HMODULE)((ULONG_PTR)data | 1);
781     HRSRC rsrc;
782
783     if ((rsrc = FindResourceW( module, manifestW, MAKEINTRESOURCEW(RT_MANIFEST) )))
784     {
785         char *manifest = LoadResource( module, rsrc );
786         register_manifest( name, manifest, SizeofResource( module, rsrc ), data, size );
787     }
788
789     info.Type = (ULONG_PTR)regtypeW;
790     if (LdrFindResourceDirectory_U( module, &info, 1, &resdir )) return;
791
792     if (!registrar)
793     {
794         /* create the object by hand since we can't guarantee that atl and ole32 are registered */
795         IClassFactory *cf;
796         HRESULT (WINAPI *pDllGetClassObject)( REFCLSID clsid, REFIID iid, LPVOID *ppv );
797         HMODULE atl = LoadLibraryW( atlW );
798
799         if ((pDllGetClassObject = (void *)GetProcAddress( atl, "DllGetClassObject" )))
800         {
801             hr = pDllGetClassObject( &CLSID_Registrar, &IID_IClassFactory, (void **)&cf );
802             if (SUCCEEDED( hr ))
803             {
804                 hr = IClassFactory_CreateInstance( cf, NULL, &IID_IRegistrar, (void **)&registrar );
805                 IClassFactory_Release( cf );
806             }
807         }
808         if (!registrar)
809         {
810             ERR( "failed to create IRegistrar: %x\n", hr );
811             return;
812         }
813     }
814
815     TRACE( "registering %s\n", debugstr_w(name) );
816     IRegistrar_ClearReplacements( registrar );
817     IRegistrar_AddReplacement( registrar, moduleW, name );
818     EnumResourceNamesW( module, regtypeW, register_resource, (LONG_PTR)&hr );
819     if (FAILED(hr)) ERR( "failed to register %s: %x\n", debugstr_w(name), hr );
820 }
821
822 /* copy a fake dll file to the dest directory */
823 static void install_fake_dll( WCHAR *dest, char *file, const char *ext )
824 {
825     int ret;
826     SIZE_T size;
827     void *data;
828     DWORD written;
829     WCHAR *destname = dest + strlenW(dest);
830     char *name = strrchr( file, '/' ) + 1;
831     char *end = name + strlen(name);
832
833     if (ext) strcpy( end, ext );
834     if (!(ret = read_file( file, &data, &size ))) return;
835
836     if (end > name + 2 && !strncmp( end - 2, "16", 2 )) end -= 2;  /* remove "16" suffix */
837     dll_name_AtoW( destname, name, end - name );
838     if (!add_handled_dll( destname )) ret = -1;
839
840     if (ret != -1)
841     {
842         HANDLE h = create_dest_file( dest );
843
844         if (h && h != INVALID_HANDLE_VALUE)
845         {
846             TRACE( "%s -> %s\n", debugstr_a(file), debugstr_w(dest) );
847
848             ret = (WriteFile( h, data, size, &written, NULL ) && written == size);
849             if (!ret) ERR( "failed to write to %s (error=%u)\n", debugstr_w(dest), GetLastError() );
850             CloseHandle( h );
851             if (ret) register_fake_dll( dest, data, size );
852             else DeleteFileW( dest );
853         }
854     }
855     *destname = 0;  /* restore it for next file */
856 }
857
858 /* find and install all fake dlls in a given lib directory */
859 static void install_lib_dir( WCHAR *dest, char *file, const char *default_ext )
860 {
861     DIR *dir;
862     struct dirent *de;
863     char *name;
864
865     if (!(dir = opendir( file ))) return;
866     name = file + strlen(file);
867     *name++ = '/';
868     while ((de = readdir( dir )))
869     {
870         if (strlen( de->d_name ) > max_dll_name_len) continue;
871         if (!strcmp( de->d_name, "." )) continue;
872         if (!strcmp( de->d_name, ".." )) continue;
873         strcpy( name, de->d_name );
874         if (default_ext)  /* inside build dir */
875         {
876             strcat( name, "/" );
877             strcat( name, de->d_name );
878             if (!strchr( de->d_name, '.' )) strcat( name, default_ext );
879             install_fake_dll( dest, file, ".fake" );
880         }
881         else install_fake_dll( dest, file, NULL );
882     }
883     closedir( dir );
884 }
885
886 /* create fake dlls in dirname for all the files we can find */
887 static BOOL create_wildcard_dlls( const WCHAR *dirname )
888 {
889     const char *build_dir = wine_get_build_dir();
890     const char *path;
891     unsigned int i, maxlen = 0;
892     char *file;
893     WCHAR *dest;
894
895     if (build_dir) maxlen = strlen(build_dir) + sizeof("/programs/");
896     for (i = 0; (path = wine_dll_enum_load_path(i)); i++) maxlen = max( maxlen, strlen(path) );
897     maxlen += 2 * max_dll_name_len + 2 + sizeof(".dll.fake");
898     if (!(file = HeapAlloc( GetProcessHeap(), 0, maxlen ))) return FALSE;
899
900     if (!(dest = HeapAlloc( GetProcessHeap(), 0, (strlenW(dirname) + max_dll_name_len) * sizeof(WCHAR) )))
901     {
902         HeapFree( GetProcessHeap(), 0, file );
903         return FALSE;
904     }
905     strcpyW( dest, dirname );
906     dest[strlenW(dest) - 1] = 0;  /* remove wildcard */
907
908     if (build_dir)
909     {
910         strcpy( file, build_dir );
911         strcat( file, "/dlls" );
912         install_lib_dir( dest, file, ".dll" );
913         strcpy( file, build_dir );
914         strcat( file, "/programs" );
915         install_lib_dir( dest, file, ".exe" );
916     }
917     for (i = 0; (path = wine_dll_enum_load_path( i )); i++)
918     {
919         strcpy( file, path );
920         strcat( file, "/fakedlls" );
921         install_lib_dir( dest, file, NULL );
922     }
923     HeapFree( GetProcessHeap(), 0, file );
924     HeapFree( GetProcessHeap(), 0, dest );
925     return TRUE;
926 }
927
928 /***********************************************************************
929  *            create_fake_dll
930  */
931 BOOL create_fake_dll( const WCHAR *name, const WCHAR *source )
932 {
933     HANDLE h;
934     BOOL ret;
935     SIZE_T size;
936     const WCHAR *filename;
937     void *buffer;
938
939     if (!(filename = strrchrW( name, '\\' ))) filename = name;
940     else filename++;
941
942     /* check for empty name which means to only create the directory */
943     if (!filename[0])
944     {
945         create_directories( name );
946         return TRUE;
947     }
948     if (filename[0] == '*' && !filename[1]) return create_wildcard_dlls( name );
949
950     add_handled_dll( filename );
951
952     if (!(h = create_dest_file( name ))) return TRUE;  /* not a fake dll */
953     if (h == INVALID_HANDLE_VALUE) return FALSE;
954
955     if (source[0] == '-' && !source[1])
956     {
957         /* '-' source means delete the file */
958         TRACE( "deleting %s\n", debugstr_w(name) );
959         ret = FALSE;
960     }
961     else if ((buffer = load_fake_dll( source, &size )))
962     {
963         DWORD written;
964
965         ret = (WriteFile( h, buffer, size, &written, NULL ) && written == size);
966         if (ret) register_fake_dll( name, buffer, size );
967         else ERR( "failed to write to %s (error=%u)\n", debugstr_w(name), GetLastError() );
968     }
969     else
970     {
971         WARN( "fake dll %s not found for %s\n", debugstr_w(source), debugstr_w(name) );
972         ret = build_fake_dll( h );
973     }
974
975     CloseHandle( h );
976     if (!ret) DeleteFileW( name );
977     return ret;
978 }
979
980
981 /***********************************************************************
982  *            cleanup_fake_dlls
983  */
984 void cleanup_fake_dlls(void)
985 {
986     if (file_buffer) VirtualFree( file_buffer, 0, MEM_RELEASE );
987     file_buffer = NULL;
988     HeapFree( GetProcessHeap(), 0, handled_dlls );
989     handled_dlls = NULL;
990     handled_count = handled_total = 0;
991     if (registrar) IRegistrar_Release( registrar );
992     registrar = NULL;
993 }