git.oblomov.eu Git - wine/blob - dlls/ntdll/loader.c

   1 /*
   2  * Loader functions
   3  *
   4  * Copyright 1995, 2003 Alexandre Julliard
   5  * Copyright 2002 Dmitry Timoshkov for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <assert.h>
  26 #include <stdarg.h>
  27
  28 #define NONAMELESSUNION
  29 #define NONAMELESSSTRUCT
  30
  31 #include "ntstatus.h"
  32 #define WIN32_NO_STATUS
  33 #include "windef.h"
  34 #include "winnt.h"
  35 #include "winternl.h"
  36
  37 #include "wine/exception.h"
  38 #include "wine/library.h"
  39 #include "wine/unicode.h"
  40 #include "wine/debug.h"
  41 #include "wine/server.h"
  42 #include "ntdll_misc.h"
  43 #include "ddk/wdm.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(module);
  46 WINE_DECLARE_DEBUG_CHANNEL(relay);
  47 WINE_DECLARE_DEBUG_CHANNEL(snoop);
  48 WINE_DECLARE_DEBUG_CHANNEL(loaddll);
  49 WINE_DECLARE_DEBUG_CHANNEL(imports);
  50
  51 /* we don't want to include winuser.h */
  52 #define RT_MANIFEST                         ((ULONG_PTR)24)
  53 #define ISOLATIONAWARE_MANIFEST_RESOURCE_ID ((ULONG_PTR)2)
  54
  55 typedef DWORD (CALLBACK *DLLENTRYPROC)(HMODULE,DWORD,LPVOID);
  56
  57 static int process_detaching = 0;  /* set on process detach to avoid deadlocks with thread detach */
  58 static int free_lib_count;   /* recursion depth of LdrUnloadDll calls */
  59
  60 static const char * const reason_names[] =
  61 {
  62     "PROCESS_DETACH",
  63     "PROCESS_ATTACH",
  64     "THREAD_ATTACH",
  65     "THREAD_DETACH",
  66     NULL, NULL, NULL, NULL,
  67     "WINE_PREATTACH"
  68 };
  69
  70 static const WCHAR dllW[] = {'.','d','l','l',0};
  71
  72 /* internal representation of 32bit modules. per process. */
  73 typedef struct _wine_modref
  74 {
  75     LDR_MODULE            ldr;
  76     int                   nDeps;
  77     struct _wine_modref **deps;
  78 } WINE_MODREF;
  79
  80 /* info about the current builtin dll load */
  81 /* used to keep track of things across the register_dll constructor call */
  82 struct builtin_load_info
  83 {
  84     const WCHAR *load_path;
  85     const WCHAR *filename;
  86     NTSTATUS     status;
  87     WINE_MODREF *wm;
  88 };
  89
  90 static struct builtin_load_info default_load_info;
  91 static struct builtin_load_info *builtin_load_info = &default_load_info;
  92
  93 static HANDLE main_exe_file;
  94 static UINT tls_module_count;      /* number of modules with TLS directory */
  95 static UINT tls_total_size;        /* total size of TLS storage */
  96 static const IMAGE_TLS_DIRECTORY **tls_dirs;  /* array of TLS directories */
  97
  98 UNICODE_STRING windows_dir = { 0, 0, NULL };  /* windows directory */
  99 UNICODE_STRING system_dir = { 0, 0, NULL };  /* system directory */
 100
 101 static RTL_CRITICAL_SECTION loader_section;
 102 static RTL_CRITICAL_SECTION_DEBUG critsect_debug =
 103 {
 104     0, 0, &loader_section,
 105     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
 106       0, 0, { (DWORD_PTR)(__FILE__ ": loader_section") }
 107 };
 108 static RTL_CRITICAL_SECTION loader_section = { &critsect_debug, -1, 0, 0, 0, 0 };
 109
 110 static WINE_MODREF *cached_modref;
 111 static WINE_MODREF *current_modref;
 112 static WINE_MODREF *last_failed_modref;
 113
 114 static NTSTATUS load_dll( LPCWSTR load_path, LPCWSTR libname, DWORD flags, WINE_MODREF** pwm );
 115 static FARPROC find_named_export( HMODULE module, const IMAGE_EXPORT_DIRECTORY *exports,
 116                                   DWORD exp_size, const char *name, int hint );
 117
 118 /* convert PE image VirtualAddress to Real Address */
 119 static inline void *get_rva( HMODULE module, DWORD va )
 120 {
 121     return (void *)((char *)module + va);
 122 }
 123
 124 /* check whether the file name contains a path */
 125 static inline int contains_path( LPCWSTR name )
 126 {
 127     return ((*name && (name[1] == ':')) || strchrW(name, '/') || strchrW(name, '\\'));
 128 }
 129
 130 /* convert from straight ASCII to Unicode without depending on the current codepage */
 131 static inline void ascii_to_unicode( WCHAR *dst, const char *src, size_t len )
 132 {
 133     while (len--) *dst++ = (unsigned char)*src++;
 134 }
 135
 136
 137 /*************************************************************************
 138  *              call_dll_entry_point
 139  *
 140  * Some brain-damaged dlls (ir32_32.dll for instance) modify ebx in
 141  * their entry point, so we need a small asm wrapper.
 142  */
 143 #ifdef __i386__
 144 extern BOOL call_dll_entry_point( DLLENTRYPROC proc, void *module, UINT reason, void *reserved );
 145 __ASM_GLOBAL_FUNC(call_dll_entry_point,
 146                   "pushl %ebp\n\t"
 147                   "movl %esp,%ebp\n\t"
 148                   "pushl %ebx\n\t"
 149                   "subl $8,%esp\n\t"
 150                   "pushl 20(%ebp)\n\t"
 151                   "pushl 16(%ebp)\n\t"
 152                   "pushl 12(%ebp)\n\t"
 153                   "movl 8(%ebp),%eax\n\t"
 154                   "call *%eax\n\t"
 155                   "leal -4(%ebp),%esp\n\t"
 156                   "popl %ebx\n\t"
 157                   "popl %ebp\n\t"
 158                   "ret" )
 159 #else /* __i386__ */
 160 static inline BOOL call_dll_entry_point( DLLENTRYPROC proc, void *module,
 161                                          UINT reason, void *reserved )
 162 {
 163     return proc( module, reason, reserved );
 164 }
 165 #endif /* __i386__ */
 166
 167
 168 #ifdef __i386__
 169 /*************************************************************************
 170  *              stub_entry_point
 171  *
 172  * Entry point for stub functions.
 173  */
 174 static void stub_entry_point( const char *dll, const char *name, ... )
 175 {
 176     EXCEPTION_RECORD rec;
 177
 178     rec.ExceptionCode           = EXCEPTION_WINE_STUB;
 179     rec.ExceptionFlags          = EH_NONCONTINUABLE;
 180     rec.ExceptionRecord         = NULL;
 181 #ifdef __GNUC__
 182     rec.ExceptionAddress        = __builtin_return_address(0);
 183 #else
 184     rec.ExceptionAddress        = *((void **)&dll - 1);
 185 #endif
 186     rec.NumberParameters        = 2;
 187     rec.ExceptionInformation[0] = (ULONG_PTR)dll;
 188     rec.ExceptionInformation[1] = (ULONG_PTR)name;
 189     for (;;) RtlRaiseException( &rec );
 190 }
 191
 192
 193 #include "pshpack1.h"
 194 struct stub
 195 {
 196     BYTE        popl_eax;   /* popl %eax */
 197     BYTE        pushl1;     /* pushl $name */
 198     const char *name;
 199     BYTE        pushl2;     /* pushl $dll */
 200     const char *dll;
 201     BYTE        pushl_eax;  /* pushl %eax */
 202     BYTE        jmp;        /* jmp stub_entry_point */
 203     DWORD       entry;
 204 };
 205 #include "poppack.h"
 206
 207 /*************************************************************************
 208  *              allocate_stub
 209  *
 210  * Allocate a stub entry point.
 211  */
 212 static ULONG_PTR allocate_stub( const char *dll, const char *name )
 213 {
 214 #define MAX_SIZE 65536
 215     static struct stub *stubs;
 216     static unsigned int nb_stubs;
 217     struct stub *stub;
 218
 219     if (nb_stubs >= MAX_SIZE / sizeof(*stub)) return 0xdeadbeef;
 220
 221     if (!stubs)
 222     {
 223         SIZE_T size = MAX_SIZE;
 224         if (NtAllocateVirtualMemory( NtCurrentProcess(), (void **)&stubs, 0, &size,
 225                                      MEM_COMMIT, PAGE_EXECUTE_WRITECOPY ) != STATUS_SUCCESS)
 226             return 0xdeadbeef;
 227     }
 228     stub = &stubs[nb_stubs++];
 229     stub->popl_eax  = 0x58;  /* popl %eax */
 230     stub->pushl1    = 0x68;  /* pushl $name */
 231     stub->name      = name;
 232     stub->pushl2    = 0x68;  /* pushl $dll */
 233     stub->dll       = dll;
 234     stub->pushl_eax = 0x50;  /* pushl %eax */
 235     stub->jmp       = 0xe9;  /* jmp stub_entry_point */
 236     stub->entry     = (BYTE *)stub_entry_point - (BYTE *)(&stub->entry + 1);
 237     return (ULONG_PTR)stub;
 238 }
 239
 240 #else  /* __i386__ */
 241 static inline ULONG_PTR allocate_stub( const char *dll, const char *name ) { return 0xdeadbeef; }
 242 #endif  /* __i386__ */
 243
 244
 245 /*************************************************************************
 246  *              get_modref
 247  *
 248  * Looks for the referenced HMODULE in the current process
 249  * The loader_section must be locked while calling this function.
 250  */
 251 static WINE_MODREF *get_modref( HMODULE hmod )
 252 {
 253     PLIST_ENTRY mark, entry;
 254     PLDR_MODULE mod;
 255
 256     if (cached_modref && cached_modref->ldr.BaseAddress == hmod) return cached_modref;
 257
 258     mark = &NtCurrentTeb()->Peb->LdrData->InMemoryOrderModuleList;
 259     for (entry = mark->Flink; entry != mark; entry = entry->Flink)
 260     {
 261         mod = CONTAINING_RECORD(entry, LDR_MODULE, InMemoryOrderModuleList);
 262         if (mod->BaseAddress == hmod)
 263             return cached_modref = CONTAINING_RECORD(mod, WINE_MODREF, ldr);
 264         if (mod->BaseAddress > (void*)hmod) break;
 265     }
 266     return NULL;
 267 }
 268
 269
 270 /**********************************************************************
 271  *          find_basename_module
 272  *
 273  * Find a module from its base name.
 274  * The loader_section must be locked while calling this function
 275  */
 276 static WINE_MODREF *find_basename_module( LPCWSTR name )
 277 {
 278     PLIST_ENTRY mark, entry;
 279
 280     if (cached_modref && !strcmpiW( name, cached_modref->ldr.BaseDllName.Buffer ))
 281         return cached_modref;
 282
 283     mark = &NtCurrentTeb()->Peb->LdrData->InLoadOrderModuleList;
 284     for (entry = mark->Flink; entry != mark; entry = entry->Flink)
 285     {
 286         LDR_MODULE *mod = CONTAINING_RECORD(entry, LDR_MODULE, InLoadOrderModuleList);
 287         if (!strcmpiW( name, mod->BaseDllName.Buffer ))
 288         {
 289             cached_modref = CONTAINING_RECORD(mod, WINE_MODREF, ldr);
 290             return cached_modref;
 291         }
 292     }
 293     return NULL;
 294 }
 295
 296
 297 /**********************************************************************
 298  *          find_fullname_module
 299  *
 300  * Find a module from its full path name.
 301  * The loader_section must be locked while calling this function
 302  */
 303 static WINE_MODREF *find_fullname_module( LPCWSTR name )
 304 {
 305     PLIST_ENTRY mark, entry;
 306
 307     if (cached_modref && !strcmpiW( name, cached_modref->ldr.FullDllName.Buffer ))
 308         return cached_modref;
 309
 310     mark = &NtCurrentTeb()->Peb->LdrData->InLoadOrderModuleList;
 311     for (entry = mark->Flink; entry != mark; entry = entry->Flink)
 312     {
 313         LDR_MODULE *mod = CONTAINING_RECORD(entry, LDR_MODULE, InLoadOrderModuleList);
 314         if (!strcmpiW( name, mod->FullDllName.Buffer ))
 315         {
 316             cached_modref = CONTAINING_RECORD(mod, WINE_MODREF, ldr);
 317             return cached_modref;
 318         }
 319     }
 320     return NULL;
 321 }
 322
 323
 324 /*************************************************************************
 325  *              find_forwarded_export
 326  *
 327  * Find the final function pointer for a forwarded function.
 328  * The loader_section must be locked while calling this function.
 329  */
 330 static FARPROC find_forwarded_export( HMODULE module, const char *forward )
 331 {
 332     const IMAGE_EXPORT_DIRECTORY *exports;
 333     DWORD exp_size;
 334     WINE_MODREF *wm;
 335     WCHAR mod_name[32];
 336     const char *end = strrchr(forward, '.');
 337     FARPROC proc = NULL;
 338
 339     if (!end) return NULL;
 340     if ((end - forward) * sizeof(WCHAR) >= sizeof(mod_name)) return NULL;
 341     ascii_to_unicode( mod_name, forward, end - forward );
 342     mod_name[end - forward] = 0;
 343     if (!strchrW( mod_name, '.' ))
 344     {
 345         if ((end - forward) * sizeof(WCHAR) >= sizeof(mod_name) - sizeof(dllW)) return NULL;
 346         memcpy( mod_name + (end - forward), dllW, sizeof(dllW) );
 347     }
 348
 349     if (!(wm = find_basename_module( mod_name )))
 350     {
 351         ERR("module not found for forward '%s' used by %s\n",
 352             forward, debugstr_w(get_modref(module)->ldr.FullDllName.Buffer) );
 353         return NULL;
 354     }
 355     if ((exports = RtlImageDirectoryEntryToData( wm->ldr.BaseAddress, TRUE,
 356                                                  IMAGE_DIRECTORY_ENTRY_EXPORT, &exp_size )))
 357         proc = find_named_export( wm->ldr.BaseAddress, exports, exp_size, end + 1, -1 );
 358
 359     if (!proc)
 360     {
 361         ERR("function not found for forward '%s' used by %s."
 362             " If you are using builtin %s, try using the native one instead.\n",
 363             forward, debugstr_w(get_modref(module)->ldr.FullDllName.Buffer),
 364             debugstr_w(get_modref(module)->ldr.BaseDllName.Buffer) );
 365     }
 366     return proc;
 367 }
 368
 369
 370 /*************************************************************************
 371  *              find_ordinal_export
 372  *
 373  * Find an exported function by ordinal.
 374  * The exports base must have been subtracted from the ordinal already.
 375  * The loader_section must be locked while calling this function.
 376  */
 377 static FARPROC find_ordinal_export( HMODULE module, const IMAGE_EXPORT_DIRECTORY *exports,
 378                                     DWORD exp_size, DWORD ordinal )
 379 {
 380     FARPROC proc;
 381     const DWORD *functions = get_rva( module, exports->AddressOfFunctions );
 382
 383     if (ordinal >= exports->NumberOfFunctions)
 384     {
 385         TRACE(" ordinal %d out of range!\n", ordinal + exports->Base );
 386         return NULL;
 387     }
 388     if (!functions[ordinal]) return NULL;
 389
 390     proc = get_rva( module, functions[ordinal] );
 391
 392     /* if the address falls into the export dir, it's a forward */
 393     if (((const char *)proc >= (const char *)exports) &&
 394         ((const char *)proc < (const char *)exports + exp_size))
 395         return find_forwarded_export( module, (const char *)proc );
 396
 397     if (TRACE_ON(snoop))
 398     {
 399         const WCHAR *user = current_modref ? current_modref->ldr.BaseDllName.Buffer : NULL;
 400         proc = SNOOP_GetProcAddress( module, exports, exp_size, proc, ordinal, user );
 401     }
 402     if (TRACE_ON(relay))
 403     {
 404         const WCHAR *user = current_modref ? current_modref->ldr.BaseDllName.Buffer : NULL;
 405         proc = RELAY_GetProcAddress( module, exports, exp_size, proc, ordinal, user );
 406     }
 407     return proc;
 408 }
 409
 410
 411 /*************************************************************************
 412  *              find_named_export
 413  *
 414  * Find an exported function by name.
 415  * The loader_section must be locked while calling this function.
 416  */
 417 static FARPROC find_named_export( HMODULE module, const IMAGE_EXPORT_DIRECTORY *exports,
 418                                   DWORD exp_size, const char *name, int hint )
 419 {
 420     const WORD *ordinals = get_rva( module, exports->AddressOfNameOrdinals );
 421     const DWORD *names = get_rva( module, exports->AddressOfNames );
 422     int min = 0, max = exports->NumberOfNames - 1;
 423
 424     /* first check the hint */
 425     if (hint >= 0 && hint <= max)
 426     {
 427         char *ename = get_rva( module, names[hint] );
 428         if (!strcmp( ename, name ))
 429             return find_ordinal_export( module, exports, exp_size, ordinals[hint] );
 430     }
 431
 432     /* then do a binary search */
 433     while (min <= max)
 434     {
 435         int res, pos = (min + max) / 2;
 436         char *ename = get_rva( module, names[pos] );
 437         if (!(res = strcmp( ename, name )))
 438             return find_ordinal_export( module, exports, exp_size, ordinals[pos] );
 439         if (res > 0) max = pos - 1;
 440         else min = pos + 1;
 441     }
 442     return NULL;
 443
 444 }
 445
 446
 447 /*************************************************************************
 448  *              import_dll
 449  *
 450  * Import the dll specified by the given import descriptor.
 451  * The loader_section must be locked while calling this function.
 452  */
 453 static WINE_MODREF *import_dll( HMODULE module, const IMAGE_IMPORT_DESCRIPTOR *descr, LPCWSTR load_path )
 454 {
 455     NTSTATUS status;
 456     WINE_MODREF *wmImp;
 457     HMODULE imp_mod;
 458     const IMAGE_EXPORT_DIRECTORY *exports;
 459     DWORD exp_size;
 460     const IMAGE_THUNK_DATA *import_list;
 461     IMAGE_THUNK_DATA *thunk_list;
 462     WCHAR buffer[32];
 463     const char *name = get_rva( module, descr->Name );
 464     DWORD len = strlen(name);
 465     PVOID protect_base;
 466     SIZE_T protect_size = 0;
 467     DWORD protect_old;
 468
 469     thunk_list = get_rva( module, (DWORD)descr->FirstThunk );
 470     if (descr->u.OriginalFirstThunk)
 471         import_list = get_rva( module, (DWORD)descr->u.OriginalFirstThunk );
 472     else
 473         import_list = thunk_list;
 474
 475     while (len && name[len-1] == ' ') len--;  /* remove trailing spaces */
 476
 477     if (len * sizeof(WCHAR) < sizeof(buffer))
 478     {
 479         ascii_to_unicode( buffer, name, len );
 480         buffer[len] = 0;
 481         status = load_dll( load_path, buffer, 0, &wmImp );
 482     }
 483     else  /* need to allocate a larger buffer */
 484     {
 485         WCHAR *ptr = RtlAllocateHeap( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) );
 486         if (!ptr) return NULL;
 487         ascii_to_unicode( ptr, name, len );
 488         ptr[len] = 0;
 489         status = load_dll( load_path, ptr, 0, &wmImp );
 490         RtlFreeHeap( GetProcessHeap(), 0, ptr );
 491     }
 492
 493     if (status)
 494     {
 495         if (status == STATUS_DLL_NOT_FOUND)
 496             ERR("Library %s (which is needed by %s) not found\n",
 497                 name, debugstr_w(current_modref->ldr.FullDllName.Buffer));
 498         else
 499             ERR("Loading library %s (which is needed by %s) failed (error %x).\n",
 500                 name, debugstr_w(current_modref->ldr.FullDllName.Buffer), status);
 501         return NULL;
 502     }
 503
 504     /* unprotect the import address table since it can be located in
 505      * readonly section */
 506     while (import_list[protect_size].u1.Ordinal) protect_size++;
 507     protect_base = thunk_list;
 508     protect_size *= sizeof(*thunk_list);
 509     NtProtectVirtualMemory( NtCurrentProcess(), &protect_base,
 510                             &protect_size, PAGE_WRITECOPY, &protect_old );
 511
 512     imp_mod = wmImp->ldr.BaseAddress;
 513     exports = RtlImageDirectoryEntryToData( imp_mod, TRUE, IMAGE_DIRECTORY_ENTRY_EXPORT, &exp_size );
 514
 515     if (!exports)
 516     {
 517         /* set all imported function to deadbeef */
 518         while (import_list->u1.Ordinal)
 519         {
 520             if (IMAGE_SNAP_BY_ORDINAL(import_list->u1.Ordinal))
 521             {
 522                 int ordinal = IMAGE_ORDINAL(import_list->u1.Ordinal);
 523                 WARN("No implementation for %s.%d", name, ordinal );
 524                 thunk_list->u1.Function = allocate_stub( name, IntToPtr(ordinal) );
 525             }
 526             else
 527             {
 528                 IMAGE_IMPORT_BY_NAME *pe_name = get_rva( module, (DWORD)import_list->u1.AddressOfData );
 529                 WARN("No implementation for %s.%s", name, pe_name->Name );
 530                 thunk_list->u1.Function = allocate_stub( name, (const char*)pe_name->Name );
 531             }
 532             WARN(" imported from %s, allocating stub %p\n",
 533                  debugstr_w(current_modref->ldr.FullDllName.Buffer),
 534                  (void *)thunk_list->u1.Function );
 535             import_list++;
 536             thunk_list++;
 537         }
 538         goto done;
 539     }
 540
 541     while (import_list->u1.Ordinal)
 542     {
 543         if (IMAGE_SNAP_BY_ORDINAL(import_list->u1.Ordinal))
 544         {
 545             int ordinal = IMAGE_ORDINAL(import_list->u1.Ordinal);
 546
 547             thunk_list->u1.Function = (ULONG_PTR)find_ordinal_export( imp_mod, exports, exp_size,
 548                                                                       ordinal - exports->Base );
 549             if (!thunk_list->u1.Function)
 550             {
 551                 thunk_list->u1.Function = allocate_stub( name, IntToPtr(ordinal) );
 552                 WARN("No implementation for %s.%d imported from %s, setting to %p\n",
 553                      name, ordinal, debugstr_w(current_modref->ldr.FullDllName.Buffer),
 554                      (void *)thunk_list->u1.Function );
 555             }
 556             TRACE_(imports)("--- Ordinal %s.%d = %p\n", name, ordinal, (void *)thunk_list->u1.Function );
 557         }
 558         else  /* import by name */
 559         {
 560             IMAGE_IMPORT_BY_NAME *pe_name;
 561             pe_name = get_rva( module, (DWORD)import_list->u1.AddressOfData );
 562             thunk_list->u1.Function = (ULONG_PTR)find_named_export( imp_mod, exports, exp_size,
 563                                                                     (const char*)pe_name->Name, pe_name->Hint );
 564             if (!thunk_list->u1.Function)
 565             {
 566                 thunk_list->u1.Function = allocate_stub( name, (const char*)pe_name->Name );
 567                 WARN("No implementation for %s.%s imported from %s, setting to %p\n",
 568                      name, pe_name->Name, debugstr_w(current_modref->ldr.FullDllName.Buffer),
 569                      (void *)thunk_list->u1.Function );
 570             }
 571             TRACE_(imports)("--- %s %s.%d = %p\n",
 572                             pe_name->Name, name, pe_name->Hint, (void *)thunk_list->u1.Function);
 573         }
 574         import_list++;
 575         thunk_list++;
 576     }
 577
 578 done:
 579     /* restore old protection of the import address table */
 580     NtProtectVirtualMemory( NtCurrentProcess(), &protect_base, &protect_size, protect_old, NULL );
 581     return wmImp;
 582 }
 583
 584
 585 /***********************************************************************
 586  *           create_module_activation_context
 587  */
 588 static NTSTATUS create_module_activation_context( LDR_MODULE *module )
 589 {
 590     NTSTATUS status;
 591     LDR_RESOURCE_INFO info;
 592     const IMAGE_RESOURCE_DATA_ENTRY *entry;
 593
 594     info.Type = RT_MANIFEST;
 595     info.Name = ISOLATIONAWARE_MANIFEST_RESOURCE_ID;
 596     info.Language = 0;
 597     if (!(status = LdrFindResource_U( module->BaseAddress, &info, 3, &entry )))
 598     {
 599         ACTCTXW ctx;
 600         ctx.cbSize   = sizeof(ctx);
 601         ctx.lpSource = NULL;
 602         ctx.dwFlags  = ACTCTX_FLAG_RESOURCE_NAME_VALID | ACTCTX_FLAG_HMODULE_VALID;
 603         ctx.hModule  = module->BaseAddress;
 604         ctx.lpResourceName = (LPCWSTR)ISOLATIONAWARE_MANIFEST_RESOURCE_ID;
 605         status = RtlCreateActivationContext( &module->ActivationContext, &ctx );
 606     }
 607     return status;
 608 }
 609
 610
 611 /****************************************************************
 612  *       fixup_imports
 613  *
 614  * Fixup all imports of a given module.
 615  * The loader_section must be locked while calling this function.
 616  */
 617 static NTSTATUS fixup_imports( WINE_MODREF *wm, LPCWSTR load_path )
 618 {
 619     int i, nb_imports;
 620     const IMAGE_IMPORT_DESCRIPTOR *imports;
 621     WINE_MODREF *prev;
 622     DWORD size;
 623     NTSTATUS status;
 624
 625     if (!(wm->ldr.Flags & LDR_DONT_RESOLVE_REFS)) return STATUS_SUCCESS;  /* already done */
 626     wm->ldr.Flags &= ~LDR_DONT_RESOLVE_REFS;
 627     create_module_activation_context( &wm->ldr );
 628
 629     if (!(imports = RtlImageDirectoryEntryToData( wm->ldr.BaseAddress, TRUE,
 630                                                   IMAGE_DIRECTORY_ENTRY_IMPORT, &size )))
 631         return STATUS_SUCCESS;
 632
 633     nb_imports = 0;
 634     while (imports[nb_imports].Name && imports[nb_imports].FirstThunk) nb_imports++;
 635
 636     if (!nb_imports) return STATUS_SUCCESS;  /* no imports */
 637
 638     /* Allocate module dependency list */
 639     wm->nDeps = nb_imports;
 640     wm->deps  = RtlAllocateHeap( GetProcessHeap(), 0, nb_imports*sizeof(WINE_MODREF *) );
 641
 642     /* load the imported modules. They are automatically
 643      * added to the modref list of the process.
 644      */
 645     prev = current_modref;
 646     current_modref = wm;
 647     status = STATUS_SUCCESS;
 648     for (i = 0; i < nb_imports; i++)
 649     {
 650         if (!(wm->deps[i] = import_dll( wm->ldr.BaseAddress, &imports[i], load_path )))
 651             status = STATUS_DLL_NOT_FOUND;
 652     }
 653     current_modref = prev;
 654     return status;
 655 }
 656
 657
 658 /*************************************************************************
 659  *              alloc_module
 660  *
 661  * Allocate a WINE_MODREF structure and add it to the process list
 662  * The loader_section must be locked while calling this function.
 663  */
 664 static WINE_MODREF *alloc_module( HMODULE hModule, LPCWSTR filename )
 665 {
 666     WINE_MODREF *wm;
 667     const WCHAR *p;
 668     const IMAGE_NT_HEADERS *nt = RtlImageNtHeader(hModule);
 669     PLIST_ENTRY entry, mark;
 670
 671     if (!(wm = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*wm) ))) return NULL;
 672
 673     wm->nDeps    = 0;
 674     wm->deps     = NULL;
 675
 676     wm->ldr.BaseAddress   = hModule;
 677     wm->ldr.EntryPoint    = NULL;
 678     wm->ldr.SizeOfImage   = nt->OptionalHeader.SizeOfImage;
 679     wm->ldr.Flags         = LDR_DONT_RESOLVE_REFS;
 680     wm->ldr.LoadCount     = 1;
 681     wm->ldr.TlsIndex      = -1;
 682     wm->ldr.SectionHandle = NULL;
 683     wm->ldr.CheckSum      = 0;
 684     wm->ldr.TimeDateStamp = 0;
 685     wm->ldr.ActivationContext = 0;
 686
 687     RtlCreateUnicodeString( &wm->ldr.FullDllName, filename );
 688     if ((p = strrchrW( wm->ldr.FullDllName.Buffer, '\\' ))) p++;
 689     else p = wm->ldr.FullDllName.Buffer;
 690     RtlInitUnicodeString( &wm->ldr.BaseDllName, p );
 691
 692     if (nt->FileHeader.Characteristics & IMAGE_FILE_DLL)
 693     {
 694         wm->ldr.Flags |= LDR_IMAGE_IS_DLL;
 695         if (nt->OptionalHeader.AddressOfEntryPoint)
 696             wm->ldr.EntryPoint = (char *)hModule + nt->OptionalHeader.AddressOfEntryPoint;
 697     }
 698
 699     InsertTailList(&NtCurrentTeb()->Peb->LdrData->InLoadOrderModuleList,
 700                    &wm->ldr.InLoadOrderModuleList);
 701
 702     /* insert module in MemoryList, sorted in increasing base addresses */
 703     mark = &NtCurrentTeb()->Peb->LdrData->InMemoryOrderModuleList;
 704     for (entry = mark->Flink; entry != mark; entry = entry->Flink)
 705     {
 706         if (CONTAINING_RECORD(entry, LDR_MODULE, InMemoryOrderModuleList)->BaseAddress > wm->ldr.BaseAddress)
 707             break;
 708     }
 709     entry->Blink->Flink = &wm->ldr.InMemoryOrderModuleList;
 710     wm->ldr.InMemoryOrderModuleList.Blink = entry->Blink;
 711     wm->ldr.InMemoryOrderModuleList.Flink = entry;
 712     entry->Blink = &wm->ldr.InMemoryOrderModuleList;
 713
 714     /* wait until init is called for inserting into this list */
 715     wm->ldr.InInitializationOrderModuleList.Flink = NULL;
 716     wm->ldr.InInitializationOrderModuleList.Blink = NULL;
 717
 718     if (!(nt->OptionalHeader.DllCharacteristics & IMAGE_DLLCHARACTERISTICS_NX_COMPAT))
 719     {
 720         WARN( "disabling no-exec because of %s\n", debugstr_w(wm->ldr.BaseDllName.Buffer) );
 721         VIRTUAL_SetForceExec( TRUE );
 722     }
 723     return wm;
 724 }
 725
 726
 727 /*************************************************************************
 728  *              alloc_process_tls
 729  *
 730  * Allocate the process-wide structure for module TLS storage.
 731  */
 732 static NTSTATUS alloc_process_tls(void)
 733 {
 734     PLIST_ENTRY mark, entry;
 735     PLDR_MODULE mod;
 736     const IMAGE_TLS_DIRECTORY *dir;
 737     ULONG size, i;
 738
 739     mark = &NtCurrentTeb()->Peb->LdrData->InMemoryOrderModuleList;
 740     for (entry = mark->Flink; entry != mark; entry = entry->Flink)
 741     {
 742         mod = CONTAINING_RECORD(entry, LDR_MODULE, InMemoryOrderModuleList);
 743         if (!(dir = RtlImageDirectoryEntryToData( mod->BaseAddress, TRUE,
 744                                                   IMAGE_DIRECTORY_ENTRY_TLS, &size )))
 745             continue;
 746         size = (dir->EndAddressOfRawData - dir->StartAddressOfRawData) + dir->SizeOfZeroFill;
 747         if (!size) continue;
 748         tls_total_size += size;
 749         tls_module_count++;
 750     }
 751     if (!tls_module_count) return STATUS_SUCCESS;
 752
 753     TRACE( "count %u size %u\n", tls_module_count, tls_total_size );
 754
 755     tls_dirs = RtlAllocateHeap( GetProcessHeap(), 0, tls_module_count * sizeof(*tls_dirs) );
 756     if (!tls_dirs) return STATUS_NO_MEMORY;
 757
 758     for (i = 0, entry = mark->Flink; entry != mark; entry = entry->Flink)
 759     {
 760         mod = CONTAINING_RECORD(entry, LDR_MODULE, InMemoryOrderModuleList);
 761         if (!(dir = RtlImageDirectoryEntryToData( mod->BaseAddress, TRUE,
 762                                                   IMAGE_DIRECTORY_ENTRY_TLS, &size )))
 763             continue;
 764         tls_dirs[i] = dir;
 765         *(DWORD *)dir->AddressOfIndex = i;
 766         mod->TlsIndex = i;
 767         mod->LoadCount = -1;  /* can't unload it */
 768         i++;
 769     }
 770     return STATUS_SUCCESS;
 771 }
 772
 773
 774 /*************************************************************************
 775  *              alloc_thread_tls
 776  *
 777  * Allocate the per-thread structure for module TLS storage.
 778  */
 779 static NTSTATUS alloc_thread_tls(void)
 780 {
 781     void **pointers;
 782     char *data;
 783     UINT i;
 784
 785     if (!tls_module_count) return STATUS_SUCCESS;
 786
 787     if (!(pointers = RtlAllocateHeap( GetProcessHeap(), 0,
 788                                       tls_module_count * sizeof(*pointers) )))
 789         return STATUS_NO_MEMORY;
 790
 791     if (!(data = RtlAllocateHeap( GetProcessHeap(), 0, tls_total_size )))
 792     {
 793         RtlFreeHeap( GetProcessHeap(), 0, pointers );
 794         return STATUS_NO_MEMORY;
 795     }
 796
 797     for (i = 0; i < tls_module_count; i++)
 798     {
 799         const IMAGE_TLS_DIRECTORY *dir = tls_dirs[i];
 800         ULONG size = dir->EndAddressOfRawData - dir->StartAddressOfRawData;
 801
 802         TRACE( "thread %04x idx %d: %d/%d bytes from %p to %p\n",
 803                GetCurrentThreadId(), i, size, dir->SizeOfZeroFill,
 804                (void *)dir->StartAddressOfRawData, data );
 805
 806         pointers[i] = data;
 807         memcpy( data, (void *)dir->StartAddressOfRawData, size );
 808         data += size;
 809         memset( data, 0, dir->SizeOfZeroFill );
 810         data += dir->SizeOfZeroFill;
 811     }
 812     NtCurrentTeb()->ThreadLocalStoragePointer = pointers;
 813     return STATUS_SUCCESS;
 814 }
 815
 816
 817 /*************************************************************************
 818  *              call_tls_callbacks
 819  */
 820 static void call_tls_callbacks( HMODULE module, UINT reason )
 821 {
 822     const IMAGE_TLS_DIRECTORY *dir;
 823     const PIMAGE_TLS_CALLBACK *callback;
 824     ULONG dirsize;
 825
 826     dir = RtlImageDirectoryEntryToData( module, TRUE, IMAGE_DIRECTORY_ENTRY_TLS, &dirsize );
 827     if (!dir || !dir->AddressOfCallBacks) return;
 828
 829     for (callback = (const PIMAGE_TLS_CALLBACK *)dir->AddressOfCallBacks; *callback; callback++)
 830     {
 831         if (TRACE_ON(relay))
 832             DPRINTF("%04x:Call TLS callback (proc=%p,module=%p,reason=%s,reserved=0)\n",
 833                     GetCurrentThreadId(), *callback, module, reason_names[reason] );
 834         __TRY
 835         {
 836             (*callback)( module, reason, NULL );
 837         }
 838         __EXCEPT(NULL)
 839         {
 840             if (TRACE_ON(relay))
 841                 DPRINTF("%04x:exception in TLS callback (proc=%p,module=%p,reason=%s,reserved=0)\n",
 842                         GetCurrentThreadId(), callback, module, reason_names[reason] );
 843             return;
 844         }
 845         __ENDTRY
 846         if (TRACE_ON(relay))
 847             DPRINTF("%04x:Ret  TLS callback (proc=%p,module=%p,reason=%s,reserved=0)\n",
 848                     GetCurrentThreadId(), *callback, module, reason_names[reason] );
 849     }
 850 }
 851
 852
 853 /*************************************************************************
 854  *              MODULE_InitDLL
 855  */
 856 static BOOL MODULE_InitDLL( WINE_MODREF *wm, UINT reason, LPVOID lpReserved )
 857 {
 858     WCHAR mod_name[32];
 859     BOOL retv = TRUE;
 860     DLLENTRYPROC entry = wm->ldr.EntryPoint;
 861     void *module = wm->ldr.BaseAddress;
 862
 863     /* Skip calls for modules loaded with special load flags */
 864
 865     if (wm->ldr.Flags & LDR_DONT_RESOLVE_REFS) return TRUE;
 866     if (wm->ldr.TlsIndex != -1) call_tls_callbacks( wm->ldr.BaseAddress, reason );
 867     if (!entry) return TRUE;
 868
 869     if (TRACE_ON(relay))
 870     {
 871         size_t len = min( wm->ldr.BaseDllName.Length, sizeof(mod_name)-sizeof(WCHAR) );
 872         memcpy( mod_name, wm->ldr.BaseDllName.Buffer, len );
 873         mod_name[len / sizeof(WCHAR)] = 0;
 874         DPRINTF("%04x:Call PE DLL (proc=%p,module=%p %s,reason=%s,res=%p)\n",
 875                 GetCurrentThreadId(), entry, module, debugstr_w(mod_name),
 876                 reason_names[reason], lpReserved );
 877     }
 878     else TRACE("(%p %s,%s,%p) - CALL\n", module, debugstr_w(wm->ldr.BaseDllName.Buffer),
 879                reason_names[reason], lpReserved );
 880
 881     retv = call_dll_entry_point( entry, module, reason, lpReserved );
 882
 883     /* The state of the module list may have changed due to the call
 884        to the dll. We cannot assume that this module has not been
 885        deleted.  */
 886     if (TRACE_ON(relay))
 887         DPRINTF("%04x:Ret  PE DLL (proc=%p,module=%p %s,reason=%s,res=%p) retval=%x\n",
 888                 GetCurrentThreadId(), entry, module, debugstr_w(mod_name),
 889                 reason_names[reason], lpReserved, retv );
 890     else TRACE("(%p,%s,%p) - RETURN %d\n", module, reason_names[reason], lpReserved, retv );
 891
 892     return retv;
 893 }
 894
 895
 896 /*************************************************************************
 897  *              process_attach
 898  *
 899  * Send the process attach notification to all DLLs the given module
 900  * depends on (recursively). This is somewhat complicated due to the fact that
 901  *
 902  * - we have to respect the module dependencies, i.e. modules implicitly
 903  *   referenced by another module have to be initialized before the module
 904  *   itself can be initialized
 905  *
 906  * - the initialization routine of a DLL can itself call LoadLibrary,
 907  *   thereby introducing a whole new set of dependencies (even involving
 908  *   the 'old' modules) at any time during the whole process
 909  *
 910  * (Note that this routine can be recursively entered not only directly
 911  *  from itself, but also via LoadLibrary from one of the called initialization
 912  *  routines.)
 913  *
 914  * Furthermore, we need to rearrange the main WINE_MODREF list to allow
 915  * the process *detach* notifications to be sent in the correct order.
 916  * This must not only take into account module dependencies, but also
 917  * 'hidden' dependencies created by modules calling LoadLibrary in their
 918  * attach notification routine.
 919  *
 920  * The strategy is rather simple: we move a WINE_MODREF to the head of the
 921  * list after the attach notification has returned.  This implies that the
 922  * detach notifications are called in the reverse of the sequence the attach
 923  * notifications *returned*.
 924  *
 925  * The loader_section must be locked while calling this function.
 926  */
 927 static NTSTATUS process_attach( WINE_MODREF *wm, LPVOID lpReserved )
 928 {
 929     NTSTATUS status = STATUS_SUCCESS;
 930     int i;
 931
 932     if (process_detaching) return status;
 933
 934     /* prevent infinite recursion in case of cyclical dependencies */
 935     if (    ( wm->ldr.Flags & LDR_LOAD_IN_PROGRESS )
 936          || ( wm->ldr.Flags & LDR_PROCESS_ATTACHED ) )
 937         return status;
 938
 939     TRACE("(%s,%p) - START\n", debugstr_w(wm->ldr.BaseDllName.Buffer), lpReserved );
 940
 941     /* Tag current MODREF to prevent recursive loop */
 942     wm->ldr.Flags |= LDR_LOAD_IN_PROGRESS;
 943
 944     /* Recursively attach all DLLs this one depends on */
 945     for ( i = 0; i < wm->nDeps; i++ )
 946     {
 947         if (!wm->deps[i]) continue;
 948         if ((status = process_attach( wm->deps[i], lpReserved )) != STATUS_SUCCESS) break;
 949     }
 950
 951     /* Call DLL entry point */
 952     if (status == STATUS_SUCCESS)
 953     {
 954         WINE_MODREF *prev = current_modref;
 955         current_modref = wm;
 956         if (MODULE_InitDLL( wm, DLL_PROCESS_ATTACH, lpReserved ))
 957         {
 958             wm->ldr.Flags |= LDR_PROCESS_ATTACHED;
 959         }
 960         else
 961         {
 962             /* point to the name so LdrInitializeThunk can print it */
 963             last_failed_modref = wm;
 964             WARN("Initialization of %s failed\n", debugstr_w(wm->ldr.BaseDllName.Buffer));
 965             status = STATUS_DLL_INIT_FAILED;
 966         }
 967         current_modref = prev;
 968     }
 969
 970     if (!wm->ldr.InInitializationOrderModuleList.Flink)
 971         InsertTailList(&NtCurrentTeb()->Peb->LdrData->InInitializationOrderModuleList,
 972                        &wm->ldr.InInitializationOrderModuleList);
 973
 974     /* Remove recursion flag */
 975     wm->ldr.Flags &= ~LDR_LOAD_IN_PROGRESS;
 976
 977     TRACE("(%s,%p) - END\n", debugstr_w(wm->ldr.BaseDllName.Buffer), lpReserved );
 978     return status;
 979 }
 980
 981
 982 /**********************************************************************
 983  *          attach_implicitly_loaded_dlls
 984  *
 985  * Attach to the (builtin) dlls that have been implicitly loaded because
 986  * of a dependency at the Unix level, but not imported at the Win32 level.
 987  */
 988 static void attach_implicitly_loaded_dlls( LPVOID reserved )
 989 {
 990     for (;;)
 991     {
 992         PLIST_ENTRY mark, entry;
 993
 994         mark = &NtCurrentTeb()->Peb->LdrData->InLoadOrderModuleList;
 995         for (entry = mark->Flink; entry != mark; entry = entry->Flink)
 996         {
 997             LDR_MODULE *mod = CONTAINING_RECORD(entry, LDR_MODULE, InLoadOrderModuleList);
 998
 999             if (mod->Flags & (LDR_LOAD_IN_PROGRESS | LDR_PROCESS_ATTACHED)) continue;
1000             TRACE( "found implicitly loaded %s, attaching to it\n",
1001                    debugstr_w(mod->BaseDllName.Buffer));
1002             mod->LoadCount = -1;  /* we can't unload it anyway */
1003             process_attach( CONTAINING_RECORD(mod, WINE_MODREF, ldr), reserved );
1004             break;  /* restart the search from the start */
1005         }
1006         if (entry == mark) break;  /* nothing found */
1007     }
1008 }
1009
1010
1011 /*************************************************************************
1012  *              process_detach
1013  *
1014  * Send DLL process detach notifications.  See the comment about calling
1015  * sequence at process_attach.  Unless the bForceDetach flag
1016  * is set, only DLLs with zero refcount are notified.
1017  */
1018 static void process_detach( BOOL bForceDetach, LPVOID lpReserved )
1019 {
1020     PLIST_ENTRY mark, entry;
1021     PLDR_MODULE mod;
1022
1023     RtlEnterCriticalSection( &loader_section );
1024     if (bForceDetach) process_detaching = 1;
1025     mark = &NtCurrentTeb()->Peb->LdrData->InInitializationOrderModuleList;
1026     do
1027     {
1028         for (entry = mark->Blink; entry != mark; entry = entry->Blink)
1029         {
1030             mod = CONTAINING_RECORD(entry, LDR_MODULE,
1031                                     InInitializationOrderModuleList);
1032             /* Check whether to detach this DLL */
1033             if ( !(mod->Flags & LDR_PROCESS_ATTACHED) )
1034                 continue;
1035             if ( mod->LoadCount && !bForceDetach )
1036                 continue;
1037
1038             /* Call detach notification */
1039             mod->Flags &= ~LDR_PROCESS_ATTACHED;
1040             MODULE_InitDLL( CONTAINING_RECORD(mod, WINE_MODREF, ldr),
1041                             DLL_PROCESS_DETACH, lpReserved );
1042
1043             /* Restart at head of WINE_MODREF list, as entries might have
1044                been added and/or removed while performing the call ... */
1045             break;
1046         }
1047     } while (entry != mark);
1048
1049     RtlLeaveCriticalSection( &loader_section );
1050 }
1051
1052 /*************************************************************************
1053  *              MODULE_DllThreadAttach
1054  *
1055  * Send DLL thread attach notifications. These are sent in the
1056  * reverse sequence of process detach notification.
1057  *
1058  */
1059 NTSTATUS MODULE_DllThreadAttach( LPVOID lpReserved )
1060 {
1061     PLIST_ENTRY mark, entry;
1062     PLDR_MODULE mod;
1063     NTSTATUS    status;
1064
1065     /* don't do any attach calls if process is exiting */
1066     if (process_detaching) return STATUS_SUCCESS;
1067     /* FIXME: there is still a race here */
1068
1069     RtlEnterCriticalSection( &loader_section );
1070
1071     if ((status = alloc_thread_tls()) != STATUS_SUCCESS) goto done;
1072
1073     mark = &NtCurrentTeb()->Peb->LdrData->InInitializationOrderModuleList;
1074     for (entry = mark->Flink; entry != mark; entry = entry->Flink)
1075     {
1076         mod = CONTAINING_RECORD(entry, LDR_MODULE,
1077                                 InInitializationOrderModuleList);
1078         if ( !(mod->Flags & LDR_PROCESS_ATTACHED) )
1079             continue;
1080         if ( mod->Flags & LDR_NO_DLL_CALLS )
1081             continue;
1082
1083         MODULE_InitDLL( CONTAINING_RECORD(mod, WINE_MODREF, ldr),
1084                         DLL_THREAD_ATTACH, lpReserved );
1085     }
1086
1087 done:
1088     RtlLeaveCriticalSection( &loader_section );
1089     return status;
1090 }
1091
1092 /******************************************************************
1093  *              LdrDisableThreadCalloutsForDll (NTDLL.@)
1094  *
1095  */
1096 NTSTATUS WINAPI LdrDisableThreadCalloutsForDll(HMODULE hModule)
1097 {
1098     WINE_MODREF *wm;
1099     NTSTATUS    ret = STATUS_SUCCESS;
1100
1101     RtlEnterCriticalSection( &loader_section );
1102
1103     wm = get_modref( hModule );
1104     if (!wm || wm->ldr.TlsIndex != -1)
1105         ret = STATUS_DLL_NOT_FOUND;
1106     else
1107         wm->ldr.Flags |= LDR_NO_DLL_CALLS;
1108
1109     RtlLeaveCriticalSection( &loader_section );
1110
1111     return ret;
1112 }
1113
1114 /******************************************************************
1115  *              LdrFindEntryForAddress (NTDLL.@)
1116  *
1117  * The loader_section must be locked while calling this function
1118  */
1119 NTSTATUS WINAPI LdrFindEntryForAddress(const void* addr, PLDR_MODULE* pmod)
1120 {
1121     PLIST_ENTRY mark, entry;
1122     PLDR_MODULE mod;
1123
1124     mark = &NtCurrentTeb()->Peb->LdrData->InMemoryOrderModuleList;
1125     for (entry = mark->Flink; entry != mark; entry = entry->Flink)
1126     {
1127         mod = CONTAINING_RECORD(entry, LDR_MODULE, InMemoryOrderModuleList);
1128         if ((const void *)mod->BaseAddress <= addr &&
1129             (const char *)addr < (char*)mod->BaseAddress + mod->SizeOfImage)
1130         {
1131             *pmod = mod;
1132             return STATUS_SUCCESS;
1133         }
1134         if ((const void *)mod->BaseAddress > addr) break;
1135     }
1136     return STATUS_NO_MORE_ENTRIES;
1137 }
1138
1139 /******************************************************************
1140  *              LdrLockLoaderLock  (NTDLL.@)
1141  *
1142  * Note: flags are not implemented.
1143  * Flag 0x01 is used to raise exceptions on errors.
1144  * Flag 0x02 is used to avoid waiting on the section (does RtlTryEnterCriticalSection instead).
1145  */
1146 NTSTATUS WINAPI LdrLockLoaderLock( ULONG flags, ULONG *result, ULONG *magic )
1147 {
1148     if (flags) FIXME( "flags %x not supported\n", flags );
1149
1150     if (result) *result = 1;
1151     if (!magic) return STATUS_INVALID_PARAMETER_3;
1152     RtlEnterCriticalSection( &loader_section );
1153     *magic = GetCurrentThreadId();
1154     return STATUS_SUCCESS;
1155 }
1156
1157
1158 /******************************************************************
1159  *              LdrUnlockLoaderUnlock  (NTDLL.@)
1160  */
1161 NTSTATUS WINAPI LdrUnlockLoaderLock( ULONG flags, ULONG magic )
1162 {
1163     if (magic)
1164     {
1165         if (magic != GetCurrentThreadId()) return STATUS_INVALID_PARAMETER_2;
1166         RtlLeaveCriticalSection( &loader_section );
1167     }
1168     return STATUS_SUCCESS;
1169 }
1170
1171
1172 /******************************************************************
1173  *              LdrGetProcedureAddress  (NTDLL.@)
1174  */
1175 NTSTATUS WINAPI LdrGetProcedureAddress(HMODULE module, const ANSI_STRING *name,
1176                                        ULONG ord, PVOID *address)
1177 {
1178     IMAGE_EXPORT_DIRECTORY *exports;
1179     DWORD exp_size;
1180     NTSTATUS ret = STATUS_PROCEDURE_NOT_FOUND;
1181
1182     RtlEnterCriticalSection( &loader_section );
1183
1184     /* check if the module itself is invalid to return the proper error */
1185     if (!get_modref( module )) ret = STATUS_DLL_NOT_FOUND;
1186     else if ((exports = RtlImageDirectoryEntryToData( module, TRUE,
1187                                                       IMAGE_DIRECTORY_ENTRY_EXPORT, &exp_size )))
1188     {
1189         void *proc = name ? find_named_export( module, exports, exp_size, name->Buffer, -1 )
1190                           : find_ordinal_export( module, exports, exp_size, ord - exports->Base );
1191         if (proc)
1192         {
1193             *address = proc;
1194             ret = STATUS_SUCCESS;
1195         }
1196     }
1197
1198     RtlLeaveCriticalSection( &loader_section );
1199     return ret;
1200 }
1201
1202
1203 /***********************************************************************
1204  *           is_fake_dll
1205  *
1206  * Check if a loaded native dll is a Wine fake dll.
1207  */
1208 static BOOL is_fake_dll( const void *base )
1209 {
1210     static const char fakedll_signature[] = "Wine placeholder DLL";
1211     const IMAGE_DOS_HEADER *dos = base;
1212
1213     if (dos->e_lfanew >= sizeof(*dos) + sizeof(fakedll_signature) &&
1214         !memcmp( dos + 1, fakedll_signature, sizeof(fakedll_signature) )) return TRUE;
1215     return FALSE;
1216 }
1217
1218
1219 /***********************************************************************
1220  *           get_builtin_fullname
1221  *
1222  * Build the full pathname for a builtin dll.
1223  */
1224 static WCHAR *get_builtin_fullname( const WCHAR *path, const char *filename )
1225 {
1226     static const WCHAR soW[] = {'.','s','o',0};
1227     WCHAR *p, *fullname;
1228     size_t i, len = strlen(filename);
1229
1230     /* check if path can correspond to the dll we have */
1231     if (path && (p = strrchrW( path, '\\' )))
1232     {
1233         p++;
1234         for (i = 0; i < len; i++)
1235             if (tolowerW(p[i]) != tolowerW( (WCHAR)filename[i]) ) break;
1236         if (i == len && (!p[len] || !strcmpiW( p + len, soW )))
1237         {
1238             /* the filename matches, use path as the full path */
1239             len += p - path;
1240             if ((fullname = RtlAllocateHeap( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) )))
1241             {
1242                 memcpy( fullname, path, len * sizeof(WCHAR) );
1243                 fullname[len] = 0;
1244             }
1245             return fullname;
1246         }
1247     }
1248
1249     if ((fullname = RtlAllocateHeap( GetProcessHeap(), 0,
1250                                      system_dir.MaximumLength + (len + 1) * sizeof(WCHAR) )))
1251     {
1252         memcpy( fullname, system_dir.Buffer, system_dir.Length );
1253         p = fullname + system_dir.Length / sizeof(WCHAR);
1254         if (p > fullname && p[-1] != '\\') *p++ = '\\';
1255         ascii_to_unicode( p, filename, len + 1 );
1256     }
1257     return fullname;
1258 }
1259
1260
1261 /***********************************************************************
1262  *           load_builtin_callback
1263  *
1264  * Load a library in memory; callback function for wine_dll_register
1265  */
1266 static void load_builtin_callback( void *module, const char *filename )
1267 {
1268     static const WCHAR emptyW[1];
1269     void *addr;
1270     IMAGE_NT_HEADERS *nt;
1271     WINE_MODREF *wm;
1272     WCHAR *fullname;
1273     const WCHAR *load_path;
1274     SIZE_T size;
1275
1276     if (!module)
1277     {
1278         ERR("could not map image for %s\n", filename ? filename : "main exe" );
1279         return;
1280     }
1281     if (!(nt = RtlImageNtHeader( module )))
1282     {
1283         ERR( "bad module for %s\n", filename ? filename : "main exe" );
1284         builtin_load_info->status = STATUS_INVALID_IMAGE_FORMAT;
1285         return;
1286     }
1287     addr = module;
1288     size = nt->OptionalHeader.SizeOfImage;
1289     NtAllocateVirtualMemory( NtCurrentProcess(), &addr, 0, &size,
1290                              MEM_SYSTEM | MEM_IMAGE, PAGE_EXECUTE_WRITECOPY );
1291     /* create the MODREF */
1292
1293     if (!(fullname = get_builtin_fullname( builtin_load_info->filename, filename )))
1294     {
1295         ERR( "can't load %s\n", filename );
1296         builtin_load_info->status = STATUS_NO_MEMORY;
1297         return;
1298     }
1299
1300     wm = alloc_module( module, fullname );
1301     RtlFreeHeap( GetProcessHeap(), 0, fullname );
1302     if (!wm)
1303     {
1304         ERR( "can't load %s\n", filename );
1305         builtin_load_info->status = STATUS_NO_MEMORY;
1306         return;
1307     }
1308     wm->ldr.Flags |= LDR_WINE_INTERNAL;
1309
1310     if (!(nt->FileHeader.Characteristics & IMAGE_FILE_DLL) &&
1311         !NtCurrentTeb()->Peb->ImageBaseAddress)  /* if we already have an executable, ignore this one */
1312     {
1313         NtCurrentTeb()->Peb->ImageBaseAddress = module;
1314     }
1315     else
1316     {
1317         /* fixup imports */
1318
1319         load_path = builtin_load_info->load_path;
1320         if (!load_path) load_path = NtCurrentTeb()->Peb->ProcessParameters->DllPath.Buffer;
1321         if (!load_path) load_path = emptyW;
1322         if (fixup_imports( wm, load_path ) != STATUS_SUCCESS)
1323         {
1324             /* the module has only be inserted in the load & memory order lists */
1325             RemoveEntryList(&wm->ldr.InLoadOrderModuleList);
1326             RemoveEntryList(&wm->ldr.InMemoryOrderModuleList);
1327             /* FIXME: free the modref */
1328             builtin_load_info->status = STATUS_DLL_NOT_FOUND;
1329             return;
1330         }
1331     }
1332
1333     builtin_load_info->wm = wm;
1334     TRACE( "loaded %s %p %p\n", filename, wm, module );
1335
1336     /* send the DLL load event */
1337
1338     SERVER_START_REQ( load_dll )
1339     {
1340         req->handle     = 0;
1341         req->base       = module;
1342         req->size       = nt->OptionalHeader.SizeOfImage;
1343         req->dbg_offset = nt->FileHeader.PointerToSymbolTable;
1344         req->dbg_size   = nt->FileHeader.NumberOfSymbols;
1345         req->name       = &wm->ldr.FullDllName.Buffer;
1346         wine_server_add_data( req, wm->ldr.FullDllName.Buffer, wm->ldr.FullDllName.Length );
1347         wine_server_call( req );
1348     }
1349     SERVER_END_REQ;
1350
1351     /* setup relay debugging entry points */
1352     if (TRACE_ON(relay)) RELAY_SetupDLL( module );
1353 }
1354
1355
1356 /******************************************************************************
1357  *      load_native_dll  (internal)
1358  */
1359 static NTSTATUS load_native_dll( LPCWSTR load_path, LPCWSTR name, HANDLE file,
1360                                  DWORD flags, WINE_MODREF** pwm )
1361 {
1362     void *module;
1363     HANDLE mapping;
1364     OBJECT_ATTRIBUTES attr;
1365     LARGE_INTEGER size;
1366     IMAGE_NT_HEADERS *nt;
1367     SIZE_T len = 0;
1368     WINE_MODREF *wm;
1369     NTSTATUS status;
1370
1371     TRACE("Trying native dll %s\n", debugstr_w(name));
1372
1373     attr.Length                   = sizeof(attr);
1374     attr.RootDirectory            = 0;
1375     attr.ObjectName               = NULL;
1376     attr.Attributes               = 0;
1377     attr.SecurityDescriptor       = NULL;
1378     attr.SecurityQualityOfService = NULL;
1379     size.QuadPart = 0;
1380
1381     status = NtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
1382                               &attr, &size, 0, SEC_IMAGE, file );
1383     if (status != STATUS_SUCCESS) return status;
1384
1385     module = NULL;
1386     status = NtMapViewOfSection( mapping, NtCurrentProcess(),
1387                                  &module, 0, 0, &size, &len, ViewShare, 0, PAGE_READONLY );
1388     NtClose( mapping );
1389     if (status != STATUS_SUCCESS) return status;
1390
1391     if (is_fake_dll( module ))
1392     {
1393         TRACE( "%s is a fake dll, not loading it\n", debugstr_w(name) );
1394         NtUnmapViewOfSection( NtCurrentProcess(), module );
1395         return STATUS_DLL_NOT_FOUND;
1396     }
1397
1398     /* create the MODREF */
1399
1400     if (!(wm = alloc_module( module, name ))) return STATUS_NO_MEMORY;
1401
1402     /* fixup imports */
1403
1404     if (!(flags & DONT_RESOLVE_DLL_REFERENCES))
1405     {
1406         if ((status = fixup_imports( wm, load_path )) != STATUS_SUCCESS)
1407         {
1408             /* the module has only be inserted in the load & memory order lists */
1409             RemoveEntryList(&wm->ldr.InLoadOrderModuleList);
1410             RemoveEntryList(&wm->ldr.InMemoryOrderModuleList);
1411
1412             /* FIXME: there are several more dangling references
1413              * left. Including dlls loaded by this dll before the
1414              * failed one. Unrolling is rather difficult with the
1415              * current structure and we can leave them lying
1416              * around with no problems, so we don't care.
1417              * As these might reference our wm, we don't free it.
1418              */
1419             return status;
1420         }
1421     }
1422
1423     /* send DLL load event */
1424
1425     nt = RtlImageNtHeader( module );
1426
1427     SERVER_START_REQ( load_dll )
1428     {
1429         req->handle     = file;
1430         req->base       = module;
1431         req->size       = nt->OptionalHeader.SizeOfImage;
1432         req->dbg_offset = nt->FileHeader.PointerToSymbolTable;
1433         req->dbg_size   = nt->FileHeader.NumberOfSymbols;
1434         req->name       = &wm->ldr.FullDllName.Buffer;
1435         wine_server_add_data( req, wm->ldr.FullDllName.Buffer, wm->ldr.FullDllName.Length );
1436         wine_server_call( req );
1437     }
1438     SERVER_END_REQ;
1439
1440     if (TRACE_ON(snoop)) SNOOP_SetupDLL( module );
1441
1442     TRACE_(loaddll)( " Loaded module %s : native\n", debugstr_w(wm->ldr.FullDllName.Buffer) );
1443
1444     wm->ldr.LoadCount = 1;
1445     *pwm = wm;
1446     return STATUS_SUCCESS;
1447 }
1448
1449
1450 /***********************************************************************
1451  *           load_builtin_dll
1452  */
1453 static NTSTATUS load_builtin_dll( LPCWSTR load_path, LPCWSTR path, HANDLE file,
1454                                   DWORD flags, WINE_MODREF** pwm )
1455 {
1456     char error[256], dllname[MAX_PATH];
1457     const WCHAR *name, *p;
1458     DWORD len, i;
1459     void *handle = NULL;
1460     struct builtin_load_info info, *prev_info;
1461
1462     /* Fix the name in case we have a full path and extension */
1463     name = path;
1464     if ((p = strrchrW( name, '\\' ))) name = p + 1;
1465     if ((p = strrchrW( name, '/' ))) name = p + 1;
1466
1467     /* load_library will modify info.status. Note also that load_library can be
1468      * called several times, if the .so file we're loading has dependencies.
1469      * info.status will gather all the errors we may get while loading all these
1470      * libraries
1471      */
1472     info.load_path = load_path;
1473     info.filename  = NULL;
1474     info.status    = STATUS_SUCCESS;
1475     info.wm        = NULL;
1476
1477     if (file)  /* we have a real file, try to load it */
1478     {
1479         UNICODE_STRING nt_name;
1480         ANSI_STRING unix_name;
1481
1482         TRACE("Trying built-in %s\n", debugstr_w(path));
1483
1484         if (!RtlDosPathNameToNtPathName_U( path, &nt_name, NULL, NULL ))
1485             return STATUS_DLL_NOT_FOUND;
1486
1487         if (wine_nt_to_unix_file_name( &nt_name, &unix_name, FILE_OPEN, FALSE ))
1488         {
1489             RtlFreeUnicodeString( &nt_name );
1490             return STATUS_DLL_NOT_FOUND;
1491         }
1492         prev_info = builtin_load_info;
1493         info.filename = nt_name.Buffer + 4;  /* skip \??\ */
1494         builtin_load_info = &info;
1495         handle = wine_dlopen( unix_name.Buffer, RTLD_NOW, error, sizeof(error) );
1496         builtin_load_info = prev_info;
1497         RtlFreeUnicodeString( &nt_name );
1498         RtlFreeHeap( GetProcessHeap(), 0, unix_name.Buffer );
1499         if (!handle)
1500         {
1501             WARN( "failed to load .so lib for builtin %s: %s\n", debugstr_w(path), error );
1502             return STATUS_INVALID_IMAGE_FORMAT;
1503         }
1504     }
1505     else
1506     {
1507         int file_exists;
1508
1509         TRACE("Trying built-in %s\n", debugstr_w(name));
1510
1511         /* we don't want to depend on the current codepage here */
1512         len = strlenW( name ) + 1;
1513         if (len >= sizeof(dllname)) return STATUS_NAME_TOO_LONG;
1514         for (i = 0; i < len; i++)
1515         {
1516             if (name[i] > 127) return STATUS_DLL_NOT_FOUND;
1517             dllname[i] = (char)name[i];
1518             if (dllname[i] >= 'A' && dllname[i] <= 'Z') dllname[i] += 'a' - 'A';
1519         }
1520
1521         prev_info = builtin_load_info;
1522         builtin_load_info = &info;
1523         handle = wine_dll_load( dllname, error, sizeof(error), &file_exists );
1524         builtin_load_info = prev_info;
1525         if (!handle)
1526         {
1527             if (!file_exists)
1528             {
1529                 /* The file does not exist -> WARN() */
1530                 WARN("cannot open .so lib for builtin %s: %s\n", debugstr_w(name), error);
1531                 return STATUS_DLL_NOT_FOUND;
1532             }
1533             /* ERR() for all other errors (missing functions, ...) */
1534             ERR("failed to load .so lib for builtin %s: %s\n", debugstr_w(name), error );
1535             return STATUS_PROCEDURE_NOT_FOUND;
1536         }
1537     }
1538
1539     if (info.status != STATUS_SUCCESS)
1540     {
1541         wine_dll_unload( handle );
1542         return info.status;
1543     }
1544
1545     if (!info.wm)
1546     {
1547         PLIST_ENTRY mark, entry;
1548
1549         /* The constructor wasn't called, this means the .so is already
1550          * loaded under a different name. Try to find the wm for it. */
1551
1552         mark = &NtCurrentTeb()->Peb->LdrData->InLoadOrderModuleList;
1553         for (entry = mark->Flink; entry != mark; entry = entry->Flink)
1554         {
1555             LDR_MODULE *mod = CONTAINING_RECORD(entry, LDR_MODULE, InLoadOrderModuleList);
1556             if (mod->Flags & LDR_WINE_INTERNAL && mod->SectionHandle == handle)
1557             {
1558                 info.wm = CONTAINING_RECORD(mod, WINE_MODREF, ldr);
1559                 TRACE( "Found already loaded module %s for builtin %s\n",
1560                        debugstr_w(info.wm->ldr.FullDllName.Buffer), debugstr_w(path) );
1561                 break;
1562             }
1563         }
1564         wine_dll_unload( handle );  /* release the libdl refcount */
1565         if (!info.wm) return STATUS_INVALID_IMAGE_FORMAT;
1566         if (info.wm->ldr.LoadCount != -1) info.wm->ldr.LoadCount++;
1567     }
1568     else
1569     {
1570         TRACE_(loaddll)( "Loaded module %s : builtin\n", debugstr_w(info.wm->ldr.FullDllName.Buffer) );
1571         info.wm->ldr.LoadCount = 1;
1572         info.wm->ldr.SectionHandle = handle;
1573     }
1574
1575     *pwm = info.wm;
1576     return STATUS_SUCCESS;
1577 }
1578
1579
1580 /***********************************************************************
1581  *      find_dll_file
1582  *
1583  * Find the file (or already loaded module) for a given dll name.
1584  */
1585 static NTSTATUS find_dll_file( const WCHAR *load_path, const WCHAR *libname,
1586                                WCHAR *filename, ULONG *size, WINE_MODREF **pwm, HANDLE *handle )
1587 {
1588     OBJECT_ATTRIBUTES attr;
1589     IO_STATUS_BLOCK io;
1590     UNICODE_STRING nt_name;
1591     WCHAR *file_part, *ext, *dllname;
1592     ULONG len;
1593
1594     /* first append .dll if needed */
1595
1596     dllname = NULL;
1597     if (!(ext = strrchrW( libname, '.')) || strchrW( ext, '/' ) || strchrW( ext, '\\'))
1598     {
1599         if (!(dllname = RtlAllocateHeap( GetProcessHeap(), 0,
1600                                          (strlenW(libname) * sizeof(WCHAR)) + sizeof(dllW) )))
1601             return STATUS_NO_MEMORY;
1602         strcpyW( dllname, libname );
1603         strcatW( dllname, dllW );
1604         libname = dllname;
1605     }
1606
1607     nt_name.Buffer = NULL;
1608
1609     if (!contains_path( libname ))
1610     {
1611         if ((*pwm = find_basename_module( libname )) != NULL) goto found;
1612     }
1613
1614     if (RtlDetermineDosPathNameType_U( libname ) == RELATIVE_PATH)
1615     {
1616         /* we need to search for it */
1617         len = RtlDosSearchPath_U( load_path, libname, NULL, *size, filename, &file_part );
1618         if (len)
1619         {
1620             if (len >= *size) goto overflow;
1621             if ((*pwm = find_fullname_module( filename )) || !handle) goto found;
1622
1623             if (!RtlDosPathNameToNtPathName_U( filename, &nt_name, NULL, NULL ))
1624             {
1625                 RtlFreeHeap( GetProcessHeap(), 0, dllname );
1626                 return STATUS_NO_MEMORY;
1627             }
1628             attr.Length = sizeof(attr);
1629             attr.RootDirectory = 0;
1630             attr.Attributes = OBJ_CASE_INSENSITIVE;
1631             attr.ObjectName = &nt_name;
1632             attr.SecurityDescriptor = NULL;
1633             attr.SecurityQualityOfService = NULL;
1634             if (NtOpenFile( handle, GENERIC_READ, &attr, &io, FILE_SHARE_READ|FILE_SHARE_DELETE, 0 )) *handle = 0;
1635             goto found;
1636         }
1637
1638         /* not found */
1639
1640         if (!contains_path( libname ))
1641         {
1642             /* if libname doesn't contain a path at all, we simply return the name as is,
1643              * to be loaded as builtin */
1644             len = strlenW(libname) * sizeof(WCHAR);
1645             if (len >= *size) goto overflow;
1646             strcpyW( filename, libname );
1647             goto found;
1648         }
1649     }
1650
1651     /* absolute path name, or relative path name but not found above */
1652
1653     if (!RtlDosPathNameToNtPathName_U( libname, &nt_name, &file_part, NULL ))
1654     {
1655         RtlFreeHeap( GetProcessHeap(), 0, dllname );
1656         return STATUS_NO_MEMORY;
1657     }
1658     len = nt_name.Length - 4*sizeof(WCHAR);  /* for \??\ prefix */
1659     if (len >= *size) goto overflow;
1660     memcpy( filename, nt_name.Buffer + 4, len + sizeof(WCHAR) );
1661     if (!(*pwm = find_fullname_module( filename )) && handle)
1662     {
1663         attr.Length = sizeof(attr);
1664         attr.RootDirectory = 0;
1665         attr.Attributes = OBJ_CASE_INSENSITIVE;
1666         attr.ObjectName = &nt_name;
1667         attr.SecurityDescriptor = NULL;
1668         attr.SecurityQualityOfService = NULL;
1669         if (NtOpenFile( handle, GENERIC_READ, &attr, &io, FILE_SHARE_READ|FILE_SHARE_DELETE, 0 )) *handle = 0;
1670     }
1671 found:
1672     RtlFreeUnicodeString( &nt_name );
1673     RtlFreeHeap( GetProcessHeap(), 0, dllname );
1674     return STATUS_SUCCESS;
1675
1676 overflow:
1677     RtlFreeUnicodeString( &nt_name );
1678     RtlFreeHeap( GetProcessHeap(), 0, dllname );
1679     *size = len + sizeof(WCHAR);
1680     return STATUS_BUFFER_TOO_SMALL;
1681 }
1682
1683
1684 /***********************************************************************
1685  *      load_dll  (internal)
1686  *
1687  * Load a PE style module according to the load order.
1688  * The loader_section must be locked while calling this function.
1689  */
1690 static NTSTATUS load_dll( LPCWSTR load_path, LPCWSTR libname, DWORD flags, WINE_MODREF** pwm )
1691 {
1692     enum loadorder loadorder;
1693     WCHAR buffer[32];
1694     WCHAR *filename;
1695     ULONG size;
1696     WINE_MODREF *main_exe;
1697     HANDLE handle = 0;
1698     NTSTATUS nts;
1699
1700     TRACE( "looking for %s in %s\n", debugstr_w(libname), debugstr_w(load_path) );
1701
1702     filename = buffer;
1703     size = sizeof(buffer);
1704     for (;;)
1705     {
1706         nts = find_dll_file( load_path, libname, filename, &size, pwm, &handle );
1707         if (nts == STATUS_SUCCESS) break;
1708         if (filename != buffer) RtlFreeHeap( GetProcessHeap(), 0, filename );
1709         if (nts != STATUS_BUFFER_TOO_SMALL) return nts;
1710         /* grow the buffer and retry */
1711         if (!(filename = RtlAllocateHeap( GetProcessHeap(), 0, size ))) return STATUS_NO_MEMORY;
1712     }
1713
1714     if (*pwm)  /* found already loaded module */
1715     {
1716         if ((*pwm)->ldr.LoadCount != -1) (*pwm)->ldr.LoadCount++;
1717
1718         if (!(flags & DONT_RESOLVE_DLL_REFERENCES)) fixup_imports( *pwm, load_path );
1719
1720         TRACE("Found loaded module %s for %s at %p, count=%d\n",
1721               debugstr_w((*pwm)->ldr.FullDllName.Buffer), debugstr_w(libname),
1722               (*pwm)->ldr.BaseAddress, (*pwm)->ldr.LoadCount);
1723         if (filename != buffer) RtlFreeHeap( GetProcessHeap(), 0, filename );
1724         return STATUS_SUCCESS;
1725     }
1726
1727     main_exe = get_modref( NtCurrentTeb()->Peb->ImageBaseAddress );
1728     loadorder = get_load_order( main_exe ? main_exe->ldr.BaseDllName.Buffer : NULL, filename );
1729
1730     switch(loadorder)
1731     {
1732     case LO_INVALID:
1733         nts = STATUS_NO_MEMORY;
1734         break;
1735     case LO_DISABLED:
1736         nts = STATUS_DLL_NOT_FOUND;
1737         break;
1738     case LO_NATIVE:
1739     case LO_NATIVE_BUILTIN:
1740         if (!handle) nts = STATUS_DLL_NOT_FOUND;
1741         else
1742         {
1743             nts = load_native_dll( load_path, filename, handle, flags, pwm );
1744             if (nts == STATUS_INVALID_FILE_FOR_SECTION)
1745                 /* not in PE format, maybe it's a builtin */
1746                 nts = load_builtin_dll( load_path, filename, handle, flags, pwm );
1747         }
1748         if (nts == STATUS_DLL_NOT_FOUND && loadorder == LO_NATIVE_BUILTIN)
1749             nts = load_builtin_dll( load_path, filename, 0, flags, pwm );
1750         break;
1751     case LO_BUILTIN:
1752     case LO_BUILTIN_NATIVE:
1753     case LO_DEFAULT:  /* default is builtin,native */
1754         nts = load_builtin_dll( load_path, filename, handle, flags, pwm );
1755         if (!handle) break;  /* nothing else we can try */
1756         /* file is not a builtin library, try without using the specified file */
1757         if (nts != STATUS_SUCCESS)
1758             nts = load_builtin_dll( load_path, filename, 0, flags, pwm );
1759         if (nts == STATUS_SUCCESS && loadorder == LO_DEFAULT &&
1760             !MODULE_InitDLL( *pwm, DLL_WINE_PREATTACH, NULL ))
1761         {
1762             /* stub-only dll, try native */
1763             TRACE( "%s pre-attach returned FALSE, preferring native\n", debugstr_w(filename) );
1764             LdrUnloadDll( (*pwm)->ldr.BaseAddress );
1765             nts = STATUS_DLL_NOT_FOUND;
1766         }
1767         if (nts == STATUS_DLL_NOT_FOUND && loadorder != LO_BUILTIN)
1768             nts = load_native_dll( load_path, filename, handle, flags, pwm );
1769         break;
1770     }
1771
1772     if (nts == STATUS_SUCCESS)
1773     {
1774         /* Initialize DLL just loaded */
1775         TRACE("Loaded module %s (%s) at %p\n", debugstr_w(filename),
1776               ((*pwm)->ldr.Flags & LDR_WINE_INTERNAL) ? "builtin" : "native",
1777               (*pwm)->ldr.BaseAddress);
1778         if (handle) NtClose( handle );
1779         if (filename != buffer) RtlFreeHeap( GetProcessHeap(), 0, filename );
1780         return nts;
1781     }
1782
1783     WARN("Failed to load module %s; status=%x\n", debugstr_w(libname), nts);
1784     if (handle) NtClose( handle );
1785     if (filename != buffer) RtlFreeHeap( GetProcessHeap(), 0, filename );
1786     return nts;
1787 }
1788
1789 /******************************************************************
1790  *              LdrLoadDll (NTDLL.@)
1791  */
1792 NTSTATUS WINAPI LdrLoadDll(LPCWSTR path_name, DWORD flags,
1793                            const UNICODE_STRING *libname, HMODULE* hModule)
1794 {
1795     WINE_MODREF *wm;
1796     NTSTATUS nts;
1797
1798     RtlEnterCriticalSection( &loader_section );
1799
1800     if (!path_name) path_name = NtCurrentTeb()->Peb->ProcessParameters->DllPath.Buffer;
1801     nts = load_dll( path_name, libname->Buffer, flags, &wm );
1802
1803     if (nts == STATUS_SUCCESS && !(wm->ldr.Flags & LDR_DONT_RESOLVE_REFS))
1804     {
1805         nts = process_attach( wm, NULL );
1806         if (nts != STATUS_SUCCESS)
1807         {
1808             LdrUnloadDll(wm->ldr.BaseAddress);
1809             wm = NULL;
1810         }
1811     }
1812     *hModule = (wm) ? wm->ldr.BaseAddress : NULL;
1813
1814     RtlLeaveCriticalSection( &loader_section );
1815     return nts;
1816 }
1817
1818
1819 /******************************************************************
1820  *              LdrGetDllHandle (NTDLL.@)
1821  */
1822 NTSTATUS WINAPI LdrGetDllHandle( LPCWSTR load_path, ULONG flags, const UNICODE_STRING *name, HMODULE *base )
1823 {
1824     NTSTATUS status;
1825     WCHAR buffer[128];
1826     WCHAR *filename;
1827     ULONG size;
1828     WINE_MODREF *wm;
1829
1830     RtlEnterCriticalSection( &loader_section );
1831
1832     if (!load_path) load_path = NtCurrentTeb()->Peb->ProcessParameters->DllPath.Buffer;
1833
1834     filename = buffer;
1835     size = sizeof(buffer);
1836     for (;;)
1837     {
1838         status = find_dll_file( load_path, name->Buffer, filename, &size, &wm, NULL );
1839         if (filename != buffer) RtlFreeHeap( GetProcessHeap(), 0, filename );
1840         if (status != STATUS_BUFFER_TOO_SMALL) break;
1841         /* grow the buffer and retry */
1842         if (!(filename = RtlAllocateHeap( GetProcessHeap(), 0, size )))
1843         {
1844             status = STATUS_NO_MEMORY;
1845             break;
1846         }
1847     }
1848
1849     if (status == STATUS_SUCCESS)
1850     {
1851         if (wm) *base = wm->ldr.BaseAddress;
1852         else status = STATUS_DLL_NOT_FOUND;
1853     }
1854
1855     RtlLeaveCriticalSection( &loader_section );
1856     TRACE( "%s -> %p (load path %s)\n", debugstr_us(name), status ? NULL : *base, debugstr_w(load_path) );
1857     return status;
1858 }
1859
1860
1861 /******************************************************************
1862  *              LdrAddRefDll (NTDLL.@)
1863  */
1864 NTSTATUS WINAPI LdrAddRefDll( ULONG flags, HMODULE module )
1865 {
1866     NTSTATUS ret = STATUS_SUCCESS;
1867     WINE_MODREF *wm;
1868
1869     if (flags) FIXME( "%p flags %x not implemented\n", module, flags );
1870
1871     RtlEnterCriticalSection( &loader_section );
1872
1873     if ((wm = get_modref( module )))
1874     {
1875         if (wm->ldr.LoadCount != -1) wm->ldr.LoadCount++;
1876         TRACE( "(%s) ldr.LoadCount: %d\n", debugstr_w(wm->ldr.BaseDllName.Buffer), wm->ldr.LoadCount );
1877     }
1878     else ret = STATUS_INVALID_PARAMETER;
1879
1880     RtlLeaveCriticalSection( &loader_section );
1881     return ret;
1882 }
1883
1884
1885 /******************************************************************
1886  *              LdrQueryProcessModuleInformation
1887  *
1888  */
1889 NTSTATUS WINAPI LdrQueryProcessModuleInformation(PSYSTEM_MODULE_INFORMATION smi,
1890                                                  ULONG buf_size, ULONG* req_size)
1891 {
1892     SYSTEM_MODULE*      sm = &smi->Modules[0];
1893     ULONG               size = sizeof(ULONG);
1894     NTSTATUS            nts = STATUS_SUCCESS;
1895     ANSI_STRING         str;
1896     char*               ptr;
1897     PLIST_ENTRY         mark, entry;
1898     PLDR_MODULE         mod;
1899     WORD id = 0;
1900
1901     smi->ModulesCount = 0;
1902
1903     RtlEnterCriticalSection( &loader_section );
1904     mark = &NtCurrentTeb()->Peb->LdrData->InLoadOrderModuleList;
1905     for (entry = mark->Flink; entry != mark; entry = entry->Flink)
1906     {
1907         mod = CONTAINING_RECORD(entry, LDR_MODULE, InLoadOrderModuleList);
1908         size += sizeof(*sm);
1909         if (size <= buf_size)
1910         {
1911             sm->Reserved1 = 0; /* FIXME */
1912             sm->Reserved2 = 0; /* FIXME */
1913             sm->ImageBaseAddress = mod->BaseAddress;
1914             sm->ImageSize = mod->SizeOfImage;
1915             sm->Flags = mod->Flags;
1916             sm->Id = id++;
1917             sm->Rank = 0; /* FIXME */
1918             sm->Unknown = 0; /* FIXME */
1919             str.Length = 0;
1920             str.MaximumLength = MAXIMUM_FILENAME_LENGTH;
1921             str.Buffer = (char*)sm->Name;
1922             RtlUnicodeStringToAnsiString(&str, &mod->FullDllName, FALSE);
1923             ptr = strrchr(str.Buffer, '\\');
1924             sm->NameOffset = (ptr != NULL) ? (ptr - str.Buffer + 1) : 0;
1925
1926             smi->ModulesCount++;
1927             sm++;
1928         }
1929         else nts = STATUS_INFO_LENGTH_MISMATCH;
1930     }
1931     RtlLeaveCriticalSection( &loader_section );
1932
1933     if (req_size) *req_size = size;
1934
1935     return nts;
1936 }
1937
1938
1939 /******************************************************************
1940  *              RtlDllShutdownInProgress  (NTDLL.@)
1941  */
1942 BOOLEAN WINAPI RtlDllShutdownInProgress(void)
1943 {
1944     return process_detaching;
1945 }
1946
1947
1948 /******************************************************************
1949  *              LdrShutdownProcess (NTDLL.@)
1950  *
1951  */
1952 void WINAPI LdrShutdownProcess(void)
1953 {
1954     TRACE("()\n");
1955     process_detach( TRUE, (LPVOID)1 );
1956 }
1957
1958 /******************************************************************
1959  *              LdrShutdownThread (NTDLL.@)
1960  *
1961  */
1962 void WINAPI LdrShutdownThread(void)
1963 {
1964     PLIST_ENTRY mark, entry;
1965     PLDR_MODULE mod;
1966
1967     TRACE("()\n");
1968
1969     /* don't do any detach calls if process is exiting */
1970     if (process_detaching) return;
1971     /* FIXME: there is still a race here */
1972
1973     RtlEnterCriticalSection( &loader_section );
1974
1975     mark = &NtCurrentTeb()->Peb->LdrData->InInitializationOrderModuleList;
1976     for (entry = mark->Blink; entry != mark; entry = entry->Blink)
1977     {
1978         mod = CONTAINING_RECORD(entry, LDR_MODULE,
1979                                 InInitializationOrderModuleList);
1980         if ( !(mod->Flags & LDR_PROCESS_ATTACHED) )
1981             continue;
1982         if ( mod->Flags & LDR_NO_DLL_CALLS )
1983             continue;
1984
1985         MODULE_InitDLL( CONTAINING_RECORD(mod, WINE_MODREF, ldr),
1986                         DLL_THREAD_DETACH, NULL );
1987     }
1988
1989     RtlLeaveCriticalSection( &loader_section );
1990     RtlFreeHeap( GetProcessHeap(), 0, NtCurrentTeb()->ThreadLocalStoragePointer );
1991 }
1992
1993
1994 /***********************************************************************
1995  *           free_modref
1996  *
1997  */
1998 static void free_modref( WINE_MODREF *wm )
1999 {
2000     RemoveEntryList(&wm->ldr.InLoadOrderModuleList);
2001     RemoveEntryList(&wm->ldr.InMemoryOrderModuleList);
2002     if (wm->ldr.InInitializationOrderModuleList.Flink)
2003         RemoveEntryList(&wm->ldr.InInitializationOrderModuleList);
2004
2005     TRACE(" unloading %s\n", debugstr_w(wm->ldr.FullDllName.Buffer));
2006     if (!TRACE_ON(module))
2007         TRACE_(loaddll)("Unloaded module %s : %s\n",
2008                         debugstr_w(wm->ldr.FullDllName.Buffer),
2009                         (wm->ldr.Flags & LDR_WINE_INTERNAL) ? "builtin" : "native" );
2010
2011     SERVER_START_REQ( unload_dll )
2012     {
2013         req->base = wm->ldr.BaseAddress;
2014         wine_server_call( req );
2015     }
2016     SERVER_END_REQ;
2017
2018     RtlReleaseActivationContext( wm->ldr.ActivationContext );
2019     NtUnmapViewOfSection( NtCurrentProcess(), wm->ldr.BaseAddress );
2020     if (wm->ldr.Flags & LDR_WINE_INTERNAL) wine_dll_unload( wm->ldr.SectionHandle );
2021     if (cached_modref == wm) cached_modref = NULL;
2022     RtlFreeUnicodeString( &wm->ldr.FullDllName );
2023     RtlFreeHeap( GetProcessHeap(), 0, wm->deps );
2024     RtlFreeHeap( GetProcessHeap(), 0, wm );
2025 }
2026
2027 /***********************************************************************
2028  *           MODULE_FlushModrefs
2029  *
2030  * Remove all unused modrefs and call the internal unloading routines
2031  * for the library type.
2032  *
2033  * The loader_section must be locked while calling this function.
2034  */
2035 static void MODULE_FlushModrefs(void)
2036 {
2037     PLIST_ENTRY mark, entry, prev;
2038     PLDR_MODULE mod;
2039     WINE_MODREF*wm;
2040
2041     mark = &NtCurrentTeb()->Peb->LdrData->InInitializationOrderModuleList;
2042     for (entry = mark->Blink; entry != mark; entry = prev)
2043     {
2044         mod = CONTAINING_RECORD(entry, LDR_MODULE, InInitializationOrderModuleList);
2045         wm = CONTAINING_RECORD(mod, WINE_MODREF, ldr);
2046         prev = entry->Blink;
2047         if (!mod->LoadCount) free_modref( wm );
2048     }
2049
2050     /* check load order list too for modules that haven't been initialized yet */
2051     mark = &NtCurrentTeb()->Peb->LdrData->InLoadOrderModuleList;
2052     for (entry = mark->Blink; entry != mark; entry = prev)
2053     {
2054         mod = CONTAINING_RECORD(entry, LDR_MODULE, InLoadOrderModuleList);
2055         wm = CONTAINING_RECORD(mod, WINE_MODREF, ldr);
2056         prev = entry->Blink;
2057         if (!mod->LoadCount) free_modref( wm );
2058     }
2059 }
2060
2061 /***********************************************************************
2062  *           MODULE_DecRefCount
2063  *
2064  * The loader_section must be locked while calling this function.
2065  */
2066 static void MODULE_DecRefCount( WINE_MODREF *wm )
2067 {
2068     int i;
2069
2070     if ( wm->ldr.Flags & LDR_UNLOAD_IN_PROGRESS )
2071         return;
2072
2073     if ( wm->ldr.LoadCount <= 0 )
2074         return;
2075
2076     --wm->ldr.LoadCount;
2077     TRACE("(%s) ldr.LoadCount: %d\n", debugstr_w(wm->ldr.BaseDllName.Buffer), wm->ldr.LoadCount );
2078
2079     if ( wm->ldr.LoadCount == 0 )
2080     {
2081         wm->ldr.Flags |= LDR_UNLOAD_IN_PROGRESS;
2082
2083         for ( i = 0; i < wm->nDeps; i++ )
2084             if ( wm->deps[i] )
2085                 MODULE_DecRefCount( wm->deps[i] );
2086
2087         wm->ldr.Flags &= ~LDR_UNLOAD_IN_PROGRESS;
2088     }
2089 }
2090
2091 /******************************************************************
2092  *              LdrUnloadDll (NTDLL.@)
2093  *
2094  *
2095  */
2096 NTSTATUS WINAPI LdrUnloadDll( HMODULE hModule )
2097 {
2098     NTSTATUS retv = STATUS_SUCCESS;
2099
2100     TRACE("(%p)\n", hModule);
2101
2102     RtlEnterCriticalSection( &loader_section );
2103
2104     /* if we're stopping the whole process (and forcing the removal of all
2105      * DLLs) the library will be freed anyway
2106      */
2107     if (!process_detaching)
2108     {
2109         WINE_MODREF *wm;
2110
2111         free_lib_count++;
2112         if ((wm = get_modref( hModule )) != NULL)
2113         {
2114             TRACE("(%s) - START\n", debugstr_w(wm->ldr.BaseDllName.Buffer));
2115
2116             /* Recursively decrement reference counts */
2117             MODULE_DecRefCount( wm );
2118
2119             /* Call process detach notifications */
2120             if ( free_lib_count <= 1 )
2121             {
2122                 process_detach( FALSE, NULL );
2123                 MODULE_FlushModrefs();
2124             }
2125
2126             TRACE("END\n");
2127         }
2128         else
2129             retv = STATUS_DLL_NOT_FOUND;
2130
2131         free_lib_count--;
2132     }
2133
2134     RtlLeaveCriticalSection( &loader_section );
2135
2136     return retv;
2137 }
2138
2139 /***********************************************************************
2140  *           RtlImageNtHeader   (NTDLL.@)
2141  */
2142 PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE hModule)
2143 {
2144     IMAGE_NT_HEADERS *ret;
2145
2146     __TRY
2147     {
2148         IMAGE_DOS_HEADER *dos = (IMAGE_DOS_HEADER *)hModule;
2149
2150         ret = NULL;
2151         if (dos->e_magic == IMAGE_DOS_SIGNATURE)
2152         {
2153             ret = (IMAGE_NT_HEADERS *)((char *)dos + dos->e_lfanew);
2154             if (ret->Signature != IMAGE_NT_SIGNATURE) ret = NULL;
2155         }
2156     }
2157     __EXCEPT_PAGE_FAULT
2158     {
2159         return NULL;
2160     }
2161     __ENDTRY
2162     return ret;
2163 }
2164
2165
2166 /******************************************************************
2167  *              LdrInitializeThunk (NTDLL.@)
2168  *
2169  */
2170 void WINAPI LdrInitializeThunk( ULONG unknown1, ULONG unknown2, ULONG unknown3, ULONG unknown4 )
2171 {
2172     NTSTATUS status;
2173     WINE_MODREF *wm;
2174     LPCWSTR load_path;
2175     PEB *peb = NtCurrentTeb()->Peb;
2176     IMAGE_NT_HEADERS *nt = RtlImageNtHeader( peb->ImageBaseAddress );
2177
2178     if (main_exe_file) NtClose( main_exe_file );  /* at this point the main module is created */
2179
2180     /* allocate the modref for the main exe (if not already done) */
2181     wm = get_modref( peb->ImageBaseAddress );
2182     assert( wm );
2183     if (wm->ldr.Flags & LDR_IMAGE_IS_DLL)
2184     {
2185         ERR("%s is a dll, not an executable\n", debugstr_w(wm->ldr.FullDllName.Buffer) );
2186         exit(1);
2187     }
2188     wm->ldr.LoadCount = -1;  /* can't unload main exe */
2189
2190     peb->ProcessParameters->ImagePathName = wm->ldr.FullDllName;
2191     version_init( wm->ldr.FullDllName.Buffer );
2192
2193     /* the main exe needs to be the first in the load order list */
2194     RemoveEntryList( &wm->ldr.InLoadOrderModuleList );
2195     InsertHeadList( &peb->LdrData->InLoadOrderModuleList, &wm->ldr.InLoadOrderModuleList );
2196
2197     status = server_init_process_done();
2198     if (status != STATUS_SUCCESS) goto error;
2199
2200     RtlEnterCriticalSection( &loader_section );
2201
2202     actctx_init();
2203     load_path = NtCurrentTeb()->Peb->ProcessParameters->DllPath.Buffer;
2204     if ((status = fixup_imports( wm, load_path )) != STATUS_SUCCESS) goto error;
2205     if ((status = alloc_process_tls()) != STATUS_SUCCESS) goto error;
2206     if ((status = alloc_thread_tls()) != STATUS_SUCCESS) goto error;
2207     if ((status = process_attach( wm, (LPVOID)1 )) != STATUS_SUCCESS)
2208     {
2209         if (last_failed_modref)
2210             ERR( "%s failed to initialize, aborting\n", debugstr_w(last_failed_modref->ldr.BaseDllName.Buffer) + 1 );
2211         goto error;
2212     }
2213     attach_implicitly_loaded_dlls( (LPVOID)1 );
2214
2215     RtlLeaveCriticalSection( &loader_section );
2216
2217     if (nt->FileHeader.Characteristics & IMAGE_FILE_LARGE_ADDRESS_AWARE) VIRTUAL_UseLargeAddressSpace();
2218     return;
2219
2220 error:
2221     ERR( "Main exe initialization for %s failed, status %x\n",
2222          debugstr_w(peb->ProcessParameters->ImagePathName.Buffer), status );
2223     exit(1);
2224 }
2225
2226
2227 /***********************************************************************
2228  *           RtlImageDirectoryEntryToData   (NTDLL.@)
2229  */
2230 PVOID WINAPI RtlImageDirectoryEntryToData( HMODULE module, BOOL image, WORD dir, ULONG *size )
2231 {
2232     const IMAGE_NT_HEADERS *nt;
2233     DWORD addr;
2234
2235     if ((ULONG_PTR)module & 1)  /* mapped as data file */
2236     {
2237         module = (HMODULE)((ULONG_PTR)module & ~1);
2238         image = FALSE;
2239     }
2240     if (!(nt = RtlImageNtHeader( module ))) return NULL;
2241     if (dir >= nt->OptionalHeader.NumberOfRvaAndSizes) return NULL;
2242     if (!(addr = nt->OptionalHeader.DataDirectory[dir].VirtualAddress)) return NULL;
2243     *size = nt->OptionalHeader.DataDirectory[dir].Size;
2244     if (image || addr < nt->OptionalHeader.SizeOfHeaders) return (char *)module + addr;
2245
2246     /* not mapped as image, need to find the section containing the virtual address */
2247     return RtlImageRvaToVa( nt, module, addr, NULL );
2248 }
2249
2250
2251 /***********************************************************************
2252  *           RtlImageRvaToSection   (NTDLL.@)
2253  */
2254 PIMAGE_SECTION_HEADER WINAPI RtlImageRvaToSection( const IMAGE_NT_HEADERS *nt,
2255                                                    HMODULE module, DWORD rva )
2256 {
2257     int i;
2258     const IMAGE_SECTION_HEADER *sec;
2259
2260     sec = (const IMAGE_SECTION_HEADER*)((const char*)&nt->OptionalHeader +
2261                                         nt->FileHeader.SizeOfOptionalHeader);
2262     for (i = 0; i < nt->FileHeader.NumberOfSections; i++, sec++)
2263     {
2264         if ((sec->VirtualAddress <= rva) && (sec->VirtualAddress + sec->SizeOfRawData > rva))
2265             return (PIMAGE_SECTION_HEADER)sec;
2266     }
2267     return NULL;
2268 }
2269
2270
2271 /***********************************************************************
2272  *           RtlImageRvaToVa   (NTDLL.@)
2273  */
2274 PVOID WINAPI RtlImageRvaToVa( const IMAGE_NT_HEADERS *nt, HMODULE module,
2275                               DWORD rva, IMAGE_SECTION_HEADER **section )
2276 {
2277     IMAGE_SECTION_HEADER *sec;
2278
2279     if (section && *section)  /* try this section first */
2280     {
2281         sec = *section;
2282         if ((sec->VirtualAddress <= rva) && (sec->VirtualAddress + sec->SizeOfRawData > rva))
2283             goto found;
2284     }
2285     if (!(sec = RtlImageRvaToSection( nt, module, rva ))) return NULL;
2286  found:
2287     if (section) *section = sec;
2288     return (char *)module + sec->PointerToRawData + (rva - sec->VirtualAddress);
2289 }
2290
2291
2292 /***********************************************************************
2293  *           RtlPcToFileHeader   (NTDLL.@)
2294  */
2295 PVOID WINAPI RtlPcToFileHeader( PVOID pc, PVOID *address )
2296 {
2297     LDR_MODULE *module;
2298     PVOID ret = NULL;
2299
2300     RtlEnterCriticalSection( &loader_section );
2301     if (!LdrFindEntryForAddress( pc, &module )) ret = module->BaseAddress;
2302     RtlLeaveCriticalSection( &loader_section );
2303     *address = ret;
2304     return ret;
2305 }
2306
2307
2308 /***********************************************************************
2309  *           NtLoadDriver   (NTDLL.@)
2310  *           ZwLoadDriver   (NTDLL.@)
2311  */
2312 NTSTATUS WINAPI NtLoadDriver( const UNICODE_STRING *DriverServiceName )
2313 {
2314     FIXME("(%p), stub!\n",DriverServiceName);
2315     return STATUS_NOT_IMPLEMENTED;
2316 }
2317
2318
2319 /***********************************************************************
2320  *           NtUnloadDriver   (NTDLL.@)
2321  *           ZwUnloadDriver   (NTDLL.@)
2322  */
2323 NTSTATUS WINAPI NtUnloadDriver( const UNICODE_STRING *DriverServiceName )
2324 {
2325     FIXME("(%p), stub!\n",DriverServiceName);
2326     return STATUS_NOT_IMPLEMENTED;
2327 }
2328
2329
2330 /******************************************************************
2331  *              DllMain   (NTDLL.@)
2332  */
2333 BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
2334 {
2335     if (reason == DLL_PROCESS_ATTACH) LdrDisableThreadCalloutsForDll( inst );
2336     return TRUE;
2337 }
2338
2339
2340 /******************************************************************
2341  *              __wine_init_windows_dir   (NTDLL.@)
2342  *
2343  * Windows and system dir initialization once kernel32 has been loaded.
2344  */
2345 void __wine_init_windows_dir( const WCHAR *windir, const WCHAR *sysdir )
2346 {
2347     PLIST_ENTRY mark, entry;
2348     LPWSTR buffer, p;
2349
2350     RtlCreateUnicodeString( &windows_dir, windir );
2351     RtlCreateUnicodeString( &system_dir, sysdir );
2352     strcpyW( user_shared_data->NtSystemRoot, windir );
2353
2354     /* prepend the system dir to the name of the already created modules */
2355     mark = &NtCurrentTeb()->Peb->LdrData->InLoadOrderModuleList;
2356     for (entry = mark->Flink; entry != mark; entry = entry->Flink)
2357     {
2358         LDR_MODULE *mod = CONTAINING_RECORD( entry, LDR_MODULE, InLoadOrderModuleList );
2359
2360         assert( mod->Flags & LDR_WINE_INTERNAL );
2361
2362         buffer = RtlAllocateHeap( GetProcessHeap(), 0,
2363                                   system_dir.Length + mod->FullDllName.Length + 2*sizeof(WCHAR) );
2364         if (!buffer) continue;
2365         strcpyW( buffer, system_dir.Buffer );
2366         p = buffer + strlenW( buffer );
2367         if (p > buffer && p[-1] != '\\') *p++ = '\\';
2368         strcpyW( p, mod->FullDllName.Buffer );
2369         RtlInitUnicodeString( &mod->FullDllName, buffer );
2370         RtlInitUnicodeString( &mod->BaseDllName, p );
2371     }
2372 }
2373
2374
2375 /***********************************************************************
2376  *           __wine_process_init
2377  */
2378 void __wine_process_init(void)
2379 {
2380     static const WCHAR kernel32W[] = {'k','e','r','n','e','l','3','2','.','d','l','l',0};
2381
2382     WINE_MODREF *wm;
2383     NTSTATUS status;
2384     ANSI_STRING func_name;
2385     void (* DECLSPEC_NORETURN init_func)(void);
2386     extern mode_t FILE_umask;
2387
2388     main_exe_file = thread_init();
2389
2390     /* retrieve current umask */
2391     FILE_umask = umask(0777);
2392     umask( FILE_umask );
2393
2394     /* setup the load callback and create ntdll modref */
2395     wine_dll_set_callback( load_builtin_callback );
2396
2397     if ((status = load_builtin_dll( NULL, kernel32W, 0, 0, &wm )) != STATUS_SUCCESS)
2398     {
2399         MESSAGE( "wine: could not load kernel32.dll, status %x\n", status );
2400         exit(1);
2401     }
2402     RtlInitAnsiString( &func_name, "__wine_kernel_init" );
2403     if ((status = LdrGetProcedureAddress( wm->ldr.BaseAddress, &func_name,
2404                                           0, (void **)&init_func )) != STATUS_SUCCESS)
2405     {
2406         MESSAGE( "wine: could not find __wine_kernel_init in kernel32.dll, status %x\n", status );
2407         exit(1);
2408     }
2409     init_func();
2410 }