lib/roken/dlfcn_w32.c

   1 /*
   2  * dlfcn-win32
   3  * Copyright (c) 2007 Ramiro Polla
   4  * Copyright (c) 2015 Tiancheng "Timothy" Gu
   5  * Copyright (c) 2019 Pali Rohár <pali.rohar@gmail.com>
   6  * Copyright (c) 2020 Ralf Habacker <ralf.habacker@freenet.de>
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a copy
   9  * of this software and associated documentation files (the "Software"), to deal
  10  * in the Software without restriction, including without limitation the rights
  11  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12  * copies of the Software, and to permit persons to whom the Software is
  13  * furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  21  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  24  * THE SOFTWARE.
  25  */
  26
  27 /*
  28  * Copied from https://github.com/dlfcn-win32/dlfcn-win32 and modified only to
  29  * fit Heimdal's lib/roken.
  30  */
  31
  32 #ifndef _WIN32_WINNT
  33 #define _WIN32_WINNT 0x0501
  34 #endif
  35 #ifdef _DEBUG
  36 #define _CRTDBG_MAP_ALLOC
  37 #include <stdlib.h>
  38 #include <crtdbg.h>
  39 #endif
  40 #include <windows.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43
  44 #ifdef _MSC_VER
  45 /* https://docs.microsoft.com/en-us/cpp/intrinsics/returnaddress */
  46 #pragma intrinsic(_ReturnAddress)
  47 #else
  48 /* https://gcc.gnu.org/onlinedocs/gcc/Return-Address.html */
  49 #ifndef _ReturnAddress
  50 #define _ReturnAddress() (__builtin_extract_return_addr(__builtin_return_address(0)))
  51 #endif
  52 #endif
  53
  54 #ifdef DLFCN_WIN32_SHARED
  55 #define DLFCN_WIN32_EXPORTS
  56 #endif
  57 #include "dlfcn.h"
  58
  59 /* Note:
  60  * MSDN says these functions are not thread-safe. We make no efforts to have
  61  * any kind of thread safety.
  62  */
  63
  64 typedef struct local_object {
  65     HMODULE hModule;
  66     struct local_object *previous;
  67     struct local_object *next;
  68 } local_object;
  69
  70 static local_object first_object;
  71
  72 /* These functions implement a double linked list for the local objects. */
  73 static local_object *local_search( HMODULE hModule )
  74 {
  75     local_object *pobject;
  76
  77     if( hModule == NULL )
  78         return NULL;
  79
  80     for( pobject = &first_object; pobject; pobject = pobject->next )
  81         if( pobject->hModule == hModule )
  82             return pobject;
  83
  84     return NULL;
  85 }
  86
  87 static BOOL local_add( HMODULE hModule )
  88 {
  89     local_object *pobject;
  90     local_object *nobject;
  91
  92     if( hModule == NULL )
  93         return TRUE;
  94
  95     pobject = local_search( hModule );
  96
  97     /* Do not add object again if it's already on the list */
  98     if( pobject )
  99         return TRUE;
 100
 101     for( pobject = &first_object; pobject->next; pobject = pobject->next );
 102
 103     nobject = (local_object*) malloc( sizeof( local_object ) );
 104
 105     if( !nobject )
 106     {
 107         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 108         return FALSE;
 109     }
 110
 111     pobject->next = nobject;
 112     nobject->next = NULL;
 113     nobject->previous = pobject;
 114     nobject->hModule = hModule;
 115
 116     return TRUE;
 117 }
 118
 119 static void local_rem( HMODULE hModule )
 120 {
 121     local_object *pobject;
 122
 123     if( hModule == NULL )
 124         return;
 125
 126     pobject = local_search( hModule );
 127
 128     if( !pobject )
 129         return;
 130
 131     if( pobject->next )
 132         pobject->next->previous = pobject->previous;
 133     if( pobject->previous )
 134         pobject->previous->next = pobject->next;
 135
 136     free( pobject );
 137 }
 138
 139 /* POSIX says dlerror( ) doesn't have to be thread-safe, so we use one
 140  * static buffer.
 141  * MSDN says the buffer cannot be larger than 64K bytes, so we set it to
 142  * the limit.
 143  */
 144 static char error_buffer[65535];
 145 static BOOL error_occurred;
 146
 147 static void save_err_str( const char *str )
 148 {
 149     DWORD dwMessageId;
 150     DWORD ret;
 151     size_t pos, len;
 152
 153     dwMessageId = GetLastError( );
 154
 155     if( dwMessageId == 0 )
 156         return;
 157
 158     len = strlen( str );
 159     if( len > sizeof( error_buffer ) - 5 )
 160         len = sizeof( error_buffer ) - 5;
 161
 162     /* Format error message to:
 163      * "<argument to function that failed>": <Windows localized error message>
 164       */
 165     pos = 0;
 166     error_buffer[pos++] = '"';
 167     memcpy( error_buffer+pos, str, len );
 168     pos += len;
 169     error_buffer[pos++] = '"';
 170     error_buffer[pos++] = ':';
 171     error_buffer[pos++] = ' ';
 172
 173     ret = FormatMessageA( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dwMessageId,
 174         MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),
 175         error_buffer+pos, (DWORD) (sizeof(error_buffer)-pos), NULL );
 176     pos += ret;
 177
 178     /* When FormatMessageA() fails it returns zero and does not touch buffer
 179      * so add trailing null byte */
 180     if( ret == 0 )
 181         error_buffer[pos] = '\0';
 182
 183     if( pos > 1 )
 184     {
 185         /* POSIX says the string must not have trailing <newline> */
 186         if( error_buffer[pos-2] == '\r' && error_buffer[pos-1] == '\n' )
 187             error_buffer[pos-2] = '\0';
 188     }
 189
 190     error_occurred = TRUE;
 191 }
 192
 193 static void save_err_ptr_str( const void *ptr )
 194 {
 195     char ptr_buf[2 + 2 * sizeof( ptr ) + 1];
 196     char num;
 197     size_t i;
 198
 199     ptr_buf[0] = '0';
 200     ptr_buf[1] = 'x';
 201
 202     for( i = 0; i < 2 * sizeof( ptr ); i++ )
 203     {
 204         num = ( ( (ULONG_PTR) ptr ) >> ( 8 * sizeof( ptr ) - 4 * ( i + 1 ) ) ) & 0xF;
 205         ptr_buf[2+i] = num + ( ( num < 0xA ) ? '0' : ( 'A' - 0xA ) );
 206     }
 207
 208     ptr_buf[2 + 2 * sizeof( ptr )] = 0;
 209
 210     save_err_str( ptr_buf );
 211 }
 212
 213 /* Load Psapi.dll at runtime, this avoids linking caveat */
 214 static BOOL MyEnumProcessModules( HANDLE hProcess, HMODULE *lphModule, DWORD cb, LPDWORD lpcbNeeded )
 215 {
 216     static BOOL (WINAPI *EnumProcessModulesPtr)(HANDLE, HMODULE *, DWORD, LPDWORD);
 217     HMODULE psapi;
 218
 219     if( !EnumProcessModulesPtr )
 220     {
 221         psapi = LoadLibraryA( "Psapi.dll" );
 222         if( psapi )
 223             EnumProcessModulesPtr = (BOOL (WINAPI *)(HANDLE, HMODULE *, DWORD, LPDWORD)) GetProcAddress( psapi, "EnumProcessModules" );
 224         if( !EnumProcessModulesPtr )
 225             return 0;
 226     }
 227
 228     return EnumProcessModulesPtr( hProcess, lphModule, cb, lpcbNeeded );
 229 }
 230
 231 ROKEN_LIB_FUNCTION void * ROKEN_LIB_CALL
 232 dlopen( const char *file, int mode )
 233 {
 234     HMODULE hModule;
 235     UINT uMode;
 236
 237     error_occurred = FALSE;
 238
 239     /* Do not let Windows display the critical-error-handler message box */
 240     uMode = SetErrorMode( SEM_FAILCRITICALERRORS );
 241
 242     if( file == 0 )
 243     {
 244         /* POSIX says that if the value of file is 0, a handle on a global
 245          * symbol object must be provided. That object must be able to access
 246          * all symbols from the original program file, and any objects loaded
 247          * with the RTLD_GLOBAL flag.
 248          * The return value from GetModuleHandle( ) allows us to retrieve
 249          * symbols only from the original program file. EnumProcessModules() is
 250          * used to access symbols from other libraries. For objects loaded
 251          * with the RTLD_LOCAL flag, we create our own list later on. They are
 252          * excluded from EnumProcessModules() iteration.
 253          */
 254         hModule = GetModuleHandle( NULL );
 255
 256         if( !hModule )
 257             save_err_str( "(null)" );
 258     }
 259     else
 260     {
 261         HANDLE hCurrentProc;
 262         DWORD dwProcModsBefore, dwProcModsAfter;
 263         char lpFileName[MAX_PATH];
 264         size_t i, len;
 265
 266         len = strlen( file );
 267
 268         if( len >= sizeof( lpFileName ) )
 269         {
 270             SetLastError( ERROR_FILENAME_EXCED_RANGE );
 271             save_err_str( file );
 272             hModule = NULL;
 273         }
 274         else
 275         {
 276             /* MSDN says backslashes *must* be used instead of forward slashes. */
 277             for( i = 0; i < len; i++ )
 278             {
 279                 if( file[i] == '/' )
 280                     lpFileName[i] = '\\';
 281                 else
 282                     lpFileName[i] = file[i];
 283             }
 284             lpFileName[len] = '\0';
 285
 286             hCurrentProc = GetCurrentProcess( );
 287
 288             if( MyEnumProcessModules( hCurrentProc, NULL, 0, &dwProcModsBefore ) == 0 )
 289                 dwProcModsBefore = 0;
 290
 291             /* POSIX says the search path is implementation-defined.
 292              * LOAD_WITH_ALTERED_SEARCH_PATH is used to make it behave more closely
 293              * to UNIX's search paths (start with system folders instead of current
 294              * folder).
 295              */
 296             hModule = LoadLibraryExA( lpFileName, NULL, LOAD_WITH_ALTERED_SEARCH_PATH );
 297
 298             if( !hModule )
 299             {
 300                 save_err_str( lpFileName );
 301             }
 302             else
 303             {
 304                 if( MyEnumProcessModules( hCurrentProc, NULL, 0, &dwProcModsAfter ) == 0 )
 305                     dwProcModsAfter = 0;
 306
 307                 /* If the object was loaded with RTLD_LOCAL, add it to list of local
 308                  * objects, so that its symbols cannot be retrieved even if the handle for
 309                  * the original program file is passed. POSIX says that if the same
 310                  * file is specified in multiple invocations, and any of them are
 311                  * RTLD_GLOBAL, even if any further invocations use RTLD_LOCAL, the
 312                  * symbols will remain global. If number of loaded modules was not
 313                  * changed after calling LoadLibraryEx(), it means that library was
 314                  * already loaded.
 315                  */
 316                 if( (mode & RTLD_LOCAL) && dwProcModsBefore != dwProcModsAfter )
 317                 {
 318                     if( !local_add( hModule ) )
 319                     {
 320                         save_err_str( lpFileName );
 321                         FreeLibrary( hModule );
 322                         hModule = NULL;
 323                     }
 324                 }
 325                 else if( !(mode & RTLD_LOCAL) && dwProcModsBefore == dwProcModsAfter )
 326                 {
 327                     local_rem( hModule );
 328                 }
 329             }
 330         }
 331     }
 332
 333     /* Return to previous state of the error-mode bit flags. */
 334     SetErrorMode( uMode );
 335
 336     return (void *) hModule;
 337 }
 338
 339 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
 340 dlclose( void *handle )
 341 {
 342     HMODULE hModule = (HMODULE) handle;
 343     BOOL ret;
 344
 345     error_occurred = FALSE;
 346
 347     ret = FreeLibrary( hModule );
 348
 349     /* If the object was loaded with RTLD_LOCAL, remove it from list of local
 350      * objects.
 351      */
 352     if( ret )
 353         local_rem( hModule );
 354     else
 355         save_err_ptr_str( handle );
 356
 357     /* dlclose's return value in inverted in relation to FreeLibrary's. */
 358     ret = !ret;
 359
 360     return (int) ret;
 361 }
 362
 363 __declspec(noinline) /* Needed for _ReturnAddress() */
 364 ROKEN_LIB_FUNCTION DLSYM_RET_TYPE ROKEN_LIB_CALL
 365 dlsym( void *handle, const char *name )
 366 {
 367     FARPROC symbol;
 368     HMODULE hCaller;
 369     HMODULE hModule;
 370     HANDLE hCurrentProc;
 371
 372     error_occurred = FALSE;
 373
 374     symbol = NULL;
 375     hCaller = NULL;
 376     hModule = GetModuleHandle( NULL );
 377     hCurrentProc = GetCurrentProcess( );
 378
 379     if( handle == RTLD_DEFAULT )
 380     {
 381         /* The symbol lookup happens in the normal global scope; that is,
 382          * a search for a symbol using this handle would find the same
 383          * definition as a direct use of this symbol in the program code.
 384          * So use same lookup procedure as when filename is NULL.
 385          */
 386         handle = hModule;
 387     }
 388     else if( handle == RTLD_NEXT )
 389     {
 390         /* Specifies the next object after this one that defines name.
 391          * This one refers to the object containing the invocation of dlsym().
 392          * The next object is the one found upon the application of a load
 393          * order symbol resolution algorithm. To get caller function of dlsym()
 394          * use _ReturnAddress() intrinsic. To get HMODULE of caller function
 395          * use standard GetModuleHandleExA() function.
 396          */
 397         if( !GetModuleHandleExA( GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, (LPCSTR) _ReturnAddress( ), &hCaller ) )
 398             goto end;
 399     }
 400
 401     if( handle != RTLD_NEXT )
 402     {
 403         symbol = GetProcAddress( (HMODULE) handle, name );
 404
 405         if( symbol != NULL )
 406             goto end;
 407     }
 408
 409     /* If the handle for the original program file is passed, also search
 410      * in all globally loaded objects.
 411      */
 412
 413     if( hModule == handle || handle == RTLD_NEXT )
 414     {
 415         HMODULE *modules;
 416         DWORD cbNeeded;
 417         DWORD dwSize;
 418         size_t i;
 419
 420         /* GetModuleHandle( NULL ) only returns the current program file. So
 421          * if we want to get ALL loaded module including those in linked DLLs,
 422          * we have to use EnumProcessModules( ).
 423          */
 424         if( MyEnumProcessModules( hCurrentProc, NULL, 0, &dwSize ) != 0 )
 425         {
 426             modules = malloc( dwSize );
 427             if( modules )
 428             {
 429                 if( MyEnumProcessModules( hCurrentProc, modules, dwSize, &cbNeeded ) != 0 && dwSize == cbNeeded )
 430                 {
 431                     for( i = 0; i < dwSize / sizeof( HMODULE ); i++ )
 432                     {
 433                         if( handle == RTLD_NEXT && hCaller )
 434                         {
 435                             /* Next modules can be used for RTLD_NEXT */
 436                             if( hCaller == modules[i] )
 437                                 hCaller = NULL;
 438                             continue;
 439                         }
 440                         if( local_search( modules[i] ) )
 441                             continue;
 442                         symbol = GetProcAddress( modules[i], name );
 443                         if( symbol != NULL )
 444                         {
 445                             free( modules );
 446                             goto end;
 447                         }
 448                     }
 449
 450                 }
 451                 free( modules );
 452             }
 453             else
 454             {
 455                 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 456                 goto end;
 457             }
 458         }
 459     }
 460
 461 end:
 462     if( symbol == NULL )
 463     {
 464         if( GetLastError() == 0 )
 465             SetLastError( ERROR_PROC_NOT_FOUND );
 466         save_err_str( name );
 467     }
 468
 469     return *(void **) (&symbol);
 470 }
 471
 472 ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL
 473 dlerror( void )
 474 {
 475     /* If this is the second consecutive call to dlerror, return NULL */
 476     if( !error_occurred )
 477         return NULL;
 478
 479     /* POSIX says that invoking dlerror( ) a second time, immediately following
 480      * a prior invocation, shall result in NULL being returned.
 481      */
 482     error_occurred = FALSE;
 483
 484     return error_buffer;
 485 }
 486
 487 /* See https://docs.microsoft.com/en-us/archive/msdn-magazine/2002/march/inside-windows-an-in-depth-look-into-the-win32-portable-executable-file-format-part-2
 488  * for details */
 489
 490 /* Get specific image section */
 491 static BOOL get_image_section( HMODULE module, int index, void **ptr, DWORD *size )
 492 {
 493     IMAGE_DOS_HEADER *dosHeader;
 494     IMAGE_OPTIONAL_HEADER *optionalHeader;
 495
 496     dosHeader = (IMAGE_DOS_HEADER *) module;
 497
 498     if( dosHeader->e_magic != 0x5A4D )
 499         return FALSE;
 500
 501     optionalHeader = (IMAGE_OPTIONAL_HEADER *) ( (BYTE *) module + dosHeader->e_lfanew + 24 );
 502
 503     if( optionalHeader->Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC )
 504         return FALSE;
 505
 506     if( index < 0 || index > IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR )
 507         return FALSE;
 508
 509     if( optionalHeader->DataDirectory[index].Size == 0 || optionalHeader->DataDirectory[index].VirtualAddress == 0 )
 510         return FALSE;
 511
 512     if( size != NULL )
 513         *size = optionalHeader->DataDirectory[index].Size;
 514
 515     *ptr = (void *)( (BYTE *) module + optionalHeader->DataDirectory[index].VirtualAddress );
 516
 517     return TRUE;
 518 }
 519
 520 /* Return symbol name for a given address */
 521 static const char *get_symbol_name( HMODULE module, IMAGE_IMPORT_DESCRIPTOR *iid, void *addr, void **func_address )
 522 {
 523     int i;
 524     void *candidateAddr = NULL;
 525     const char *candidateName = NULL;
 526     BYTE *base = (BYTE *) module; /* Required to have correct calculations */
 527
 528     for( i = 0; iid[i].Characteristics != 0 && iid[i].FirstThunk != 0; i++ )
 529     {
 530         IMAGE_THUNK_DATA *thunkILT = (IMAGE_THUNK_DATA *)( base + iid[i].Characteristics );
 531         IMAGE_THUNK_DATA *thunkIAT = (IMAGE_THUNK_DATA *)( base + iid[i].FirstThunk );
 532
 533         for( ; thunkILT->u1.AddressOfData != 0; thunkILT++, thunkIAT++ )
 534         {
 535             IMAGE_IMPORT_BY_NAME *nameData;
 536
 537             if( IMAGE_SNAP_BY_ORDINAL( thunkILT->u1.Ordinal ) )
 538                 continue;
 539
 540             if( (void *) thunkIAT->u1.Function > addr || candidateAddr >= (void *) thunkIAT->u1.Function )
 541                 continue;
 542
 543             candidateAddr = (void *) thunkIAT->u1.Function;
 544             nameData = (IMAGE_IMPORT_BY_NAME *)( base + (ULONG_PTR) thunkILT->u1.AddressOfData );
 545             candidateName = (const char *) nameData->Name;
 546         }
 547     }
 548
 549     *func_address = candidateAddr;
 550     return candidateName;
 551 }
 552
 553 static BOOL is_valid_address( void *addr )
 554 {
 555     MEMORY_BASIC_INFORMATION info;
 556     SIZE_T result;
 557
 558     if( addr == NULL )
 559         return FALSE;
 560
 561     /* check valid pointer */
 562     result = VirtualQuery( addr, &info, sizeof( info ) );
 563
 564     if( result == 0 || info.AllocationBase == NULL || info.AllocationProtect == 0 || info.AllocationProtect == PAGE_NOACCESS )
 565         return FALSE;
 566
 567     return TRUE;
 568 }
 569
 570 /* Return state if address points to an import thunk
 571  *
 572  * An import thunk is setup with a 'jmp' instruction followed by an
 573  * absolute address (32bit) or relative offset (64bit) pointing into
 574  * the import address table (iat), which is partially maintained by
 575  * the runtime linker.
 576  */
 577 static BOOL is_import_thunk( void *addr )
 578 {
 579     return *(short *) addr == 0x25ff ? TRUE : FALSE;
 580 }
 581
 582 /* Return adress from the import address table (iat),
 583  * if the original address points to a thunk table entry.
 584  */
 585 static void *get_address_from_import_address_table( void *iat, DWORD iat_size, void *addr )
 586 {
 587     BYTE *thkp = (BYTE *) addr;
 588     /* Get offset from thunk table (after instruction 0xff 0x25)
 589      *   4018c8 <_VirtualQuery>: ff 25 4a 8a 00 00
 590      */
 591     ULONG offset = *(ULONG *)( thkp + 2 );
 592 #ifdef _WIN64
 593     /* On 64 bit the offset is relative
 594      *      4018c8:   ff 25 4a 8a 00 00    jmpq    *0x8a4a(%rip)    # 40a318 <__imp_VirtualQuery>
 595      * And can be also negative (MSVC in WDK)
 596      *   100002f20:   ff 25 3a e1 ff ff    jmpq   *-0x1ec6(%rip)    # 0x100001060
 597      * So cast to signed LONG type
 598      */
 599     BYTE *ptr = (BYTE *)( thkp + 6 + (LONG) offset );
 600 #else
 601     /* On 32 bit the offset is absolute
 602      *   4019b4:    ff 25 90 71 40 00    jmp    *0x40719
 603      */
 604     BYTE *ptr = (BYTE *) offset;
 605 #endif
 606
 607     if( !is_valid_address( ptr ) || ptr < (BYTE *) iat || ptr > (BYTE *) iat + iat_size )
 608         return NULL;
 609
 610     return *(void **) ptr;
 611 }
 612
 613 /* Holds module filename */
 614 static char module_filename[2*MAX_PATH];
 615
 616 static BOOL fill_module_info( void *addr, Dl_info *info )
 617 {
 618     HMODULE hModule;
 619     DWORD dwSize;
 620
 621     if( !GetModuleHandleExA( GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, addr, &hModule ) || hModule == NULL )
 622         return FALSE;
 623
 624     dwSize = GetModuleFileNameA( hModule, module_filename, sizeof( module_filename ) );
 625
 626     if( dwSize == 0 || dwSize == sizeof( module_filename ) )
 627         return FALSE;
 628
 629     info->dli_fbase = (void *) hModule;
 630     info->dli_fname = module_filename;
 631
 632     return TRUE;
 633 }
 634
 635 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
 636 dladdr( void *addr, Dl_info *info )
 637 {
 638     void *realAddr, *funcAddress = NULL;
 639     HMODULE hModule;
 640     IMAGE_IMPORT_DESCRIPTOR *iid;
 641     DWORD iidSize = 0;
 642
 643     if( addr == NULL || info == NULL )
 644         return 0;
 645
 646     hModule = GetModuleHandleA( NULL );
 647     if( hModule == NULL )
 648         return 0;
 649
 650     if( !is_valid_address( addr ) )
 651         return 0;
 652
 653     realAddr = addr;
 654
 655     if( !get_image_section( hModule, IMAGE_DIRECTORY_ENTRY_IMPORT, (void **) &iid, &iidSize ) )
 656         return 0;
 657
 658     if( is_import_thunk( addr ) )
 659     {
 660         void *iat;
 661         void *iatAddr = NULL;
 662         DWORD iatSize = 0;
 663
 664         if( !get_image_section( hModule, IMAGE_DIRECTORY_ENTRY_IAT, &iat, &iatSize ) )
 665         {
 666             /* Fallback for cases where the iat is not defined,
 667              * for example i586-mingw32msvc-gcc */
 668             if( iid == NULL || iid->Characteristics == 0 || iid->FirstThunk == 0 )
 669                 return 0;
 670
 671             iat = (void *)( (BYTE *) hModule + iid->FirstThunk );
 672             /* We assume that in this case iid and iat's are in linear order */
 673             iatSize = iidSize - (DWORD) ( (BYTE *) iat - (BYTE *) iid );
 674         }
 675
 676         iatAddr = get_address_from_import_address_table( iat, iatSize, addr );
 677         if( iatAddr == NULL )
 678             return 0;
 679
 680         realAddr = iatAddr;
 681     }
 682
 683     if( !fill_module_info( realAddr, info ) )
 684         return 0;
 685
 686     info->dli_sname = get_symbol_name( hModule, iid, realAddr, &funcAddress );
 687
 688     info->dli_saddr = !info->dli_sname ? NULL : funcAddress ? funcAddress : realAddr;
 689     return 1;
 690 }
 691
 692 #ifdef DLFCN_WIN32_SHARED
 693 BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
 694 {
 695     (void) hinstDLL;
 696     (void) fdwReason;
 697     (void) lpvReserved;
 698     return TRUE;
 699 }
 700 #endif