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 #include <sys/types.h>
  17 #ifdef HAVE_SYS_MMAN_H
  18 #include <sys/mman.h>
  19 #endif
  20
  21 #include "windef.h"
  22 #include "wine/winbase16.h"
  23 #include "wingdi.h"
  24 #include "winuser.h"
  25 #include "builtin32.h"
  26 #include "elfdll.h"
  27 #include "file.h"
  28 #include "global.h"
  29 #include "neexe.h"
  30 #include "heap.h"
  31 #include "main.h"
  32 #include "snoop.h"
  33 #include "winerror.h"
  34 #include "server.h"
  35 #include "debugtools.h"
  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     int page_size = VIRTUAL_GetPageSize();
 149
 150     /* Allocate the module */
 151
 152     nb_sections = 2;  /* code + data */
 153
 154     size = (sizeof(IMAGE_DOS_HEADER)
 155             + sizeof(IMAGE_NT_HEADERS)
 156             + nb_sections * sizeof(IMAGE_SECTION_HEADER)
 157             + (descr->nb_imports+1) * sizeof(IMAGE_IMPORT_DESCRIPTOR));
 158
 159     assert( size <= page_size );
 160
 161     if (descr->pe_header)
 162     {
 163         if ((addr = FILE_dommap( -1, descr->pe_header, 0, page_size, 0, 0,
 164                                  PROT_READ|PROT_WRITE, MAP_FIXED )) != descr->pe_header)
 165         {
 166             ERR("failed to map over PE header for %s at %p\n", descr->filename, descr->pe_header );
 167             return 0;
 168         }
 169     }
 170     else
 171     {
 172         if (!(addr = VirtualAlloc( NULL, page_size, MEM_COMMIT, PAGE_READWRITE ))) return 0;
 173     }
 174
 175     dos    = (IMAGE_DOS_HEADER *)addr;
 176     nt     = (IMAGE_NT_HEADERS *)(dos + 1);
 177     sec    = (IMAGE_SECTION_HEADER *)(nt + 1);
 178     imp    = (IMAGE_IMPORT_DESCRIPTOR *)(sec + nb_sections);
 179     code_start = addr + page_size;
 180
 181     /* HACK! */
 182     data_start = code_start + page_size;
 183
 184     /* Build the DOS and NT headers */
 185
 186     dos->e_magic  = IMAGE_DOS_SIGNATURE;
 187     dos->e_lfanew = sizeof(*dos);
 188
 189     nt->Signature                       = IMAGE_NT_SIGNATURE;
 190     nt->FileHeader.Machine              = IMAGE_FILE_MACHINE_I386;
 191     nt->FileHeader.NumberOfSections     = nb_sections;
 192     nt->FileHeader.SizeOfOptionalHeader = sizeof(nt->OptionalHeader);
 193     nt->FileHeader.Characteristics      = descr->characteristics;
 194
 195     nt->OptionalHeader.Magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
 196     nt->OptionalHeader.SizeOfCode                  = data_start - code_start;
 197     nt->OptionalHeader.SizeOfInitializedData       = 0;
 198     nt->OptionalHeader.SizeOfUninitializedData     = 0;
 199     nt->OptionalHeader.ImageBase                   = (DWORD)addr;
 200     nt->OptionalHeader.SectionAlignment            = page_size;
 201     nt->OptionalHeader.FileAlignment               = page_size;
 202     nt->OptionalHeader.MajorOperatingSystemVersion = 1;
 203     nt->OptionalHeader.MinorOperatingSystemVersion = 0;
 204     nt->OptionalHeader.MajorSubsystemVersion       = 4;
 205     nt->OptionalHeader.MinorSubsystemVersion       = 0;
 206     nt->OptionalHeader.SizeOfImage                 = page_size;
 207     nt->OptionalHeader.SizeOfHeaders               = page_size;
 208     nt->OptionalHeader.NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
 209     if (descr->dllentrypoint)
 210         nt->OptionalHeader.AddressOfEntryPoint = (DWORD)descr->dllentrypoint - (DWORD)addr;
 211
 212     /* Build the code section */
 213
 214     strcpy( sec->Name, ".text" );
 215     sec->SizeOfRawData = data_start - code_start;
 216     sec->Misc.VirtualSize = sec->SizeOfRawData;
 217     sec->VirtualAddress   = code_start - addr;
 218     sec->PointerToRawData = code_start - addr;
 219     sec->Characteristics  = (IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ);
 220     sec++;
 221
 222     /* Build the data section */
 223
 224     strcpy( sec->Name, ".data" );
 225     sec->SizeOfRawData = 0;
 226     sec->Misc.VirtualSize = sec->SizeOfRawData;
 227     sec->VirtualAddress   = data_start - addr;
 228     sec->PointerToRawData = data_start - addr;
 229     sec->Characteristics  = (IMAGE_SCN_CNT_INITIALIZED_DATA |
 230                              IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_READ);
 231     sec++;
 232
 233     /* Build the import directory */
 234
 235     if (descr->nb_imports)
 236     {
 237         dir = &nt->OptionalHeader.DataDirectory[IMAGE_FILE_IMPORT_DIRECTORY];
 238         dir->VirtualAddress = (BYTE *)imp - addr;
 239         dir->Size = sizeof(*imp) * (descr->nb_imports + 1);
 240
 241         /* Build the imports */
 242         for (i = 0; i < descr->nb_imports; i++)
 243         {
 244             imp[i].u.Characteristics = 0;
 245             imp[i].ForwarderChain = -1;
 246             imp[i].Name = (BYTE *)descr->imports[i] - addr;
 247             /* hack: make first thunk point to some zero value */
 248             imp[i].FirstThunk = (PIMAGE_THUNK_DATA)((BYTE *)&imp[i].u.Characteristics - addr);
 249         }
 250     }
 251
 252     /* Build the resource directory */
 253
 254     if (descr->rsrc)
 255     {
 256         BUILTIN32_RESOURCE *rsrc = descr->rsrc;
 257         IMAGE_RESOURCE_DATA_ENTRY *rdep;
 258         dir = &nt->OptionalHeader.DataDirectory[IMAGE_FILE_RESOURCE_DIRECTORY];
 259         dir->VirtualAddress = (BYTE *)rsrc->restab - addr;
 260         dir->Size = rsrc->restabsize;
 261         rdep = rsrc->entries;
 262         for (i = 0; i < rsrc->nresources; i++) rdep[i].OffsetToData += dir->VirtualAddress;
 263     }
 264
 265     /* Build the export directory */
 266
 267     if (exports)
 268     {
 269         dir = &nt->OptionalHeader.DataDirectory[IMAGE_FILE_EXPORT_DIRECTORY];
 270         dir->VirtualAddress = (BYTE *)exports - addr;
 271         dir->Size = descr->exports_size;
 272
 273         fixup_rva_ptrs( (void *)exports->AddressOfFunctions, addr, exports->NumberOfFunctions );
 274         fixup_rva_ptrs( (void *)exports->AddressOfNames, addr, exports->NumberOfNames );
 275         fixup_rva_ptrs( &exports->Name, addr, 1 );
 276         fixup_rva_ptrs( &exports->AddressOfFunctions, addr, 1 );
 277         fixup_rva_ptrs( &exports->AddressOfNames, addr, 1 );
 278         fixup_rva_ptrs( &exports->AddressOfNameOrdinals, addr, 1 );
 279
 280         /* Setup relay debugging entry points */
 281         if (WARN_ON(relay) || TRACE_ON(relay)) RELAY_SetupDLL( addr );
 282     }
 283
 284     return (HMODULE)addr;
 285 }
 286
 287 /***********************************************************************
 288  *           BUILTIN32_LoadLibraryExA
 289  *
 290  * Partly copied from the original PE_ version.
 291  *
 292  */
 293 WINE_MODREF *BUILTIN32_LoadLibraryExA(LPCSTR path, DWORD flags)
 294 {
 295     struct load_dll_request *req = get_req_buffer();
 296     HMODULE16      hModule16;
 297     NE_MODULE     *pModule;
 298     WINE_MODREF   *wm;
 299     char           dllname[MAX_PATH], *p;
 300     void *handle;
 301     int i;
 302
 303     /* Fix the name in case we have a full path and extension */
 304     if ((p = strrchr( path, '\\' ))) path = p + 1;
 305     lstrcpynA( dllname, path, sizeof(dllname) );
 306
 307     p = strrchr( dllname, '.' );
 308     if (!p) strcat( dllname, ".dll" );
 309
 310     /* Search built-in descriptor */
 311     for (i = 0; i < nb_dlls; i++)
 312         if (!strcasecmp( builtin_dlls[i]->filename, dllname )) goto found;
 313
 314     if ((handle = BUILTIN32_dlopen( dllname )))
 315     {
 316         for (i = 0; i < nb_dlls; i++)
 317             if (!strcasecmp( builtin_dlls[i]->filename, dllname )) goto found;
 318         ERR( "loaded .so but dll %s still not found\n", dllname );
 319         BUILTIN32_dlclose( handle );
 320     }
 321
 322     SetLastError( ERROR_FILE_NOT_FOUND );
 323     return NULL;
 324
 325  found:
 326     /* Load built-in module */
 327     if (!dll_modules[i])
 328     {
 329         if (!(dll_modules[i] = BUILTIN32_DoLoadImage( builtin_dlls[i] ))) return NULL;
 330     }
 331     else BUILTIN32_WarnSecondInstance( builtin_dlls[i]->filename );
 332
 333     /* Create 16-bit dummy module */
 334     if ((hModule16 = MODULE_CreateDummyModule( dllname, dll_modules[i] )) < 32)
 335     {
 336         SetLastError( (DWORD)hModule16 );
 337         return NULL;    /* FIXME: Should unload the builtin module */
 338     }
 339     pModule = (NE_MODULE *)GlobalLock16( hModule16 );
 340     pModule->flags = NE_FFLAGS_LIBMODULE | NE_FFLAGS_SINGLEDATA | NE_FFLAGS_WIN32 | NE_FFLAGS_BUILTIN;
 341
 342     /* Create 32-bit MODREF */
 343     if ( !(wm = PE_CreateModule( pModule->module32, dllname, flags, TRUE )) )
 344     {
 345         ERR( "can't load %s\n", path );
 346         FreeLibrary16( hModule16 );     /* FIXME: Should unload the builtin module */
 347         SetLastError( ERROR_OUTOFMEMORY );
 348         return NULL;
 349     }
 350
 351     if (wm->binfmt.pe.pe_export)
 352         SNOOP_RegisterDLL(wm->module,wm->modname,wm->binfmt.pe.pe_export->NumberOfFunctions);
 353
 354     req->handle     = -1;
 355     req->base       = (void *)pModule->module32;
 356     req->dbg_offset = 0;
 357     req->dbg_size   = 0;
 358     req->name       = &wm->modname;
 359     server_call_noerr( REQ_LOAD_DLL );
 360     return wm;
 361 }
 362
 363 /***********************************************************************
 364  *           BUILTIN32_LoadExeModule
 365  */
 366 HMODULE BUILTIN32_LoadExeModule(void)
 367 {
 368     int i, exe = -1;
 369
 370     /* Search built-in EXE descriptor */
 371     for ( i = 0; i < nb_dlls; i++ )
 372         if ( !(builtin_dlls[i]->characteristics & IMAGE_FILE_DLL) )
 373         {
 374             if ( exe != -1 )
 375             {
 376                 MESSAGE( "More than one built-in EXE module loaded!\n" );
 377                 break;
 378             }
 379
 380             exe = i;
 381         }
 382
 383     if ( exe == -1 )
 384     {
 385         MESSAGE( "No built-in EXE module loaded!  Did you create a .spec file?\n" );
 386         return 0;
 387     }
 388
 389     /* Load built-in module */
 390     if ( !dll_modules[exe] )
 391         if ( !(dll_modules[exe] = BUILTIN32_DoLoadImage( builtin_dlls[exe] )) )
 392             return 0;
 393     return dll_modules[exe];
 394 }
 395
 396
 397 /***********************************************************************
 398  *      BUILTIN32_UnloadLibrary
 399  *
 400  * Unload the built-in library and free the modref.
 401  */
 402 void BUILTIN32_UnloadLibrary(WINE_MODREF *wm)
 403 {
 404         /* FIXME: do something here */
 405 }
 406
 407 /***********************************************************************
 408  *           BUILTIN32_RegisterDLL
 409  *
 410  * Register a built-in DLL descriptor.
 411  */
 412 void BUILTIN32_RegisterDLL( const BUILTIN32_DESCRIPTOR *descr )
 413 {
 414     assert( nb_dlls < MAX_DLLS );
 415     builtin_dlls[nb_dlls++] = descr;
 416 }
 417
 418 /***********************************************************************
 419  *           BUILTIN32_Unimplemented
 420  *
 421  * This function is called for unimplemented 32-bit entry points (declared
 422  * as 'stub' in the spec file).
 423  */
 424 void BUILTIN32_Unimplemented( const char *dllname, const char *funcname )
 425 {
 426     __RESTORE_ES;  /* Just in case */
 427
 428     MESSAGE( "No handler for Win32 routine %s.%s", dllname, funcname );
 429 #ifdef __GNUC__
 430     MESSAGE( " (called from %p)", __builtin_return_address(1) );
 431 #endif
 432     MESSAGE( "\n" );
 433     ExitProcess(1);
 434 }