setup_native/source/win32/customactions/patch/swappatchfiles.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 #define _WIN32_WINDOWS 0x0410
  30
  31 #ifdef _MSC_VER
  32 #pragma warning(push, 1) /* disable warnings within system headers */
  33 #endif
  34 #define WIN32_LEAN_AND_MEAN
  35 #include <windows.h>
  36 #include <msiquery.h>
  37 #ifdef _MSC_VER
  38 #pragma warning(pop)
  39 #endif
  40
  41 #include <malloc.h>
  42 #include <assert.h>
  43
  44 #ifdef UNICODE
  45 #define _UNICODE
  46 #define _tstring    wstring
  47 #else
  48 #define _tstring    string
  49 #endif
  50 #include <tchar.h>
  51 #include <string>
  52 #include <queue>
  53 #include <stdio.h>
  54 #include <sal/macros.h>
  55
  56 #include <systools/win32/uwinapi.h>
  57 #include <../tools/seterror.hxx>
  58
  59 #ifdef DEBUG
  60 inline void OutputDebugStringFormat( LPCTSTR pFormat, ... )
  61 {
  62     _TCHAR  buffer[1024];
  63     va_list args;
  64
  65     va_start( args, pFormat );
  66     _vsntprintf( buffer, SAL_N_ELEMENTS(buffer), pFormat, args );
  67     OutputDebugString( buffer );
  68 }
  69 #else
  70 static inline void OutputDebugStringFormat( LPCTSTR, ... )
  71 {
  72 }
  73 #endif
  74
  75 static std::_tstring GetMsiProperty( MSIHANDLE handle, const std::_tstring& sProperty )
  76 {
  77     std::_tstring   result;
  78     TCHAR   szDummy[1] = TEXT("");
  79     DWORD   nChars = 0;
  80
  81     if ( MsiGetProperty( handle, sProperty.c_str(), szDummy, &nChars ) == ERROR_MORE_DATA )
  82     {
  83         DWORD nBytes = ++nChars * sizeof(TCHAR);
  84         LPTSTR buffer = reinterpret_cast<LPTSTR>(_alloca(nBytes));
  85         ZeroMemory( buffer, nBytes );
  86         MsiGetProperty(handle, sProperty.c_str(), buffer, &nChars);
  87         result = buffer;
  88     }
  89
  90     return  result;
  91 }
  92
  93 // The provided GUID must be without surounding '{}'
  94 static std::_tstring GetGuidPart(const std::_tstring& guid, int index)
  95 {
  96     assert((guid.length() == 36) && "No GUID or wrong format!");
  97     assert(((index > -1) && (index < 5)) && "Out of range!");
  98
  99     if (index == 0) return std::_tstring(guid.c_str(), 8);
 100     if (index == 1) return std::_tstring(guid.c_str() + 9, 4);
 101     if (index == 2) return std::_tstring(guid.c_str() + 14, 4);
 102     if (index == 3) return std::_tstring(guid.c_str() + 19, 4);
 103     if (index == 4) return std::_tstring(guid.c_str() + 24, 12);
 104
 105     return std::_tstring();
 106 }
 107
 108 static void Swap(char* p1, char* p2)
 109 {
 110     char tmp = *p1;
 111     *p1 = *p2;
 112     *p2 = tmp;
 113 }
 114
 115 static std::_tstring Invert(const std::_tstring& str)
 116 {
 117     char* buff = reinterpret_cast<char*>(_alloca(str.length()));
 118     strncpy(buff, str.c_str(), str.length());
 119
 120     char* front = buff;
 121     char* back = buff + str.length() - 1;
 122
 123     while (front < back)
 124         Swap(front++, back--);
 125
 126     return std::_tstring(buff, str.length());
 127 }
 128
 129 // Convert the upgrade code (which is a GUID) according
 130 // to the way the windows installer does when writing it
 131 // to the registry
 132 // The first 8 bytes will be inverted, from the the last
 133 // 8 bytes always the nibbles will be inverted for further
 134 // details look in the MSDN under compressed registry keys
 135 static std::_tstring ConvertGuid(const std::_tstring& guid)
 136 {
 137     std::_tstring convertedGuid;
 138
 139     std::_tstring part = GetGuidPart(guid, 0);
 140     convertedGuid = Invert(part);
 141
 142     part = GetGuidPart(guid, 1);
 143     convertedGuid += Invert(part);
 144
 145     part = GetGuidPart(guid, 2);
 146     convertedGuid += Invert(part);
 147
 148     part = GetGuidPart(guid, 3);
 149     convertedGuid += Invert(std::_tstring(part.c_str(), 2));
 150     convertedGuid += Invert(std::_tstring(part.c_str() + 2, 2));
 151
 152     part = GetGuidPart(guid, 4);
 153     int pos = 0;
 154     for (int i = 0; i < 6; i++)
 155     {
 156         convertedGuid += Invert(std::_tstring(part.c_str() + pos, 2));
 157         pos += 2;
 158     }
 159     return convertedGuid;
 160 }
 161
 162 static inline bool IsSetMsiProperty(MSIHANDLE handle, const std::_tstring& sProperty)
 163 {
 164     std::_tstring value = GetMsiProperty(handle, sProperty);
 165     return (value.length() > 0);
 166 }
 167
 168 static inline void UnsetMsiProperty(MSIHANDLE handle, const std::_tstring& sProperty)
 169 {
 170     MsiSetProperty(handle, sProperty.c_str(), NULL);
 171 }
 172
 173 static inline void SetMsiProperty(MSIHANDLE handle, const std::_tstring& sProperty)
 174 {
 175     MsiSetProperty(handle, sProperty.c_str(), TEXT("1"));
 176 }
 177
 178 static bool SwapFiles( const std::_tstring& sFileName1, const std::_tstring& sFileName2 )
 179 {
 180     std::_tstring   sTempFileName = sFileName1 + TEXT(".tmp");
 181
 182     bool fSuccess = true;
 183
 184     //Try to move the original file to a temp file
 185     fSuccess = MoveFileExA( sFileName1.c_str(), sTempFileName.c_str(), MOVEFILE_REPLACE_EXISTING);
 186
 187     if ( fSuccess )
 188     {
 189         fSuccess = MoveFileExA( sFileName2.c_str(), sFileName1.c_str(), MOVEFILE_REPLACE_EXISTING );
 190
 191         if ( fSuccess )
 192         {
 193             fSuccess = MoveFileExA( sTempFileName.c_str(), sFileName2.c_str(),
 194                                         MOVEFILE_REPLACE_EXISTING );
 195             if ( !fSuccess )
 196             {
 197                 MoveFileExA( sFileName1.c_str(), sFileName2.c_str(), MOVEFILE_REPLACE_EXISTING );
 198             }
 199         }
 200         else
 201         {
 202             MoveFileExA( sTempFileName.c_str(), sFileName1.c_str(), MOVEFILE_REPLACE_EXISTING  );
 203         }
 204     }
 205     else
 206     {
 207         //It could be that there is no original file and therefore copying the original to a temp
 208         // file failed. Examine if there is no original and if so then move file2 to file1
 209
 210         WIN32_FIND_DATA data;
 211         HANDLE hdl = FindFirstFile(sFileName1.c_str(), &data);
 212         if (hdl == INVALID_HANDLE_VALUE)
 213         {
 214             fSuccess = MoveFileExA( sFileName2.c_str(), sFileName1.c_str(), MOVEFILE_REPLACE_EXISTING );
 215         }
 216         else
 217         {
 218             FindClose(hdl);
 219         }
 220     }
 221
 222     OutputDebugStringFormat( TEXT("%s <-> %s: %s"), sFileName1.c_str(), sFileName2.c_str(), fSuccess ? TEXT("OK") : TEXT("FAILED") );
 223
 224     if (!fSuccess )
 225     {
 226         DWORD   dwError = GetLastError();
 227         LPVOID lpMsgBuf;
 228         if ( FormatMessage(
 229             FORMAT_MESSAGE_ALLOCATE_BUFFER |
 230             FORMAT_MESSAGE_FROM_SYSTEM |
 231             FORMAT_MESSAGE_IGNORE_INSERTS,
 232             NULL,
 233             GetLastError(),
 234             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
 235             (LPTSTR) &lpMsgBuf,
 236             0,
 237             NULL ))
 238         {
 239             OutputDebugStringFormat( TEXT("Error Code %d: %s"), dwError, lpMsgBuf );
 240             LocalFree( lpMsgBuf );
 241         }
 242         else
 243             OutputDebugStringFormat( TEXT("Error Code %d: Unknown"), dwError );
 244         SetMsiErrorCode( dwError );
 245     }
 246
 247     return fSuccess;
 248 }
 249
 250 static std::_tstring strip( const std::_tstring& s, _TCHAR c )
 251 {
 252     std::_tstring   result = s;
 253
 254     std::_tstring::size_type f;
 255
 256     do
 257     {
 258         f = result.find( c );
 259         if ( f != std::_tstring::npos )
 260             result.erase( f, 1 );
 261     } while ( f != std::_tstring::npos );
 262
 263     return result;
 264 }
 265
 266 static std::_tstring trim( const std::_tstring& rString )
 267 {
 268     std::_tstring temp = rString;
 269
 270     while ( temp.length() && temp[0] == ' ' || temp[0] == '\t' )
 271         temp.erase( 0, 1 );
 272
 273     std::_tstring::size_type    len = temp.length();
 274
 275     while ( len && temp[len-1] == ' ' || temp[len-1] == '\t' )
 276     {
 277         temp.erase( len - 1, 1 );
 278         len = temp.length();
 279     }
 280
 281     return temp;
 282 }
 283
 284 static bool readLine( FILE *fp, std::_tstring& rLine )
 285 {
 286     _TCHAR szBuffer[1024];
 287     bool    bSuccess = false;
 288     bool    bEOL = false;
 289     std::_tstring   line;
 290
 291
 292     while ( !bEOL && _fgetts( szBuffer, sizeof(szBuffer), fp ) )
 293     {
 294         int len = _tcslen(szBuffer);
 295
 296         bSuccess = true;
 297
 298         while ( len && szBuffer[len - 1] == '\n' )
 299         {
 300             szBuffer[--len] = 0;
 301             bEOL = true;
 302         }
 303
 304         line.append( szBuffer );
 305     }
 306
 307     rLine = line;
 308     return bSuccess;
 309 }
 310
 311
 312 static std::_tstring getProfileString(
 313     const std::_tstring& aFileName,
 314     const std::_tstring& aSectionName,
 315     const std::_tstring& aKeyName,
 316     const std::_tstring& aDefault = _T("") )
 317 {
 318     FILE    *fp = _tfopen( aFileName.c_str(), _T("r") );
 319     std::_tstring   retValue = aDefault.length() ? aDefault : _T("");
 320
 321     if ( fp )
 322     {
 323         std::_tstring line;
 324         std::_tstring section;
 325
 326         while ( readLine( fp, line ) )
 327         {
 328             line = trim( line );
 329
 330             if ( line.length() && line[0] == '[' )
 331             {
 332                 line.erase( 0, 1 );
 333                 std::_tstring::size_type end = line.find( ']', 0 );
 334
 335                 if ( std::_tstring::npos != end )
 336                     section = trim( line.substr( 0, end ) );
 337             }
 338             else
 339             {
 340
 341                 std::_tstring::size_type iEqualSign = line.find( '=', 0 );
 342
 343                 if ( iEqualSign != std::_tstring::npos )
 344                 {
 345                     std::_tstring   keyname = line.substr( 0, iEqualSign );
 346                     keyname = trim( keyname );
 347
 348                     std::_tstring   value = line.substr( iEqualSign + 1 /*, std::_tstring::npos */ );
 349                     value = trim( value );
 350
 351                     if (
 352                         0 == _tcsicmp( section.c_str(), aSectionName.c_str() ) &&
 353                         0 == _tcsicmp( keyname.c_str(), aKeyName.c_str() )
 354                          )
 355                     {
 356                         retValue = value;
 357                         break;
 358                     }
 359                 }
 360             }
 361         }
 362
 363         fclose( fp );
 364     }
 365
 366     return retValue;
 367 }
 368
 369 static std::queue< std::_tstring > getProfileSections( const std::_tstring& aFileName )
 370 {
 371     FILE    *fp = _tfopen( aFileName.c_str(), _T("r") );
 372     std::queue< std::_tstring > aResult;
 373
 374     OutputDebugStringFormat( TEXT("*** Retrieving Section Names ****") );
 375
 376     if ( fp )
 377     {
 378         std::_tstring line;
 379         std::_tstring section;
 380
 381         while ( readLine( fp, line ) )
 382         {
 383             line = trim( line );
 384
 385             if ( line.length() && line[0] == '[' )
 386             {
 387                 line.erase( 0, 1 );
 388                 std::_tstring::size_type end = line.find( ']', 0 );
 389
 390                 if ( std::_tstring::npos != end )
 391                     section = trim( line.substr( 0, end ) );
 392
 393                 aResult.push( section );
 394
 395                 OutputDebugStringFormat( TEXT("Section: %s"), section.c_str() );
 396
 397             }
 398         }
 399
 400         fclose( fp );
 401     }
 402
 403     OutputDebugStringFormat( TEXT("*** Done Section Names ***") );
 404
 405     return aResult;
 406 }
 407
 408 static std::queue< std::_tstring > getProfileKeys( const std::_tstring& aFileName, const std::_tstring& aSectionName )
 409 {
 410     FILE    *fp = _tfopen( aFileName.c_str(), _T("r") );
 411     std::queue< std::_tstring > aResult;
 412
 413     OutputDebugStringFormat( TEXT("*** Retrieving Key Names for [%s] ***"), aSectionName.c_str() );
 414
 415     if ( fp )
 416     {
 417         std::_tstring line;
 418         std::_tstring section;
 419
 420         while ( readLine( fp, line ) )
 421         {
 422             line = trim( line );
 423
 424             if ( line.length() && line[0] == '[' )
 425             {
 426                 line.erase( 0, 1 );
 427                 std::_tstring::size_type end = line.find( ']', 0 );
 428
 429                 if ( std::_tstring::npos != end )
 430                     section = trim( line.substr( 0, end ) );
 431             }
 432             else
 433             {
 434
 435                 std::_tstring::size_type iEqualSign = line.find( '=', 0 );
 436
 437                 if ( iEqualSign != std::_tstring::npos )
 438                 {
 439                     std::_tstring   keyname = line.substr( 0, iEqualSign );
 440                     keyname = trim( keyname );
 441
 442                     if ( 0 == _tcsicmp( section.c_str(), aSectionName.c_str() ) )
 443                     {
 444                         aResult.push( keyname );
 445
 446                         OutputDebugStringFormat( keyname.c_str() );
 447
 448                     }
 449                 }
 450             }
 451         }
 452
 453         fclose( fp );
 454     }
 455
 456     OutputDebugStringFormat( TEXT("*** Done Key Names for [%s] ***"), aSectionName.c_str() );
 457
 458     return aResult;
 459 }
 460
 461 extern "C" UINT __stdcall InstallPatchedFiles( MSIHANDLE handle )
 462 {
 463     std::_tstring   sInstDir = GetMsiProperty( handle, TEXT("INSTALLLOCATION") );
 464     std::_tstring   sProgramDir = sInstDir + TEXT("program\\");
 465     std::_tstring   sPatchFile = sProgramDir + TEXT("patchlist.txt");
 466
 467     std::queue< std::_tstring > aSectionNames;
 468     std::queue< std::_tstring > aKeyNames;
 469
 470     OutputDebugStringA( "Starting Custom Action" );
 471
 472     aSectionNames = getProfileSections( sPatchFile );
 473     while ( !aSectionNames.empty() )
 474     {
 475         std::_tstring   sSectionName = aSectionNames.front();
 476         if ( std::_tstring(TEXT("_root")) == sSectionName ) { sSectionName = TEXT(""); }
 477
 478         aKeyNames = getProfileKeys( sPatchFile, sSectionName );
 479         while ( !aKeyNames.empty() )
 480         {
 481             std::_tstring   sKeyName = aKeyNames.front();
 482             std::_tstring   sValue = getProfileString( sPatchFile, sSectionName, sKeyName );
 483
 484             if ( sValue.length() )
 485             {
 486                 std::_tstring   sFileName1 = sKeyName;
 487                 std::_tstring   sExtension = sValue;
 488                 std::_tstring   sFileName2;
 489
 490                 sFileName1 = strip( sFileName1, '\"' );
 491                 sExtension = strip( sExtension, '\"' );
 492
 493                 sFileName1 = sInstDir + sSectionName + sFileName1;
 494                 sFileName2 = sFileName1 + sExtension;
 495
 496                 SwapFiles( sFileName1, sFileName2 );
 497             }
 498
 499             aKeyNames.pop();
 500         }
 501
 502         aSectionNames.pop();
 503     }
 504
 505     return ERROR_SUCCESS;
 506 }
 507
 508 extern "C" UINT __stdcall UninstallPatchedFiles( MSIHANDLE handle )
 509 {
 510     TCHAR   szValue[8192];
 511     DWORD   nValueSize = sizeof(szValue);
 512     HKEY    hKey;
 513
 514     std::_tstring   sInstDir;
 515
 516     std::_tstring   sProductKey = GetMsiProperty( handle, TEXT("FINDPRODUCT") );
 517
 518     if ( ERROR_SUCCESS == RegOpenKey( HKEY_CURRENT_USER,  sProductKey.c_str(), &hKey ) )
 519     {
 520         if ( ERROR_SUCCESS == RegQueryValueEx( hKey, TEXT("INSTALLLOCATION"), NULL, NULL, (LPBYTE)szValue, &nValueSize ) )
 521         {
 522             sInstDir = szValue;
 523         }
 524         RegCloseKey( hKey );
 525     }
 526     else if ( ERROR_SUCCESS == RegOpenKey( HKEY_LOCAL_MACHINE,  sProductKey.c_str(), &hKey ) )
 527     {
 528         if ( ERROR_SUCCESS == RegQueryValueEx( hKey, TEXT("INSTALLLOCATION"), NULL, NULL, (LPBYTE)szValue, &nValueSize ) )
 529         {
 530             sInstDir = szValue;
 531         }
 532         RegCloseKey( hKey );
 533     }
 534     else
 535         return ERROR_SUCCESS;
 536
 537     std::_tstring   sProgramDir = sInstDir + TEXT("program\\");
 538     std::_tstring   sPatchFile = sProgramDir + TEXT("patchlist.txt");
 539
 540     std::queue< std::_tstring > aSectionNames;
 541     std::queue< std::_tstring > aKeyNames;
 542
 543     aSectionNames = getProfileSections( sPatchFile );
 544     while ( !aSectionNames.empty() )
 545     {
 546         std::_tstring   sSectionName = aSectionNames.front();
 547         if ( std::_tstring(TEXT("_root")) == sSectionName ) { sSectionName = TEXT(""); }
 548
 549         aKeyNames = getProfileKeys( sPatchFile, sSectionName );
 550         while( !aKeyNames.empty() )
 551         {
 552             std::_tstring   sKeyName = aKeyNames.front();
 553             std::_tstring   sValue = getProfileString( sPatchFile, sSectionName, sKeyName );
 554
 555             if ( sValue.length() )
 556             {
 557                 std::_tstring   sFileName1 = sKeyName;
 558                 std::_tstring   sExtension = sValue;
 559                 std::_tstring   sFileName2;
 560
 561                 sFileName1 = strip( sFileName1, '\"' );
 562                 sExtension = strip( sExtension, '\"' );
 563
 564                 sFileName1 = sInstDir + sSectionName + sFileName1;
 565                 sFileName2 = sFileName1 + sExtension;
 566
 567                 SwapFiles( sFileName2, sFileName1 );
 568             }
 569
 570             aKeyNames.pop();
 571         }
 572
 573         aSectionNames.pop();
 574     }
 575
 576     return ERROR_SUCCESS;
 577 }
 578
 579 extern "C" UINT __stdcall SetFeatureState( MSIHANDLE handle )
 580 {
 581
 582     // 1. Reading Product Code from setup.ini of installed Office
 583
 584     std::_tstring sInstallPath = GetMsiProperty(handle, TEXT("INSTALLLOCATION"));
 585     std::_tstring sSetupiniPath = sInstallPath + TEXT("program\\setup.ini");
 586
 587     TCHAR szProductCode[32767];
 588
 589     GetPrivateProfileString(
 590         TEXT("Bootstrap"),
 591         TEXT("ProductCode"),
 592         TEXT("NOTFOUND"),
 593         szProductCode,
 594         SAL_N_ELEMENTS(szProductCode),
 595         sSetupiniPath.c_str()
 596         );
 597
 598     if ( !_tcsicmp( szProductCode, TEXT("NOTFOUND") ) )
 599     {
 600         // No setup.ini or no "ProductCode" in setup.ini. This is an invalid directory.
 601         return ERROR_SUCCESS;
 602     }
 603
 604     // 2. Converting Product code
 605
 606     std::_tstring productCode = TEXT(szProductCode);
 607     productCode = ConvertGuid(std::_tstring(productCode.c_str() + 1, productCode.length() - 2));
 608
 609     // 3. Setting path in the Windows registry to find installed features
 610
 611     std::_tstring registryKey;
 612     HKEY registryRoot;
 613
 614     if ( IsSetMsiProperty(handle, TEXT("ALLUSERS")) )
 615     {
 616         registryRoot = HKEY_LOCAL_MACHINE;
 617         registryKey = TEXT("Software\\Classes\\Installer\\Features\\") + productCode;
 618     }
 619     else
 620     {
 621         registryRoot = HKEY_CURRENT_USER;
 622         registryKey = TEXT("Software\\Microsoft\\Installer\\Features\\") + productCode;
 623     }
 624
 625     // 4. Collecting all installed features from Windows registry
 626
 627     HKEY hKey;
 628     if (RegOpenKey(registryRoot, registryKey.c_str(), &hKey) == ERROR_SUCCESS)
 629     {
 630         int counter = 0;
 631         LONG lEnumResult;
 632
 633         do
 634         {
 635             TCHAR szValueName[8192];
 636             DWORD nValueNameSize = sizeof(szValueName);
 637             LPDWORD pValueNameSize = &nValueNameSize;
 638             TCHAR szValueData[8192];
 639             DWORD nValueDataSize = sizeof(szValueData);
 640
 641             lEnumResult = RegEnumValue( hKey, counter, szValueName, pValueNameSize, NULL, NULL, (LPBYTE)szValueData, &nValueDataSize);
 642
 643             if ( ERROR_SUCCESS == lEnumResult )
 644             {
 645                 std::_tstring sValueName = szValueName;
 646
 647                 // Does this feature exist in this patch?
 648                 if ( IsSetMsiProperty(handle, sValueName) )
 649                 {
 650                     // Feature is not installed, if szValueData starts with a "square" (ascii 6)
 651                     if ( 6 == szValueData[0] )
 652                     {
 653                         MsiSetFeatureState(handle,sValueName.c_str(),INSTALLSTATE_ABSENT); // do not install this feature
 654                     }
 655                     else
 656                     {
 657                         MsiSetFeatureState(handle,sValueName.c_str(),INSTALLSTATE_LOCAL); // do install this feature
 658                     }
 659                 }
 660             }
 661
 662             counter = counter + 1;
 663
 664         } while ( ERROR_SUCCESS == lEnumResult );
 665
 666         RegCloseKey( hKey );
 667     }
 668
 669     return ERROR_SUCCESS;
 670 }
 671
 672 extern "C" UINT __stdcall SetNewFeatureState( MSIHANDLE handle )
 673 {
 674     std::_tstring sValueName;
 675
 676     sValueName = TEXT("gm_o_Onlineupdate");
 677
 678     if (IsSetMsiProperty(handle, TEXT("SELECT_OU_FEATURE")))
 679     {
 680         MsiSetFeatureState(handle,sValueName.c_str(),INSTALLSTATE_LOCAL); // do install this feature
 681     }
 682     else
 683     {
 684         MsiSetFeatureState(handle,sValueName.c_str(),INSTALLSTATE_ABSENT); // do not install this feature
 685     }
 686
 687     return ERROR_SUCCESS;
 688 }
 689
 690 extern "C" UINT __stdcall ShowOnlineUpdateDialog( MSIHANDLE handle )
 691 {
 692     // Checking existence of file "updchk.uno.dll", which shows, that
 693     // Online Update functionality is always available. Then the dialog
 694     // that offers the Online Update is superfluous.
 695
 696     std::_tstring sInstDir = GetMsiProperty( handle, TEXT("INSTALLLOCATION") );
 697     std::_tstring sProgramDir = sInstDir + TEXT("program\\");
 698     std::_tstring sSearchFile = sProgramDir + TEXT("updchk.uno.dll");
 699
 700     WIN32_FIND_DATA data;
 701     HANDLE hdl = FindFirstFile(sSearchFile.c_str(), &data);
 702     if (hdl != INVALID_HANDLE_VALUE)  // the file exists
 703     {
 704         // And finally setting property SHOW_ONLINEUPDATE_DIALOG
 705         // to hide this dialog
 706         UnsetMsiProperty(handle, TEXT("SHOW_ONLINEUPDATE_DIALOG"));
 707
 708         // Setting SELECT_OU_FEATURE to 1, which is probably superfluous
 709         // because this is already the default value. But only this
 710         // guarantees, that CustomAction SetNewFeatureState always sets
 711         // the correct FeatureState for "gm_o_Onlineupdate", if it is
 712         // already installed.
 713         SetMsiProperty(handle, TEXT("SELECT_OU_FEATURE"));
 714     }
 715     else
 716     {
 717         // If the file does not exist, the Online Update dialog
 718         // has to be shown.
 719         SetMsiProperty(handle, TEXT("SHOW_ONLINEUPDATE_DIALOG"));
 720         FindClose(hdl);
 721     }
 722
 723     return ERROR_SUCCESS;
 724 }
 725
 726 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */