| /* |
| * Creation of Wine fake dlls for apps that access the dll file directly. |
| * |
| * Copyright 2006 Alexandre Julliard |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #include "config.h" |
| #include "wine/port.h" |
| |
| #include <stdarg.h> |
| #include <fcntl.h> |
| #ifdef HAVE_DIRENT_H |
| # include <dirent.h> |
| #endif |
| #ifdef HAVE_SYS_STAT_H |
| # include <sys/stat.h> |
| #endif |
| #ifdef HAVE_UNISTD_H |
| # include <unistd.h> |
| #endif |
| |
| #define NONAMELESSSTRUCT |
| #define NONAMELESSUNION |
| #include "ntstatus.h" |
| #define WIN32_NO_STATUS |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winuser.h" |
| #include "winnt.h" |
| #include "winternl.h" |
| #include "wine/unicode.h" |
| #include "wine/library.h" |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(setupapi); |
| |
| static const char fakedll_signature[] = "Wine placeholder DLL"; |
| |
| static const unsigned int file_alignment = 512; |
| static const unsigned int section_alignment = 4096; |
| static const unsigned int max_dll_name_len = 64; |
| |
| static void *file_buffer; |
| static size_t file_buffer_size; |
| static unsigned int handled_count; |
| static unsigned int handled_total; |
| static char **handled_dlls; |
| |
| struct dll_info |
| { |
| HANDLE handle; |
| IMAGE_NT_HEADERS *nt; |
| DWORD file_pos; |
| DWORD mem_pos; |
| }; |
| |
| #define ALIGN(size,align) (((size) + (align) - 1) & ~((align) - 1)) |
| |
| /* contents of the dll sections */ |
| |
| static const BYTE dll_code_section[] = { 0x31, 0xc0, /* xor %eax,%eax */ |
| 0xc2, 0x0c, 0x00 }; /* ret $12 */ |
| |
| static const BYTE exe_code_section[] = { 0xb8, 0x01, 0x00, 0x00, 0x00, /* movl $1,%eax */ |
| 0xc2, 0x04, 0x00 }; /* ret $4 */ |
| |
| static const IMAGE_BASE_RELOCATION reloc_section; /* empty relocs */ |
| |
| |
| /* wrapper for WriteFile */ |
| static inline BOOL xwrite( struct dll_info *info, const void *data, DWORD size, DWORD offset ) |
| { |
| DWORD res; |
| |
| return (SetFilePointer( info->handle, offset, NULL, FILE_BEGIN ) != INVALID_SET_FILE_POINTER && |
| WriteFile( info->handle, data, size, &res, NULL ) && |
| res == size); |
| } |
| |
| /* add a new section to the dll NT header */ |
| static void add_section( struct dll_info *info, const char *name, DWORD size, DWORD flags ) |
| { |
| IMAGE_SECTION_HEADER *sec = (IMAGE_SECTION_HEADER *)(info->nt + 1); |
| |
| sec += info->nt->FileHeader.NumberOfSections; |
| memcpy( sec->Name, name, min( strlen(name), sizeof(sec->Name)) ); |
| sec->Misc.VirtualSize = ALIGN( size, section_alignment ); |
| sec->VirtualAddress = info->mem_pos; |
| sec->SizeOfRawData = size; |
| sec->PointerToRawData = info->file_pos; |
| sec->Characteristics = flags; |
| info->file_pos += ALIGN( size, file_alignment ); |
| info->mem_pos += ALIGN( size, section_alignment ); |
| info->nt->FileHeader.NumberOfSections++; |
| } |
| |
| /* add a data directory to the dll NT header */ |
| static inline void add_directory( struct dll_info *info, unsigned int idx, DWORD rva, DWORD size ) |
| { |
| info->nt->OptionalHeader.DataDirectory[idx].VirtualAddress = rva; |
| info->nt->OptionalHeader.DataDirectory[idx].Size = size; |
| } |
| |
| /* convert a dll name W->A without depending on the current codepage */ |
| static char *dll_name_WtoA( char *nameA, const WCHAR *nameW, unsigned int len ) |
| { |
| unsigned int i; |
| |
| for (i = 0; i < len; i++) |
| { |
| char c = nameW[i]; |
| if (nameW[i] > 127) return NULL; |
| if (c >= 'A' && c <= 'Z') c += 'a' - 'A'; |
| nameA[i] = c; |
| } |
| nameA[i] = 0; |
| return nameA; |
| } |
| |
| /* convert a dll name A->W without depending on the current codepage */ |
| static WCHAR *dll_name_AtoW( WCHAR *nameW, const char *nameA, unsigned int len ) |
| { |
| unsigned int i; |
| |
| for (i = 0; i < len; i++) nameW[i] = nameA[i]; |
| nameW[i] = 0; |
| return nameW; |
| } |
| |
| /* add a dll to the list of dll that have been taken care of */ |
| static BOOL add_handled_dll( const WCHAR *name ) |
| { |
| unsigned int len = strlenW( name ); |
| int i, min, max, pos, res; |
| char *nameA; |
| |
| if (!(nameA = HeapAlloc( GetProcessHeap(), 0, len + 1 ))) return FALSE; |
| if (!dll_name_WtoA( nameA, name, len )) goto failed; |
| |
| min = 0; |
| max = handled_count - 1; |
| while (min <= max) |
| { |
| pos = (min + max) / 2; |
| res = strcmp( handled_dlls[pos], nameA ); |
| if (!res) goto failed; /* already in the list */ |
| if (res < 0) min = pos + 1; |
| else max = pos - 1; |
| } |
| |
| if (handled_count >= handled_total) |
| { |
| char **new_dlls; |
| unsigned int new_count = max( 64, handled_total * 2 ); |
| |
| if (handled_dlls) new_dlls = HeapReAlloc( GetProcessHeap(), 0, handled_dlls, |
| new_count * sizeof(*handled_dlls) ); |
| else new_dlls = HeapAlloc( GetProcessHeap(), 0, new_count * sizeof(*handled_dlls) ); |
| if (!new_dlls) goto failed; |
| handled_dlls = new_dlls; |
| handled_total = new_count; |
| } |
| |
| for (i = handled_count; i > min; i--) handled_dlls[i] = handled_dlls[i - 1]; |
| handled_dlls[i] = nameA; |
| handled_count++; |
| return TRUE; |
| |
| failed: |
| HeapFree( GetProcessHeap(), 0, nameA ); |
| return FALSE; |
| } |
| |
| /* read in the contents of a file into the global file buffer */ |
| /* return 1 on success, 0 on nonexistent file, -1 on other error */ |
| static int read_file( const char *name, void **data, size_t *size ) |
| { |
| static char static_file_buffer[4096]; |
| struct stat st; |
| void *buffer = static_file_buffer; |
| int fd, ret = -1; |
| size_t header_size; |
| IMAGE_DOS_HEADER *dos; |
| IMAGE_NT_HEADERS *nt; |
| const size_t min_size = sizeof(*dos) + sizeof(fakedll_signature) + |
| FIELD_OFFSET( IMAGE_NT_HEADERS, OptionalHeader.MajorLinkerVersion ); |
| |
| if ((fd = open( name, O_RDONLY | O_BINARY )) == -1) return 0; |
| if (fstat( fd, &st ) == -1) goto done; |
| *size = st.st_size; |
| if (st.st_size > sizeof(static_file_buffer)) |
| { |
| if (!file_buffer || st.st_size > file_buffer_size) |
| { |
| HeapFree( GetProcessHeap(), 0, file_buffer ); |
| if (!(file_buffer = HeapAlloc( GetProcessHeap(), 0, st.st_size ))) goto done; |
| file_buffer_size = st.st_size; |
| } |
| buffer = file_buffer; |
| } |
| |
| /* check for valid fake dll file */ |
| |
| if (st.st_size < min_size) goto done; |
| header_size = min( st.st_size, 4096 ); |
| if (pread( fd, buffer, header_size, 0 ) != header_size) goto done; |
| dos = buffer; |
| if (dos->e_magic != IMAGE_DOS_SIGNATURE) goto done; |
| if (dos->e_lfanew < sizeof(fakedll_signature)) goto done; |
| if (memcmp( dos + 1, fakedll_signature, sizeof(fakedll_signature) )) goto done; |
| if (dos->e_lfanew + FIELD_OFFSET(IMAGE_NT_HEADERS,OptionalHeader.MajorLinkerVersion) > header_size) |
| goto done; |
| nt = (IMAGE_NT_HEADERS *)((char *)buffer + dos->e_lfanew); |
| if (nt->Signature == IMAGE_NT_SIGNATURE && nt->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC) |
| { |
| /* wrong 32/64 type, pretend it doesn't exist */ |
| ret = 0; |
| goto done; |
| } |
| if (st.st_size == header_size || |
| pread( fd, (char *)buffer + header_size, |
| st.st_size - header_size, header_size ) == st.st_size - header_size) |
| { |
| *data = buffer; |
| ret = 1; |
| } |
| done: |
| close( fd ); |
| return ret; |
| } |
| |
| /* build a complete fake dll from scratch */ |
| static BOOL build_fake_dll( HANDLE file ) |
| { |
| IMAGE_DOS_HEADER *dos; |
| IMAGE_NT_HEADERS *nt; |
| struct dll_info info; |
| BYTE *buffer; |
| BOOL ret = FALSE; |
| DWORD lfanew = (sizeof(*dos) + sizeof(fakedll_signature) + 15) & ~15; |
| DWORD size, header_size = lfanew + sizeof(*nt); |
| |
| info.handle = file; |
| buffer = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, header_size + 8 * sizeof(IMAGE_SECTION_HEADER) ); |
| |
| dos = (IMAGE_DOS_HEADER *)buffer; |
| dos->e_magic = IMAGE_DOS_SIGNATURE; |
| dos->e_cblp = sizeof(*dos); |
| dos->e_cp = 1; |
| dos->e_cparhdr = lfanew / 16; |
| dos->e_minalloc = 0; |
| dos->e_maxalloc = 0xffff; |
| dos->e_ss = 0x0000; |
| dos->e_sp = 0x00b8; |
| dos->e_lfarlc = lfanew; |
| dos->e_lfanew = lfanew; |
| memcpy( dos + 1, fakedll_signature, sizeof(fakedll_signature) ); |
| |
| nt = info.nt = (IMAGE_NT_HEADERS *)(buffer + lfanew); |
| /* some fields are copied from the source dll */ |
| #ifdef _WIN64 |
| nt->FileHeader.Machine = IMAGE_FILE_MACHINE_AMD64; |
| #else |
| nt->FileHeader.Machine = IMAGE_FILE_MACHINE_I386; |
| #endif |
| nt->FileHeader.TimeDateStamp = 0; |
| nt->FileHeader.Characteristics = IMAGE_FILE_DLL; |
| nt->OptionalHeader.MajorLinkerVersion = 1; |
| nt->OptionalHeader.MinorLinkerVersion = 0; |
| nt->OptionalHeader.MajorOperatingSystemVersion = 1; |
| nt->OptionalHeader.MinorOperatingSystemVersion = 0; |
| nt->OptionalHeader.MajorImageVersion = 1; |
| nt->OptionalHeader.MinorImageVersion = 0; |
| nt->OptionalHeader.MajorSubsystemVersion = 4; |
| nt->OptionalHeader.MinorSubsystemVersion = 0; |
| nt->OptionalHeader.Win32VersionValue = 0; |
| nt->OptionalHeader.Subsystem = IMAGE_SUBSYSTEM_WINDOWS_GUI; |
| nt->OptionalHeader.DllCharacteristics = 0; |
| nt->OptionalHeader.SizeOfStackReserve = 0; |
| nt->OptionalHeader.SizeOfStackCommit = 0; |
| nt->OptionalHeader.SizeOfHeapReserve = 0; |
| nt->OptionalHeader.SizeOfHeapCommit = 0; |
| /* other fields have fixed values */ |
| nt->Signature = IMAGE_NT_SIGNATURE; |
| nt->FileHeader.NumberOfSections = 0; |
| nt->FileHeader.SizeOfOptionalHeader = IMAGE_SIZEOF_NT_OPTIONAL_HEADER; |
| nt->OptionalHeader.Magic = IMAGE_NT_OPTIONAL_HDR_MAGIC; |
| nt->OptionalHeader.ImageBase = 0x10000000; |
| nt->OptionalHeader.SectionAlignment = section_alignment; |
| nt->OptionalHeader.FileAlignment = file_alignment; |
| nt->OptionalHeader.NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES; |
| |
| header_size = (BYTE *)(nt + 1) - buffer; |
| info.mem_pos = ALIGN( header_size, section_alignment ); |
| info.file_pos = ALIGN( header_size, file_alignment ); |
| |
| nt->OptionalHeader.AddressOfEntryPoint = info.mem_pos; |
| nt->OptionalHeader.BaseOfCode = info.mem_pos; |
| |
| if (nt->FileHeader.Characteristics & IMAGE_FILE_DLL) |
| { |
| size = sizeof(dll_code_section); |
| if (!xwrite( &info, dll_code_section, size, info.file_pos )) goto done; |
| } |
| else |
| { |
| size = sizeof(exe_code_section); |
| if (!xwrite( &info, exe_code_section, size, info.file_pos )) goto done; |
| } |
| nt->OptionalHeader.SizeOfCode = size; |
| add_section( &info, ".text", size, IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ ); |
| |
| if (!xwrite( &info, &reloc_section, sizeof(reloc_section), info.file_pos )) goto done; |
| add_directory( &info, IMAGE_DIRECTORY_ENTRY_BASERELOC, info.mem_pos, sizeof(reloc_section) ); |
| add_section( &info, ".reloc", sizeof(reloc_section), |
| IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_MEM_READ ); |
| |
| header_size += nt->FileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER); |
| nt->OptionalHeader.SizeOfHeaders = ALIGN( header_size, file_alignment ); |
| nt->OptionalHeader.SizeOfImage = ALIGN( info.mem_pos, section_alignment ); |
| ret = xwrite( &info, buffer, header_size, 0 ); |
| done: |
| HeapFree( GetProcessHeap(), 0, buffer ); |
| return ret; |
| } |
| |
| /* check if an existing file is a fake dll so that we can overwrite it */ |
| static BOOL is_fake_dll( HANDLE h ) |
| { |
| IMAGE_DOS_HEADER *dos; |
| DWORD size; |
| BYTE buffer[sizeof(*dos) + sizeof(fakedll_signature)]; |
| |
| if (!ReadFile( h, buffer, sizeof(buffer), &size, NULL ) || size != sizeof(buffer)) |
| return FALSE; |
| dos = (IMAGE_DOS_HEADER *)buffer; |
| if (dos->e_magic != IMAGE_DOS_SIGNATURE) return FALSE; |
| if (dos->e_lfanew < size) return FALSE; |
| return !memcmp( dos + 1, fakedll_signature, sizeof(fakedll_signature) ); |
| } |
| |
| /* create directories leading to a given file */ |
| static void create_directories( const WCHAR *name ) |
| { |
| WCHAR *path, *p; |
| |
| /* create the directory/directories */ |
| path = HeapAlloc(GetProcessHeap(), 0, (strlenW(name) + 1)*sizeof(WCHAR)); |
| strcpyW(path, name); |
| |
| p = strchrW(path, '\\'); |
| while (p != NULL) |
| { |
| *p = 0; |
| if (!CreateDirectoryW(path, NULL)) |
| TRACE("Couldn't create directory %s - error: %d\n", wine_dbgstr_w(path), GetLastError()); |
| *p = '\\'; |
| p = strchrW(p+1, '\\'); |
| } |
| HeapFree(GetProcessHeap(), 0, path); |
| } |
| |
| static inline char *prepend( char *buffer, const char *str, size_t len ) |
| { |
| return memcpy( buffer - len, str, len ); |
| } |
| |
| /* try to load a pre-compiled fake dll */ |
| static void *load_fake_dll( const WCHAR *name, size_t *size ) |
| { |
| const char *build_dir = wine_get_build_dir(); |
| const char *path; |
| char *file, *ptr; |
| void *data = NULL; |
| unsigned int i, pos, len, namelen, maxlen = 0; |
| WCHAR *p; |
| int res = 0; |
| |
| if ((p = strrchrW( name, '\\' ))) name = p + 1; |
| |
| i = 0; |
| if (build_dir) maxlen = strlen(build_dir) + sizeof("/programs/") + strlenW(name); |
| while ((path = wine_dll_enum_load_path( i++ ))) maxlen = max( maxlen, strlen(path) ); |
| maxlen += sizeof("/fakedlls") + strlenW(name) + 2; |
| |
| if (!(file = HeapAlloc( GetProcessHeap(), 0, maxlen ))) return NULL; |
| |
| len = strlenW( name ); |
| pos = maxlen - len - sizeof(".fake"); |
| if (!dll_name_WtoA( file + pos, name, len )) goto done; |
| file[--pos] = '/'; |
| |
| if (build_dir) |
| { |
| strcpy( file + pos + len + 1, ".fake" ); |
| |
| /* try as a dll */ |
| ptr = file + pos; |
| namelen = len + 1; |
| if (namelen > 4 && !memcmp( ptr + namelen - 4, ".dll", 4 )) namelen -= 4; |
| ptr = prepend( ptr, ptr, namelen ); |
| ptr = prepend( ptr, "/dlls", sizeof("/dlls") - 1 ); |
| ptr = prepend( ptr, build_dir, strlen(build_dir) ); |
| if ((res = read_file( ptr, &data, size ))) goto done; |
| |
| /* now as a program */ |
| ptr = file + pos; |
| namelen = len + 1; |
| if (namelen > 4 && !memcmp( ptr + namelen - 4, ".exe", 4 )) namelen -= 4; |
| ptr = prepend( ptr, ptr, namelen ); |
| ptr = prepend( ptr, "/programs", sizeof("/programs") - 1 ); |
| ptr = prepend( ptr, build_dir, strlen(build_dir) ); |
| if ((res = read_file( ptr, &data, size ))) goto done; |
| } |
| |
| file[pos + len + 1] = 0; |
| for (i = 0; (path = wine_dll_enum_load_path( i )); i++) |
| { |
| ptr = prepend( file + pos, "/fakedlls", sizeof("/fakedlls") - 1 ); |
| ptr = prepend( ptr, path, strlen(path) ); |
| if ((res = read_file( ptr, &data, size ))) break; |
| } |
| |
| done: |
| HeapFree( GetProcessHeap(), 0, file ); |
| if (res == 1) return data; |
| return NULL; |
| } |
| |
| /* create the fake dll destination file */ |
| static HANDLE create_dest_file( const WCHAR *name ) |
| { |
| /* first check for an existing file */ |
| HANDLE h = CreateFileW( name, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL ); |
| if (h != INVALID_HANDLE_VALUE) |
| { |
| if (!is_fake_dll( h )) |
| { |
| TRACE( "%s is not a fake dll, not overwriting it\n", debugstr_w(name) ); |
| CloseHandle( h ); |
| return 0; |
| } |
| /* truncate the file */ |
| SetFilePointer( h, 0, NULL, FILE_BEGIN ); |
| SetEndOfFile( h ); |
| } |
| else |
| { |
| if (GetLastError() == ERROR_PATH_NOT_FOUND) create_directories( name ); |
| |
| h = CreateFileW( name, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, NULL ); |
| if (h == INVALID_HANDLE_VALUE) |
| ERR( "failed to create %s (error=%u)\n", debugstr_w(name), GetLastError() ); |
| } |
| return h; |
| } |
| |
| /* copy a fake dll file to the dest directory */ |
| static void install_fake_dll( WCHAR *dest, char *file, const char *ext ) |
| { |
| int ret; |
| size_t size; |
| void *data; |
| DWORD written; |
| WCHAR *destname = dest + strlenW(dest); |
| char *name = strrchr( file, '/' ) + 1; |
| char *end = name + strlen(name); |
| |
| if (ext) strcpy( end, ext ); |
| if (!(ret = read_file( file, &data, &size ))) return; |
| |
| if (end > name + 2 && !strncmp( end - 2, "16", 2 )) end -= 2; /* remove "16" suffix */ |
| dll_name_AtoW( destname, name, end - name ); |
| if (!add_handled_dll( destname )) ret = -1; |
| |
| if (ret != -1) |
| { |
| HANDLE h = create_dest_file( dest ); |
| |
| if (h && h != INVALID_HANDLE_VALUE) |
| { |
| TRACE( "%s -> %s\n", debugstr_a(file), debugstr_w(dest) ); |
| |
| ret = (WriteFile( h, data, size, &written, NULL ) && written == size); |
| if (!ret) ERR( "failed to write to %s (error=%u)\n", debugstr_w(dest), GetLastError() ); |
| CloseHandle( h ); |
| if (!ret) DeleteFileW( dest ); |
| } |
| } |
| *destname = 0; /* restore it for next file */ |
| } |
| |
| /* find and install all fake dlls in a given lib directory */ |
| static void install_lib_dir( WCHAR *dest, char *file, const char *default_ext ) |
| { |
| DIR *dir; |
| struct dirent *de; |
| char *name; |
| |
| if (!(dir = opendir( file ))) return; |
| name = file + strlen(file); |
| *name++ = '/'; |
| while ((de = readdir( dir ))) |
| { |
| if (strlen( de->d_name ) > max_dll_name_len) continue; |
| if (!strcmp( de->d_name, "." )) continue; |
| if (!strcmp( de->d_name, ".." )) continue; |
| strcpy( name, de->d_name ); |
| if (default_ext) /* inside build dir */ |
| { |
| strcat( name, "/" ); |
| strcat( name, de->d_name ); |
| if (!strchr( de->d_name, '.' )) strcat( name, default_ext ); |
| install_fake_dll( dest, file, ".fake" ); |
| } |
| else install_fake_dll( dest, file, NULL ); |
| } |
| closedir( dir ); |
| } |
| |
| /* create fake dlls in dirname for all the files we can find */ |
| static BOOL create_wildcard_dlls( const WCHAR *dirname ) |
| { |
| const char *build_dir = wine_get_build_dir(); |
| const char *path; |
| unsigned int i, maxlen = 0; |
| char *file; |
| WCHAR *dest; |
| |
| if (build_dir) maxlen = strlen(build_dir) + sizeof("/programs/"); |
| for (i = 0; (path = wine_dll_enum_load_path(i)); i++) maxlen = max( maxlen, strlen(path) ); |
| maxlen += 2 * max_dll_name_len + 2 + sizeof(".dll.fake"); |
| if (!(file = HeapAlloc( GetProcessHeap(), 0, maxlen ))) return FALSE; |
| |
| if (!(dest = HeapAlloc( GetProcessHeap(), 0, (strlenW(dirname) + max_dll_name_len) * sizeof(WCHAR) ))) |
| { |
| HeapFree( GetProcessHeap(), 0, file ); |
| return FALSE; |
| } |
| strcpyW( dest, dirname ); |
| dest[strlenW(dest) - 1] = 0; /* remove wildcard */ |
| |
| if (build_dir) |
| { |
| strcpy( file, build_dir ); |
| strcat( file, "/dlls" ); |
| install_lib_dir( dest, file, ".dll" ); |
| strcpy( file, build_dir ); |
| strcat( file, "/programs" ); |
| install_lib_dir( dest, file, ".exe" ); |
| } |
| for (i = 0; (path = wine_dll_enum_load_path( i )); i++) |
| { |
| strcpy( file, path ); |
| strcat( file, "/fakedlls" ); |
| install_lib_dir( dest, file, NULL ); |
| } |
| HeapFree( GetProcessHeap(), 0, file ); |
| HeapFree( GetProcessHeap(), 0, dest ); |
| return TRUE; |
| } |
| |
| /*********************************************************************** |
| * create_fake_dll |
| */ |
| BOOL create_fake_dll( const WCHAR *name, const WCHAR *source ) |
| { |
| HANDLE h; |
| BOOL ret; |
| size_t size; |
| const WCHAR *filename; |
| void *buffer; |
| |
| if (!(filename = strrchrW( name, '\\' ))) filename = name; |
| else filename++; |
| |
| /* check for empty name which means to only create the directory */ |
| if (!filename[0]) |
| { |
| create_directories( name ); |
| return TRUE; |
| } |
| if (filename[0] == '*' && !filename[1]) return create_wildcard_dlls( name ); |
| |
| add_handled_dll( filename ); |
| |
| if (!(h = create_dest_file( name ))) return TRUE; /* not a fake dll */ |
| if (h == INVALID_HANDLE_VALUE) return FALSE; |
| |
| if (source[0] == '-' && !source[1]) |
| { |
| /* '-' source means delete the file */ |
| TRACE( "deleting %s\n", debugstr_w(name) ); |
| ret = FALSE; |
| } |
| else if ((buffer = load_fake_dll( source, &size ))) |
| { |
| DWORD written; |
| |
| ret = (WriteFile( h, buffer, size, &written, NULL ) && written == size); |
| if (!ret) ERR( "failed to write to %s (error=%u)\n", debugstr_w(name), GetLastError() ); |
| } |
| else |
| { |
| WARN( "fake dll %s not found for %s\n", debugstr_w(source), debugstr_w(name) ); |
| ret = build_fake_dll( h ); |
| } |
| |
| CloseHandle( h ); |
| if (!ret) DeleteFileW( name ); |
| return ret; |
| } |
| |
| |
| /*********************************************************************** |
| * cleanup_fake_dlls |
| */ |
| void cleanup_fake_dlls(void) |
| { |
| HeapFree( GetProcessHeap(), 0, file_buffer ); |
| file_buffer = NULL; |
| HeapFree( GetProcessHeap(), 0, handled_dlls ); |
| handled_dlls = NULL; |
| handled_count = handled_total = 0; |
| } |