setup_native/source/win32/customactions/regactivex/regactivex.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 #if !defined WIN32_LEAN_AND_MEAN
  21 # define WIN32_LEAN_AND_MEAN
  22 #endif
  23 #include <windows.h>
  24 #include <msiquery.h>
  25
  26 #include <cassert>
  27 #include <string.h>
  28 #include <malloc.h>
  29
  30 #define CHART_COMPONENT 1
  31 #define DRAW_COMPONENT 2
  32 #define IMPRESS_COMPONENT 4
  33 #define CALC_COMPONENT 8
  34 #define WRITER_COMPONENT 16
  35 #define MATH_COMPONENT 32
  36
  37 typedef int ( __stdcall * DllNativeRegProc ) ( int, BOOL, BOOL, const wchar_t* );
  38 typedef int ( __stdcall * DllNativeUnregProc ) ( int, BOOL, BOOL );
  39
  40 static bool UnicodeEquals( wchar_t const * pStr1, wchar_t const * pStr2 )
  41 {
  42     if ( pStr1 == nullptr && pStr2 == nullptr )
  43         return true;
  44     else if ( pStr1 == nullptr || pStr2 == nullptr )
  45         return false;
  46
  47     while( *pStr1 == *pStr2 && *pStr1 && *pStr2 )
  48     {
  49         pStr1++;
  50         pStr2++;
  51     }
  52
  53     return ( *pStr1 == 0 && *pStr2 == 0 );
  54 }
  55
  56
  57 static void RegisterActiveXNative( const wchar_t* pActiveXPath, int nMode, bool InstallForAllUser, bool InstallFor64Bit )
  58 {
  59     HINSTANCE hModule = LoadLibraryExW( pActiveXPath, nullptr, LOAD_WITH_ALTERED_SEARCH_PATH );
  60     if( hModule )
  61     {
  62         DllNativeRegProc pNativeProc = reinterpret_cast<DllNativeRegProc>(GetProcAddress( hModule, "DllRegisterServerNative" ));
  63         if( pNativeProc!=nullptr )
  64         {
  65             int nLen = wcslen( pActiveXPath );
  66             int nRemoveLen = strlen( "\\so_activex.dll" );
  67             if ( nLen > nRemoveLen )
  68             {
  69                 wchar_t* pProgramPath = static_cast<wchar_t*>( malloc( (nLen - nRemoveLen + 1) * sizeof(wchar_t) ) );
  70                 assert(pProgramPath && "Don't handle OOM conditions");
  71                 wcsncpy( pProgramPath, pActiveXPath, nLen - nRemoveLen );
  72                 pProgramPath[ nLen - nRemoveLen ] = 0;
  73
  74                 ( *pNativeProc )( nMode, InstallForAllUser, InstallFor64Bit, pProgramPath );
  75
  76                 free( pProgramPath );
  77             }
  78         }
  79
  80         FreeLibrary( hModule );
  81     }
  82 }
  83
  84
  85 static void UnregisterActiveXNative( const wchar_t* pActiveXPath, int nMode, bool InstallForAllUser, bool InstallFor64Bit )
  86 {
  87     HINSTANCE hModule = LoadLibraryExW( pActiveXPath, nullptr, LOAD_WITH_ALTERED_SEARCH_PATH );
  88     if( hModule )
  89     {
  90         DllNativeUnregProc pNativeProc = reinterpret_cast<DllNativeUnregProc>(GetProcAddress( hModule, "DllUnregisterServerNative" ));
  91         if( pNativeProc!=nullptr )
  92             ( *pNativeProc )( nMode, InstallForAllUser, InstallFor64Bit );
  93
  94         FreeLibrary( hModule );
  95     }
  96 }
  97
  98
  99 static bool GetMsiPropW( MSIHANDLE hMSI, const wchar_t* pPropName, wchar_t** ppValue )
 100 {
 101     DWORD sz = 0;
 102     if ( MsiGetPropertyW( hMSI, pPropName, const_cast<wchar_t *>(L""), &sz ) == ERROR_MORE_DATA )
 103     {
 104         sz++;
 105         DWORD nbytes = sz * sizeof( wchar_t );
 106         wchar_t* buff = static_cast<wchar_t*>( malloc( nbytes ) );
 107         assert(buff && "Don't handle OOM conditions");
 108         ZeroMemory( buff, nbytes );
 109         MsiGetPropertyW( hMSI, pPropName, buff, &sz );
 110         *ppValue = buff;
 111
 112         return true;
 113     }
 114
 115     return false;
 116 }
 117
 118
 119 static bool GetActiveXControlPath( MSIHANDLE hMSI, wchar_t** ppActiveXPath )
 120 {
 121     wchar_t* pProgPath = nullptr;
 122     if ( GetMsiPropW( hMSI, L"INSTALLLOCATION", &pProgPath ) && pProgPath )
 123     {
 124         int nLen = wcslen( pProgPath );
 125         *ppActiveXPath = static_cast<wchar_t*>( malloc( (nLen + 23) * sizeof(wchar_t) ) );
 126         assert(*ppActiveXPath && "Don't handle OOM conditions");
 127         wcsncpy( *ppActiveXPath, pProgPath, nLen );
 128         wcsncpy( (*ppActiveXPath) + nLen, L"program\\so_activex.dll", 22 );
 129         (*ppActiveXPath)[nLen+22] = 0;
 130
 131         free(pProgPath);
 132
 133         return true;
 134     }
 135
 136     return false;
 137 }
 138
 139
 140 static bool GetDelta( MSIHANDLE hMSI, int& nOldInstallMode, int& nInstallMode, int& nDeinstallMode )
 141 {
 142     // for now the chart is always installed
 143     nOldInstallMode = CHART_COMPONENT;
 144     nInstallMode = CHART_COMPONENT;
 145     nDeinstallMode = 0;
 146
 147     INSTALLSTATE current_state;
 148     INSTALLSTATE future_state;
 149
 150     if ( ERROR_SUCCESS == MsiGetFeatureStateW( hMSI, L"gm_p_Wrt_Bin", &current_state, &future_state ) )
 151     {
 152         // analyze writer installation mode
 153         if ( current_state == INSTALLSTATE_LOCAL )
 154             nOldInstallMode |= WRITER_COMPONENT;
 155
 156         if ( future_state == INSTALLSTATE_LOCAL
 157           || ( current_state == INSTALLSTATE_LOCAL && future_state == INSTALLSTATE_UNKNOWN ) )
 158             nInstallMode |= WRITER_COMPONENT;
 159         else if ( current_state == INSTALLSTATE_LOCAL && future_state == INSTALLSTATE_ABSENT )
 160             nDeinstallMode |= WRITER_COMPONENT;
 161     }
 162     else
 163     {
 164         // assert( FALSE );
 165     }
 166
 167     if ( ERROR_SUCCESS == MsiGetFeatureStateW( hMSI, L"gm_p_Calc_Bin", &current_state, &future_state ) )
 168     {
 169         // analyze calc installation mode
 170         if ( current_state == INSTALLSTATE_LOCAL )
 171             nOldInstallMode |= CALC_COMPONENT;
 172
 173         if ( future_state == INSTALLSTATE_LOCAL
 174           || ( current_state == INSTALLSTATE_LOCAL && future_state == INSTALLSTATE_UNKNOWN ) )
 175             nInstallMode |= CALC_COMPONENT;
 176         else if ( current_state == INSTALLSTATE_LOCAL && future_state == INSTALLSTATE_ABSENT )
 177             nDeinstallMode |= CALC_COMPONENT;
 178     }
 179     else
 180     {
 181         // assert( FALSE );
 182     }
 183
 184     if ( ERROR_SUCCESS == MsiGetFeatureStateW( hMSI, L"gm_p_Draw_Bin", &current_state, &future_state ) )
 185     {
 186         // analyze draw installation mode
 187         if ( current_state == INSTALLSTATE_LOCAL )
 188             nOldInstallMode |= DRAW_COMPONENT;
 189
 190         if ( future_state == INSTALLSTATE_LOCAL
 191           || ( current_state == INSTALLSTATE_LOCAL && future_state == INSTALLSTATE_UNKNOWN ) )
 192             nInstallMode |= DRAW_COMPONENT;
 193         else if ( current_state == INSTALLSTATE_LOCAL && future_state == INSTALLSTATE_ABSENT )
 194             nDeinstallMode |= DRAW_COMPONENT;
 195     }
 196     else
 197     {
 198         // assert( FALSE );
 199     }
 200
 201     if ( ERROR_SUCCESS == MsiGetFeatureStateW( hMSI, L"gm_p_Impress_Bin", &current_state, &future_state ) )
 202     {
 203         // analyze impress installation mode
 204         if ( current_state == INSTALLSTATE_LOCAL )
 205             nOldInstallMode |= IMPRESS_COMPONENT;
 206
 207         if ( future_state == INSTALLSTATE_LOCAL
 208           || ( current_state == INSTALLSTATE_LOCAL && future_state == INSTALLSTATE_UNKNOWN ) )
 209             nInstallMode |= IMPRESS_COMPONENT;
 210         else if ( current_state == INSTALLSTATE_LOCAL && future_state == INSTALLSTATE_ABSENT )
 211             nDeinstallMode |= IMPRESS_COMPONENT;
 212     }
 213     else
 214     {
 215         // assert( FALSE );
 216     }
 217
 218     if ( ERROR_SUCCESS == MsiGetFeatureStateW( hMSI, L"gm_p_Math_Bin", &current_state, &future_state ) )
 219     {
 220         // analyze math installation mode
 221         if ( current_state == INSTALLSTATE_LOCAL )
 222             nOldInstallMode |= MATH_COMPONENT;
 223
 224         if ( future_state == INSTALLSTATE_LOCAL
 225           || ( current_state == INSTALLSTATE_LOCAL && future_state == INSTALLSTATE_UNKNOWN ) )
 226             nInstallMode |= MATH_COMPONENT;
 227         else if ( current_state == INSTALLSTATE_LOCAL && future_state == INSTALLSTATE_ABSENT )
 228             nDeinstallMode |= MATH_COMPONENT;
 229     }
 230     else
 231     {
 232         // assert( FALSE );
 233     }
 234
 235     return true;
 236 }
 237
 238
 239 static bool MakeInstallForAllUsers( MSIHANDLE hMSI )
 240 {
 241     bool bResult = false;
 242     wchar_t* pVal = nullptr;
 243     if ( GetMsiPropW( hMSI, L"ALLUSERS", &pVal ) && pVal )
 244     {
 245         bResult = UnicodeEquals( pVal , L"1" );
 246         free( pVal );
 247     }
 248
 249     return bResult;
 250 }
 251
 252
 253 static bool MakeInstallFor64Bit( MSIHANDLE hMSI )
 254 {
 255     bool bResult = false;
 256     wchar_t* pVal = nullptr;
 257     if ( GetMsiPropW( hMSI, L"VersionNT64", &pVal ) && pVal )
 258     {
 259         bResult = true;
 260         free( pVal );
 261     }
 262
 263     return bResult;
 264 }
 265
 266 extern "C" __declspec(dllexport) UINT __stdcall InstallActiveXControl( MSIHANDLE hMSI )
 267 {
 268     INSTALLSTATE current_state;
 269     INSTALLSTATE future_state;
 270
 271     if ( ERROR_SUCCESS == MsiGetFeatureStateW( hMSI, L"gm_o_Activexcontrol", &current_state, &future_state ) )
 272     {
 273         int nOldInstallMode = 0;
 274         int nInstallMode = 0;
 275         int nDeinstallMode = 0;
 276         bool bInstallForAllUser = MakeInstallForAllUsers( hMSI );
 277         bool bInstallFor64Bit = MakeInstallFor64Bit( hMSI );
 278
 279         wchar_t* pActiveXPath = nullptr;
 280         if ( GetActiveXControlPath( hMSI, &pActiveXPath ) && pActiveXPath
 281         && GetDelta( hMSI, nOldInstallMode, nInstallMode, nDeinstallMode ) )
 282         {
 283             if ( future_state == INSTALLSTATE_LOCAL
 284               || ( current_state == INSTALLSTATE_LOCAL && future_state == INSTALLSTATE_UNKNOWN ) )
 285             {
 286                 // the control is installed in the new selected configuration
 287
 288                 if ( current_state == INSTALLSTATE_LOCAL && nDeinstallMode )
 289                     UnregisterActiveXNative( pActiveXPath, nDeinstallMode, bInstallForAllUser, bInstallFor64Bit );
 290
 291                 if ( nInstallMode )
 292                     RegisterActiveXNative( pActiveXPath, nInstallMode, bInstallForAllUser, bInstallFor64Bit );
 293             }
 294             else if ( current_state == INSTALLSTATE_LOCAL && future_state == INSTALLSTATE_ABSENT )
 295             {
 296                 if ( nOldInstallMode )
 297                     UnregisterActiveXNative( pActiveXPath, nOldInstallMode, bInstallForAllUser, bInstallFor64Bit );
 298             }
 299         }
 300
 301         if ( pActiveXPath )
 302             free( pActiveXPath );
 303     }
 304     else
 305     {
 306         // assert( FALSE );
 307     }
 308
 309     return ERROR_SUCCESS;
 310 }
 311
 312
 313 extern "C" __declspec(dllexport) UINT __stdcall DeinstallActiveXControl( MSIHANDLE hMSI )
 314 {
 315     INSTALLSTATE current_state;
 316     INSTALLSTATE future_state;
 317
 318     if ( ERROR_SUCCESS == MsiGetFeatureStateW( hMSI, L"gm_o_Activexcontrol", &current_state, &future_state ) )
 319     {
 320         wchar_t* pActiveXPath = nullptr;
 321         if ( current_state == INSTALLSTATE_LOCAL && GetActiveXControlPath( hMSI, &pActiveXPath ) && pActiveXPath )
 322         {
 323             bool bInstallForAllUser = MakeInstallForAllUsers( hMSI );
 324             bool bInstallFor64Bit = MakeInstallFor64Bit( hMSI );
 325
 326             {
 327                 UnregisterActiveXNative( pActiveXPath,
 328                                         CHART_COMPONENT
 329                                         | DRAW_COMPONENT
 330                                         | IMPRESS_COMPONENT
 331                                         | CALC_COMPONENT
 332                                         | WRITER_COMPONENT
 333                                         | MATH_COMPONENT,
 334                                         bInstallForAllUser,
 335                                         bInstallFor64Bit );
 336             }
 337
 338             free( pActiveXPath );
 339         }
 340     }
 341
 342     return ERROR_SUCCESS;
 343 }
 344
 345 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */