libs/wine/loader.c

   1 /*
   2  * Win32 builtin dlls support
   3  *
   4  * Copyright 2000 Alexandre Julliard
   5  *
   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.
  10  *
  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.
  15  *
  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
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <assert.h>
  25 #include <ctype.h>
  26 #include <fcntl.h>
  27 #include <limits.h>
  28 #include <stdarg.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <sys/types.h>
  32 #ifdef HAVE_SYS_MMAN_H
  33 #include <sys/mman.h>
  34 #endif
  35 #ifdef HAVE_SYS_RESOURCE_H
  36 # include <sys/resource.h>
  37 #endif
  38 #ifdef HAVE_UNISTD_H
  39 # include <unistd.h>
  40 #endif
  41
  42 #ifdef __APPLE__
  43 #include <crt_externs.h>
  44 #define environ (*_NSGetEnviron())
  45 #include <CoreFoundation/CoreFoundation.h>
  46 #define LoadResource MacLoadResource
  47 #define GetCurrentThread MacGetCurrentThread
  48 #include <CoreServices/CoreServices.h>
  49 #undef LoadResource
  50 #undef GetCurrentThread
  51 #include <pthread.h>
  52 #include <mach-o/getsect.h>
  53 #else
  54 extern char **environ;
  55 #endif
  56
  57 #ifdef __ANDROID__
  58 #include <jni.h>
  59 #endif
  60
  61 #define NONAMELESSUNION
  62 #define NONAMELESSSTRUCT
  63 #include "windef.h"
  64 #include "winbase.h"
  65 #include "wine/asm.h"
  66
  67 /* argc/argv for the Windows application */
  68 int __wine_main_argc = 0;
  69 char **__wine_main_argv = NULL;
  70 WCHAR **__wine_main_wargv = NULL;
  71 char **__wine_main_environ = NULL;
  72
  73 struct dll_path_context
  74 {
  75     unsigned int index; /* current index in the dll path list */
  76     char *buffer;       /* buffer used for storing path names */
  77     char *name;         /* start of file name part in buffer (including leading slash) */
  78     int   namelen;      /* length of file name without .so extension */
  79     int   win16;        /* 16-bit dll search */
  80 };
  81
  82 #define MAX_DLLS 100
  83
  84 static struct
  85 {
  86     const IMAGE_NT_HEADERS *nt;           /* NT header */
  87     const char             *filename;     /* DLL file name */
  88 } builtin_dlls[MAX_DLLS];
  89
  90 static int nb_dlls;
  91
  92 static const IMAGE_NT_HEADERS *main_exe;
  93
  94 typedef void (*load_dll_callback_t)( void *, const char * );
  95 static load_dll_callback_t load_dll_callback;
  96
  97 extern const char *build_dir;
  98 static const char *default_dlldir;
  99 static const char **dll_paths;
 100 static unsigned int nb_dll_paths;
 101 static int dll_path_maxlen;
 102
 103 extern void *wine_anon_mmap( void *start, size_t size, int prot, int flags );
 104 extern void wine_init_argv0_path( const char *argv0 );
 105 extern void wine_init( int argc, char *argv[], char *error, int error_size );
 106 extern void mmap_init(void);
 107 extern const char *get_dlldir( const char **default_dlldir );
 108
 109 /* build the dll load path from the WINEDLLPATH variable */
 110 static void build_dll_path(void)
 111 {
 112     int len, count = 0;
 113     char *p, *path = getenv( "WINEDLLPATH" );
 114     const char *dlldir = get_dlldir( &default_dlldir );
 115
 116     if (path)
 117     {
 118         /* count how many path elements we need */
 119         path = strdup(path);
 120         p = path;
 121         while (*p)
 122         {
 123             while (*p == ':') p++;
 124             if (!*p) break;
 125             count++;
 126             while (*p && *p != ':') p++;
 127         }
 128     }
 129
 130     dll_paths = malloc( (count+2) * sizeof(*dll_paths) );
 131     nb_dll_paths = 0;
 132
 133     if (dlldir)
 134     {
 135         dll_path_maxlen = strlen(dlldir);
 136         dll_paths[nb_dll_paths++] = dlldir;
 137     }
 138     else if (build_dir)
 139     {
 140         dll_path_maxlen = strlen(build_dir) + sizeof("/programs");
 141     }
 142
 143     if (count)
 144     {
 145         p = path;
 146         while (*p)
 147         {
 148             while (*p == ':') *p++ = 0;
 149             if (!*p) break;
 150             dll_paths[nb_dll_paths] = p;
 151             while (*p && *p != ':') p++;
 152             if (p - dll_paths[nb_dll_paths] > dll_path_maxlen)
 153                 dll_path_maxlen = p - dll_paths[nb_dll_paths];
 154             nb_dll_paths++;
 155         }
 156     }
 157
 158     /* append default dll dir (if not empty) to path */
 159     if ((len = strlen(default_dlldir)) > 0)
 160     {
 161         if (len > dll_path_maxlen) dll_path_maxlen = len;
 162         dll_paths[nb_dll_paths++] = default_dlldir;
 163     }
 164 }
 165
 166 static inline char *prepend( char *buffer, const char *str, size_t len )
 167 {
 168     return memcpy( buffer - len, str, len );
 169 }
 170
 171 /* get a filename from the next entry in the dll path */
 172 static char *next_dll_path( struct dll_path_context *context )
 173 {
 174     unsigned int index = context->index++;
 175     int namelen = context->namelen;
 176     char *path = context->name;
 177
 178     switch(index)
 179     {
 180     case 0:  /* try dlls dir with subdir prefix */
 181         if (namelen > 4 && !memcmp( context->name + namelen - 4, ".dll", 4 )) namelen -= 4;
 182         if (!context->win16) path = prepend( path, context->name, namelen );
 183         path = prepend( path, "/dlls", sizeof("/dlls") - 1 );
 184         path = prepend( path, build_dir, strlen(build_dir) );
 185         return path;
 186     case 1:  /* try programs dir with subdir prefix */
 187         if (!context->win16)
 188         {
 189             if (namelen > 4 && !memcmp( context->name + namelen - 4, ".exe", 4 )) namelen -= 4;
 190             path = prepend( path, context->name, namelen );
 191             path = prepend( path, "/programs", sizeof("/programs") - 1 );
 192             path = prepend( path, build_dir, strlen(build_dir) );
 193             return path;
 194         }
 195         context->index++;
 196         /* fall through */
 197     default:
 198         index -= 2;
 199         if (index >= nb_dll_paths) return NULL;
 200         path = prepend( path, dll_paths[index], strlen( dll_paths[index] ));
 201         return path;
 202     }
 203 }
 204
 205
 206 /* get a filename from the first entry in the dll path */
 207 static char *first_dll_path( const char *name, int win16, struct dll_path_context *context )
 208 {
 209     char *p;
 210     int namelen = strlen( name );
 211     const char *ext = win16 ? "16" : ".so";
 212
 213     context->buffer = malloc( dll_path_maxlen + 2 * namelen + strlen(ext) + 3 );
 214     context->index = build_dir ? 0 : 2;  /* if no build dir skip all the build dir magic cases */
 215     context->name = context->buffer + dll_path_maxlen + namelen + 1;
 216     context->namelen = namelen + 1;
 217     context->win16 = win16;
 218
 219     /* store the name at the end of the buffer, followed by extension */
 220     p = context->name;
 221     *p++ = '/';
 222     memcpy( p, name, namelen );
 223     strcpy( p + namelen, ext );
 224     return next_dll_path( context );
 225 }
 226
 227
 228 /* free the dll path context created by first_dll_path */
 229 static inline void free_dll_path( struct dll_path_context *context )
 230 {
 231     free( context->buffer );
 232 }
 233
 234
 235 /* adjust an array of pointers to make them into RVAs */
 236 static inline void fixup_rva_ptrs( void *array, BYTE *base, unsigned int count )
 237 {
 238     void **src = (void **)array;
 239     DWORD *dst = (DWORD *)array;
 240     while (count--)
 241     {
 242         *dst++ = *src ? (BYTE *)*src - base : 0;
 243         src++;
 244     }
 245 }
 246
 247 /* fixup an array of RVAs by adding the specified delta */
 248 static inline void fixup_rva_dwords( DWORD *ptr, int delta, unsigned int count )
 249 {
 250     while (count--)
 251     {
 252         if (*ptr) *ptr += delta;
 253         ptr++;
 254     }
 255 }
 256
 257
 258 /* fixup an array of name/ordinal RVAs by adding the specified delta */
 259 static inline void fixup_rva_names( UINT_PTR *ptr, int delta )
 260 {
 261     while (*ptr)
 262     {
 263         if (!(*ptr & IMAGE_ORDINAL_FLAG)) *ptr += delta;
 264         ptr++;
 265     }
 266 }
 267
 268
 269 /* fixup RVAs in the import directory */
 270 static void fixup_imports( IMAGE_IMPORT_DESCRIPTOR *dir, BYTE *base, int delta )
 271 {
 272     while (dir->Name)
 273     {
 274         fixup_rva_dwords( &dir->u.OriginalFirstThunk, delta, 1 );
 275         fixup_rva_dwords( &dir->Name, delta, 1 );
 276         fixup_rva_dwords( &dir->FirstThunk, delta, 1 );
 277         if (dir->u.OriginalFirstThunk) fixup_rva_names( (UINT_PTR *)(base + dir->u.OriginalFirstThunk), delta );
 278         if (dir->FirstThunk) fixup_rva_names( (UINT_PTR *)(base + dir->FirstThunk), delta );
 279         dir++;
 280     }
 281 }
 282
 283
 284 /* fixup RVAs in the export directory */
 285 static void fixup_exports( IMAGE_EXPORT_DIRECTORY *dir, BYTE *base, int delta )
 286 {
 287     fixup_rva_dwords( &dir->Name, delta, 1 );
 288     fixup_rva_dwords( &dir->AddressOfFunctions, delta, 1 );
 289     fixup_rva_dwords( &dir->AddressOfNames, delta, 1 );
 290     fixup_rva_dwords( &dir->AddressOfNameOrdinals, delta, 1 );
 291     fixup_rva_dwords( (DWORD *)(base + dir->AddressOfNames), delta, dir->NumberOfNames );
 292     fixup_rva_ptrs( (base + dir->AddressOfFunctions), base, dir->NumberOfFunctions );
 293 }
 294
 295
 296 /* fixup RVAs in the resource directory */
 297 static void fixup_resources( IMAGE_RESOURCE_DIRECTORY *dir, BYTE *root, int delta )
 298 {
 299     IMAGE_RESOURCE_DIRECTORY_ENTRY *entry;
 300     int i;
 301
 302     entry = (IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1);
 303     for (i = 0; i < dir->NumberOfNamedEntries + dir->NumberOfIdEntries; i++, entry++)
 304     {
 305         void *ptr = root + entry->u2.s2.OffsetToDirectory;
 306         if (entry->u2.s2.DataIsDirectory) fixup_resources( ptr, root, delta );
 307         else
 308         {
 309             IMAGE_RESOURCE_DATA_ENTRY *data = ptr;
 310             fixup_rva_dwords( &data->OffsetToData, delta, 1 );
 311         }
 312     }
 313 }
 314
 315
 316 /* map a builtin dll in memory and fixup RVAs */
 317 static void *map_dll( const IMAGE_NT_HEADERS *nt_descr )
 318 {
 319     IMAGE_DATA_DIRECTORY *dir;
 320     IMAGE_DOS_HEADER *dos;
 321     IMAGE_NT_HEADERS *nt;
 322     IMAGE_SECTION_HEADER *sec;
 323     BYTE *addr;
 324     DWORD code_start, code_end, data_start, data_end;
 325     const size_t page_size = sysconf( _SC_PAGESIZE );
 326     const size_t page_mask = page_size - 1;
 327     int delta, nb_sections = 2;  /* code + data */
 328     unsigned int i;
 329 #ifdef __APPLE__
 330     Dl_info dli;
 331     unsigned long data_size;
 332 #endif
 333
 334     size_t size = (sizeof(IMAGE_DOS_HEADER)
 335                    + sizeof(IMAGE_NT_HEADERS)
 336                    + nb_sections * sizeof(IMAGE_SECTION_HEADER));
 337
 338     assert( size <= page_size );
 339
 340     /* module address must be aligned on 64K boundary */
 341     addr = (BYTE *)((nt_descr->OptionalHeader.ImageBase + 0xffff) & ~0xffff);
 342     if (wine_anon_mmap( addr, page_size, PROT_READ|PROT_WRITE, MAP_FIXED ) != addr) return NULL;
 343
 344     dos    = (IMAGE_DOS_HEADER *)addr;
 345     nt     = (IMAGE_NT_HEADERS *)(dos + 1);
 346     sec    = (IMAGE_SECTION_HEADER *)(nt + 1);
 347
 348     /* Build the DOS and NT headers */
 349
 350     dos->e_magic    = IMAGE_DOS_SIGNATURE;
 351     dos->e_cblp     = 0x90;
 352     dos->e_cp       = 3;
 353     dos->e_cparhdr  = (sizeof(*dos)+0xf)/0x10;
 354     dos->e_minalloc = 0;
 355     dos->e_maxalloc = 0xffff;
 356     dos->e_ss       = 0x0000;
 357     dos->e_sp       = 0x00b8;
 358     dos->e_lfarlc   = sizeof(*dos);
 359     dos->e_lfanew   = sizeof(*dos);
 360
 361     *nt = *nt_descr;
 362
 363     delta      = (const BYTE *)nt_descr - addr;
 364     code_start = page_size;
 365     data_start = delta & ~page_mask;
 366 #ifdef __APPLE__
 367     /* Need the mach_header, not the PE header, to give to getsegmentdata(3) */
 368     dladdr(addr, &dli);
 369     code_end   = getsegmentdata(dli.dli_fbase, "__DATA", &data_size) - addr;
 370     data_end   = (code_end + data_size + page_mask) & ~page_mask;
 371 #else
 372     code_end   = data_start;
 373     data_end   = (nt->OptionalHeader.SizeOfImage + delta + page_mask) & ~page_mask;
 374 #endif
 375
 376     fixup_rva_ptrs( &nt->OptionalHeader.AddressOfEntryPoint, addr, 1 );
 377
 378     nt->FileHeader.NumberOfSections                = nb_sections;
 379     nt->OptionalHeader.BaseOfCode                  = code_start;
 380 #ifndef _WIN64
 381     nt->OptionalHeader.BaseOfData                  = data_start;
 382 #endif
 383     nt->OptionalHeader.SizeOfCode                  = code_end - code_start;
 384     nt->OptionalHeader.SizeOfInitializedData       = data_end - data_start;
 385     nt->OptionalHeader.SizeOfUninitializedData     = 0;
 386     nt->OptionalHeader.SizeOfImage                 = data_end;
 387     nt->OptionalHeader.ImageBase                   = (ULONG_PTR)addr;
 388
 389     /* Build the code section */
 390
 391     memcpy( sec->Name, ".text", sizeof(".text") );
 392     sec->SizeOfRawData = code_end - code_start;
 393     sec->Misc.VirtualSize = sec->SizeOfRawData;
 394     sec->VirtualAddress   = code_start;
 395     sec->PointerToRawData = code_start;
 396     sec->Characteristics  = (IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ);
 397     sec++;
 398
 399     /* Build the data section */
 400
 401     memcpy( sec->Name, ".data", sizeof(".data") );
 402     sec->SizeOfRawData = data_end - data_start;
 403     sec->Misc.VirtualSize = sec->SizeOfRawData;
 404     sec->VirtualAddress   = data_start;
 405     sec->PointerToRawData = data_start;
 406     sec->Characteristics  = (IMAGE_SCN_CNT_INITIALIZED_DATA |
 407                              IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_READ);
 408     sec++;
 409
 410     for (i = 0; i < nt->OptionalHeader.NumberOfRvaAndSizes; i++)
 411         fixup_rva_dwords( &nt->OptionalHeader.DataDirectory[i].VirtualAddress, delta, 1 );
 412
 413     /* Build the import directory */
 414
 415     dir = &nt->OptionalHeader.DataDirectory[IMAGE_FILE_IMPORT_DIRECTORY];
 416     if (dir->Size)
 417     {
 418         IMAGE_IMPORT_DESCRIPTOR *imports = (void *)(addr + dir->VirtualAddress);
 419         fixup_imports( imports, addr, delta );
 420     }
 421
 422     /* Build the resource directory */
 423
 424     dir = &nt->OptionalHeader.DataDirectory[IMAGE_FILE_RESOURCE_DIRECTORY];
 425     if (dir->Size)
 426     {
 427         void *ptr = (void *)(addr + dir->VirtualAddress);
 428         fixup_resources( ptr, ptr, delta );
 429     }
 430
 431     /* Build the export directory */
 432
 433     dir = &nt->OptionalHeader.DataDirectory[IMAGE_FILE_EXPORT_DIRECTORY];
 434     if (dir->Size)
 435     {
 436         IMAGE_EXPORT_DIRECTORY *exports = (void *)(addr + dir->VirtualAddress);
 437         fixup_exports( exports, addr, delta );
 438     }
 439     return addr;
 440 }
 441
 442
 443 /***********************************************************************
 444  *           __wine_get_main_environment
 445  *
 446  * Return an environment pointer to work around lack of environ variable.
 447  * Only exported on Mac OS.
 448  */
 449 char **__wine_get_main_environment(void)
 450 {
 451     return environ;
 452 }
 453
 454
 455 /***********************************************************************
 456  *           __wine_dll_register
 457  *
 458  * Register a built-in DLL descriptor.
 459  */
 460 void __wine_dll_register( const IMAGE_NT_HEADERS *header, const char *filename )
 461 {
 462     if (load_dll_callback) load_dll_callback( map_dll(header), filename );
 463     else
 464     {
 465         if (!(header->FileHeader.Characteristics & IMAGE_FILE_DLL))
 466             main_exe = header;
 467         else
 468         {
 469             assert( nb_dlls < MAX_DLLS );
 470             builtin_dlls[nb_dlls].nt = header;
 471             builtin_dlls[nb_dlls].filename = filename;
 472             nb_dlls++;
 473         }
 474     }
 475 }
 476
 477
 478 /***********************************************************************
 479  *           wine_dll_set_callback
 480  *
 481  * Set the callback function for dll loading, and call it
 482  * for all dlls that were implicitly loaded already.
 483  */
 484 void wine_dll_set_callback( load_dll_callback_t load )
 485 {
 486     int i;
 487     load_dll_callback = load;
 488     for (i = 0; i < nb_dlls; i++)
 489     {
 490         const IMAGE_NT_HEADERS *nt = builtin_dlls[i].nt;
 491         if (!nt) continue;
 492         builtin_dlls[i].nt = NULL;
 493         load_dll_callback( map_dll(nt), builtin_dlls[i].filename );
 494     }
 495     nb_dlls = 0;
 496     if (main_exe) load_dll_callback( map_dll(main_exe), "" );
 497 }
 498
 499
 500 #ifdef __ASM_OBSOLETE
 501
 502 /***********************************************************************
 503  *           wine_dll_enum_load_path
 504  *
 505  * Enumerate the dll load path.
 506  */
 507 const char *wine_dll_enum_load_path_obsolete( unsigned int index )
 508 {
 509     if (index >= nb_dll_paths) return NULL;
 510     return dll_paths[index];
 511 }
 512
 513
 514 /*
 515  * These functions provide wrappers around dlopen() and associated
 516  * functions.  They work around a bug in glibc 2.1.x where calling
 517  * a dl*() function after a previous dl*() function has failed
 518  * without a dlerror() call between the two will cause a crash.
 519  * They all take a pointer to a buffer that
 520  * will receive the error description (from dlerror()).  This
 521  * parameter may be NULL if the error description is not required.
 522  */
 523
 524 #ifndef RTLD_FIRST
 525 #define RTLD_FIRST 0
 526 #endif
 527
 528 /***********************************************************************
 529  *              wine_dlopen
 530  */
 531 void *wine_dlopen_obsolete( const char *filename, int flag, char *error, size_t errorsize )
 532 {
 533     void *ret;
 534     const char *s;
 535
 536 #ifdef __APPLE__
 537     /* the Mac OS loader pretends to be able to load PE files, so avoid them here */
 538     unsigned char magic[2];
 539     int fd = open( filename, O_RDONLY );
 540     if (fd != -1)
 541     {
 542         if (pread( fd, magic, 2, 0 ) == 2 && magic[0] == 'M' && magic[1] == 'Z')
 543         {
 544             if (error && errorsize)
 545             {
 546                 static const char msg[] = "MZ format";
 547                 size_t len = min( errorsize, sizeof(msg) );
 548                 memcpy( error, msg, len );
 549                 error[len - 1] = 0;
 550             }
 551             close( fd );
 552             return NULL;
 553         }
 554         close( fd );
 555     }
 556 #endif
 557     dlerror(); dlerror();
 558 #ifdef __sun
 559     if (strchr( filename, ':' ))
 560     {
 561         char path[PATH_MAX];
 562         /* Solaris' brain damaged dlopen() treats ':' as a path separator */
 563         realpath( filename, path );
 564         ret = dlopen( path, flag | RTLD_FIRST );
 565     }
 566     else
 567 #endif
 568     ret = dlopen( filename, flag | RTLD_FIRST );
 569     s = dlerror();
 570     if (error && errorsize)
 571     {
 572         if (s)
 573         {
 574             size_t len = strlen(s);
 575             if (len >= errorsize) len = errorsize - 1;
 576             memcpy( error, s, len );
 577             error[len] = 0;
 578         }
 579         else error[0] = 0;
 580     }
 581     dlerror();
 582     return ret;
 583 }
 584
 585 /***********************************************************************
 586  *              wine_dlsym
 587  */
 588 void *wine_dlsym_obsolete( void *handle, const char *symbol, char *error, size_t errorsize )
 589 {
 590     void *ret;
 591     const char *s;
 592     dlerror(); dlerror();
 593     ret = dlsym( handle, symbol );
 594     s = dlerror();
 595     if (error && errorsize)
 596     {
 597         if (s)
 598         {
 599             size_t len = strlen(s);
 600             if (len >= errorsize) len = errorsize - 1;
 601             memcpy( error, s, len );
 602             error[len] = 0;
 603         }
 604         else error[0] = 0;
 605     }
 606     dlerror();
 607     return ret;
 608 }
 609
 610 /***********************************************************************
 611  *              wine_dlclose
 612  */
 613 int wine_dlclose_obsolete( void *handle, char *error, size_t errorsize )
 614 {
 615     int ret;
 616     const char *s;
 617     dlerror(); dlerror();
 618     ret = dlclose( handle );
 619     s = dlerror();
 620     if (error && errorsize)
 621     {
 622         if (s)
 623         {
 624             size_t len = strlen(s);
 625             if (len >= errorsize) len = errorsize - 1;
 626             memcpy( error, s, len );
 627             error[len] = 0;
 628         }
 629         else error[0] = 0;
 630     }
 631     dlerror();
 632     return ret;
 633 }
 634
 635
 636 /* check if the library is the correct architecture */
 637 /* only returns false for a valid library of the wrong arch */
 638 static int check_library_arch( int fd )
 639 {
 640 #ifdef __APPLE__
 641     struct  /* Mach-O header */
 642     {
 643         unsigned int magic;
 644         unsigned int cputype;
 645     } header;
 646
 647     if (read( fd, &header, sizeof(header) ) != sizeof(header)) return 1;
 648     if (header.magic != 0xfeedface) return 1;
 649     if (sizeof(void *) == sizeof(int)) return !(header.cputype >> 24);
 650     else return (header.cputype >> 24) == 1; /* CPU_ARCH_ABI64 */
 651 #else
 652     struct  /* ELF header */
 653     {
 654         unsigned char magic[4];
 655         unsigned char class;
 656         unsigned char data;
 657         unsigned char version;
 658     } header;
 659
 660     if (read( fd, &header, sizeof(header) ) != sizeof(header)) return 1;
 661     if (memcmp( header.magic, "\177ELF", 4 )) return 1;
 662     if (header.version != 1 /* EV_CURRENT */) return 1;
 663 #ifdef WORDS_BIGENDIAN
 664     if (header.data != 2 /* ELFDATA2MSB */) return 1;
 665 #else
 666     if (header.data != 1 /* ELFDATA2LSB */) return 1;
 667 #endif
 668     if (sizeof(void *) == sizeof(int)) return header.class == 1; /* ELFCLASS32 */
 669     else return header.class == 2; /* ELFCLASS64 */
 670 #endif
 671 }
 672
 673 /* check if a given file can be opened */
 674 static int file_exists( const char *name )
 675 {
 676     int ret = 0;
 677     int fd = open( name, O_RDONLY );
 678     if (fd != -1)
 679     {
 680         ret = check_library_arch( fd );
 681         close( fd );
 682     }
 683     return ret;
 684 }
 685
 686 /* open a library for a given dll, searching in the dll path
 687  * 'name' must be the Windows dll name (e.g. "kernel32.dll") */
 688 static void *dlopen_dll( const char *name, char *error, int errorsize,
 689                          int test_only, int *exists )
 690 {
 691     struct dll_path_context context;
 692     char *path;
 693     void *ret = NULL;
 694
 695     *exists = 0;
 696     for (path = first_dll_path( name, 0, &context ); path; path = next_dll_path( &context ))
 697     {
 698         if (!test_only && (ret = wine_dlopen_obsolete( path, RTLD_NOW, error, errorsize ))) break;
 699         if ((*exists = file_exists( path ))) break; /* exists but cannot be loaded, return the error */
 700     }
 701     free_dll_path( &context );
 702     return ret;
 703 }
 704
 705
 706 /***********************************************************************
 707  *           wine_dll_load
 708  *
 709  * Load a builtin dll.
 710  */
 711 void *wine_dll_load_obsolete( const char *filename, char *error, int errorsize, int *file_exists )
 712 {
 713     int i;
 714
 715     /* callback must have been set already */
 716     assert( load_dll_callback );
 717
 718     /* check if we have it in the list */
 719     /* this can happen when initializing pre-loaded dlls in wine_dll_set_callback */
 720     for (i = 0; i < nb_dlls; i++)
 721     {
 722         if (!builtin_dlls[i].nt) continue;
 723         if (!strcmp( builtin_dlls[i].filename, filename ))
 724         {
 725             const IMAGE_NT_HEADERS *nt = builtin_dlls[i].nt;
 726             builtin_dlls[i].nt = NULL;
 727             load_dll_callback( map_dll(nt), builtin_dlls[i].filename );
 728             *file_exists = 1;
 729             return (void *)1;
 730         }
 731     }
 732     return dlopen_dll( filename, error, errorsize, 0, file_exists );
 733 }
 734
 735
 736 /***********************************************************************
 737  *           wine_dll_unload
 738  *
 739  * Unload a builtin dll.
 740  */
 741 void wine_dll_unload_obsolete( void *handle )
 742 {
 743     if (handle != (void *)1)
 744         wine_dlclose_obsolete( handle, NULL, 0 );
 745 }
 746
 747
 748 /***********************************************************************
 749  *           wine_dll_load_main_exe
 750  *
 751  * Try to load the .so for the main exe.
 752  */
 753 void *wine_dll_load_main_exe_obsolete( const char *name, char *error, int errorsize,
 754                                        int test_only, int *file_exists )
 755 {
 756     return dlopen_dll( name, error, errorsize, test_only, file_exists );
 757 }
 758
 759
 760 /***********************************************************************
 761  *           wine_dll_get_owner
 762  *
 763  * Retrieve the name of the 32-bit owner dll for a 16-bit dll.
 764  * Return 0 if OK, -1 on error.
 765  */
 766 int wine_dll_get_owner_obsolete( const char *name, char *buffer, int size, int *exists )
 767 {
 768     int ret = -1;
 769     char *path;
 770     struct dll_path_context context;
 771
 772     *exists = 0;
 773
 774     for (path = first_dll_path( name, 1, &context ); path; path = next_dll_path( &context ))
 775     {
 776         int fd = open( path, O_RDONLY );
 777         if (fd != -1)
 778         {
 779             int res = read( fd, buffer, size - 1 );
 780             while (res > 0 && (buffer[res-1] == '\n' || buffer[res-1] == '\r')) res--;
 781             buffer[res] = 0;
 782             close( fd );
 783             *exists = 1;
 784             ret = 0;
 785             break;
 786         }
 787     }
 788     free_dll_path( &context );
 789     return ret;
 790 }
 791
 792 __ASM_OBSOLETE(wine_dlopen);
 793 __ASM_OBSOLETE(wine_dlsym);
 794 __ASM_OBSOLETE(wine_dlclose);
 795 __ASM_OBSOLETE(wine_dll_enum_load_path);
 796 __ASM_OBSOLETE(wine_dll_get_owner);
 797 __ASM_OBSOLETE(wine_dll_load);
 798 __ASM_OBSOLETE(wine_dll_load_main_exe);
 799 __ASM_OBSOLETE(wine_dll_unload);
 800
 801 #endif /* __ASM_OBSOLETE */
 802
 803 /***********************************************************************
 804  *           set_max_limit
 805  *
 806  * Set a user limit to the maximum allowed value.
 807  */
 808 static void set_max_limit( int limit )
 809 {
 810     struct rlimit rlimit;
 811
 812     if (!getrlimit( limit, &rlimit ))
 813     {
 814         rlimit.rlim_cur = rlimit.rlim_max;
 815         if (setrlimit( limit, &rlimit ) != 0)
 816         {
 817 #if defined(__APPLE__) && defined(RLIMIT_NOFILE) && defined(OPEN_MAX)
 818             /* On Leopard, setrlimit(RLIMIT_NOFILE, ...) fails on attempts to set
 819              * rlim_cur above OPEN_MAX (even if rlim_max > OPEN_MAX). */
 820             if (limit == RLIMIT_NOFILE && rlimit.rlim_cur > OPEN_MAX)
 821             {
 822                 rlimit.rlim_cur = OPEN_MAX;
 823                 setrlimit( limit, &rlimit );
 824             }
 825 #endif
 826         }
 827     }
 828 }
 829
 830
 831 #ifdef __APPLE__
 832 struct apple_stack_info
 833 {
 834     void *stack;
 835     size_t desired_size;
 836 };
 837
 838 /***********************************************************************
 839  *           apple_alloc_thread_stack
 840  *
 841  * Callback for wine_mmap_enum_reserved_areas to allocate space for
 842  * the secondary thread's stack.
 843  */
 844 #ifndef _WIN64
 845 static int apple_alloc_thread_stack( void *base, size_t size, void *arg )
 846 {
 847     struct apple_stack_info *info = arg;
 848
 849     /* For mysterious reasons, putting the thread stack at the very top
 850      * of the address space causes subsequent execs to fail, even on the
 851      * child side of a fork.  Avoid the top 16MB. */
 852     char * const limit = (char*)0xff000000;
 853     if ((char *)base >= limit) return 0;
 854     if (size > limit - (char*)base)
 855         size = limit - (char*)base;
 856     if (size < info->desired_size) return 0;
 857     info->stack = wine_anon_mmap( (char *)base + size - info->desired_size,
 858                                   info->desired_size, PROT_READ|PROT_WRITE, MAP_FIXED );
 859     return (info->stack != (void *)-1);
 860 }
 861 #endif
 862
 863 /***********************************************************************
 864  *           apple_create_wine_thread
 865  *
 866  * Spin off a secondary thread to complete Wine initialization, leaving
 867  * the original thread for the Mac frameworks.
 868  *
 869  * Invoked as a CFRunLoopSource perform callback.
 870  */
 871 static void apple_create_wine_thread( void *init_func )
 872 {
 873     int success = 0;
 874     pthread_t thread;
 875     pthread_attr_t attr;
 876
 877     if (!pthread_attr_init( &attr ))
 878     {
 879 #ifndef _WIN64
 880         struct apple_stack_info info;
 881
 882         /* Try to put the new thread's stack in the reserved area.  If this
 883          * fails, just let it go wherever.  It'll be a waste of space, but we
 884          * can go on. */
 885         if (!pthread_attr_getstacksize( &attr, &info.desired_size ) &&
 886             wine_mmap_enum_reserved_areas( apple_alloc_thread_stack, &info, 1 ))
 887         {
 888             wine_mmap_remove_reserved_area( info.stack, info.desired_size, 0 );
 889             pthread_attr_setstackaddr( &attr, (char*)info.stack + info.desired_size );
 890         }
 891 #endif
 892
 893         if (!pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE ) &&
 894             !pthread_create( &thread, &attr, init_func, NULL ))
 895             success = 1;
 896
 897         pthread_attr_destroy( &attr );
 898     }
 899
 900     /* Failure is indicated by returning from wine_init().  Stopping
 901      * the run loop allows apple_main_thread() and thus wine_init() to
 902      * return. */
 903     if (!success)
 904         CFRunLoopStop( CFRunLoopGetCurrent() );
 905 }
 906
 907
 908 /***********************************************************************
 909  *           apple_main_thread
 910  *
 911  * Park the process's original thread in a Core Foundation run loop for
 912  * use by the Mac frameworks, especially receiving and handling
 913  * distributed notifications.  Spin off a new thread for the rest of the
 914  * Wine initialization.
 915  */
 916 static void apple_main_thread( void (*init_func)(void) )
 917 {
 918     CFRunLoopSourceContext source_context = { 0 };
 919     CFRunLoopSourceRef source;
 920
 921     if (!pthread_main_np())
 922     {
 923         init_func();
 924         return;
 925     }
 926
 927     /* Multi-processing Services can get confused about the main thread if the
 928      * first time it's used is on a secondary thread.  Use it here to make sure
 929      * that doesn't happen. */
 930     MPTaskIsPreemptive(MPCurrentTaskID());
 931
 932     /* Give ourselves the best chance of having the distributed notification
 933      * center scheduled on this thread's run loop.  In theory, it's scheduled
 934      * in the first thread to ask for it. */
 935     CFNotificationCenterGetDistributedCenter();
 936
 937     /* We use this run loop source for two purposes.  First, a run loop exits
 938      * if it has no more sources scheduled.  So, we need at least one source
 939      * to keep the run loop running.  Second, although it's not critical, it's
 940      * preferable for the Wine initialization to not proceed until we know
 941      * the run loop is running.  So, we signal our source immediately after
 942      * adding it and have its callback spin off the Wine thread. */
 943     source_context.info = init_func;
 944     source_context.perform = apple_create_wine_thread;
 945     source = CFRunLoopSourceCreate( NULL, 0, &source_context );
 946
 947     if (source)
 948     {
 949         CFRunLoopAddSource( CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes );
 950         CFRunLoopSourceSignal( source );
 951         CFRelease( source );
 952
 953         CFRunLoopRun(); /* Should never return, except on error. */
 954     }
 955
 956     /* If we get here (i.e. return), that indicates failure to our caller. */
 957 }
 958 #endif
 959
 960
 961 #ifdef __ANDROID__
 962
 963 #ifndef WINE_JAVA_CLASS
 964 #define WINE_JAVA_CLASS "org/winehq/wine/WineActivity"
 965 #endif
 966
 967 static JavaVM *java_vm;
 968 static jobject java_object;
 969
 970 /* return the Java VM that was used for JNI initialisation */
 971 JavaVM *wine_get_java_vm(void)
 972 {
 973     return java_vm;
 974 }
 975
 976 /* return the Java object that called the wine_init method */
 977 jobject wine_get_java_object(void)
 978 {
 979     return java_object;
 980 }
 981
 982 /* main Wine initialisation */
 983 static jstring wine_init_jni( JNIEnv *env, jobject obj, jobjectArray cmdline, jobjectArray environment )
 984 {
 985     char **argv;
 986     char *str;
 987     char error[1024];
 988     int i, argc, length;
 989
 990     /* get the command line array */
 991
 992     argc = (*env)->GetArrayLength( env, cmdline );
 993     for (i = length = 0; i < argc; i++)
 994     {
 995         jobject str_obj = (*env)->GetObjectArrayElement( env, cmdline, i );
 996         length += (*env)->GetStringUTFLength( env, str_obj ) + 1;
 997     }
 998
 999     argv = malloc( (argc + 1) * sizeof(*argv) + length );
1000     str = (char *)(argv + argc + 1);
1001     for (i = 0; i < argc; i++)
1002     {
1003         jobject str_obj = (*env)->GetObjectArrayElement( env, cmdline, i );
1004         length = (*env)->GetStringUTFLength( env, str_obj );
1005         (*env)->GetStringUTFRegion( env, str_obj, 0,
1006                                     (*env)->GetStringLength( env, str_obj ), str );
1007         argv[i] = str;
1008         str[length] = 0;
1009         str += length + 1;
1010     }
1011     argv[argc] = NULL;
1012
1013     /* set the environment variables */
1014
1015     if (environment)
1016     {
1017         int count = (*env)->GetArrayLength( env, environment );
1018         for (i = 0; i < count - 1; i += 2)
1019         {
1020             jobject var_obj = (*env)->GetObjectArrayElement( env, environment, i );
1021             jobject val_obj = (*env)->GetObjectArrayElement( env, environment, i + 1 );
1022             const char *var = (*env)->GetStringUTFChars( env, var_obj, NULL );
1023
1024             if (val_obj)
1025             {
1026                 const char *val = (*env)->GetStringUTFChars( env, val_obj, NULL );
1027                 setenv( var, val, 1 );
1028                 if (!strcmp( var, "LD_LIBRARY_PATH" ))
1029                 {
1030                     void (*update_func)( const char * ) = dlsym( RTLD_DEFAULT,
1031                                                                  "android_update_LD_LIBRARY_PATH" );
1032                     if (update_func) update_func( val );
1033                 }
1034                 else if (!strcmp( var, "WINEDEBUGLOG" ))
1035                 {
1036                     int fd = open( val, O_WRONLY | O_CREAT | O_APPEND, 0666 );
1037                     if (fd != -1)
1038                     {
1039                         dup2( fd, 2 );
1040                         close( fd );
1041                     }
1042                 }
1043                 (*env)->ReleaseStringUTFChars( env, val_obj, val );
1044             }
1045             else unsetenv( var );
1046
1047             (*env)->ReleaseStringUTFChars( env, var_obj, var );
1048         }
1049     }
1050
1051     java_object = (*env)->NewGlobalRef( env, obj );
1052
1053 #ifdef __i386__
1054     {
1055         unsigned short java_fs;
1056         __asm__( "mov %%fs,%0" : "=r" (java_fs) );
1057         __asm__( "mov %0,%%fs" :: "r" (0) );
1058         wine_init( argc, argv, error, sizeof(error) );
1059         __asm__( "mov %0,%%fs" :: "r" (java_fs) );
1060     }
1061 #else
1062     wine_init( argc, argv, error, sizeof(error) );
1063 #endif
1064     return (*env)->NewStringUTF( env, error );
1065 }
1066
1067 jint JNI_OnLoad( JavaVM *vm, void *reserved )
1068 {
1069     static const JNINativeMethod method =
1070     {
1071         "wine_init", "([Ljava/lang/String;[Ljava/lang/String;)Ljava/lang/String;", wine_init_jni
1072     };
1073
1074     JNIEnv *env;
1075     jclass class;
1076
1077     java_vm = vm;
1078     if ((*vm)->AttachCurrentThread( vm, &env, NULL ) != JNI_OK) return JNI_ERR;
1079     if (!(class = (*env)->FindClass( env, WINE_JAVA_CLASS ))) return JNI_ERR;
1080     (*env)->RegisterNatives( env, class, &method, 1 );
1081     return JNI_VERSION_1_6;
1082 }
1083
1084 #endif  /* __ANDROID__ */
1085
1086 /***********************************************************************
1087  *           wine_init
1088  *
1089  * Main Wine initialisation.
1090  */
1091 void wine_init( int argc, char *argv[], char *error, int error_size )
1092 {
1093     struct dll_path_context context;
1094     char *path;
1095     void *ntdll = NULL;
1096     void (*init_func)(void);
1097
1098     /* force a few limits that are set too low on some platforms */
1099 #ifdef RLIMIT_NOFILE
1100     set_max_limit( RLIMIT_NOFILE );
1101 #endif
1102 #ifdef RLIMIT_AS
1103     set_max_limit( RLIMIT_AS );
1104 #endif
1105
1106     wine_init_argv0_path( argv[0] );
1107     build_dll_path();
1108     __wine_main_argc = argc;
1109     __wine_main_argv = argv;
1110     __wine_main_environ = __wine_get_main_environment();
1111     mmap_init();
1112
1113     for (path = first_dll_path( "ntdll.dll", 0, &context ); path; path = next_dll_path( &context ))
1114     {
1115         if ((ntdll = dlopen( path, RTLD_NOW )))
1116         {
1117             /* if we didn't use the default dll dir, remove it from the search path */
1118             if (default_dlldir[0] && context.index < nb_dll_paths + 2) nb_dll_paths--;
1119             break;
1120         }
1121     }
1122     free_dll_path( &context );
1123
1124     if (!ntdll || !(init_func = dlsym( ntdll, "__wine_process_init" )))
1125     {
1126         if (error && error_size)
1127         {
1128             const char *s = dlerror();
1129             if (s)
1130             {
1131                 size_t len = min( strlen(s), error_size - 1 );
1132                 memcpy( error, s, len );
1133                 error[len] = 0;
1134             }
1135             else error[0] = 0;
1136         }
1137         return;
1138     }
1139 #ifdef __APPLE__
1140     apple_main_thread( init_func );
1141 #else
1142     init_func();
1143 #endif
1144 }