dlls/kernel32/module.c

   1 /*
   2  * Modules
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <fcntl.h>
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <sys/types.h>
  30 #ifdef HAVE_UNISTD_H
  31 # include <unistd.h>
  32 #endif
  33 #include "ntstatus.h"
  34 #define WIN32_NO_STATUS
  35 #include "winerror.h"
  36 #include "windef.h"
  37 #include "winbase.h"
  38 #include "winternl.h"
  39 #include "kernel_private.h"
  40 #include "psapi.h"
  41
  42 #include "wine/exception.h"
  43 #include "wine/list.h"
  44 #include "wine/debug.h"
  45 #include "wine/unicode.h"
  46
  47 WINE_DEFAULT_DEBUG_CHANNEL(module);
  48
  49 #define NE_FFLAGS_LIBMODULE 0x8000
  50
  51 struct dll_dir_entry
  52 {
  53     struct list entry;
  54     WCHAR       dir[1];
  55 };
  56
  57 static struct list dll_dir_list = LIST_INIT( dll_dir_list );  /* extra dirs from AddDllDirectory */
  58 static WCHAR *dll_directory;  /* extra path for SetDllDirectoryW */
  59 static DWORD default_search_flags;  /* default flags set by SetDefaultDllDirectories */
  60
  61 /* to keep track of LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE file handles */
  62 struct exclusive_datafile
  63 {
  64     struct list entry;
  65     HMODULE     module;
  66     HANDLE      file;
  67 };
  68 static struct list exclusive_datafile_list = LIST_INIT( exclusive_datafile_list );
  69
  70 static CRITICAL_SECTION dlldir_section;
  71 static CRITICAL_SECTION_DEBUG critsect_debug =
  72 {
  73     0, 0, &dlldir_section,
  74     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  75       0, 0, { (DWORD_PTR)(__FILE__ ": dlldir_section") }
  76 };
  77 static CRITICAL_SECTION dlldir_section = { &critsect_debug, -1, 0, 0, 0, 0 };
  78
  79 /****************************************************************************
  80  *              GetDllDirectoryA   (KERNEL32.@)
  81  */
  82 DWORD WINAPI GetDllDirectoryA( DWORD buf_len, LPSTR buffer )
  83 {
  84     DWORD len;
  85
  86     RtlEnterCriticalSection( &dlldir_section );
  87     len = dll_directory ? FILE_name_WtoA( dll_directory, strlenW(dll_directory), NULL, 0 ) : 0;
  88     if (buffer && buf_len > len)
  89     {
  90         if (dll_directory) FILE_name_WtoA( dll_directory, -1, buffer, buf_len );
  91         else *buffer = 0;
  92     }
  93     else
  94     {
  95         len++;  /* for terminating null */
  96         if (buffer) *buffer = 0;
  97     }
  98     RtlLeaveCriticalSection( &dlldir_section );
  99     return len;
 100 }
 101
 102
 103 /****************************************************************************
 104  *              GetDllDirectoryW   (KERNEL32.@)
 105  */
 106 DWORD WINAPI GetDllDirectoryW( DWORD buf_len, LPWSTR buffer )
 107 {
 108     DWORD len;
 109
 110     RtlEnterCriticalSection( &dlldir_section );
 111     len = dll_directory ? strlenW( dll_directory ) : 0;
 112     if (buffer && buf_len > len)
 113     {
 114         if (dll_directory) memcpy( buffer, dll_directory, (len + 1) * sizeof(WCHAR) );
 115         else *buffer = 0;
 116     }
 117     else
 118     {
 119         len++;  /* for terminating null */
 120         if (buffer) *buffer = 0;
 121     }
 122     RtlLeaveCriticalSection( &dlldir_section );
 123     return len;
 124 }
 125
 126
 127 /****************************************************************************
 128  *              SetDllDirectoryA   (KERNEL32.@)
 129  */
 130 BOOL WINAPI SetDllDirectoryA( LPCSTR dir )
 131 {
 132     WCHAR *dirW;
 133     BOOL ret;
 134
 135     if (!(dirW = FILE_name_AtoW( dir, TRUE ))) return FALSE;
 136     ret = SetDllDirectoryW( dirW );
 137     HeapFree( GetProcessHeap(), 0, dirW );
 138     return ret;
 139 }
 140
 141
 142 /****************************************************************************
 143  *              SetDllDirectoryW   (KERNEL32.@)
 144  */
 145 BOOL WINAPI SetDllDirectoryW( LPCWSTR dir )
 146 {
 147     WCHAR *newdir = NULL;
 148
 149     if (dir)
 150     {
 151         DWORD len = (strlenW(dir) + 1) * sizeof(WCHAR);
 152         if (!(newdir = HeapAlloc( GetProcessHeap(), 0, len )))
 153         {
 154             SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 155             return FALSE;
 156         }
 157         memcpy( newdir, dir, len );
 158     }
 159
 160     RtlEnterCriticalSection( &dlldir_section );
 161     HeapFree( GetProcessHeap(), 0, dll_directory );
 162     dll_directory = newdir;
 163     RtlLeaveCriticalSection( &dlldir_section );
 164     return TRUE;
 165 }
 166
 167
 168 /****************************************************************************
 169  *              AddDllDirectory   (KERNEL32.@)
 170  */
 171 DLL_DIRECTORY_COOKIE WINAPI AddDllDirectory( const WCHAR *dir )
 172 {
 173     WCHAR path[MAX_PATH];
 174     DWORD len;
 175     struct dll_dir_entry *ptr;
 176     DOS_PATHNAME_TYPE type = RtlDetermineDosPathNameType_U( dir );
 177
 178     if (type != ABSOLUTE_PATH && type != ABSOLUTE_DRIVE_PATH)
 179     {
 180         SetLastError( ERROR_INVALID_PARAMETER );
 181         return NULL;
 182     }
 183     if (!(len = GetFullPathNameW( dir, MAX_PATH, path, NULL ))) return NULL;
 184     if (GetFileAttributesW( path ) == INVALID_FILE_ATTRIBUTES) return NULL;
 185
 186     if (!(ptr = HeapAlloc( GetProcessHeap(), 0, offsetof(struct dll_dir_entry, dir[++len] )))) return NULL;
 187     memcpy( ptr->dir, path, len * sizeof(WCHAR) );
 188     TRACE( "%s\n", debugstr_w( ptr->dir ));
 189
 190     RtlEnterCriticalSection( &dlldir_section );
 191     list_add_head( &dll_dir_list, &ptr->entry );
 192     RtlLeaveCriticalSection( &dlldir_section );
 193     return ptr;
 194 }
 195
 196
 197 /****************************************************************************
 198  *              RemoveDllDirectory   (KERNEL32.@)
 199  */
 200 BOOL WINAPI RemoveDllDirectory( DLL_DIRECTORY_COOKIE cookie )
 201 {
 202     struct dll_dir_entry *ptr = cookie;
 203
 204     TRACE( "%s\n", debugstr_w( ptr->dir ));
 205
 206     RtlEnterCriticalSection( &dlldir_section );
 207     list_remove( &ptr->entry );
 208     HeapFree( GetProcessHeap(), 0, ptr );
 209     RtlLeaveCriticalSection( &dlldir_section );
 210     return TRUE;
 211 }
 212
 213
 214 /*************************************************************************
 215  *           SetDefaultDllDirectories   (KERNEL32.@)
 216  */
 217 BOOL WINAPI SetDefaultDllDirectories( DWORD flags )
 218 {
 219     /* LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR doesn't make sense in default dirs */
 220     const DWORD load_library_search_flags = (LOAD_LIBRARY_SEARCH_APPLICATION_DIR |
 221                                              LOAD_LIBRARY_SEARCH_USER_DIRS |
 222                                              LOAD_LIBRARY_SEARCH_SYSTEM32 |
 223                                              LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
 224
 225     if (!flags || (flags & ~load_library_search_flags))
 226     {
 227         SetLastError( ERROR_INVALID_PARAMETER );
 228         return FALSE;
 229     }
 230     default_search_flags = flags;
 231     return TRUE;
 232 }
 233
 234
 235 /****************************************************************************
 236  *              DisableThreadLibraryCalls (KERNEL32.@)
 237  *
 238  * Inform the module loader that thread notifications are not required for a dll.
 239  *
 240  * PARAMS
 241  *  hModule [I] Module handle to skip calls for
 242  *
 243  * RETURNS
 244  *  Success: TRUE. Thread attach and detach notifications will not be sent
 245  *           to hModule.
 246  *  Failure: FALSE. Use GetLastError() to determine the cause.
 247  *
 248  * NOTES
 249  *  This is typically called from the dll entry point of a dll during process
 250  *  attachment, for dlls that do not need to process thread notifications.
 251  */
 252 BOOL WINAPI DisableThreadLibraryCalls( HMODULE hModule )
 253 {
 254     NTSTATUS    nts = LdrDisableThreadCalloutsForDll( hModule );
 255     if (nts == STATUS_SUCCESS) return TRUE;
 256
 257     SetLastError( RtlNtStatusToDosError( nts ) );
 258     return FALSE;
 259 }
 260
 261
 262 /***********************************************************************
 263  *             GetBinaryTypeW                     [KERNEL32.@]
 264  *
 265  * Determine whether a file is executable, and if so, what kind.
 266  *
 267  * PARAMS
 268  *  lpApplicationName [I] Path of the file to check
 269  *  lpBinaryType      [O] Destination for the binary type
 270  *
 271  * RETURNS
 272  *  TRUE, if the file is an executable, in which case lpBinaryType is set.
 273  *  FALSE, if the file is not an executable or if the function fails.
 274  *
 275  * NOTES
 276  *  The type of executable is a property that determines which subsystem an
 277  *  executable file runs under. lpBinaryType can be set to one of the following
 278  *  values:
 279  *   SCS_32BIT_BINARY: A Win32 based application
 280  *   SCS_64BIT_BINARY: A Win64 based application
 281  *   SCS_DOS_BINARY: An MS-Dos based application
 282  *   SCS_WOW_BINARY: A Win16 based application
 283  *   SCS_PIF_BINARY: A PIF file that executes an MS-Dos based app
 284  *   SCS_POSIX_BINARY: A POSIX based application ( Not implemented )
 285  *   SCS_OS216_BINARY: A 16bit OS/2 based application
 286  *
 287  *  To find the binary type, this function reads in the files header information.
 288  *  If extended header information is not present it will assume that the file
 289  *  is a DOS executable. If extended header information is present it will
 290  *  determine if the file is a 16, 32 or 64 bit Windows executable by checking the
 291  *  flags in the header.
 292  *
 293  *  ".com" and ".pif" files are only recognized by their file name extension,
 294  *  as per native Windows.
 295  */
 296 BOOL WINAPI GetBinaryTypeW( LPCWSTR name, LPDWORD type )
 297 {
 298     static const WCHAR comW[] = { '.','c','o','m',0 };
 299     static const WCHAR pifW[] = { '.','p','i','f',0 };
 300     HANDLE hfile, mapping;
 301     NTSTATUS status;
 302     const WCHAR *ptr;
 303
 304     TRACE("%s\n", debugstr_w(name) );
 305
 306     if (type == NULL) return FALSE;
 307
 308     hfile = CreateFileW( name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
 309     if ( hfile == INVALID_HANDLE_VALUE )
 310         return FALSE;
 311
 312     status = NtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY,
 313                               NULL, NULL, PAGE_READONLY, SEC_IMAGE, hfile );
 314     CloseHandle( hfile );
 315
 316     switch (status)
 317     {
 318     case STATUS_SUCCESS:
 319         {
 320             SECTION_IMAGE_INFORMATION info;
 321
 322             status = NtQuerySection( mapping, SectionImageInformation, &info, sizeof(info), NULL );
 323             CloseHandle( mapping );
 324             if (status) return FALSE;
 325             switch (info.Machine)
 326             {
 327             case IMAGE_FILE_MACHINE_I386:
 328             case IMAGE_FILE_MACHINE_ARM:
 329             case IMAGE_FILE_MACHINE_THUMB:
 330             case IMAGE_FILE_MACHINE_ARMNT:
 331             case IMAGE_FILE_MACHINE_POWERPC:
 332                 *type = SCS_32BIT_BINARY;
 333                 return TRUE;
 334             case IMAGE_FILE_MACHINE_AMD64:
 335             case IMAGE_FILE_MACHINE_ARM64:
 336                 *type = SCS_64BIT_BINARY;
 337                 return TRUE;
 338             }
 339             return FALSE;
 340         }
 341     case STATUS_INVALID_IMAGE_WIN_16:
 342         *type = SCS_WOW_BINARY;
 343         return TRUE;
 344     case STATUS_INVALID_IMAGE_WIN_32:
 345         *type = SCS_32BIT_BINARY;
 346         return TRUE;
 347     case STATUS_INVALID_IMAGE_WIN_64:
 348         *type = SCS_64BIT_BINARY;
 349         return TRUE;
 350     case STATUS_INVALID_IMAGE_NE_FORMAT:
 351         *type = SCS_OS216_BINARY;
 352         return TRUE;
 353     case STATUS_INVALID_IMAGE_PROTECT:
 354         *type = SCS_DOS_BINARY;
 355         return TRUE;
 356     case STATUS_INVALID_IMAGE_NOT_MZ:
 357         if ((ptr = strrchrW( name, '.' )))
 358         {
 359             if (!strcmpiW( ptr, comW ))
 360             {
 361                 *type = SCS_DOS_BINARY;
 362                 return TRUE;
 363             }
 364             if (!strcmpiW( ptr, pifW ))
 365             {
 366                 *type = SCS_PIF_BINARY;
 367                 return TRUE;
 368             }
 369         }
 370         return FALSE;
 371     default:
 372         return FALSE;
 373     }
 374 }
 375
 376 /***********************************************************************
 377  *             GetBinaryTypeA                     [KERNEL32.@]
 378  *             GetBinaryType                      [KERNEL32.@]
 379  *
 380  * See GetBinaryTypeW.
 381  */
 382 BOOL WINAPI GetBinaryTypeA( LPCSTR lpApplicationName, LPDWORD lpBinaryType )
 383 {
 384     ANSI_STRING app_nameA;
 385     NTSTATUS status;
 386
 387     TRACE("%s\n", debugstr_a(lpApplicationName));
 388
 389     /* Sanity check.
 390      */
 391     if ( lpApplicationName == NULL || lpBinaryType == NULL )
 392         return FALSE;
 393
 394     RtlInitAnsiString(&app_nameA, lpApplicationName);
 395     status = RtlAnsiStringToUnicodeString(&NtCurrentTeb()->StaticUnicodeString,
 396                                           &app_nameA, FALSE);
 397     if (!status)
 398         return GetBinaryTypeW(NtCurrentTeb()->StaticUnicodeString.Buffer, lpBinaryType);
 399
 400     SetLastError(RtlNtStatusToDosError(status));
 401     return FALSE;
 402 }
 403
 404 /***********************************************************************
 405  *              GetModuleHandleExA         (KERNEL32.@)
 406  */
 407 BOOL WINAPI GetModuleHandleExA( DWORD flags, LPCSTR name, HMODULE *module )
 408 {
 409     WCHAR *nameW;
 410
 411     if (!name || (flags & GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS))
 412         return GetModuleHandleExW( flags, (LPCWSTR)name, module );
 413
 414     if (!(nameW = FILE_name_AtoW( name, FALSE ))) return FALSE;
 415     return GetModuleHandleExW( flags, nameW, module );
 416 }
 417
 418 /***********************************************************************
 419  *              GetModuleHandleExW         (KERNEL32.@)
 420  */
 421 BOOL WINAPI GetModuleHandleExW( DWORD flags, LPCWSTR name, HMODULE *module )
 422 {
 423     NTSTATUS status = STATUS_SUCCESS;
 424     HMODULE ret;
 425     ULONG_PTR magic;
 426     BOOL lock;
 427
 428     if (!module)
 429     {
 430         SetLastError( ERROR_INVALID_PARAMETER );
 431         return FALSE;
 432     }
 433
 434     /* if we are messing with the refcount, grab the loader lock */
 435     lock = (flags & GET_MODULE_HANDLE_EX_FLAG_PIN) || !(flags & GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT);
 436     if (lock)
 437         LdrLockLoaderLock( 0, NULL, &magic );
 438
 439     if (!name)
 440     {
 441         ret = NtCurrentTeb()->Peb->ImageBaseAddress;
 442     }
 443     else if (flags & GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS)
 444     {
 445         void *dummy;
 446         if (!(ret = RtlPcToFileHeader( (void *)name, &dummy ))) status = STATUS_DLL_NOT_FOUND;
 447     }
 448     else
 449     {
 450         UNICODE_STRING wstr;
 451         RtlInitUnicodeString( &wstr, name );
 452         status = LdrGetDllHandle( NULL, 0, &wstr, &ret );
 453     }
 454
 455     if (status == STATUS_SUCCESS)
 456     {
 457         if (flags & GET_MODULE_HANDLE_EX_FLAG_PIN)
 458             LdrAddRefDll( LDR_ADDREF_DLL_PIN, ret );
 459         else if (!(flags & GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT))
 460             LdrAddRefDll( 0, ret );
 461     }
 462     else SetLastError( RtlNtStatusToDosError( status ) );
 463
 464     if (lock)
 465         LdrUnlockLoaderLock( 0, magic );
 466
 467     if (status == STATUS_SUCCESS) *module = ret;
 468     else *module = NULL;
 469
 470     return (status == STATUS_SUCCESS);
 471 }
 472
 473 /***********************************************************************
 474  *              GetModuleHandleA         (KERNEL32.@)
 475  *
 476  * Get the handle of a dll loaded into the process address space.
 477  *
 478  * PARAMS
 479  *  module [I] Name of the dll
 480  *
 481  * RETURNS
 482  *  Success: A handle to the loaded dll.
 483  *  Failure: A NULL handle. Use GetLastError() to determine the cause.
 484  */
 485 HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR module)
 486 {
 487     HMODULE ret;
 488
 489     GetModuleHandleExA( GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, module, &ret );
 490     return ret;
 491 }
 492
 493 /***********************************************************************
 494  *              GetModuleHandleW (KERNEL32.@)
 495  *
 496  * Unicode version of GetModuleHandleA.
 497  */
 498 HMODULE WINAPI GetModuleHandleW(LPCWSTR module)
 499 {
 500     HMODULE ret;
 501
 502     GetModuleHandleExW( GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, module, &ret );
 503     return ret;
 504 }
 505
 506
 507 /***********************************************************************
 508  *              GetModuleFileNameA      (KERNEL32.@)
 509  *
 510  * Get the file name of a loaded module from its handle.
 511  *
 512  * RETURNS
 513  *  Success: The length of the file name, excluding the terminating NUL.
 514  *  Failure: 0. Use GetLastError() to determine the cause.
 515  *
 516  * NOTES
 517  *  This function always returns the long path of hModule
 518  *  The function doesn't write a terminating '\0' if the buffer is too
 519  *  small.
 520  */
 521 DWORD WINAPI GetModuleFileNameA(
 522         HMODULE hModule,        /* [in] Module handle (32 bit) */
 523         LPSTR lpFileName,       /* [out] Destination for file name */
 524         DWORD size )            /* [in] Size of lpFileName in characters */
 525 {
 526     LPWSTR filenameW = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) );
 527     DWORD len;
 528
 529     if (!filenameW)
 530     {
 531         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 532         return 0;
 533     }
 534     if ((len = GetModuleFileNameW( hModule, filenameW, size )))
 535     {
 536         len = FILE_name_WtoA( filenameW, len, lpFileName, size );
 537         if (len < size)
 538             lpFileName[len] = '\0';
 539         else
 540             SetLastError( ERROR_INSUFFICIENT_BUFFER );
 541     }
 542     HeapFree( GetProcessHeap(), 0, filenameW );
 543     return len;
 544 }
 545
 546 /***********************************************************************
 547  *              GetModuleFileNameW      (KERNEL32.@)
 548  *
 549  * Unicode version of GetModuleFileNameA.
 550  */
 551 DWORD WINAPI GetModuleFileNameW( HMODULE hModule, LPWSTR lpFileName, DWORD size )
 552 {
 553     ULONG len = 0;
 554     ULONG_PTR magic;
 555     LDR_MODULE *pldr;
 556     NTSTATUS nts;
 557     WIN16_SUBSYSTEM_TIB *win16_tib;
 558
 559     if (!hModule && ((win16_tib = NtCurrentTeb()->Tib.SubSystemTib)) && win16_tib->exe_name)
 560     {
 561         len = min(size, win16_tib->exe_name->Length / sizeof(WCHAR));
 562         memcpy( lpFileName, win16_tib->exe_name->Buffer, len * sizeof(WCHAR) );
 563         if (len < size) lpFileName[len] = '\0';
 564         goto done;
 565     }
 566
 567     LdrLockLoaderLock( 0, NULL, &magic );
 568
 569     if (!hModule) hModule = NtCurrentTeb()->Peb->ImageBaseAddress;
 570     nts = LdrFindEntryForAddress( hModule, &pldr );
 571     if (nts == STATUS_SUCCESS)
 572     {
 573         len = min(size, pldr->FullDllName.Length / sizeof(WCHAR));
 574         memcpy(lpFileName, pldr->FullDllName.Buffer, len * sizeof(WCHAR));
 575         if (len < size)
 576         {
 577             lpFileName[len] = '\0';
 578             SetLastError( 0 );
 579         }
 580         else
 581             SetLastError( ERROR_INSUFFICIENT_BUFFER );
 582     }
 583     else SetLastError( RtlNtStatusToDosError( nts ) );
 584
 585     LdrUnlockLoaderLock( 0, magic );
 586 done:
 587     TRACE( "%s\n", debugstr_wn(lpFileName, len) );
 588     return len;
 589 }
 590
 591
 592 /***********************************************************************
 593  *           get_dll_system_path
 594  */
 595 static const WCHAR *get_dll_system_path(void)
 596 {
 597     static WCHAR *cached_path;
 598
 599     if (!cached_path)
 600     {
 601         WCHAR *p, *path;
 602         int len = 1;
 603
 604         len += 2 * GetSystemDirectoryW( NULL, 0 );
 605         len += GetWindowsDirectoryW( NULL, 0 );
 606         p = path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 607         GetSystemDirectoryW( p, path + len - p);
 608         p += strlenW(p);
 609         /* if system directory ends in "32" add 16-bit version too */
 610         if (p[-2] == '3' && p[-1] == '2')
 611         {
 612             *p++ = ';';
 613             GetSystemDirectoryW( p, path + len - p);
 614             p += strlenW(p) - 2;
 615         }
 616         *p++ = ';';
 617         GetWindowsDirectoryW( p, path + len - p);
 618         cached_path = path;
 619     }
 620     return cached_path;
 621 }
 622
 623 /***********************************************************************
 624  *           get_dll_safe_mode
 625  */
 626 static BOOL get_dll_safe_mode(void)
 627 {
 628     static const WCHAR keyW[] = {'\\','R','e','g','i','s','t','r','y','\\',
 629                                  'M','a','c','h','i','n','e','\\',
 630                                  'S','y','s','t','e','m','\\',
 631                                  'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 632                                  'C','o','n','t','r','o','l','\\',
 633                                  'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r',0};
 634     static const WCHAR valueW[] = {'S','a','f','e','D','l','l','S','e','a','r','c','h','M','o','d','e',0};
 635
 636     static int safe_mode = -1;
 637
 638     if (safe_mode == -1)
 639     {
 640         char buffer[offsetof(KEY_VALUE_PARTIAL_INFORMATION, Data[sizeof(DWORD)])];
 641         KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
 642         OBJECT_ATTRIBUTES attr;
 643         UNICODE_STRING nameW;
 644         HANDLE hkey;
 645         DWORD size = sizeof(buffer);
 646
 647         attr.Length = sizeof(attr);
 648         attr.RootDirectory = 0;
 649         attr.ObjectName = &nameW;
 650         attr.Attributes = 0;
 651         attr.SecurityDescriptor = NULL;
 652         attr.SecurityQualityOfService = NULL;
 653
 654         safe_mode = 1;
 655         RtlInitUnicodeString( &nameW, keyW );
 656         if (!NtOpenKey( &hkey, KEY_READ, &attr ))
 657         {
 658             RtlInitUnicodeString( &nameW, valueW );
 659             if (!NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, buffer, size, &size ) &&
 660                 info->Type == REG_DWORD && info->DataLength == sizeof(DWORD))
 661                 safe_mode = !!*(DWORD *)info->Data;
 662             NtClose( hkey );
 663         }
 664         if (!safe_mode) TRACE( "SafeDllSearchMode disabled through the registry\n" );
 665     }
 666     return safe_mode;
 667 }
 668
 669 /******************************************************************
 670  *              get_module_path_end
 671  *
 672  * Returns the end of the directory component of the module path.
 673  */
 674 static inline const WCHAR *get_module_path_end(const WCHAR *module)
 675 {
 676     const WCHAR *p;
 677     const WCHAR *mod_end = module;
 678     if (!module) return mod_end;
 679
 680     if ((p = strrchrW( mod_end, '\\' ))) mod_end = p;
 681     if ((p = strrchrW( mod_end, '/' ))) mod_end = p;
 682     if (mod_end == module + 2 && module[1] == ':') mod_end++;
 683     if (mod_end == module && module[0] && module[1] == ':') mod_end += 2;
 684
 685     return mod_end;
 686 }
 687
 688
 689 /******************************************************************
 690  *              append_path_len
 691  *
 692  * Append a counted string to the load path. Helper for MODULE_get_dll_load_path.
 693  */
 694 static inline WCHAR *append_path_len( WCHAR *p, const WCHAR *str, DWORD len )
 695 {
 696     if (!len) return p;
 697     memcpy( p, str, len * sizeof(WCHAR) );
 698     p[len] = ';';
 699     return p + len + 1;
 700 }
 701
 702
 703 /******************************************************************
 704  *              append_path
 705  *
 706  * Append a string to the load path. Helper for MODULE_get_dll_load_path.
 707  */
 708 static inline WCHAR *append_path( WCHAR *p, const WCHAR *str )
 709 {
 710     return append_path_len( p, str, strlenW(str) );
 711 }
 712
 713
 714 /******************************************************************
 715  *              MODULE_get_dll_load_path
 716  *
 717  * Compute the load path to use for a given dll.
 718  * Returned pointer must be freed by caller.
 719  */
 720 WCHAR *MODULE_get_dll_load_path( LPCWSTR module, int safe_mode )
 721 {
 722     static const WCHAR pathW[] = {'P','A','T','H',0};
 723     static const WCHAR dotW[] = {'.',0};
 724
 725     const WCHAR *system_path = get_dll_system_path();
 726     const WCHAR *mod_end = NULL;
 727     UNICODE_STRING name, value;
 728     WCHAR *p, *ret;
 729     int len = 0, path_len = 0;
 730
 731     /* adjust length for module name */
 732
 733     if (module)
 734         mod_end = get_module_path_end( module );
 735     /* if module is NULL or doesn't contain a path, fall back to directory
 736      * process was loaded from */
 737     if (module == mod_end)
 738     {
 739         module = NtCurrentTeb()->Peb->ProcessParameters->ImagePathName.Buffer;
 740         mod_end = get_module_path_end( module );
 741     }
 742     len += (mod_end - module) + 1;
 743
 744     len += strlenW( system_path ) + 2;
 745
 746     /* get the PATH variable */
 747
 748     RtlInitUnicodeString( &name, pathW );
 749     value.Length = 0;
 750     value.MaximumLength = 0;
 751     value.Buffer = NULL;
 752     if (RtlQueryEnvironmentVariable_U( NULL, &name, &value ) == STATUS_BUFFER_TOO_SMALL)
 753         path_len = value.Length;
 754
 755     RtlEnterCriticalSection( &dlldir_section );
 756     if (safe_mode == -1) safe_mode = get_dll_safe_mode();
 757     if (dll_directory) len += strlenW(dll_directory) + 1;
 758     else len += 2;  /* current directory */
 759     if ((p = ret = HeapAlloc( GetProcessHeap(), 0, path_len + len * sizeof(WCHAR) )))
 760     {
 761         if (module) p = append_path_len( p, module, mod_end - module );
 762
 763         if (dll_directory) p = append_path( p, dll_directory );
 764         else if (!safe_mode) p = append_path( p, dotW );
 765
 766         p = append_path( p, system_path );
 767
 768         if (!dll_directory && safe_mode) p = append_path( p, dotW );
 769     }
 770     RtlLeaveCriticalSection( &dlldir_section );
 771     if (!ret) return NULL;
 772
 773     value.Buffer = p;
 774     value.MaximumLength = path_len;
 775
 776     while (RtlQueryEnvironmentVariable_U( NULL, &name, &value ) == STATUS_BUFFER_TOO_SMALL)
 777     {
 778         WCHAR *new_ptr;
 779
 780         /* grow the buffer and retry */
 781         path_len = value.Length;
 782         if (!(new_ptr = HeapReAlloc( GetProcessHeap(), 0, ret, path_len + len * sizeof(WCHAR) )))
 783         {
 784             HeapFree( GetProcessHeap(), 0, ret );
 785             return NULL;
 786         }
 787         value.Buffer = new_ptr + (value.Buffer - ret);
 788         value.MaximumLength = path_len;
 789         ret = new_ptr;
 790     }
 791     value.Buffer[value.Length / sizeof(WCHAR)] = 0;
 792     return ret;
 793 }
 794
 795
 796 /******************************************************************
 797  *              get_dll_load_path_search_flags
 798  */
 799 static WCHAR *get_dll_load_path_search_flags( LPCWSTR module, DWORD flags )
 800 {
 801     const WCHAR *image = NULL, *mod_end, *image_end;
 802     struct dll_dir_entry *dir;
 803     WCHAR *p, *ret;
 804     int len = 1;
 805
 806     if (flags & LOAD_LIBRARY_SEARCH_DEFAULT_DIRS)
 807         flags |= (LOAD_LIBRARY_SEARCH_APPLICATION_DIR |
 808                   LOAD_LIBRARY_SEARCH_USER_DIRS |
 809                   LOAD_LIBRARY_SEARCH_SYSTEM32);
 810
 811     if (flags & LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR)
 812     {
 813         DWORD type = RtlDetermineDosPathNameType_U( module );
 814         if (type != ABSOLUTE_DRIVE_PATH && type != ABSOLUTE_PATH)
 815         {
 816             SetLastError( ERROR_INVALID_PARAMETER );
 817             return NULL;
 818         }
 819         mod_end = get_module_path_end( module );
 820         len += (mod_end - module) + 1;
 821     }
 822     else module = NULL;
 823
 824     RtlEnterCriticalSection( &dlldir_section );
 825
 826     if (flags & LOAD_LIBRARY_SEARCH_APPLICATION_DIR)
 827     {
 828         image = NtCurrentTeb()->Peb->ProcessParameters->ImagePathName.Buffer;
 829         image_end = get_module_path_end( image );
 830         len += (image_end - image) + 1;
 831     }
 832
 833     if (flags & LOAD_LIBRARY_SEARCH_USER_DIRS)
 834     {
 835         LIST_FOR_EACH_ENTRY( dir, &dll_dir_list, struct dll_dir_entry, entry )
 836             len += strlenW( dir->dir ) + 1;
 837         if (dll_directory) len += strlenW(dll_directory) + 1;
 838     }
 839
 840     if (flags & LOAD_LIBRARY_SEARCH_SYSTEM32) len += GetSystemDirectoryW( NULL, 0 );
 841
 842     if ((p = ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
 843     {
 844         if (module) p = append_path_len( p, module, mod_end - module );
 845         if (image) p = append_path_len( p, image, image_end - image );
 846         if (flags & LOAD_LIBRARY_SEARCH_USER_DIRS)
 847         {
 848             LIST_FOR_EACH_ENTRY( dir, &dll_dir_list, struct dll_dir_entry, entry )
 849                 p = append_path( p, dir->dir );
 850             if (dll_directory) p = append_path( p, dll_directory );
 851         }
 852         if (flags & LOAD_LIBRARY_SEARCH_SYSTEM32) GetSystemDirectoryW( p, ret + len - p );
 853         else
 854         {
 855             if (p > ret) p--;
 856             *p = 0;
 857         }
 858     }
 859
 860     RtlLeaveCriticalSection( &dlldir_section );
 861     return ret;
 862 }
 863
 864
 865 /******************************************************************
 866  *              load_library_as_datafile
 867  */
 868 static BOOL load_library_as_datafile( LPCWSTR name, HMODULE *hmod, DWORD flags )
 869 {
 870     static const WCHAR dotDLL[] = {'.','d','l','l',0};
 871
 872     WCHAR filenameW[MAX_PATH];
 873     HANDLE hFile = INVALID_HANDLE_VALUE;
 874     HANDLE mapping;
 875     HMODULE module = 0;
 876     DWORD protect = PAGE_READONLY;
 877     DWORD sharing = FILE_SHARE_READ | FILE_SHARE_DELETE;
 878
 879     *hmod = 0;
 880
 881     if (flags & LOAD_LIBRARY_AS_IMAGE_RESOURCE) protect |= SEC_IMAGE;
 882
 883     if (SearchPathW( NULL, name, dotDLL, ARRAY_SIZE( filenameW ), filenameW, NULL ))
 884     {
 885         hFile = CreateFileW( filenameW, GENERIC_READ, sharing, NULL, OPEN_EXISTING, 0, 0 );
 886     }
 887     if (hFile == INVALID_HANDLE_VALUE) return FALSE;
 888
 889     mapping = CreateFileMappingW( hFile, NULL, protect, 0, 0, NULL );
 890     if (!mapping) goto failed;
 891
 892     module = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
 893     CloseHandle( mapping );
 894     if (!module) goto failed;
 895
 896     if (!(flags & LOAD_LIBRARY_AS_IMAGE_RESOURCE))
 897     {
 898         /* make sure it's a valid PE file */
 899         if (!RtlImageNtHeader( module )) goto failed;
 900         *hmod = (HMODULE)((char *)module + 1); /* set bit 0 for data file module */
 901
 902         if (flags & LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE)
 903         {
 904             struct exclusive_datafile *file = HeapAlloc( GetProcessHeap(), 0, sizeof(*file) );
 905             if (!file) goto failed;
 906             file->module = *hmod;
 907             file->file   = hFile;
 908             list_add_head( &exclusive_datafile_list, &file->entry );
 909             TRACE( "delaying close %p for module %p\n", file->file, file->module );
 910             return TRUE;
 911         }
 912     }
 913     else *hmod = (HMODULE)((char *)module + 2); /* set bit 1 for image resource module */
 914
 915     CloseHandle( hFile );
 916     return TRUE;
 917
 918 failed:
 919     if (module) UnmapViewOfFile( module );
 920     CloseHandle( hFile );
 921     return FALSE;
 922 }
 923
 924
 925 /******************************************************************
 926  *              load_library
 927  *
 928  * Helper for LoadLibraryExA/W.
 929  */
 930 static HMODULE load_library( const UNICODE_STRING *libname, DWORD flags )
 931 {
 932     NTSTATUS nts;
 933     HMODULE hModule;
 934     WCHAR *load_path;
 935     const DWORD load_library_search_flags = (LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR |
 936                                              LOAD_LIBRARY_SEARCH_APPLICATION_DIR |
 937                                              LOAD_LIBRARY_SEARCH_USER_DIRS |
 938                                              LOAD_LIBRARY_SEARCH_SYSTEM32 |
 939                                              LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
 940     const DWORD unsupported_flags = (LOAD_IGNORE_CODE_AUTHZ_LEVEL |
 941                                      LOAD_LIBRARY_REQUIRE_SIGNED_TARGET);
 942
 943     if (!(flags & load_library_search_flags)) flags |= default_search_flags;
 944
 945     if( flags & unsupported_flags)
 946         FIXME("unsupported flag(s) used (flags: 0x%08x)\n", flags);
 947
 948     if (flags & load_library_search_flags)
 949         load_path = get_dll_load_path_search_flags( libname->Buffer, flags );
 950     else
 951         load_path = MODULE_get_dll_load_path( flags & LOAD_WITH_ALTERED_SEARCH_PATH ? libname->Buffer : NULL, -1 );
 952     if (!load_path) return 0;
 953
 954     if (flags & (LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE | LOAD_LIBRARY_AS_IMAGE_RESOURCE))
 955     {
 956         ULONG_PTR magic;
 957
 958         LdrLockLoaderLock( 0, NULL, &magic );
 959         if (!LdrGetDllHandle( load_path, flags, libname, &hModule ))
 960         {
 961             LdrAddRefDll( 0, hModule );
 962             LdrUnlockLoaderLock( 0, magic );
 963             goto done;
 964         }
 965         if (load_library_as_datafile( libname->Buffer, &hModule, flags ))
 966         {
 967             LdrUnlockLoaderLock( 0, magic );
 968             goto done;
 969         }
 970         LdrUnlockLoaderLock( 0, magic );
 971         flags |= DONT_RESOLVE_DLL_REFERENCES; /* Just in case */
 972         /* Fallback to normal behaviour */
 973     }
 974
 975     nts = LdrLoadDll( load_path, flags, libname, &hModule );
 976     if (nts != STATUS_SUCCESS)
 977     {
 978         hModule = 0;
 979         if (nts == STATUS_DLL_NOT_FOUND && (GetVersion() & 0x80000000))
 980             SetLastError( ERROR_DLL_NOT_FOUND );
 981         else
 982             SetLastError( RtlNtStatusToDosError( nts ) );
 983     }
 984 done:
 985     HeapFree( GetProcessHeap(), 0, load_path );
 986     return hModule;
 987 }
 988
 989
 990 /******************************************************************
 991  *              LoadLibraryExA          (KERNEL32.@)
 992  *
 993  * Load a dll file into the process address space.
 994  *
 995  * PARAMS
 996  *  libname [I] Name of the file to load
 997  *  hfile   [I] Reserved, must be 0.
 998  *  flags   [I] Flags for loading the dll
 999  *
1000  * RETURNS
1001  *  Success: A handle to the loaded dll.
1002  *  Failure: A NULL handle. Use GetLastError() to determine the cause.
1003  *
1004  * NOTES
1005  * The HFILE parameter is not used and marked reserved in the SDK. I can
1006  * only guess that it should force a file to be mapped, but I rather
1007  * ignore the parameter because it would be extremely difficult to
1008  * integrate this with different types of module representations.
1009  */
1010 HMODULE WINAPI DECLSPEC_HOTPATCH LoadLibraryExA(LPCSTR libname, HANDLE hfile, DWORD flags)
1011 {
1012     WCHAR *libnameW;
1013
1014     if (!(libnameW = FILE_name_AtoW( libname, FALSE ))) return 0;
1015     return LoadLibraryExW( libnameW, hfile, flags );
1016 }
1017
1018 /***********************************************************************
1019  *           LoadLibraryExW       (KERNEL32.@)
1020  *
1021  * Unicode version of LoadLibraryExA.
1022  */
1023 HMODULE WINAPI DECLSPEC_HOTPATCH LoadLibraryExW(LPCWSTR libnameW, HANDLE hfile, DWORD flags)
1024 {
1025     UNICODE_STRING      wstr;
1026     HMODULE             res;
1027
1028     if (!libnameW)
1029     {
1030         SetLastError(ERROR_INVALID_PARAMETER);
1031         return 0;
1032     }
1033     RtlInitUnicodeString( &wstr, libnameW );
1034     if (wstr.Buffer[wstr.Length/sizeof(WCHAR) - 1] != ' ')
1035         return load_library( &wstr, flags );
1036
1037     /* Library name has trailing spaces */
1038     RtlCreateUnicodeString( &wstr, libnameW );
1039     while (wstr.Length > sizeof(WCHAR) &&
1040            wstr.Buffer[wstr.Length/sizeof(WCHAR) - 1] == ' ')
1041     {
1042         wstr.Length -= sizeof(WCHAR);
1043     }
1044     wstr.Buffer[wstr.Length/sizeof(WCHAR)] = '\0';
1045     res = load_library( &wstr, flags );
1046     RtlFreeUnicodeString( &wstr );
1047     return res;
1048 }
1049
1050 /***********************************************************************
1051  *           LoadLibraryA         (KERNEL32.@)
1052  *
1053  * Load a dll file into the process address space.
1054  *
1055  * PARAMS
1056  *  libname [I] Name of the file to load
1057  *
1058  * RETURNS
1059  *  Success: A handle to the loaded dll.
1060  *  Failure: A NULL handle. Use GetLastError() to determine the cause.
1061  *
1062  * NOTES
1063  * See LoadLibraryExA().
1064  */
1065 HMODULE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR libname)
1066 {
1067     return LoadLibraryExA(libname, 0, 0);
1068 }
1069
1070 /***********************************************************************
1071  *           LoadLibraryW         (KERNEL32.@)
1072  *
1073  * Unicode version of LoadLibraryA.
1074  */
1075 HMODULE WINAPI DECLSPEC_HOTPATCH LoadLibraryW(LPCWSTR libnameW)
1076 {
1077     return LoadLibraryExW(libnameW, 0, 0);
1078 }
1079
1080 /***********************************************************************
1081  *           FreeLibrary   (KERNEL32.@)
1082  *
1083  * Free a dll loaded into the process address space.
1084  *
1085  * PARAMS
1086  *  hLibModule [I] Handle to the dll returned by LoadLibraryA().
1087  *
1088  * RETURNS
1089  *  Success: TRUE. The dll is removed if it is not still in use.
1090  *  Failure: FALSE. Use GetLastError() to determine the cause.
1091  */
1092 BOOL WINAPI DECLSPEC_HOTPATCH FreeLibrary(HINSTANCE hLibModule)
1093 {
1094     BOOL                retv = FALSE;
1095     NTSTATUS            nts;
1096
1097     if (!hLibModule)
1098     {
1099         SetLastError( ERROR_INVALID_HANDLE );
1100         return FALSE;
1101     }
1102
1103     if ((ULONG_PTR)hLibModule & 3) /* this is a datafile module */
1104     {
1105         if ((ULONG_PTR)hLibModule & 1)
1106         {
1107             struct exclusive_datafile *file;
1108             ULONG_PTR magic;
1109
1110             LdrLockLoaderLock( 0, NULL, &magic );
1111             LIST_FOR_EACH_ENTRY( file, &exclusive_datafile_list, struct exclusive_datafile, entry )
1112             {
1113                 if (file->module != hLibModule) continue;
1114                 TRACE( "closing %p for module %p\n", file->file, file->module );
1115                 CloseHandle( file->file );
1116                 list_remove( &file->entry );
1117                 HeapFree( GetProcessHeap(), 0, file );
1118                 break;
1119             }
1120             LdrUnlockLoaderLock( 0, magic );
1121         }
1122         return UnmapViewOfFile( (void *)((ULONG_PTR)hLibModule & ~3) );
1123     }
1124
1125     if ((nts = LdrUnloadDll( hLibModule )) == STATUS_SUCCESS) retv = TRUE;
1126     else SetLastError( RtlNtStatusToDosError( nts ) );
1127
1128     return retv;
1129 }
1130
1131 /***********************************************************************
1132  *           GetProcAddress             (KERNEL32.@)
1133  *
1134  * Find the address of an exported symbol in a loaded dll.
1135  *
1136  * PARAMS
1137  *  hModule  [I] Handle to the dll returned by LoadLibraryA().
1138  *  function [I] Name of the symbol, or an integer ordinal number < 16384
1139  *
1140  * RETURNS
1141  *  Success: A pointer to the symbol in the process address space.
1142  *  Failure: NULL. Use GetLastError() to determine the cause.
1143  */
1144 FARPROC get_proc_address( HMODULE hModule, LPCSTR function )
1145 {
1146     NTSTATUS    nts;
1147     FARPROC     fp;
1148
1149     if (!hModule) hModule = NtCurrentTeb()->Peb->ImageBaseAddress;
1150
1151     if ((ULONG_PTR)function >> 16)
1152     {
1153         ANSI_STRING     str;
1154
1155         RtlInitAnsiString( &str, function );
1156         nts = LdrGetProcedureAddress( hModule, &str, 0, (void**)&fp );
1157     }
1158     else
1159         nts = LdrGetProcedureAddress( hModule, NULL, LOWORD(function), (void**)&fp );
1160     if (nts != STATUS_SUCCESS)
1161     {
1162         SetLastError( RtlNtStatusToDosError( nts ) );
1163         fp = NULL;
1164     }
1165     return fp;
1166 }
1167
1168 #ifdef __x86_64__
1169 /*
1170  * Work around a Delphi bug on x86_64.  When delay loading a symbol,
1171  * Delphi saves rcx, rdx, r8 and r9 to the stack.  It then calls
1172  * GetProcAddress(), pops the saved registers and calls the function.
1173  * This works fine if all of the parameters are ints.  However, since
1174  * it does not save xmm0 - 3, it relies on GetProcAddress() preserving
1175  * these registers if the function takes floating point parameters.
1176  * This wrapper saves xmm0 - 3 to the stack.
1177  */
1178 extern FARPROC get_proc_address_wrapper( HMODULE module, LPCSTR function );
1179
1180 __ASM_GLOBAL_FUNC( get_proc_address_wrapper,
1181                    "pushq %rbp\n\t"
1182                    __ASM_CFI(".cfi_adjust_cfa_offset 8\n\t")
1183                    __ASM_CFI(".cfi_rel_offset %rbp,0\n\t")
1184                    "movq %rsp,%rbp\n\t"
1185                    __ASM_CFI(".cfi_def_cfa_register %rbp\n\t")
1186                    "subq $0x40,%rsp\n\t"
1187                    "movaps %xmm0,-0x10(%rbp)\n\t"
1188                    "movaps %xmm1,-0x20(%rbp)\n\t"
1189                    "movaps %xmm2,-0x30(%rbp)\n\t"
1190                    "movaps %xmm3,-0x40(%rbp)\n\t"
1191                    "call " __ASM_NAME("get_proc_address") "\n\t"
1192                    "movaps -0x40(%rbp), %xmm3\n\t"
1193                    "movaps -0x30(%rbp), %xmm2\n\t"
1194                    "movaps -0x20(%rbp), %xmm1\n\t"
1195                    "movaps -0x10(%rbp), %xmm0\n\t"
1196                    "movq %rbp,%rsp\n\t"
1197                    __ASM_CFI(".cfi_def_cfa_register %rsp\n\t")
1198                    "popq %rbp\n\t"
1199                    __ASM_CFI(".cfi_adjust_cfa_offset -8\n\t")
1200                    __ASM_CFI(".cfi_same_value %rbp\n\t")
1201                    "ret" )
1202 #else /* __x86_64__ */
1203
1204 static inline FARPROC get_proc_address_wrapper( HMODULE module, LPCSTR function )
1205 {
1206     return get_proc_address( module, function );
1207 }
1208
1209 #endif /* __x86_64__ */
1210
1211 FARPROC WINAPI GetProcAddress( HMODULE hModule, LPCSTR function )
1212 {
1213     return get_proc_address_wrapper( hModule, function );
1214 }
1215
1216 /***********************************************************************
1217  *           DelayLoadFailureHook  (KERNEL32.@)
1218  */
1219 FARPROC WINAPI DelayLoadFailureHook( LPCSTR name, LPCSTR function )
1220 {
1221     ULONG_PTR args[2];
1222
1223     if ((ULONG_PTR)function >> 16)
1224         ERR( "failed to delay load %s.%s\n", name, function );
1225     else
1226         ERR( "failed to delay load %s.%u\n", name, LOWORD(function) );
1227     args[0] = (ULONG_PTR)name;
1228     args[1] = (ULONG_PTR)function;
1229     RaiseException( EXCEPTION_WINE_STUB, EH_NONCONTINUABLE, 2, args );
1230     return NULL;
1231 }
1232
1233 typedef struct _PEB32
1234 {
1235     BOOLEAN InheritedAddressSpace;
1236     BOOLEAN ReadImageFileExecOptions;
1237     BOOLEAN BeingDebugged;
1238     BOOLEAN SpareBool;
1239     DWORD   Mutant;
1240     DWORD   ImageBaseAddress;
1241     DWORD   LdrData;
1242 } PEB32;
1243
1244 typedef struct _LIST_ENTRY32
1245 {
1246   DWORD Flink;
1247   DWORD Blink;
1248 } LIST_ENTRY32;
1249
1250 typedef struct _PEB_LDR_DATA32
1251 {
1252     ULONG        Length;
1253     BOOLEAN      Initialized;
1254     DWORD        SsHandle;
1255     LIST_ENTRY32 InLoadOrderModuleList;
1256 } PEB_LDR_DATA32;
1257
1258 typedef struct _UNICODE_STRING32
1259 {
1260   USHORT Length;
1261   USHORT MaximumLength;
1262   DWORD  Buffer;
1263 } UNICODE_STRING32;
1264
1265 typedef struct _LDR_MODULE32
1266 {
1267     LIST_ENTRY32        InLoadOrderModuleList;
1268     LIST_ENTRY32        InMemoryOrderModuleList;
1269     LIST_ENTRY32        InInitializationOrderModuleList;
1270     DWORD               BaseAddress;
1271     DWORD               EntryPoint;
1272     ULONG               SizeOfImage;
1273     UNICODE_STRING32    FullDllName;
1274     UNICODE_STRING32    BaseDllName;
1275 } LDR_MODULE32;
1276
1277 typedef struct {
1278     HANDLE process;
1279     PLIST_ENTRY head, current;
1280     LDR_MODULE ldr_module;
1281     BOOL wow64;
1282     LDR_MODULE32 ldr_module32;
1283 } MODULE_ITERATOR;
1284
1285 static BOOL init_module_iterator(MODULE_ITERATOR *iter, HANDLE process)
1286 {
1287     PROCESS_BASIC_INFORMATION pbi;
1288     PPEB_LDR_DATA ldr_data;
1289     NTSTATUS status;
1290
1291     if (!IsWow64Process(process, &iter->wow64))
1292         return FALSE;
1293
1294     /* Get address of PEB */
1295     status = NtQueryInformationProcess(process, ProcessBasicInformation,
1296                                        &pbi, sizeof(pbi), NULL);
1297     if (status != STATUS_SUCCESS)
1298     {
1299         SetLastError(RtlNtStatusToDosError(status));
1300         return FALSE;
1301     }
1302
1303     if (sizeof(void *) == 8 && iter->wow64)
1304     {
1305         PEB_LDR_DATA32 *ldr_data32_ptr;
1306         DWORD ldr_data32, first_module;
1307         PEB32 *peb32;
1308
1309         peb32 = (PEB32 *)(DWORD_PTR)pbi.PebBaseAddress;
1310
1311         if (!ReadProcessMemory(process, &peb32->LdrData, &ldr_data32,
1312                                sizeof(ldr_data32), NULL))
1313             return FALSE;
1314         ldr_data32_ptr = (PEB_LDR_DATA32 *)(DWORD_PTR) ldr_data32;
1315
1316         if (!ReadProcessMemory(process,
1317                                &ldr_data32_ptr->InLoadOrderModuleList.Flink,
1318                                &first_module, sizeof(first_module), NULL))
1319             return FALSE;
1320         iter->head = (LIST_ENTRY *)&ldr_data32_ptr->InLoadOrderModuleList;
1321         iter->current = (LIST_ENTRY *)(DWORD_PTR) first_module;
1322         iter->process = process;
1323
1324         return TRUE;
1325     }
1326
1327     /* Read address of LdrData from PEB */
1328     if (!ReadProcessMemory(process, &pbi.PebBaseAddress->LdrData,
1329                            &ldr_data, sizeof(ldr_data), NULL))
1330         return FALSE;
1331
1332     /* Read address of first module from LdrData */
1333     if (!ReadProcessMemory(process,
1334                            &ldr_data->InLoadOrderModuleList.Flink,
1335                            &iter->current, sizeof(iter->current), NULL))
1336         return FALSE;
1337
1338     iter->head = &ldr_data->InLoadOrderModuleList;
1339     iter->process = process;
1340
1341     return TRUE;
1342 }
1343
1344 static int module_iterator_next(MODULE_ITERATOR *iter)
1345 {
1346     if (iter->current == iter->head)
1347         return 0;
1348
1349     if (sizeof(void *) == 8 && iter->wow64)
1350     {
1351         LIST_ENTRY32 *entry32 = (LIST_ENTRY32 *)iter->current;
1352
1353         if (!ReadProcessMemory(iter->process,
1354                                CONTAINING_RECORD(entry32, LDR_MODULE32, InLoadOrderModuleList),
1355                                &iter->ldr_module32, sizeof(iter->ldr_module32), NULL))
1356             return -1;
1357
1358         iter->current = (LIST_ENTRY *)(DWORD_PTR) iter->ldr_module32.InLoadOrderModuleList.Flink;
1359         return 1;
1360     }
1361
1362     if (!ReadProcessMemory(iter->process,
1363                            CONTAINING_RECORD(iter->current, LDR_MODULE, InLoadOrderModuleList),
1364                            &iter->ldr_module, sizeof(iter->ldr_module), NULL))
1365          return -1;
1366
1367     iter->current = iter->ldr_module.InLoadOrderModuleList.Flink;
1368     return 1;
1369 }
1370
1371 static BOOL get_ldr_module(HANDLE process, HMODULE module, LDR_MODULE *ldr_module)
1372 {
1373     MODULE_ITERATOR iter;
1374     INT ret;
1375
1376     if (!init_module_iterator(&iter, process))
1377         return FALSE;
1378
1379     while ((ret = module_iterator_next(&iter)) > 0)
1380         /* When hModule is NULL we return the process image - which will be
1381          * the first module since our iterator uses InLoadOrderModuleList */
1382         if (!module || module == iter.ldr_module.BaseAddress)
1383         {
1384             *ldr_module = iter.ldr_module;
1385             return TRUE;
1386         }
1387
1388     if (ret == 0)
1389         SetLastError(ERROR_INVALID_HANDLE);
1390
1391     return FALSE;
1392 }
1393
1394 static BOOL get_ldr_module32(HANDLE process, HMODULE module, LDR_MODULE32 *ldr_module)
1395 {
1396     MODULE_ITERATOR iter;
1397     INT ret;
1398
1399     if (!init_module_iterator(&iter, process))
1400         return FALSE;
1401
1402     while ((ret = module_iterator_next(&iter)) > 0)
1403         /* When hModule is NULL we return the process image - which will be
1404          * the first module since our iterator uses InLoadOrderModuleList */
1405         if (!module || (DWORD)(DWORD_PTR) module == iter.ldr_module32.BaseAddress)
1406         {
1407             *ldr_module = iter.ldr_module32;
1408             return TRUE;
1409         }
1410
1411     if (ret == 0)
1412         SetLastError(ERROR_INVALID_HANDLE);
1413
1414     return FALSE;
1415 }
1416
1417 /***********************************************************************
1418  *           K32EnumProcessModules (KERNEL32.@)
1419  *
1420  * NOTES
1421  *  Returned list is in load order.
1422  */
1423 BOOL WINAPI K32EnumProcessModules(HANDLE process, HMODULE *lphModule,
1424                                   DWORD cb, DWORD *needed)
1425 {
1426     MODULE_ITERATOR iter;
1427     DWORD size = 0;
1428     INT ret;
1429
1430     if (!init_module_iterator(&iter, process))
1431         return FALSE;
1432
1433     if (cb && !lphModule)
1434     {
1435         SetLastError(ERROR_NOACCESS);
1436         return FALSE;
1437     }
1438
1439     while ((ret = module_iterator_next(&iter)) > 0)
1440     {
1441         if (cb >= sizeof(HMODULE))
1442         {
1443             if (sizeof(void *) == 8 && iter.wow64)
1444                 *lphModule++ = (HMODULE) (DWORD_PTR)iter.ldr_module32.BaseAddress;
1445             else
1446                 *lphModule++ = iter.ldr_module.BaseAddress;
1447             cb -= sizeof(HMODULE);
1448         }
1449         size += sizeof(HMODULE);
1450     }
1451
1452     if (!needed)
1453     {
1454         SetLastError(ERROR_NOACCESS);
1455         return FALSE;
1456     }
1457     *needed = size;
1458
1459     return ret == 0;
1460 }
1461
1462 /***********************************************************************
1463  *           K32EnumProcessModulesEx (KERNEL32.@)
1464  *
1465  * NOTES
1466  *  Returned list is in load order.
1467  */
1468 BOOL WINAPI K32EnumProcessModulesEx(HANDLE process, HMODULE *lphModule,
1469                                     DWORD cb, DWORD *needed, DWORD filter)
1470 {
1471     FIXME("(%p, %p, %d, %p, %d) semi-stub\n",
1472           process, lphModule, cb, needed, filter);
1473     return K32EnumProcessModules(process, lphModule, cb, needed);
1474 }
1475
1476 /***********************************************************************
1477  *           K32GetModuleBaseNameW (KERNEL32.@)
1478  */
1479 DWORD WINAPI K32GetModuleBaseNameW(HANDLE process, HMODULE module,
1480                                    LPWSTR base_name, DWORD size)
1481 {
1482     LDR_MODULE ldr_module;
1483     BOOL wow64;
1484
1485     if (!IsWow64Process(process, &wow64))
1486         return 0;
1487
1488     if (sizeof(void *) == 8 && wow64)
1489     {
1490         LDR_MODULE32 ldr_module32;
1491
1492         if (!get_ldr_module32(process, module, &ldr_module32))
1493             return 0;
1494
1495         size = min(ldr_module32.BaseDllName.Length / sizeof(WCHAR), size);
1496         if (!ReadProcessMemory(process, (void *)(DWORD_PTR)ldr_module32.BaseDllName.Buffer,
1497                                base_name, size * sizeof(WCHAR), NULL))
1498             return 0;
1499     }
1500     else
1501     {
1502         if (!get_ldr_module(process, module, &ldr_module))
1503             return 0;
1504
1505         size = min(ldr_module.BaseDllName.Length / sizeof(WCHAR), size);
1506         if (!ReadProcessMemory(process, ldr_module.BaseDllName.Buffer,
1507                                base_name, size * sizeof(WCHAR), NULL))
1508             return 0;
1509     }
1510
1511     base_name[size] = 0;
1512     return size;
1513 }
1514
1515 /***********************************************************************
1516  *           K32GetModuleBaseNameA (KERNEL32.@)
1517  */
1518 DWORD WINAPI K32GetModuleBaseNameA(HANDLE process, HMODULE module,
1519                                    LPSTR base_name, DWORD size)
1520 {
1521     WCHAR *base_name_w;
1522     DWORD len, ret = 0;
1523
1524     if(!base_name || !size) {
1525         SetLastError(ERROR_INVALID_PARAMETER);
1526         return 0;
1527     }
1528
1529     base_name_w = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * size);
1530     if(!base_name_w)
1531         return 0;
1532
1533     len = K32GetModuleBaseNameW(process, module, base_name_w, size);
1534     TRACE("%d, %s\n", len, debugstr_w(base_name_w));
1535     if (len)
1536     {
1537         ret = WideCharToMultiByte(CP_ACP, 0, base_name_w, len,
1538                                   base_name, size, NULL, NULL);
1539         if (ret < size) base_name[ret] = 0;
1540     }
1541     HeapFree(GetProcessHeap(), 0, base_name_w);
1542     return ret;
1543 }
1544
1545 /***********************************************************************
1546  *           K32GetModuleFileNameExW (KERNEL32.@)
1547  */
1548 DWORD WINAPI K32GetModuleFileNameExW(HANDLE process, HMODULE module,
1549                                      LPWSTR file_name, DWORD size)
1550 {
1551     LDR_MODULE ldr_module;
1552     BOOL wow64;
1553     DWORD len;
1554
1555     if (!size) return 0;
1556
1557     if (!IsWow64Process(process, &wow64))
1558         return 0;
1559
1560     if (sizeof(void *) == 8 && wow64)
1561     {
1562         LDR_MODULE32 ldr_module32;
1563
1564         if (!get_ldr_module32(process, module, &ldr_module32))
1565             return 0;
1566
1567         len = ldr_module32.FullDllName.Length / sizeof(WCHAR);
1568         if (!ReadProcessMemory(process, (void *)(DWORD_PTR)ldr_module32.FullDllName.Buffer,
1569                                file_name, min( len, size ) * sizeof(WCHAR), NULL))
1570             return 0;
1571     }
1572     else
1573     {
1574         if (!get_ldr_module(process, module, &ldr_module))
1575             return 0;
1576
1577         len = ldr_module.FullDllName.Length / sizeof(WCHAR);
1578         if (!ReadProcessMemory(process, ldr_module.FullDllName.Buffer,
1579                                file_name, min( len, size ) * sizeof(WCHAR), NULL))
1580             return 0;
1581     }
1582
1583     if (len < size)
1584     {
1585         file_name[len] = 0;
1586         return len;
1587     }
1588     else
1589     {
1590         file_name[size - 1] = 0;
1591         return size;
1592     }
1593 }
1594
1595 /***********************************************************************
1596  *           K32GetModuleFileNameExA (KERNEL32.@)
1597  */
1598 DWORD WINAPI K32GetModuleFileNameExA(HANDLE process, HMODULE module,
1599                                      LPSTR file_name, DWORD size)
1600 {
1601     WCHAR *ptr;
1602     DWORD len;
1603
1604     TRACE("(hProcess=%p, hModule=%p, %p, %d)\n", process, module, file_name, size);
1605
1606     if (!file_name || !size)
1607     {
1608         SetLastError( ERROR_INVALID_PARAMETER );
1609         return 0;
1610     }
1611
1612     if ( process == GetCurrentProcess() )
1613     {
1614         len = GetModuleFileNameA( module, file_name, size );
1615         if (size) file_name[size - 1] = '\0';
1616         return len;
1617     }
1618
1619     if (!(ptr = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR)))) return 0;
1620
1621     len = K32GetModuleFileNameExW(process, module, ptr, size);
1622     if (!len)
1623     {
1624         file_name[0] = '\0';
1625     }
1626     else
1627     {
1628         if (!WideCharToMultiByte( CP_ACP, 0, ptr, -1, file_name, size, NULL, NULL ))
1629         {
1630             file_name[size - 1] = 0;
1631             len = size;
1632         }
1633         else if (len < size) len = strlen( file_name );
1634     }
1635
1636     HeapFree(GetProcessHeap(), 0, ptr);
1637     return len;
1638 }
1639
1640 /***********************************************************************
1641  *           K32GetModuleInformation (KERNEL32.@)
1642  */
1643 BOOL WINAPI K32GetModuleInformation(HANDLE process, HMODULE module,
1644                                     MODULEINFO *modinfo, DWORD cb)
1645 {
1646     LDR_MODULE ldr_module;
1647     BOOL wow64;
1648
1649     if (cb < sizeof(MODULEINFO))
1650     {
1651         SetLastError(ERROR_INSUFFICIENT_BUFFER);
1652         return FALSE;
1653     }
1654
1655     if (!IsWow64Process(process, &wow64))
1656         return FALSE;
1657
1658     if (sizeof(void *) == 8 && wow64)
1659     {
1660         LDR_MODULE32 ldr_module32;
1661
1662         if (!get_ldr_module32(process, module, &ldr_module32))
1663             return FALSE;
1664
1665         modinfo->lpBaseOfDll = (void *)(DWORD_PTR)ldr_module32.BaseAddress;
1666         modinfo->SizeOfImage = ldr_module32.SizeOfImage;
1667         modinfo->EntryPoint  = (void *)(DWORD_PTR)ldr_module32.EntryPoint;
1668     }
1669     else
1670     {
1671         if (!get_ldr_module(process, module, &ldr_module))
1672             return FALSE;
1673
1674         modinfo->lpBaseOfDll = ldr_module.BaseAddress;
1675         modinfo->SizeOfImage = ldr_module.SizeOfImage;
1676         modinfo->EntryPoint  = ldr_module.EntryPoint;
1677     }
1678     return TRUE;
1679 }
1680
1681 #ifdef __i386__
1682
1683 /***********************************************************************
1684  *           __wine_dll_register_16 (KERNEL32.@)
1685  *
1686  * No longer used.
1687  */
1688 void __wine_dll_register_16( const IMAGE_DOS_HEADER *header, const char *file_name )
1689 {
1690     ERR( "loading old style 16-bit dll %s no longer supported\n", file_name );
1691 }
1692
1693
1694 /***********************************************************************
1695  *           __wine_dll_unregister_16 (KERNEL32.@)
1696  *
1697  * No longer used.
1698  */
1699 void __wine_dll_unregister_16( const IMAGE_DOS_HEADER *header )
1700 {
1701 }
1702
1703 #endif