Fixed wrong NE module registration so that resources work.
[wine] / 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