2 * Win32 builtin dlls support
4 * Copyright 2000 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/port.h"
31 #include <sys/types.h>
32 #ifdef HAVE_SYS_MMAN_H
35 #ifdef HAVE_SYS_RESOURCE_H
36 # include <sys/resource.h>
42 #define NONAMELESSUNION
43 #define NONAMELESSSTRUCT
46 #include "wine/library.h"
49 #include <crt_externs.h>
50 #define environ (*_NSGetEnviron())
52 extern char **environ
;
55 /* argc/argv for the Windows application */
56 int __wine_main_argc
= 0;
57 char **__wine_main_argv
= NULL
;
58 WCHAR
**__wine_main_wargv
= NULL
;
59 char **__wine_main_environ
= NULL
;
61 struct dll_path_context
63 unsigned int index
; /* current index in the dll path list */
64 char *buffer
; /* buffer used for storing path names */
65 char *name
; /* start of file name part in buffer (including leading slash) */
66 int namelen
; /* length of file name without .so extension */
67 int win16
; /* 16-bit dll search */
74 const IMAGE_NT_HEADERS
*nt
; /* NT header */
75 const char *filename
; /* DLL file name */
76 } builtin_dlls
[MAX_DLLS
];
80 static const IMAGE_NT_HEADERS
*main_exe
;
82 static load_dll_callback_t load_dll_callback
;
84 static const char *build_dir
;
85 static const char *default_dlldir
;
86 static const char **dll_paths
;
87 static unsigned int nb_dll_paths
;
88 static int dll_path_maxlen
;
90 extern void mmap_init(void);
91 extern const char *get_dlldir( const char **default_dlldir
);
93 /* build the dll load path from the WINEDLLPATH variable */
94 static void build_dll_path(void)
97 char *p
, *path
= getenv( "WINEDLLPATH" );
98 const char *dlldir
= get_dlldir( &default_dlldir
);
102 /* count how many path elements we need */
107 while (*p
== ':') p
++;
110 while (*p
&& *p
!= ':') p
++;
114 dll_paths
= malloc( (count
+2) * sizeof(*dll_paths
) );
119 dll_path_maxlen
= strlen(dlldir
);
120 dll_paths
[nb_dll_paths
++] = dlldir
;
122 else if ((build_dir
= wine_get_build_dir()))
124 dll_path_maxlen
= strlen(build_dir
) + sizeof("/programs");
132 while (*p
== ':') *p
++ = 0;
134 dll_paths
[nb_dll_paths
] = p
;
135 while (*p
&& *p
!= ':') p
++;
136 if (p
- dll_paths
[nb_dll_paths
] > dll_path_maxlen
)
137 dll_path_maxlen
= p
- dll_paths
[nb_dll_paths
];
142 /* append default dll dir (if not empty) to path */
143 if ((len
= strlen(default_dlldir
)) > 0)
145 if (len
> dll_path_maxlen
) dll_path_maxlen
= len
;
146 dll_paths
[nb_dll_paths
++] = default_dlldir
;
150 /* check if a given file can be opened */
151 static inline int file_exists( const char *name
)
153 int fd
= open( name
, O_RDONLY
);
154 if (fd
!= -1) close( fd
);
158 static inline char *prepend( char *buffer
, const char *str
, size_t len
)
160 return memcpy( buffer
- len
, str
, len
);
163 /* get a filename from the next entry in the dll path */
164 static char *next_dll_path( struct dll_path_context
*context
)
166 unsigned int index
= context
->index
++;
167 int namelen
= context
->namelen
;
168 char *path
= context
->name
;
172 case 0: /* try dlls dir with subdir prefix */
173 if (namelen
> 4 && !memcmp( context
->name
+ namelen
- 4, ".dll", 4 )) namelen
-= 4;
174 if (!context
->win16
) path
= prepend( path
, context
->name
, namelen
);
175 path
= prepend( path
, "/dlls", sizeof("/dlls") - 1 );
176 path
= prepend( path
, build_dir
, strlen(build_dir
) );
178 case 1: /* try programs dir with subdir prefix */
181 if (namelen
> 4 && !memcmp( context
->name
+ namelen
- 4, ".exe", 4 )) namelen
-= 4;
182 path
= prepend( path
, context
->name
, namelen
);
183 path
= prepend( path
, "/programs", sizeof("/programs") - 1 );
184 path
= prepend( path
, build_dir
, strlen(build_dir
) );
191 if (index
< nb_dll_paths
)
192 return prepend( context
->name
, dll_paths
[index
], strlen( dll_paths
[index
] ));
199 /* get a filename from the first entry in the dll path */
200 static char *first_dll_path( const char *name
, int win16
, struct dll_path_context
*context
)
203 int namelen
= strlen( name
);
204 const char *ext
= win16
? "16" : ".so";
206 context
->buffer
= malloc( dll_path_maxlen
+ 2 * namelen
+ strlen(ext
) + 3 );
207 context
->index
= build_dir
? 0 : 2; /* if no build dir skip all the build dir magic cases */
208 context
->name
= context
->buffer
+ dll_path_maxlen
+ namelen
+ 1;
209 context
->namelen
= namelen
+ 1;
210 context
->win16
= win16
;
212 /* store the name at the end of the buffer, followed by extension */
215 memcpy( p
, name
, namelen
);
216 strcpy( p
+ namelen
, ext
);
217 return next_dll_path( context
);
221 /* free the dll path context created by first_dll_path */
222 static inline void free_dll_path( struct dll_path_context
*context
)
224 free( context
->buffer
);
228 /* open a library for a given dll, searching in the dll path
229 * 'name' must be the Windows dll name (e.g. "kernel32.dll") */
230 static void *dlopen_dll( const char *name
, char *error
, int errorsize
,
231 int test_only
, int *exists
)
233 struct dll_path_context context
;
238 for (path
= first_dll_path( name
, 0, &context
); path
; path
= next_dll_path( &context
))
240 if (!test_only
&& (ret
= wine_dlopen( path
, RTLD_NOW
, error
, errorsize
))) break;
241 if ((*exists
= file_exists( path
))) break; /* exists but cannot be loaded, return the error */
243 free_dll_path( &context
);
248 /* adjust an array of pointers to make them into RVAs */
249 static inline void fixup_rva_ptrs( void *array
, BYTE
*base
, unsigned int count
)
251 void **src
= (void **)array
;
252 DWORD
*dst
= (DWORD
*)array
;
255 *dst
++ = *src
? (BYTE
*)*src
- base
: 0;
260 /* fixup an array of RVAs by adding the specified delta */
261 static inline void fixup_rva_dwords( DWORD
*ptr
, int delta
, unsigned int count
)
265 if (*ptr
) *ptr
+= delta
;
271 /* fixup RVAs in the import directory */
272 static void fixup_imports( IMAGE_IMPORT_DESCRIPTOR
*dir
, BYTE
*base
, int delta
)
278 fixup_rva_dwords( &dir
->u
.OriginalFirstThunk
, delta
, 1 );
279 fixup_rva_dwords( &dir
->Name
, delta
, 1 );
280 fixup_rva_dwords( &dir
->FirstThunk
, delta
, 1 );
281 ptr
= (UINT_PTR
*)(base
+ (dir
->u
.OriginalFirstThunk
? dir
->u
.OriginalFirstThunk
: dir
->FirstThunk
));
284 if (!(*ptr
& IMAGE_ORDINAL_FLAG
)) *ptr
+= delta
;
292 /* fixup RVAs in the export directory */
293 static void fixup_exports( IMAGE_EXPORT_DIRECTORY
*dir
, BYTE
*base
, int delta
)
295 fixup_rva_dwords( &dir
->Name
, delta
, 1 );
296 fixup_rva_dwords( &dir
->AddressOfFunctions
, delta
, 1 );
297 fixup_rva_dwords( &dir
->AddressOfNames
, delta
, 1 );
298 fixup_rva_dwords( &dir
->AddressOfNameOrdinals
, delta
, 1 );
299 fixup_rva_dwords( (DWORD
*)(base
+ dir
->AddressOfNames
), delta
, dir
->NumberOfNames
);
300 fixup_rva_ptrs( (base
+ dir
->AddressOfFunctions
), base
, dir
->NumberOfFunctions
);
304 /* fixup RVAs in the resource directory */
305 static void fixup_resources( IMAGE_RESOURCE_DIRECTORY
*dir
, BYTE
*root
, int delta
)
307 IMAGE_RESOURCE_DIRECTORY_ENTRY
*entry
;
310 entry
= (IMAGE_RESOURCE_DIRECTORY_ENTRY
*)(dir
+ 1);
311 for (i
= 0; i
< dir
->NumberOfNamedEntries
+ dir
->NumberOfIdEntries
; i
++, entry
++)
313 void *ptr
= root
+ entry
->u2
.s3
.OffsetToDirectory
;
314 if (entry
->u2
.s3
.DataIsDirectory
) fixup_resources( ptr
, root
, delta
);
317 IMAGE_RESOURCE_DATA_ENTRY
*data
= ptr
;
318 fixup_rva_dwords( &data
->OffsetToData
, delta
, 1 );
324 /* map a builtin dll in memory and fixup RVAs */
325 static void *map_dll( const IMAGE_NT_HEADERS
*nt_descr
)
328 IMAGE_DATA_DIRECTORY
*dir
;
329 IMAGE_DOS_HEADER
*dos
;
330 IMAGE_NT_HEADERS
*nt
;
331 IMAGE_SECTION_HEADER
*sec
;
333 DWORD code_start
, data_start
, data_end
;
334 const size_t page_size
= getpagesize();
335 const size_t page_mask
= page_size
- 1;
336 int delta
, nb_sections
= 2; /* code + data */
339 size_t size
= (sizeof(IMAGE_DOS_HEADER
)
340 + sizeof(IMAGE_NT_HEADERS
)
341 + nb_sections
* sizeof(IMAGE_SECTION_HEADER
));
343 assert( size
<= page_size
);
345 /* module address must be aligned on 64K boundary */
346 addr
= (BYTE
*)((nt_descr
->OptionalHeader
.ImageBase
+ 0xffff) & ~0xffff);
347 if (wine_anon_mmap( addr
, page_size
, PROT_READ
|PROT_WRITE
, MAP_FIXED
) != addr
) return NULL
;
349 dos
= (IMAGE_DOS_HEADER
*)addr
;
350 nt
= (IMAGE_NT_HEADERS
*)(dos
+ 1);
351 sec
= (IMAGE_SECTION_HEADER
*)(nt
+ 1);
353 /* Build the DOS and NT headers */
355 dos
->e_magic
= IMAGE_DOS_SIGNATURE
;
358 dos
->e_cparhdr
= (sizeof(*dos
)+0xf)/0x10;
360 dos
->e_maxalloc
= 0xffff;
363 dos
->e_lfarlc
= sizeof(*dos
);
364 dos
->e_lfanew
= sizeof(*dos
);
368 delta
= (const BYTE
*)nt_descr
- addr
;
369 code_start
= page_size
;
370 data_start
= delta
& ~page_mask
;
371 data_end
= (nt
->OptionalHeader
.SizeOfImage
+ delta
+ page_mask
) & ~page_mask
;
373 fixup_rva_ptrs( &nt
->OptionalHeader
.AddressOfEntryPoint
, addr
, 1 );
375 nt
->FileHeader
.NumberOfSections
= nb_sections
;
376 nt
->OptionalHeader
.BaseOfCode
= code_start
;
378 nt
->OptionalHeader
.BaseOfData
= data_start
;
380 nt
->OptionalHeader
.SizeOfCode
= data_start
- code_start
;
381 nt
->OptionalHeader
.SizeOfInitializedData
= data_end
- data_start
;
382 nt
->OptionalHeader
.SizeOfUninitializedData
= 0;
383 nt
->OptionalHeader
.SizeOfImage
= data_end
;
384 nt
->OptionalHeader
.ImageBase
= (ULONG_PTR
)addr
;
386 /* Build the code section */
388 memcpy( sec
->Name
, ".text", sizeof(".text") );
389 sec
->SizeOfRawData
= data_start
- code_start
;
390 sec
->Misc
.VirtualSize
= sec
->SizeOfRawData
;
391 sec
->VirtualAddress
= code_start
;
392 sec
->PointerToRawData
= code_start
;
393 sec
->Characteristics
= (IMAGE_SCN_CNT_CODE
| IMAGE_SCN_MEM_EXECUTE
| IMAGE_SCN_MEM_READ
);
396 /* Build the data section */
398 memcpy( sec
->Name
, ".data", sizeof(".data") );
399 sec
->SizeOfRawData
= data_end
- data_start
;
400 sec
->Misc
.VirtualSize
= sec
->SizeOfRawData
;
401 sec
->VirtualAddress
= data_start
;
402 sec
->PointerToRawData
= data_start
;
403 sec
->Characteristics
= (IMAGE_SCN_CNT_INITIALIZED_DATA
|
404 IMAGE_SCN_MEM_WRITE
| IMAGE_SCN_MEM_READ
);
407 for (i
= 0; i
< nt
->OptionalHeader
.NumberOfRvaAndSizes
; i
++)
408 fixup_rva_dwords( &nt
->OptionalHeader
.DataDirectory
[i
].VirtualAddress
, delta
, 1 );
410 /* Build the import directory */
412 dir
= &nt
->OptionalHeader
.DataDirectory
[IMAGE_FILE_IMPORT_DIRECTORY
];
415 IMAGE_IMPORT_DESCRIPTOR
*imports
= (void *)(addr
+ dir
->VirtualAddress
);
416 fixup_imports( imports
, addr
, delta
);
419 /* Build the resource directory */
421 dir
= &nt
->OptionalHeader
.DataDirectory
[IMAGE_FILE_RESOURCE_DIRECTORY
];
424 void *ptr
= (void *)(addr
+ dir
->VirtualAddress
);
425 fixup_resources( ptr
, ptr
, delta
);
428 /* Build the export directory */
430 dir
= &nt
->OptionalHeader
.DataDirectory
[IMAGE_FILE_EXPORT_DIRECTORY
];
433 IMAGE_EXPORT_DIRECTORY
*exports
= (void *)(addr
+ dir
->VirtualAddress
);
434 fixup_exports( exports
, addr
, delta
);
437 #else /* HAVE_MMAP */
439 #endif /* HAVE_MMAP */
443 /***********************************************************************
444 * __wine_dll_register
446 * Register a built-in DLL descriptor.
448 void __wine_dll_register( const IMAGE_NT_HEADERS
*header
, const char *filename
)
450 if (load_dll_callback
) load_dll_callback( map_dll(header
), filename
);
453 if (!(header
->FileHeader
.Characteristics
& IMAGE_FILE_DLL
))
457 assert( nb_dlls
< MAX_DLLS
);
458 builtin_dlls
[nb_dlls
].nt
= header
;
459 builtin_dlls
[nb_dlls
].filename
= filename
;
466 /***********************************************************************
467 * wine_dll_set_callback
469 * Set the callback function for dll loading, and call it
470 * for all dlls that were implicitly loaded already.
472 void wine_dll_set_callback( load_dll_callback_t load
)
475 load_dll_callback
= load
;
476 for (i
= 0; i
< nb_dlls
; i
++)
478 const IMAGE_NT_HEADERS
*nt
= builtin_dlls
[i
].nt
;
480 builtin_dlls
[i
].nt
= NULL
;
481 load_dll_callback( map_dll(nt
), builtin_dlls
[i
].filename
);
484 if (main_exe
) load_dll_callback( map_dll(main_exe
), "" );
488 /***********************************************************************
491 * Load a builtin dll.
493 void *wine_dll_load( const char *filename
, char *error
, int errorsize
, int *file_exists
)
497 /* callback must have been set already */
498 assert( load_dll_callback
);
500 /* check if we have it in the list */
501 /* this can happen when initializing pre-loaded dlls in wine_dll_set_callback */
502 for (i
= 0; i
< nb_dlls
; i
++)
504 if (!builtin_dlls
[i
].nt
) continue;
505 if (!strcmp( builtin_dlls
[i
].filename
, filename
))
507 const IMAGE_NT_HEADERS
*nt
= builtin_dlls
[i
].nt
;
508 builtin_dlls
[i
].nt
= NULL
;
509 load_dll_callback( map_dll(nt
), builtin_dlls
[i
].filename
);
514 return dlopen_dll( filename
, error
, errorsize
, 0, file_exists
);
518 /***********************************************************************
521 * Unload a builtin dll.
523 void wine_dll_unload( void *handle
)
525 if (handle
!= (void *)1)
526 wine_dlclose( handle
, NULL
, 0 );
530 /***********************************************************************
531 * wine_dll_load_main_exe
533 * Try to load the .so for the main exe.
535 void *wine_dll_load_main_exe( const char *name
, char *error
, int errorsize
,
536 int test_only
, int *file_exists
)
538 return dlopen_dll( name
, error
, errorsize
, test_only
, file_exists
);
542 /***********************************************************************
543 * wine_dll_enum_load_path
545 * Enumerate the dll load path.
547 const char *wine_dll_enum_load_path( unsigned int index
)
549 if (index
>= nb_dll_paths
) return NULL
;
550 return dll_paths
[index
];
554 /***********************************************************************
557 * Retrieve the name of the 32-bit owner dll for a 16-bit dll.
558 * Return 0 if OK, -1 on error.
560 int wine_dll_get_owner( const char *name
, char *buffer
, int size
, int *exists
)
564 struct dll_path_context context
;
568 for (path
= first_dll_path( name
, 1, &context
); path
; path
= next_dll_path( &context
))
570 int fd
= open( path
, O_RDONLY
);
573 int res
= read( fd
, buffer
, size
- 1 );
574 while (res
> 0 && (buffer
[res
-1] == '\n' || buffer
[res
-1] == '\r')) res
--;
582 free_dll_path( &context
);
587 /***********************************************************************
590 * Set a user limit to the maximum allowed value.
592 static void set_max_limit( int limit
)
594 #ifdef HAVE_SETRLIMIT
595 struct rlimit rlimit
;
597 if (!getrlimit( limit
, &rlimit
))
599 rlimit
.rlim_cur
= rlimit
.rlim_max
;
600 if (setrlimit( limit
, &rlimit
) != 0)
602 #if defined(__APPLE__) && defined(RLIMIT_NOFILE) && defined(OPEN_MAX)
603 /* On Leopard, setrlimit(RLIMIT_NOFILE, ...) fails on attempts to set
604 * rlim_cur above OPEN_MAX (even if rlim_max > OPEN_MAX). */
605 if (limit
== RLIMIT_NOFILE
&& rlimit
.rlim_cur
> OPEN_MAX
)
607 rlimit
.rlim_cur
= OPEN_MAX
;
608 setrlimit( limit
, &rlimit
);
617 /***********************************************************************
620 * Main Wine initialisation.
622 void wine_init( int argc
, char *argv
[], char *error
, int error_size
)
624 struct dll_path_context context
;
627 void (*init_func
)(void);
629 /* force a few limits that are set too low on some platforms */
631 set_max_limit( RLIMIT_NOFILE
);
634 set_max_limit( RLIMIT_AS
);
637 wine_init_argv0_path( argv
[0] );
639 __wine_main_argc
= argc
;
640 __wine_main_argv
= argv
;
641 __wine_main_environ
= environ
;
644 for (path
= first_dll_path( "ntdll.dll", 0, &context
); path
; path
= next_dll_path( &context
))
646 if ((ntdll
= wine_dlopen( path
, RTLD_NOW
, error
, error_size
)))
648 /* if we didn't use the default dll dir, remove it from the search path */
649 if (default_dlldir
[0] && context
.index
< nb_dll_paths
+ 2) nb_dll_paths
--;
653 free_dll_path( &context
);
656 if (!(init_func
= wine_dlsym( ntdll
, "__wine_process_init", error
, error_size
))) return;
662 * These functions provide wrappers around dlopen() and associated
663 * functions. They work around a bug in glibc 2.1.x where calling
664 * a dl*() function after a previous dl*() function has failed
665 * without a dlerror() call between the two will cause a crash.
666 * They all take a pointer to a buffer that
667 * will receive the error description (from dlerror()). This
668 * parameter may be NULL if the error description is not required.
675 /***********************************************************************
678 void *wine_dlopen( const char *filename
, int flag
, char *error
, size_t errorsize
)
685 /* the Mac OS loader pretends to be able to load PE files, so avoid them here */
686 unsigned char magic
[2];
687 int fd
= open( filename
, O_RDONLY
);
690 if (pread( fd
, magic
, 2, 0 ) == 2 && magic
[0] == 'M' && magic
[1] == 'Z')
692 static const char msg
[] = "MZ format";
693 size_t len
= min( errorsize
, sizeof(msg
) );
694 memcpy( error
, msg
, len
);
702 dlerror(); dlerror();
704 if (strchr( filename
, ':' ))
707 /* Solaris' brain damaged dlopen() treats ':' as a path separator */
708 realpath( filename
, path
);
709 ret
= dlopen( path
, flag
| RTLD_FIRST
);
713 ret
= dlopen( filename
, flag
| RTLD_FIRST
);
715 if (error
&& errorsize
)
719 size_t len
= strlen(s
);
720 if (len
>= errorsize
) len
= errorsize
- 1;
721 memcpy( error
, s
, len
);
731 static const char msg
[] = "dlopen interface not detected by configure";
732 size_t len
= min( errorsize
, sizeof(msg
) );
733 memcpy( error
, msg
, len
);
740 /***********************************************************************
743 void *wine_dlsym( void *handle
, const char *symbol
, char *error
, size_t errorsize
)
748 dlerror(); dlerror();
749 ret
= dlsym( handle
, symbol
);
751 if (error
&& errorsize
)
755 size_t len
= strlen(s
);
756 if (len
>= errorsize
) len
= errorsize
- 1;
757 memcpy( error
, s
, len
);
767 static const char msg
[] = "dlopen interface not detected by configure";
768 size_t len
= min( errorsize
, sizeof(msg
) );
769 memcpy( error
, msg
, len
);
776 /***********************************************************************
779 int wine_dlclose( void *handle
, char *error
, size_t errorsize
)
784 dlerror(); dlerror();
785 ret
= dlclose( handle
);
787 if (error
&& errorsize
)
791 size_t len
= strlen(s
);
792 if (len
>= errorsize
) len
= errorsize
- 1;
793 memcpy( error
, s
, len
);
803 static const char msg
[] = "dlopen interface not detected by configure";
804 size_t len
= min( errorsize
, sizeof(msg
) );
805 memcpy( error
, msg
, len
);