relay32/builtin32.c

   1 /*
   2  * Win32 builtin functions
   3  *
   4  * Copyright 1997 Alexandre Julliard
   5  */
   6
   7 #include "config.h"
   8
   9 #include <assert.h>
  10 #include <string.h>
  11 #include <stdio.h>
  12 #include <ctype.h>
  13 #ifdef HAVE_DL_API
  14 #include <dlfcn.h>
  15 #endif
  16 #ifdef HAVE_SYS_MMAN_H
  17 #include <sys/mman.h>
  18 #endif
  19
  20 #include "windef.h"
  21 #include "wine/winbase16.h"
  22 #include "wingdi.h"
  23 #include "winuser.h"
  24 #include "builtin32.h"
  25 #include "elfdll.h"
  26 #include "file.h"
  27 #include "global.h"
  28 #include "neexe.h"
  29 #include "heap.h"
  30 #include "main.h"
  31 #include "snoop.h"
  32 #include "winerror.h"
  33 #include "server.h"
  34 #include "debugtools.h"
  35 #include "options.h" /* for argv0 */
  36
  37 DEFAULT_DEBUG_CHANNEL(module);
  38 DECLARE_DEBUG_CHANNEL(relay);
  39
  40 typedef struct
  41 {
  42     BYTE                        *restab;
  43     DWORD                       nresources;
  44     DWORD                       restabsize;
  45     IMAGE_RESOURCE_DATA_ENTRY   *entries;
  46 } BUILTIN32_RESOURCE;
  47
  48 #define MAX_DLLS 60
  49
  50 static const BUILTIN32_DESCRIPTOR *builtin_dlls[MAX_DLLS];
  51 static HMODULE dll_modules[MAX_DLLS];
  52 static int nb_dlls;
  53
  54
  55 /***********************************************************************
  56  *           BUILTIN32_WarnSecondInstance
  57  *
  58  * Emit a warning when we are creating a second instance for a DLL
  59  * that is known to not support this.
  60  */
  61 static void BUILTIN32_WarnSecondInstance( const char *name )
  62 {
  63     static const char * const warning_list[] =
  64     { "comctl32.dll", "comdlg32.dll", "crtdll.dll",
  65       "imagehlp.dll", "msacm32.dll", "shell32.dll", NULL };
  66
  67     const char * const *ptr = warning_list;
  68
  69     while (*ptr)
  70     {
  71         if (!strcasecmp( *ptr, name ))
  72         {
  73             ERR( "Attempt to instantiate built-in dll '%s' twice "
  74                  "in the same address space. Expect trouble!\n", name );
  75             return;
  76         }
  77         ptr++;
  78     }
  79 }
  80
  81 /***********************************************************************
  82  *           BUILTIN32_dlopen
  83  */
  84 void *BUILTIN32_dlopen( const char *name )
  85 {
  86 #ifdef HAVE_DL_API
  87     void *handle;
  88     char buffer[128], *p;
  89     if ((p = strrchr( name, '/' ))) name = p + 1;
  90     if ((p = strrchr( name, '\\' ))) name = p + 1;
  91     sprintf( buffer, "lib%s", name );
  92     for (p = buffer; *p; p++) *p = tolower(*p);
  93     if ((p = strrchr( buffer, '.' )) && (!strcmp( p, ".dll" ) || !strcmp( p, ".exe" ))) *p = 0;
  94     strcat( buffer, ".so" );
  95
  96     if (!(handle = ELFDLL_dlopen( buffer, RTLD_NOW )))
  97         ERR( "failed to load %s: %s\n", buffer, dlerror() );
  98     return handle;
  99 #else
 100     return NULL;
 101 #endif
 102 }
 103
 104 /***********************************************************************
 105  *           BUILTIN32_dlclose
 106  */
 107 int BUILTIN32_dlclose( void *handle )
 108 {
 109 #ifdef HAVE_DL_API
 110     /* FIXME: should unregister descriptors first */
 111     /* return dlclose( handle ); */
 112 #endif
 113     return 0;
 114 }
 115
 116
 117 /***********************************************************************
 118  *           fixup_rva_ptrs
 119  *
 120  * Adjust an array of pointers to make them into RVAs.
 121  */
 122 static inline void fixup_rva_ptrs( void *array, void *base, int count )
 123 {
 124     void **ptr = (void **)array;
 125     while (count--)
 126     {
 127         if (*ptr) *ptr = (void *)((char *)*ptr - (char *)base);
 128         ptr++;
 129     }
 130 }
 131
 132
 133 /***********************************************************************
 134  *           BUILTIN32_DoLoadImage
 135  *
 136  * Load a built-in Win32 module. Helper function for BUILTIN32_LoadImage.
 137  */
 138 static HMODULE BUILTIN32_DoLoadImage( const BUILTIN32_DESCRIPTOR *descr )
 139 {
 140     IMAGE_DATA_DIRECTORY *dir;
 141     IMAGE_DOS_HEADER *dos;
 142     IMAGE_NT_HEADERS *nt;
 143     IMAGE_SECTION_HEADER *sec;
 144     IMAGE_IMPORT_DESCRIPTOR *imp;
 145     IMAGE_EXPORT_DIRECTORY *exports = descr->exports;
 146     INT i, size, nb_sections;
 147     BYTE *addr, *code_start, *data_start;
 148     BYTE* xcnlnk;
 149     DWORD xcnsize = 0;
 150     int page_size = VIRTUAL_GetPageSize();
 151
 152     /* Allocate the module */
 153
 154     nb_sections = 2;  /* code + data */
 155
 156     if (!strcmp(descr->filename, "kernel32.dll")) {
 157        nb_sections++;
 158        xcnsize = sizeof(DWORD);
 159     }
 160     size = (sizeof(IMAGE_DOS_HEADER)
 161             + sizeof(IMAGE_NT_HEADERS)
 162             + nb_sections * sizeof(IMAGE_SECTION_HEADER)
 163             + (descr->nb_imports+1) * sizeof(IMAGE_IMPORT_DESCRIPTOR)
 164             + xcnsize);
 165
 166     assert( size <= page_size );
 167
 168     if (descr->pe_header)
 169     {
 170         if ((addr = FILE_dommap( -1, descr->pe_header, 0, page_size, 0, 0,
 171                                  PROT_READ|PROT_WRITE, MAP_FIXED )) != descr->pe_header)
 172         {
 173             ERR("failed to map over PE header for %s at %p\n", descr->filename, descr->pe_header );
 174             return 0;
 175         }
 176     }
 177     else
 178     {
 179         if (!(addr = VirtualAlloc( NULL, page_size, MEM_COMMIT, PAGE_READWRITE ))) return 0;
 180     }
 181
 182     dos    = (IMAGE_DOS_HEADER *)addr;
 183     nt     = (IMAGE_NT_HEADERS *)(dos + 1);
 184     sec    = (IMAGE_SECTION_HEADER *)(nt + 1);
 185     imp    = (IMAGE_IMPORT_DESCRIPTOR *)(sec + nb_sections);
 186     xcnlnk = (char *)(imp + descr->nb_imports + 1);
 187     code_start = addr + page_size;
 188
 189     /* HACK! */
 190     data_start = code_start + page_size;
 191
 192     /* Build the DOS and NT headers */
 193
 194     dos->e_magic  = IMAGE_DOS_SIGNATURE;
 195     dos->e_lfanew = sizeof(*dos);
 196
 197     nt->Signature                       = IMAGE_NT_SIGNATURE;
 198     nt->FileHeader.Machine              = IMAGE_FILE_MACHINE_I386;
 199     nt->FileHeader.NumberOfSections     = nb_sections;
 200     nt->FileHeader.SizeOfOptionalHeader = sizeof(nt->OptionalHeader);
 201     nt->FileHeader.Characteristics      = descr->characteristics;
 202
 203     nt->OptionalHeader.Magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
 204     nt->OptionalHeader.SizeOfCode                  = data_start - code_start;
 205     nt->OptionalHeader.SizeOfInitializedData       = 0;
 206     nt->OptionalHeader.SizeOfUninitializedData     = 0;
 207     nt->OptionalHeader.ImageBase                   = (DWORD)addr;
 208     nt->OptionalHeader.SectionAlignment            = page_size;
 209     nt->OptionalHeader.FileAlignment               = page_size;
 210     nt->OptionalHeader.MajorOperatingSystemVersion = 1;
 211     nt->OptionalHeader.MinorOperatingSystemVersion = 0;
 212     nt->OptionalHeader.MajorSubsystemVersion       = 4;
 213     nt->OptionalHeader.MinorSubsystemVersion       = 0;
 214     nt->OptionalHeader.SizeOfImage                 = page_size;
 215     nt->OptionalHeader.SizeOfHeaders               = page_size;
 216     nt->OptionalHeader.NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
 217     if (descr->dllentrypoint)
 218         nt->OptionalHeader.AddressOfEntryPoint = (DWORD)descr->dllentrypoint - (DWORD)addr;
 219
 220     /* Build the code section */
 221
 222     strcpy( sec->Name, ".text" );
 223     sec->SizeOfRawData = data_start - code_start;
 224     sec->Misc.VirtualSize = sec->SizeOfRawData;
 225     sec->VirtualAddress   = code_start - addr;
 226     sec->PointerToRawData = code_start - addr;
 227     sec->Characteristics  = (IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ);
 228     sec++;
 229
 230     /* Build the data section */
 231
 232     strcpy( sec->Name, ".data" );
 233     sec->SizeOfRawData = 0;
 234     sec->Misc.VirtualSize = sec->SizeOfRawData;
 235     sec->VirtualAddress   = data_start - addr;
 236     sec->PointerToRawData = data_start - addr;
 237     sec->Characteristics  = (IMAGE_SCN_CNT_INITIALIZED_DATA |
 238                              IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_READ);
 239     sec++;
 240
 241     /* Build the import directory */
 242
 243     if (descr->nb_imports)
 244     {
 245         dir = &nt->OptionalHeader.DataDirectory[IMAGE_FILE_IMPORT_DIRECTORY];
 246         dir->VirtualAddress = (BYTE *)imp - addr;
 247         dir->Size = sizeof(*imp) * (descr->nb_imports + 1);
 248
 249         /* Build the imports */
 250         for (i = 0; i < descr->nb_imports; i++)
 251         {
 252             imp[i].u.Characteristics = 0;
 253             imp[i].ForwarderChain = -1;
 254             imp[i].Name = (BYTE *)descr->imports[i] - addr;
 255             /* hack: make first thunk point to some zero value */
 256             imp[i].FirstThunk = (PIMAGE_THUNK_DATA)((BYTE *)&imp[i].u.Characteristics - addr);
 257         }
 258     }
 259
 260     /* Build Wine's .so link section. Those sections are used by the wine debugger to
 261      * link a builtin PE header with the corresponding ELF module (from either a
 262      * shared library, or the main executable - wine emulator or any winelib program
 263      */
 264     if (xcnsize)
 265     {
 266        strcpy( sec->Name, ".xcnlnk" );
 267        sec->Misc.VirtualSize = xcnsize;
 268        sec->VirtualAddress   = (BYTE *)xcnlnk - addr;
 269        sec->SizeOfRawData    = sec->Misc.VirtualSize;
 270        sec->PointerToRawData = (BYTE *)xcnlnk - addr;
 271        sec->Characteristics  = (IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ);
 272        sec++;
 273
 274        *(const char**)xcnlnk = argv0;
 275     }
 276
 277     /* Build the resource directory */
 278
 279     if (descr->rsrc)
 280     {
 281         BUILTIN32_RESOURCE *rsrc = descr->rsrc;
 282         IMAGE_RESOURCE_DATA_ENTRY *rdep;
 283         dir = &nt->OptionalHeader.DataDirectory[IMAGE_FILE_RESOURCE_DIRECTORY];
 284         dir->VirtualAddress = (BYTE *)rsrc->restab - addr;
 285         dir->Size = rsrc->restabsize;
 286         rdep = rsrc->entries;
 287         for (i = 0; i < rsrc->nresources; i++) rdep[i].OffsetToData += dir->VirtualAddress;
 288     }
 289
 290     /* Build the export directory */
 291
 292     if (exports)
 293     {
 294         dir = &nt->OptionalHeader.DataDirectory[IMAGE_FILE_EXPORT_DIRECTORY];
 295         dir->VirtualAddress = (BYTE *)exports - addr;
 296         dir->Size = descr->exports_size;
 297
 298         fixup_rva_ptrs( (void *)exports->AddressOfFunctions, addr, exports->NumberOfFunctions );
 299         fixup_rva_ptrs( (void *)exports->AddressOfNames, addr, exports->NumberOfNames );
 300         fixup_rva_ptrs( &exports->Name, addr, 1 );
 301         fixup_rva_ptrs( &exports->AddressOfFunctions, addr, 1 );
 302         fixup_rva_ptrs( &exports->AddressOfNames, addr, 1 );
 303         fixup_rva_ptrs( &exports->AddressOfNameOrdinals, addr, 1 );
 304
 305         /* Setup relay debugging entry points */
 306         if (WARN_ON(relay) || TRACE_ON(relay)) RELAY_SetupDLL( addr );
 307     }
 308
 309     return (HMODULE)addr;
 310 }
 311
 312 /***********************************************************************
 313  *           BUILTIN32_LoadLibraryExA
 314  *
 315  * Partly copied from the original PE_ version.
 316  *
 317  */
 318 WINE_MODREF *BUILTIN32_LoadLibraryExA(LPCSTR path, DWORD flags)
 319 {
 320     struct load_dll_request *req = get_req_buffer();
 321     HMODULE16      hModule16;
 322     NE_MODULE     *pModule;
 323     WINE_MODREF   *wm;
 324     char           dllname[MAX_PATH], *p;
 325     void *handle;
 326     int i;
 327
 328     /* Fix the name in case we have a full path and extension */
 329     if ((p = strrchr( path, '\\' ))) path = p + 1;
 330     lstrcpynA( dllname, path, sizeof(dllname) );
 331
 332     p = strrchr( dllname, '.' );
 333     if (!p) strcat( dllname, ".dll" );
 334
 335     /* Search built-in descriptor */
 336     for (i = 0; i < nb_dlls; i++)
 337         if (!strcasecmp( builtin_dlls[i]->filename, dllname )) goto found;
 338
 339     if ((handle = BUILTIN32_dlopen( dllname )))
 340     {
 341         for (i = 0; i < nb_dlls; i++)
 342             if (!strcasecmp( builtin_dlls[i]->filename, dllname )) goto found;
 343         ERR( "loaded .so but dll %s still not found\n", dllname );
 344         BUILTIN32_dlclose( handle );
 345     }
 346
 347     SetLastError( ERROR_FILE_NOT_FOUND );
 348     return NULL;
 349
 350  found:
 351     /* Load built-in module */
 352     if (!dll_modules[i])
 353     {
 354         if (!(dll_modules[i] = BUILTIN32_DoLoadImage( builtin_dlls[i] ))) return NULL;
 355     }
 356     else BUILTIN32_WarnSecondInstance( builtin_dlls[i]->filename );
 357
 358     /* Create 16-bit dummy module */
 359     if ((hModule16 = MODULE_CreateDummyModule( dllname, dll_modules[i] )) < 32)
 360     {
 361         SetLastError( (DWORD)hModule16 );
 362         return NULL;    /* FIXME: Should unload the builtin module */
 363     }
 364     pModule = (NE_MODULE *)GlobalLock16( hModule16 );
 365     pModule->flags = NE_FFLAGS_LIBMODULE | NE_FFLAGS_SINGLEDATA | NE_FFLAGS_WIN32 | NE_FFLAGS_BUILTIN;
 366
 367     /* Create 32-bit MODREF */
 368     if ( !(wm = PE_CreateModule( pModule->module32, dllname, flags, TRUE )) )
 369     {
 370         ERR( "can't load %s\n", path );
 371         FreeLibrary16( hModule16 );     /* FIXME: Should unload the builtin module */
 372         SetLastError( ERROR_OUTOFMEMORY );
 373         return NULL;
 374     }
 375
 376     if (wm->binfmt.pe.pe_export)
 377         SNOOP_RegisterDLL(wm->module,wm->modname,wm->binfmt.pe.pe_export->NumberOfFunctions);
 378
 379     req->handle     = -1;
 380     req->base       = (void *)pModule->module32;
 381     req->dbg_offset = 0;
 382     req->dbg_size   = 0;
 383     req->name       = &wm->modname;
 384     server_call_noerr( REQ_LOAD_DLL );
 385     return wm;
 386 }
 387
 388 /***********************************************************************
 389  *           BUILTIN32_LoadExeModule
 390  */
 391 HMODULE BUILTIN32_LoadExeModule( LPCSTR *filename )
 392 {
 393     int i, exe = -1;
 394
 395     /* Search built-in EXE descriptor */
 396     for ( i = 0; i < nb_dlls; i++ )
 397         if ( !(builtin_dlls[i]->characteristics & IMAGE_FILE_DLL) )
 398         {
 399             if ( exe != -1 )
 400             {
 401                 MESSAGE( "More than one built-in EXE module loaded!\n" );
 402                 break;
 403             }
 404
 405             exe = i;
 406         }
 407
 408     if ( exe == -1 )
 409     {
 410         MESSAGE( "No built-in EXE module loaded!  Did you create a .spec file?\n" );
 411         return 0;
 412     }
 413
 414     /* Load built-in module */
 415     if ( !dll_modules[exe] )
 416         if ( !(dll_modules[exe] = BUILTIN32_DoLoadImage( builtin_dlls[exe] )) )
 417             return 0;
 418
 419     *filename = builtin_dlls[exe]->filename;
 420     return dll_modules[exe];
 421 }
 422
 423
 424 /***********************************************************************
 425  *      BUILTIN32_UnloadLibrary
 426  *
 427  * Unload the built-in library and free the modref.
 428  */
 429 void BUILTIN32_UnloadLibrary(WINE_MODREF *wm)
 430 {
 431         /* FIXME: do something here */
 432 }
 433
 434 /***********************************************************************
 435  *           BUILTIN32_RegisterDLL
 436  *
 437  * Register a built-in DLL descriptor.
 438  */
 439 void BUILTIN32_RegisterDLL( const BUILTIN32_DESCRIPTOR *descr )
 440 {
 441     assert( nb_dlls < MAX_DLLS );
 442     builtin_dlls[nb_dlls++] = descr;
 443 }
 444
 445 /***********************************************************************
 446  *           BUILTIN32_Unimplemented
 447  *
 448  * This function is called for unimplemented 32-bit entry points (declared
 449  * as 'stub' in the spec file).
 450  */
 451 void BUILTIN32_Unimplemented( const char *dllname, const char *funcname )
 452 {
 453     __RESTORE_ES;  /* Just in case */
 454
 455     MESSAGE( "No handler for Win32 routine %s.%s", dllname, funcname );
 456 #ifdef __GNUC__
 457     MESSAGE( " (called from %p)", __builtin_return_address(1) );
 458 #endif
 459     MESSAGE( "\n" );
 460     ExitProcess(1);
 461 }