sal/osl/w32/module.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "system.h"
  21 #include <tlhelp32.h>
  22
  23 #include "file_url.hxx"
  24 #include "path_helper.hxx"
  25
  26 #include <osl/module.h>
  27 #include <osl/diagnose.h>
  28 #include <osl/thread.h>
  29 #include <osl/file.h>
  30 #include <sal/log.hxx>
  31 #include <o3tl/char16_t2wchar_t.hxx>
  32 #include <vector>
  33
  34 /*
  35     under WIN32, we use the void* oslModule
  36     as a WIN32 HANDLE (which is also a 32-bit value)
  37 */
  38
  39 oslModule SAL_CALL osl_loadModule(rtl_uString *strModuleName, sal_Int32 /*nRtldMode*/ )
  40 {
  41     HMODULE h;
  42 #if OSL_DEBUG_LEVEL < 2
  43     UINT errorMode = SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
  44 #endif
  45     rtl_uString* Module = nullptr;
  46     oslModule ret = nullptr;
  47     oslFileError    nError;
  48
  49     SAL_INFO( "sal.osl", "osl_loadModule: " << OUString(strModuleName->buffer, wcslen(o3tl::toW(strModuleName->buffer))) );
  50     OSL_ASSERT(strModuleName);
  51
  52     nError = osl_getSystemPathFromFileURL(strModuleName, &Module);
  53
  54     if ( osl_File_E_None != nError )
  55         rtl_uString_assign(&Module, strModuleName);
  56
  57     h = LoadLibraryW(o3tl::toW(Module->buffer));
  58
  59     if (h == nullptr)
  60         h = LoadLibraryExW(o3tl::toW(Module->buffer), nullptr, LOAD_WITH_ALTERED_SEARCH_PATH);
  61
  62     // In case of long path names (\\?\c:\...) try to shorten the filename.
  63     // LoadLibrary cannot handle file names which exceed 260 letters.
  64     // In case the path is to long, the function will fail. However, the error
  65     // code can be different. For example, it returned  ERROR_FILENAME_EXCED_RANGE
  66     // on Windows XP and ERROR_INSUFFICIENT_BUFFER on Windows 7 (64bit)
  67     if (h == nullptr && Module->length > 260)
  68     {
  69         std::vector<WCHAR> vec(Module->length + 1);
  70         DWORD len = GetShortPathNameW(o3tl::toW(Module->buffer), &vec[0], Module->length + 1);
  71         if (len )
  72         {
  73             h = LoadLibraryW(&vec[0]);
  74
  75             if (h == nullptr)
  76                 h = LoadLibraryExW(&vec[0], nullptr, LOAD_WITH_ALTERED_SEARCH_PATH);
  77         }
  78     }
  79
  80     ret = static_cast<oslModule>(h);
  81     rtl_uString_release(Module);
  82 #if OSL_DEBUG_LEVEL < 2
  83     SetErrorMode(errorMode);
  84 #endif
  85
  86     return ret;
  87 }
  88
  89 oslModule SAL_CALL osl_loadModuleAscii(const sal_Char *pModuleName, sal_Int32 )
  90 {
  91     HMODULE h;
  92     UINT errorMode = SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
  93     oslModule ret = nullptr;
  94
  95     SAL_INFO( "sal.osl", "osl_loadModule: " << pModuleName );
  96     OSL_ASSERT(pModuleName);
  97
  98     h = LoadLibraryA(pModuleName);
  99     if (h == nullptr)
 100         h = LoadLibraryExA(pModuleName, nullptr,
 101                                   LOAD_WITH_ALTERED_SEARCH_PATH);
 102
 103     ret = static_cast<oslModule>(h);
 104     SetErrorMode(errorMode);
 105
 106     return ret;
 107 }
 108
 109 oslModule osl_loadModuleRelativeAscii(
 110     oslGenericFunction, char const * relativePath, sal_Int32 mode)
 111 {
 112     return osl_loadModuleAscii(relativePath, mode); //TODO: FIXME
 113 }
 114
 115 sal_Bool SAL_CALL
 116 osl_getModuleHandle(rtl_uString *pModuleName, oslModule *pResult)
 117 {
 118     LPCWSTR pName = pModuleName ? o3tl::toW(pModuleName->buffer) : nullptr;
 119     HMODULE h = GetModuleHandleW(pName);
 120     if( h )
 121     {
 122         *pResult = static_cast<oslModule>(h);
 123         return true;
 124     }
 125
 126     return false;
 127 }
 128
 129 void SAL_CALL osl_unloadModule(oslModule Module)
 130 {
 131     FreeLibrary(static_cast<HMODULE>(Module));
 132 }
 133
 134 void* SAL_CALL osl_getSymbol(oslModule Module, rtl_uString *strSymbolName)
 135 {
 136     /* casting from a function pointer to a data pointer is invalid
 137        be in this case unavoidable because the API has to stay
 138        compatible. We need to keep this function which returns a
 139        void* by definition */
 140 #ifdef _MSC_VER
 141 #pragma warning(push)
 142 #pragma warning(disable:4054)
 143 #endif
 144     return reinterpret_cast<void*>(osl_getFunctionSymbol(Module, strSymbolName));
 145 #ifdef _MSC_VER
 146 #pragma warning(pop)
 147 #endif
 148 }
 149
 150 oslGenericFunction SAL_CALL osl_getFunctionSymbol( oslModule Module, rtl_uString *strSymbolName )
 151 {
 152     rtl_String *symbolName = nullptr;
 153     oslGenericFunction address;
 154
 155     OSL_ASSERT(Module);
 156     OSL_ASSERT(strSymbolName);
 157
 158     rtl_uString2String(
 159         &symbolName,
 160         strSymbolName->buffer,
 161         strSymbolName->length,
 162         RTL_TEXTENCODING_UTF8,
 163         OUSTRING_TO_OSTRING_CVTFLAGS
 164     );
 165
 166     address=osl_getAsciiFunctionSymbol(Module, rtl_string_getStr(symbolName));
 167     rtl_string_release(symbolName);
 168
 169     return address;
 170 }
 171
 172 oslGenericFunction SAL_CALL
 173 osl_getAsciiFunctionSymbol( oslModule Module, const sal_Char *pSymbol )
 174 {
 175     oslGenericFunction fncAddr = nullptr;
 176
 177     if( pSymbol )
 178         fncAddr=reinterpret_cast<oslGenericFunction>(GetProcAddress(static_cast<HMODULE>(Module), pSymbol));
 179
 180     return fncAddr;
 181 }
 182
 183 /*****************************************************************************/
 184 /* Implementation for Windows 95, 98 and Me */
 185 /*****************************************************************************/
 186
 187 /* Undefine because there is no explicit "A" definition */
 188
 189 #ifdef MODULEENTRY32
 190 #undef MODULEENTRY32
 191 #endif
 192
 193 #ifdef LPMODULEENTRY32
 194 #undef LPMODULEENTRY32
 195 #endif
 196
 197 /***************************************************************************************/
 198 /* Implementation for Windows NT, 2K and XP (2K and XP could use the above method too) */
 199 /***************************************************************************************/
 200
 201 #include <imagehlp.h>
 202
 203 typedef BOOL (WINAPI *SymInitialize_PROC)(
 204     HANDLE   hProcess,
 205     LPWSTR   UserSearchPath,
 206     BOOL     fInvadeProcess
 207     );
 208
 209 typedef BOOL (WINAPI *SymCleanup_PROC)(
 210     HANDLE hProcess
 211     );
 212
 213 typedef BOOL (WINAPI *SymGetModuleInfo_PROC)(
 214     HANDLE              hProcess,
 215     DWORD               dwAddr,
 216     PIMAGEHLP_MODULEW   ModuleInfo
 217     );
 218
 219 /* Seems that IMAGEHLP.DLL is always available on NT 4. But MSDN from Platform SDK says Win 2K is required. MSDN from VS 6.0a says
 220     it's O.K on NT 4 ???!!!
 221     BTW: We are using ANSI function because not all version of IMAGEHLP.DLL contain Unicode support
 222 */
 223
 224 static bool osl_addressGetModuleURL_NT4_( void *pv, rtl_uString **pustrURL )
 225 {
 226     bool    bSuccess    = false;    /* Assume failure */
 227
 228     /*  IMAGEHELP.DLL has a bug that it recursively scans subdirectories of
 229         the root when calling SymInitialize(), so we prefer DBGHELP.DLL
 230         which exports the same symbols and is shipped with OOo */
 231
 232     HMODULE     hModImageHelp = LoadLibraryW( L"DBGHELP.DLL" );
 233
 234     if ( !hModImageHelp )
 235         hModImageHelp = LoadLibraryW( L"IMAGEHLP.DLL" );
 236
 237     if ( hModImageHelp )
 238     {
 239         SymGetModuleInfo_PROC   lpfnSymGetModuleInfo;
 240         SymInitialize_PROC      lpfnSymInitialize;
 241         SymCleanup_PROC         lpfnSymCleanup;
 242
 243         lpfnSymInitialize = reinterpret_cast<SymInitialize_PROC>(GetProcAddress( hModImageHelp, "SymInitializeW" ));
 244         lpfnSymCleanup = reinterpret_cast<SymCleanup_PROC>(GetProcAddress( hModImageHelp, "SymCleanup" ));
 245         lpfnSymGetModuleInfo = reinterpret_cast<SymGetModuleInfo_PROC>(GetProcAddress( hModImageHelp, "SymGetModuleInfoW" ));
 246
 247         if ( lpfnSymInitialize && lpfnSymCleanup && lpfnSymGetModuleInfo )
 248         {
 249             IMAGEHLP_MODULEW ModuleInfo;
 250             ::osl::LongPathBuffer< sal_Unicode > aModuleFileName( MAX_LONG_PATH );
 251             LPWSTR lpSearchPath = nullptr;
 252
 253             if ( GetModuleFileNameW( nullptr, o3tl::toW(aModuleFileName), aModuleFileName.getBufSizeInSymbols() ) )
 254             {
 255                 wchar_t *pLastBkSlash = wcsrchr( o3tl::toW(aModuleFileName), L'\\' );
 256
 257                 if (
 258                     pLastBkSlash &&
 259                     pLastBkSlash > o3tl::toW(aModuleFileName)
 260                     && *(pLastBkSlash - 1) != L':'
 261                     && *(pLastBkSlash - 1) != L'\\'
 262                     )
 263                 {
 264                     *pLastBkSlash = 0;
 265                     lpSearchPath = o3tl::toW(aModuleFileName);
 266                 }
 267             }
 268
 269             lpfnSymInitialize( GetCurrentProcess(), lpSearchPath, TRUE );
 270
 271             ZeroMemory( &ModuleInfo, sizeof(ModuleInfo) );
 272             ModuleInfo.SizeOfStruct = sizeof(ModuleInfo);
 273
 274             bSuccess = !!lpfnSymGetModuleInfo( GetCurrentProcess(), reinterpret_cast<DWORD_PTR>(pv), &ModuleInfo );
 275
 276             if ( bSuccess )
 277             {
 278                 /*  #99182 On localized (non-english) NT4 and XP (!!!) for some libraries the LoadedImageName member of ModuleInfo isn't filled. Because
 279                     other members ModuleName and ImageName do not contain the full path we can cast the Member
 280                     BaseOfImage to a HMODULE (on NT it's the same) and use GetModuleFileName to retrieve the full
 281                     path of the loaded image */
 282
 283                 if ( ModuleInfo.LoadedImageName[0] || GetModuleFileNameW( reinterpret_cast<HMODULE>(ModuleInfo.BaseOfImage), ModuleInfo.LoadedImageName, SAL_N_ELEMENTS(ModuleInfo.LoadedImageName) ) )
 284                 {
 285                     rtl_uString *ustrSysPath = nullptr;
 286
 287                     rtl_uString_newFromStr( &ustrSysPath, o3tl::toU(ModuleInfo.LoadedImageName) );
 288                     OSL_ASSERT(ustrSysPath != nullptr);
 289                     osl_getFileURLFromSystemPath( ustrSysPath, pustrURL );
 290                     rtl_uString_release( ustrSysPath );
 291                 }
 292                 else
 293                     bSuccess = false;
 294             }
 295
 296             lpfnSymCleanup( GetCurrentProcess() );
 297         }
 298
 299         FreeLibrary( hModImageHelp );
 300     }
 301
 302     return bSuccess;
 303 }
 304
 305 typedef struct MODULEINFO {
 306     LPVOID lpBaseOfDll;
 307     DWORD SizeOfImage;
 308     LPVOID EntryPoint;
 309 } *LPMODULEINFO;
 310
 311 typedef BOOL (WINAPI *EnumProcessModules_PROC)(
 312   HANDLE hProcess,      // handle to the process
 313   HMODULE * lphModule,  // array to receive the module handles
 314   DWORD cb,             // size of the array
 315   LPDWORD lpcbNeeded    // receives the number of bytes returned
 316 );
 317
 318 typedef BOOL (WINAPI *GetModuleInformation_PROC)(
 319   HANDLE hProcess,         // handle to the process
 320   HMODULE hModule,         // handle to the module
 321   LPMODULEINFO lpmodinfo,  // structure that receives information
 322   DWORD cb                 // size of the structure
 323 );
 324
 325 /* This version can fail because PSAPI.DLL is not always part of NT 4 despite MSDN Library 6.0a say so */
 326
 327 static bool osl_addressGetModuleURL_NT_( void *pv, rtl_uString **pustrURL )
 328 {
 329     bool    bSuccess    = false;    /* Assume failure */
 330     static HMODULE      hModPsapi = nullptr;
 331
 332     if ( !hModPsapi )
 333         hModPsapi = LoadLibraryW( L"PSAPI.DLL" );
 334
 335     if ( hModPsapi )
 336     {
 337         EnumProcessModules_PROC     lpfnEnumProcessModules      = reinterpret_cast<EnumProcessModules_PROC>(GetProcAddress( hModPsapi, "EnumProcessModules" ));
 338         GetModuleInformation_PROC   lpfnGetModuleInformation    = reinterpret_cast<GetModuleInformation_PROC>(GetProcAddress( hModPsapi, "GetModuleInformation" ));
 339
 340         if ( lpfnEnumProcessModules && lpfnGetModuleInformation )
 341         {
 342             DWORD       cbNeeded = 0;
 343             HMODULE     *lpModules = nullptr;
 344             DWORD       nModules = 0;
 345             UINT        iModule = 0;
 346             MODULEINFO  modinfo;
 347
 348             lpfnEnumProcessModules( GetCurrentProcess(), nullptr, 0, &cbNeeded );
 349
 350             lpModules = static_cast<HMODULE *>(_alloca( cbNeeded ));
 351             lpfnEnumProcessModules( GetCurrentProcess(), lpModules, cbNeeded, &cbNeeded );
 352
 353             nModules = cbNeeded / sizeof(HMODULE);
 354
 355             for ( iModule = 0; !bSuccess && iModule < nModules; iModule++ )
 356             {
 357                 lpfnGetModuleInformation( GetCurrentProcess(), lpModules[iModule], &modinfo, sizeof(modinfo) );
 358
 359                 if ( static_cast<BYTE *>(pv) >= static_cast<BYTE *>(modinfo.lpBaseOfDll) && static_cast<BYTE *>(pv) < static_cast<BYTE *>(modinfo.lpBaseOfDll) + modinfo.SizeOfImage )
 360                 {
 361                     ::osl::LongPathBuffer< sal_Unicode > aBuffer( MAX_LONG_PATH );
 362                     rtl_uString *ustrSysPath = nullptr;
 363
 364                     GetModuleFileNameW( lpModules[iModule], o3tl::toW(aBuffer), aBuffer.getBufSizeInSymbols() );
 365
 366                     rtl_uString_newFromStr( &ustrSysPath, aBuffer );
 367                     osl_getFileURLFromSystemPath( ustrSysPath, pustrURL );
 368                     rtl_uString_release( ustrSysPath );
 369
 370                     bSuccess = true;
 371                 }
 372             }
 373         }
 374
 375     }
 376
 377     return bSuccess;
 378 }
 379
 380 sal_Bool SAL_CALL osl_getModuleURLFromAddress( void *pv, rtl_uString **pustrURL )
 381 {
 382     /* Use ..._NT first because ..._NT4 is much slower */
 383     return osl_addressGetModuleURL_NT_( pv, pustrURL ) || osl_addressGetModuleURL_NT4_( pv, pustrURL );
 384 }
 385
 386 sal_Bool SAL_CALL osl_getModuleURLFromFunctionAddress( oslGenericFunction addr, rtl_uString ** ppLibraryUrl )
 387 {
 388     /* casting a function pointer to a data pointer (void*) is
 389        not allowed according to the C/C++ standards. In this case
 390        it is unavoidable because we have to stay compatible we
 391        cannot remove any function. */
 392 #ifdef _MSC_VER
 393 #pragma warning(push)
 394 #pragma warning(disable:4054)
 395 #endif
 396     return osl_getModuleURLFromAddress(reinterpret_cast<void*>(addr), ppLibraryUrl);
 397 #ifdef _MSC_VER
 398 #pragma warning(pop)
 399 #endif
 400 }
 401
 402 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */