cli_ure/source/native/native_bootstrap.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 "native_share.h"
  21
  22 #include "rtl/bootstrap.hxx"
  23 #include "com/sun/star/uno/XComponentContext.hpp"
  24 #include "cppuhelper/bootstrap.hxx"
  25 #include <memory>
  26 #include <stdio.h>
  27 #define WIN32_LEAN_AND_MEAN
  28 #include <windows.h>
  29 #include <delayimp.h>
  30
  31 #define INSTALL_PATH L"Software\\LibreOffice\\UNO\\InstallPath"
  32 #define UNO_PATH L"UNO_PATH"
  33
  34 namespace {
  35
  36 /* Gets the installation path from the Windows Registry for the specified
  37    registry key.
  38
  39    @param hroot       open handle to predefined root registry key
  40    @param subKeyName  name of the subkey to open
  41
  42    @return the installation path or nullptr, if no installation was found or
  43            if an error occurred
  44 */
  45 WCHAR* getPathFromRegistryKey( HKEY hroot, LPCWSTR subKeyName )
  46 {
  47     // open the specified registry key
  48     HKEY hkey;
  49     if ( RegOpenKeyExW( hroot, subKeyName, 0, KEY_READ, &hkey ) != ERROR_SUCCESS )
  50         return nullptr;
  51
  52     struct CloseKeyGuard {
  53         HKEY m_hkey;
  54         ~CloseKeyGuard() { RegCloseKey( m_hkey ); }
  55     } aCloseKeyGuard{hkey};
  56
  57     // find the type and size of the default value
  58     DWORD type;
  59     DWORD size;
  60     if ( RegQueryValueExW( hkey, nullptr, nullptr, &type, nullptr, &size ) != ERROR_SUCCESS )
  61         return nullptr;
  62
  63     // get memory to hold the default value
  64     std::unique_ptr<WCHAR[]> data(new WCHAR[size]);
  65
  66     // read the default value
  67     if ( RegQueryValueExW( hkey, nullptr, nullptr, &type, reinterpret_cast<LPBYTE>(data.get()), &size ) != ERROR_SUCCESS )
  68         return nullptr;
  69
  70     return data.release();
  71 }
  72
  73 /* Returns the path to the program folder of the brand layer,
  74    for example C:/Program Files/LibreOffice/program
  75    This path is either obtained from the environment variable UNO_PATH
  76    or the registry item "Software\\LibreOffice\\UNO\\InstallPath"
  77    either in HKEY_CURRENT_USER or HKEY_LOCAL_MACHINE
  78    The return value must be freed with delete[]
  79 */
  80 WCHAR* getInstallPath()
  81 {
  82     std::unique_ptr<WCHAR[]> szInstallPath;
  83
  84     DWORD cChars = GetEnvironmentVariableW(UNO_PATH, nullptr, 0);
  85     if (cChars > 0)
  86     {
  87         szInstallPath.reset(new WCHAR[cChars]);
  88         cChars = GetEnvironmentVariableW(UNO_PATH, szInstallPath.get(), cChars);
  89         // If PATH is not set then it is no error
  90         if (cChars == 0)
  91             return nullptr;
  92     }
  93
  94     if (! szInstallPath)
  95     {
  96         szInstallPath.reset(getPathFromRegistryKey( HKEY_CURRENT_USER, INSTALL_PATH ));
  97         if (! szInstallPath)
  98         {
  99             // read the key's default value from HKEY_LOCAL_MACHINE
 100             szInstallPath.reset(getPathFromRegistryKey( HKEY_LOCAL_MACHINE, INSTALL_PATH ));
 101         }
 102     }
 103     return szInstallPath.release();
 104 }
 105
 106 /* We extend the path to contain the install folder,
 107    so that components can use osl_loadModule with arguments, such as
 108    "reg3.dll". That is, the arguments are only the library names.
 109 */
 110 void extendPath(LPCWSTR szPath)
 111 {
 112     if (!szPath)
 113         return;
 114
 115     std::unique_ptr<WCHAR[]> sEnvPath;
 116     DWORD cChars = GetEnvironmentVariableW(L"PATH", nullptr, 0);
 117     if (cChars > 0)
 118     {
 119         sEnvPath.reset(new WCHAR[cChars]);
 120         cChars = GetEnvironmentVariableW(L"PATH", sEnvPath.get(), cChars);
 121         // If PATH is not set then it is no error
 122         if (cChars == 0 && GetLastError() != ERROR_ENVVAR_NOT_FOUND)
 123             return;
 124     }
 125     // Prepare the new PATH. Add the directory at the front.
 126     // Note also adding ';'
 127     std::unique_ptr<WCHAR[]> sNewPath(new WCHAR[lstrlenW(sEnvPath.get()) + lstrlenW(szPath) + 2]);
 128     lstrcpyW(sNewPath.get(), szPath);
 129     if (lstrlenW(sEnvPath.get()))
 130     {
 131         lstrcatW(sNewPath.get(), L";");
 132         lstrcatW(sNewPath.get(), sEnvPath.get());
 133     }
 134     SetEnvironmentVariableW(L"PATH", sNewPath.get());
 135 }
 136
 137 HMODULE loadFromPath(LPCSTR sLibName)
 138 {
 139     if (!sLibName)
 140         return nullptr;
 141
 142     // Convert the ansi file name to wchar_t*
 143     int size = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, sLibName, -1, nullptr, 0);
 144     if (size == 0)
 145         return nullptr;
 146     std::unique_ptr<WCHAR[]> wsLibName(new WCHAR[size]);
 147     if (!MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, sLibName, -1, wsLibName.get(), size))
 148         return nullptr;
 149
 150     std::unique_ptr<WCHAR[]> szPath(getInstallPath());
 151     if (!szPath)
 152         return nullptr;
 153
 154     extendPath(szPath.get());
 155
 156     std::unique_ptr<WCHAR[]> szFullPath(new WCHAR[lstrlenW(wsLibName.get()) + lstrlenW(szPath.get()) + 2]);
 157     lstrcpyW(szFullPath.get(), szPath.get());
 158     lstrcatW(szFullPath.get(), L"\\");
 159     lstrcatW(szFullPath.get(), wsLibName.get());
 160     HMODULE handle = LoadLibraryW(szFullPath.get());
 161     return handle;
 162 }
 163
 164 /* Hook for delayed loading of libraries which this library is linked with.
 165    This is a failure hook. That is, it is only called when the loading of
 166    a library failed. It will be called when loading of cppuhelper failed.
 167    Because we extend the PATH to the install folder while this function is
 168    executed (see extendPath), all other libraries are found.
 169 */
 170 extern "C" FARPROC WINAPI delayLoadHook(
 171     unsigned int   dliNotify,
 172     PDelayLoadInfo pdli
 173     )
 174 {
 175     if (dliNotify == dliFailLoadLib)
 176     {
 177         HANDLE h = loadFromPath(pdli->szDll);
 178         return reinterpret_cast<FARPROC>(h);
 179     }
 180     return nullptr;
 181 }
 182 }
 183
 184 ExternC
 185 const PfnDliHook __pfnDliFailureHook2 = delayLoadHook;
 186
 187 using namespace ::com::sun::star;
 188 using namespace ::com::sun::star::uno;
 189
 190 namespace uno
 191 {
 192 namespace util
 193 {
 194
 195 /** Bootstrapping native UNO.
 196
 197     Bootstrapping requires the existence of many libraries which are contained
 198     in an URE installation. To find and load these libraries the Windows
 199     registry keys HKEY_CURRENT_USER\Software\LibreOffice\Layer\URE\1
 200     and HKEY_LOCAL_MACHINE\Software\LibreOffice\Layer\URE\1 are examined.
 201     These contain a named value UREINSTALLLOCATION which holds a path to the URE
 202     installation folder.
 203 */
 204 public ref class Bootstrap sealed
 205 {
 206     inline Bootstrap() {}
 207
 208 public:
 209
 210     /** Bootstraps the initial component context from a native UNO installation.
 211
 212         @see cppuhelper/bootstrap.hxx:defaultBootstrap_InitialComponentContext()
 213     */
 214     static ::unoidl::com::sun::star::uno::XComponentContext ^
 215         defaultBootstrap_InitialComponentContext();
 216
 217     /** Bootstraps the initial component context from a native UNO installation.
 218
 219         @param ini_file
 220                a file URL of an ini file, e.g. uno.ini/unorc. (The ini file must
 221                reside next to the cppuhelper library)
 222         @param bootstrap_parameters
 223                bootstrap parameters (maybe null)
 224
 225         @see cppuhelper/bootstrap.hxx:defaultBootstrap_InitialComponentContext()
 226     */
 227     static ::unoidl::com::sun::star::uno::XComponentContext ^
 228         defaultBootstrap_InitialComponentContext(
 229             ::System::String ^ ini_file,
 230             ::System::Collections::IDictionaryEnumerator ^
 231               bootstrap_parameters );
 232
 233     /** Bootstraps the initial component context from a native UNO installation.
 234
 235     @see cppuhelper/bootstrap.hxx:bootstrap()
 236      */
 237     static ::unoidl::com::sun::star::uno::XComponentContext ^
 238     bootstrap();
 239 };
 240
 241
 242 ::unoidl::com::sun::star::uno::XComponentContext ^
 243 Bootstrap::defaultBootstrap_InitialComponentContext(
 244     ::System::String ^ ini_file,
 245     ::System::Collections::IDictionaryEnumerator ^ bootstrap_parameters )
 246 {
 247     if (nullptr != bootstrap_parameters)
 248     {
 249         bootstrap_parameters->Reset();
 250         while (bootstrap_parameters->MoveNext())
 251         {
 252             OUString key(
 253                 String_to_ustring( safe_cast< ::System::String ^ >(
 254                                        bootstrap_parameters->Key ) ) );
 255             OUString value(
 256                 String_to_ustring( safe_cast< ::System::String ^ >(
 257                                        bootstrap_parameters->Value ) ) );
 258
 259             ::rtl::Bootstrap::set( key, value );
 260         }
 261     }
 262
 263     // bootstrap native uno
 264     Reference< XComponentContext > xContext;
 265     if (nullptr == ini_file)
 266     {
 267         xContext = ::cppu::defaultBootstrap_InitialComponentContext();
 268     }
 269     else
 270     {
 271         xContext = ::cppu::defaultBootstrap_InitialComponentContext(
 272             String_to_ustring( safe_cast< ::System::String ^ >( ini_file ) ) );
 273     }
 274
 275     return safe_cast< ::unoidl::com::sun::star::uno::XComponentContext ^ >(
 276         to_cli( xContext ) );
 277 }
 278
 279
 280 ::unoidl::com::sun::star::uno::XComponentContext ^
 281 Bootstrap::defaultBootstrap_InitialComponentContext()
 282 {
 283     return defaultBootstrap_InitialComponentContext( nullptr, nullptr );
 284 }
 285
 286 ::unoidl::com::sun::star::uno::XComponentContext ^ Bootstrap::bootstrap()
 287 {
 288     Reference<XComponentContext> xContext = ::cppu::bootstrap();
 289     return safe_cast< ::unoidl::com::sun::star::uno::XComponentContext ^ >(
 290         to_cli( xContext ) );
 291
 292 }
 293
 294 }
 295 }
 296
 297 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */