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
  22 #include "file_url.hxx"
  23 #include "path_helper.hxx"
  24
  25 #include <osl/module.h>
  26 #include <osl/diagnose.h>
  27 #include <osl/thread.h>
  28 #include <osl/file.h>
  29 #include <rtl/ustring.hxx>
  30 #include <sal/log.hxx>
  31 #include <o3tl/char16_t2wchar_t.hxx>
  32 #include <systools/win32/extended_max_path.hxx>
  33 #include <vector>
  34
  35 /*
  36     under WIN32, we use the void* oslModule
  37     as a WIN32 HANDLE (which is also a 32-bit value)
  38 */
  39
  40 oslModule SAL_CALL osl_loadModule(rtl_uString *strModuleName, sal_Int32 /*nRtldMode*/ )
  41 {
  42 #if OSL_DEBUG_LEVEL < 2
  43     UINT errorMode = SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
  44 #endif
  45     SAL_INFO( "sal.osl", "osl_loadModule: " << OUString(strModuleName) );
  46     OSL_ASSERT(strModuleName);
  47
  48     OUString Module;
  49     oslFileError nError = osl_getSystemPathFromFileURL(strModuleName, &Module.pData);
  50
  51     if ( osl_File_E_None != nError )
  52         Module = OUString::unacquired(&strModuleName);
  53
  54     HMODULE h = LoadLibraryW(o3tl::toW(Module.getStr()));
  55
  56     if (h == nullptr)
  57         h = LoadLibraryExW(o3tl::toW(Module.getStr()), nullptr, LOAD_WITH_ALTERED_SEARCH_PATH);
  58
  59     // In case of long path names (\\?\c:\...) try to shorten the filename.
  60     // LoadLibrary cannot handle file names which exceed 260 letters.
  61     // In case the path is too long, the function will fail. However, the error
  62     // code can be different. For example, it returned  ERROR_FILENAME_EXCED_RANGE
  63     // on Windows XP and ERROR_INSUFFICIENT_BUFFER on Windows 7 (64bit)
  64     if (h == nullptr && Module.getLength() > 260)
  65     {
  66         std::vector<WCHAR> vec(Module.getLength() + 1);
  67         DWORD len = GetShortPathNameW(o3tl::toW(Module.getStr()), vec.data(), vec.size());
  68         if (len )
  69         {
  70             h = LoadLibraryW(vec.data());
  71
  72             if (h == nullptr)
  73                 h = LoadLibraryExW(vec.data(), nullptr, LOAD_WITH_ALTERED_SEARCH_PATH);
  74         }
  75     }
  76
  77 #if OSL_DEBUG_LEVEL < 2
  78     SetErrorMode(errorMode);
  79 #endif
  80
  81     return static_cast<oslModule>(h);
  82 }
  83
  84 oslModule SAL_CALL osl_loadModuleAscii(const char *pModuleName, sal_Int32 )
  85 {
  86     UINT errorMode = SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
  87
  88     SAL_INFO( "sal.osl", "osl_loadModule: " << pModuleName );
  89     OSL_ASSERT(pModuleName);
  90
  91     HMODULE h = LoadLibraryA(pModuleName);
  92     if (h == nullptr)
  93         h = LoadLibraryExA(pModuleName, nullptr,
  94                                   LOAD_WITH_ALTERED_SEARCH_PATH);
  95
  96     SetErrorMode(errorMode);
  97
  98     return static_cast<oslModule>(h);
  99 }
 100
 101 oslModule osl_loadModuleRelativeAscii(
 102     oslGenericFunction baseModule, char const * relativePath, sal_Int32 mode)
 103 {
 104     return osl_loadModuleRelative(baseModule, OUString::createFromAscii(relativePath).pData, mode);
 105 }
 106
 107 sal_Bool SAL_CALL
 108 osl_getModuleHandle(rtl_uString *pModuleName, oslModule *pResult)
 109 {
 110     LPCWSTR pName = pModuleName ? o3tl::toW(pModuleName->buffer) : nullptr;
 111     HMODULE h = GetModuleHandleW(pName);
 112     if( h )
 113     {
 114         *pResult = static_cast<oslModule>(h);
 115         return true;
 116     }
 117
 118     return false;
 119 }
 120
 121 void SAL_CALL osl_unloadModule(oslModule Module)
 122 {
 123     FreeLibrary(static_cast<HMODULE>(Module));
 124 }
 125
 126 void* SAL_CALL osl_getSymbol(oslModule Module, rtl_uString *strSymbolName)
 127 {
 128     /* casting from a function pointer to a data pointer is invalid
 129        be in this case unavoidable because the API has to stay
 130        compatible. We need to keep this function which returns a
 131        void* by definition */
 132     return reinterpret_cast<void*>(osl_getFunctionSymbol(Module, strSymbolName));
 133 }
 134
 135 oslGenericFunction SAL_CALL osl_getFunctionSymbol( oslModule Module, rtl_uString *strSymbolName )
 136 {
 137     OSL_ASSERT(Module);
 138     assert(strSymbolName);
 139
 140     auto symbolName(OUStringToOString(OUString::unacquired(&strSymbolName), RTL_TEXTENCODING_UTF8));
 141
 142     return osl_getAsciiFunctionSymbol(Module, symbolName.getStr());
 143 }
 144
 145 oslGenericFunction SAL_CALL
 146 osl_getAsciiFunctionSymbol( oslModule Module, const char *pSymbol )
 147 {
 148     oslGenericFunction fncAddr = nullptr;
 149
 150     if( pSymbol )
 151         fncAddr=reinterpret_cast<oslGenericFunction>(GetProcAddress(static_cast<HMODULE>(Module), pSymbol));
 152
 153     return fncAddr;
 154 }
 155
 156 sal_Bool SAL_CALL osl_getModuleURLFromAddress( void *pv, rtl_uString **pustrURL )
 157 {
 158     HMODULE hModule{};
 159     GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
 160                            | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
 161                        static_cast<LPCWSTR>(pv), &hModule);
 162     if (!hModule)
 163         return false;
 164
 165     osl::LongPathBuffer<sal_Unicode> aBuffer(EXTENDED_MAX_PATH);
 166
 167     DWORD nch = GetModuleFileNameW(hModule, o3tl::toW(aBuffer), aBuffer.getBufSizeInSymbols());
 168
 169     OUString ustrSysPath(aBuffer, nch);
 170     return osl_getFileURLFromSystemPath(ustrSysPath.pData, pustrURL) == osl_File_E_None;
 171 }
 172
 173 sal_Bool SAL_CALL osl_getModuleURLFromFunctionAddress( oslGenericFunction addr, rtl_uString ** ppLibraryUrl )
 174 {
 175     /* casting a function pointer to a data pointer (void*) is
 176        not allowed according to the C/C++ standards. In this case
 177        it is unavoidable because we have to stay compatible we
 178        cannot remove any function. */
 179     return osl_getModuleURLFromAddress(reinterpret_cast<void*>(addr), ppLibraryUrl);
 180 }
 181
 182 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */