git.oblomov.eu Git - wine/blob - loader/elfdll.c

   1 /*
   2  * Elf-dll loader functions
   3  *
   4  * Copyright 1999 Bertho A. Stultiens
   5  */
   6
   7 #include <string.h>
   8 #include <ctype.h>
   9 #include <stdlib.h>
  10
  11 #include "config.h"
  12 #include "windef.h"
  13 #include "global.h"
  14 #include "process.h"
  15 #include "module.h"
  16 #include "neexe.h"
  17 #include "heap.h"
  18 #include "wine/winbase16.h"
  19 #include "elfdll.h"
  20 #include "debugtools.h"
  21 #include "winerror.h"
  22
  23 DECLARE_DEBUG_CHANNEL(elfdll)
  24
  25 #if defined(HAVE_DL_API)
  26 #include <dlfcn.h>
  27
  28 /*------------------ HACKS -----------------*/
  29 extern DWORD fixup_imports(WINE_MODREF *wm);
  30 extern void dump_exports(HMODULE hModule);
  31 /*---------------- END HACKS ---------------*/
  32
  33 char *extra_ld_library_path = NULL;     /* The extra search-path set in wine.conf */
  34
  35 struct elfdll_image
  36 {
  37         HMODULE         pe_module_start;
  38         DWORD           pe_module_size;
  39         NE_MODULE       *ne_module_start;
  40         DWORD           ne_module_size;
  41 };
  42
  43
  44 /****************************************************************************
  45  *      ELFDLL_dlopen
  46  *
  47  * Wrapper for dlopen to search the EXTRA_LD_LIBRARY_PATH from wine.conf
  48  * manually because libdl.so caches the environment and does not accept our
  49  * changes.
  50  */
  51 void *ELFDLL_dlopen(const char *libname, int flags)
  52 {
  53         char buffer[256];
  54         int namelen;
  55         void *handle;
  56         char *ldpath;
  57
  58         /* First try the default path search of dlopen() */
  59         handle = dlopen(libname, flags);
  60         if(handle)
  61                 return handle;
  62
  63         /* Now try to construct searches through our extra search-path */
  64         namelen = strlen(libname);
  65         ldpath = extra_ld_library_path;
  66         while(ldpath && *ldpath)
  67         {
  68                 int len;
  69                 char *cptr;
  70                 char *from;
  71
  72                 from = ldpath;
  73                 cptr = strchr(ldpath, ':');
  74                 if(!cptr)
  75                 {
  76                         len = strlen(ldpath);
  77                         ldpath = NULL;
  78                 }
  79                 else
  80                 {
  81                         len = cptr - ldpath;
  82                         ldpath = cptr + 1;
  83                 }
  84
  85                 if(len + namelen + 1 >= sizeof(buffer))
  86                 {
  87                         ERR_(elfdll)("Buffer overflow! Check EXTRA_LD_LIBRARY_PATH or increase buffer size.\n");
  88                         return NULL;
  89                 }
  90
  91                 strncpy(buffer, from, len);
  92                 if(len)
  93                 {
  94                         buffer[len] = '/';
  95                         strcpy(buffer + len + 1, libname);
  96                 }
  97                 else
  98                         strcpy(buffer + len, libname);
  99
 100                 TRACE_(elfdll)("Trying dlopen('%s', %d)\n", buffer, flags);
 101
 102                 handle = dlopen(buffer, flags);
 103                 if(handle)
 104                         return handle;
 105         }
 106         return NULL;
 107 }
 108
 109
 110 /****************************************************************************
 111  *      get_sobasename  (internal)
 112  *
 113  */
 114 static LPSTR get_sobasename(LPCSTR path, LPSTR name)
 115 {
 116         char *cptr;
 117
 118         /* Strip the path from the library name */
 119         if((cptr = strrchr(path, '/')))
 120         {
 121                 char *cp = strrchr(cptr+1, '\\');
 122                 if(cp && cp > cptr)
 123                         cptr = cp;
 124         }
 125         else
 126                 cptr = strrchr(path, '\\');
 127
 128         if(!cptr)
 129                 cptr = (char *)path;    /* No '/' nor '\\' in path */
 130         else
 131                 cptr++;
 132
 133         strcpy(name, cptr);
 134         cptr = strrchr(name, '.');
 135         if(cptr)
 136                 *cptr = '\0';   /* Strip extension */
 137
 138         /* Convert to lower case.
 139          * This must be done manually because it is not sure that
 140          * other modules are accessible.
 141          */
 142         for(cptr = name; *cptr; cptr++)
 143                 *cptr = tolower(*cptr);
 144
 145         return name;
 146 }
 147
 148
 149 /****************************************************************************
 150  *      ELFDLL_CreateModref     (internal)
 151  *
 152  * INPUT
 153  *      hModule - the header from the elf-dll's data-segment
 154  *      path    - requested path from original call
 155  *
 156  * OUTPUT
 157  *      A WINE_MODREF pointer to the new object
 158  *
 159  * BUGS
 160  *      - Does not handle errors due to dependencies correctly
 161  *      - path can be wrong
 162  */
 163 #define RVA(base, va)   (((DWORD)base) + ((DWORD)va))
 164
 165 static WINE_MODREF *ELFDLL_CreateModref(HMODULE hModule, LPCSTR path)
 166 {
 167         IMAGE_NT_HEADERS *nt = PE_HEADER(hModule);
 168         IMAGE_DATA_DIRECTORY *dir;
 169         IMAGE_IMPORT_DESCRIPTOR *pe_import = NULL;
 170         WINE_MODREF *wm;
 171         int len;
 172         HANDLE procheap = GetProcessHeap();
 173
 174         wm = (WINE_MODREF *)HeapAlloc(procheap, HEAP_ZERO_MEMORY, sizeof(*wm));
 175         if(!wm)
 176                 return NULL;
 177
 178         wm->module = hModule;
 179         wm->type = MODULE32_PE;         /* FIXME */
 180
 181         dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_EXPORT;
 182         if(dir->Size)
 183                 wm->binfmt.pe.pe_export = (PIMAGE_EXPORT_DIRECTORY)RVA(hModule, dir->VirtualAddress);
 184
 185         dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_IMPORT;
 186         if(dir->Size)
 187                 pe_import = wm->binfmt.pe.pe_import = (PIMAGE_IMPORT_DESCRIPTOR)RVA(hModule, dir->VirtualAddress);
 188
 189         dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_RESOURCE;
 190         if(dir->Size)
 191                 wm->binfmt.pe.pe_resource = (PIMAGE_RESOURCE_DIRECTORY)RVA(hModule, dir->VirtualAddress);
 192
 193         wm->modname = HEAP_strdupA(procheap, 0, (char *)RVA(hModule, wm->binfmt.pe.pe_export->Name));
 194
 195         len = GetLongPathNameA(path, NULL, 0);
 196         wm->longname = (char *)HeapAlloc(procheap, 0, len+1);
 197         GetLongPathNameA(path, wm->longname, len+1);
 198
 199         wm->shortname = HEAP_strdupA(procheap, 0, path);
 200
 201         /* Link MODREF into process list */
 202         wm->next = PROCESS_Current()->modref_list;
 203         PROCESS_Current()->modref_list = wm;
 204
 205         if(!(nt->FileHeader.Characteristics & IMAGE_FILE_DLL))
 206         {
 207                 if(PROCESS_Current()->exe_modref)
 208                         FIXME_(elfdll)("overwriting old exe_modref... arrgh\n");
 209                 PROCESS_Current()->exe_modref = wm;
 210         }
 211
 212         /* Fixup Imports */
 213         if(pe_import && fixup_imports(wm))
 214         {
 215                 /* Error in this module or its dependencies
 216                  * remove entry from modref chain
 217                  */
 218                 WINE_MODREF **xwm;
 219                 for(xwm = &(PROCESS_Current()->modref_list); *xwm; xwm = &((*xwm)->next))
 220                 {
 221                         if ( *xwm == wm )
 222                         {
 223                                 *xwm = wm->next;
 224                                 break;
 225                         }
 226                 }
 227                 if(wm == PROCESS_Current()->exe_modref)
 228                         ERR_(elfdll)("Have to delete current exe_modref. Expect crash now\n");
 229                 HeapFree(procheap, 0, wm->shortname);
 230                 HeapFree(procheap, 0, wm->longname);
 231                 HeapFree(procheap, 0, wm->modname);
 232                 HeapFree(procheap, 0, wm);
 233                 return NULL;
 234
 235                 /* FIXME: We should traverse back in the recursion
 236                  * with an error to unload everything that got loaded
 237                  * before this error occurred.
 238                  * Too dificult for now though and we don't care at the
 239                  * moment. But, it *MUST* be implemented someday because
 240                  * we won't be able to map the elf-dll twice in this
 241                  * address-space which can cause some unexpected and
 242                  * weird problems later on.
 243                  */
 244         }
 245
 246         return wm;
 247 }
 248
 249
 250 /***********************************************************************
 251  *           ELFDLL_CreateNEModule
 252  *
 253  * Create a dummy NE module for the win32 elf-dll based on the supplied
 254  * NE header in the elf-dll.
 255  */
 256 static HMODULE16 ELFDLL_CreateNEModule(NE_MODULE *ne_image, DWORD size)
 257 {
 258         NE_MODULE *pModule;
 259         HMODULE16 hModule = GLOBAL_CreateBlock(GMEM_MOVEABLE, ne_image, size, 0,
 260                                                 FALSE, FALSE, FALSE, NULL);
 261         if(!hModule)
 262                 return (HMODULE16)0;
 263
 264         FarSetOwner16(hModule, hModule);
 265         pModule = (NE_MODULE *)GlobalLock16(hModule);
 266         pModule->self = hModule;
 267         NE_RegisterModule(pModule);
 268         return hModule;
 269 }
 270
 271
 272 /****************************************************************************
 273  *      ELFDLL_LoadLibraryExA   (internal)
 274  *
 275  * Implementation of elf-dll loading for PE modules
 276  */
 277 WINE_MODREF *ELFDLL_LoadLibraryExA(LPCSTR path, DWORD flags, DWORD *err)
 278 {
 279         LPVOID dlhandle;
 280         struct elfdll_image *image;
 281         char name[129];
 282         char soname[129];
 283         HMODULE16 hmod16;
 284         WINE_MODREF *wm;
 285
 286         get_sobasename(path, name);
 287         strcpy(soname, name);
 288         strcat(soname, ".so");
 289
 290         /* Try to open the elf-dll */
 291         dlhandle = ELFDLL_dlopen(soname, RTLD_LAZY);
 292         if(!dlhandle)
 293         {
 294                 WARN_(elfdll)("Could not load %s (%s)\n", soname, dlerror());
 295                 *err = ERROR_FILE_NOT_FOUND;
 296                 return NULL;
 297         }
 298
 299         /* Get the 'dllname_elfdll_image' variable */
 300         strcpy(soname, name);
 301         strcat(soname, "_elfdll_image");
 302         image = (struct elfdll_image *)dlsym(dlhandle, soname);
 303         if(!image)
 304         {
 305                 ERR_(elfdll)("Could not get elfdll image descriptor %s (%s)\n", soname, dlerror());
 306                 dlclose(dlhandle);
 307                 *err = ERROR_BAD_FORMAT;
 308                 return NULL;
 309         }
 310
 311         /* Create a win16 dummy module */
 312         hmod16 = ELFDLL_CreateNEModule(image->ne_module_start, image->ne_module_size);
 313         if(!hmod16)
 314         {
 315                 ERR_(elfdll)("Could not create win16 dummy module for %s\n", path);
 316                 dlclose(dlhandle);
 317                 *err = ERROR_OUTOFMEMORY;
 318                 return NULL;
 319         }
 320
 321         image->ne_module_start->module32 = image->pe_module_start;
 322
 323         wm = ELFDLL_CreateModref(image->pe_module_start, path);
 324         if(!wm)
 325         {
 326                 ERR_(elfdll)("Could not create WINE_MODREF for %s\n", path);
 327                 GLOBAL_FreeBlock((HGLOBAL16)hmod16);
 328                 dlclose(dlhandle);
 329                 *err = ERROR_OUTOFMEMORY;
 330                 return NULL;
 331         }
 332
 333         dump_exports(image->pe_module_start);
 334
 335         *err = 0;
 336         return wm;
 337 }
 338
 339
 340 /****************************************************************************
 341  *      ELFDLL_UnloadLibrary    (internal)
 342  *
 343  * Unload an elf-dll completely from memory and deallocate the modref
 344  */
 345 void ELFDLL_UnloadLibrary(WINE_MODREF *wm)
 346 {
 347 }
 348
 349
 350 /****************************************************************************
 351  *      ELFDLL_LoadModule16     (internal)
 352  *
 353  * Implementation of elf-dll loading for NE modules
 354  */
 355 HINSTANCE16 ELFDLL_LoadModule16(LPCSTR libname, BOOL implicit)
 356 {
 357         return (HINSTANCE16)ERROR_FILE_NOT_FOUND;
 358 }
 359
 360 #else
 361
 362 /*
 363  * No elfdlls possible
 364  * Just put stubs in here.
 365  */
 366
 367 WINE_MODREF *ELFDLL_LoadLibraryExA(LPCSTR libname, DWORD flags, DWORD *err)
 368 {
 369         *err = ERROR_FILE_NOT_FOUND;
 370         return NULL;
 371 }
 372
 373 void ELFDLL_UnloadLibrary(WINE_MODREF *wm)
 374 {
 375 }
 376
 377 HINSTANCE16 ELFDLL_LoadModule16(LPCSTR libname, BOOL implicit)
 378 {
 379         return (HINSTANCE16)ERROR_FILE_NOT_FOUND;
 380 }
 381
 382 #endif