xref: /aoo41x/main/setup_native/source/win32/customactions/patch/swappatchfiles.cxx (revision 28b67305)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



#define _WIN32_WINDOWS 0x0410

#ifdef _MSC_VER
#pragma warning(push, 1) /* disable warnings within system headers */
#endif
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <msiquery.h>
#ifdef _MSC_VER
#pragma warning(pop)
#endif

#include <malloc.h>
#include <assert.h>

#ifdef UNICODE
#define _UNICODE
#define _tstring	wstring
#else
#define _tstring	string
#endif
#include <tchar.h>
#include <string>
#include <queue>
#include <stdio.h>

#include <systools/win32/uwinapi.h>
#include <../tools/seterror.hxx>

#define	WININIT_FILENAME	"wininit.ini"
#define RENAME_SECTION		"rename"

#ifdef DEBUG
inline void OutputDebugStringFormat( LPCTSTR pFormat, ... )
{
	_TCHAR	buffer[1024];
	va_list	args;

	va_start( args, pFormat );
	_vsntprintf( buffer, elementsof(buffer), pFormat, args );
	OutputDebugString( buffer );
}
#else
static inline void OutputDebugStringFormat( LPCTSTR, ... )
{
}
#endif

static std::_tstring GetMsiProperty( MSIHANDLE handle, const std::_tstring& sProperty )
{
	std::_tstring	result;
	TCHAR	szDummy[1] = TEXT("");
	DWORD	nChars = 0;

	if ( MsiGetProperty( handle, sProperty.c_str(), szDummy, &nChars ) == ERROR_MORE_DATA )
	{
		DWORD nBytes = ++nChars * sizeof(TCHAR);
		LPTSTR buffer = reinterpret_cast<LPTSTR>(_alloca(nBytes));
		ZeroMemory( buffer, nBytes );
		MsiGetProperty(handle, sProperty.c_str(), buffer, &nChars);
		result = buffer;
	}

	return	result;
}

// The provided GUID must be without surounding '{}'
static std::_tstring GetGuidPart(const std::_tstring& guid, int index)
{
	assert((guid.length() == 36) && "No GUID or wrong format!");
	assert(((index > -1) && (index < 5)) && "Out of range!");

	if (index == 0) return std::_tstring(guid.c_str(), 8);
	if (index == 1) return std::_tstring(guid.c_str() + 9, 4);
	if (index == 2) return std::_tstring(guid.c_str() + 14, 4);
	if (index == 3) return std::_tstring(guid.c_str() + 19, 4);
	if (index == 4) return std::_tstring(guid.c_str() + 24, 12);

	return std::_tstring();
}

static void Swap(char* p1, char* p2)
{
	char tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

static std::_tstring Invert(const std::_tstring& str)
{
	char* buff = reinterpret_cast<char*>(_alloca(str.length()));
	strncpy(buff, str.c_str(), str.length());

	char* front = buff;
	char* back = buff + str.length() - 1;

	while (front < back)
		Swap(front++, back--);

	return std::_tstring(buff, str.length());
}

// Convert the upgrade code (which is a GUID) according
// to the way the windows installer does when writing it
// to the registry
// The first 8 bytes will be inverted, from the the last
// 8 bytes always the nibbles will be inverted for further
// details look in the MSDN under compressed registry keys
static std::_tstring ConvertGuid(const std::_tstring& guid)
{
	std::_tstring convertedGuid;

	std::_tstring part = GetGuidPart(guid, 0);
	convertedGuid = Invert(part);

	part = GetGuidPart(guid, 1);
	convertedGuid += Invert(part);

	part = GetGuidPart(guid, 2);
	convertedGuid += Invert(part);

	part = GetGuidPart(guid, 3);
	convertedGuid += Invert(std::_tstring(part.c_str(), 2));
	convertedGuid += Invert(std::_tstring(part.c_str() + 2, 2));

	part = GetGuidPart(guid, 4);
	int pos = 0;
	for (int i = 0; i < 6; i++)
	{
		convertedGuid += Invert(std::_tstring(part.c_str() + pos, 2));
		pos += 2;
	}
	return convertedGuid;
}

static inline bool IsSetMsiProperty(MSIHANDLE handle, const std::_tstring& sProperty)
{
	std::_tstring value = GetMsiProperty(handle, sProperty);
	return (value.length() > 0);
}

static inline void UnsetMsiProperty(MSIHANDLE handle, const std::_tstring& sProperty)
{
	MsiSetProperty(handle, sProperty.c_str(), NULL);
}

static inline void SetMsiProperty(MSIHANDLE handle, const std::_tstring& sProperty)
{
	MsiSetProperty(handle, sProperty.c_str(), TEXT("1"));
}

static BOOL MoveFileEx9x( LPCSTR lpExistingFileNameA, LPCSTR lpNewFileNameA, DWORD dwFlags )
{
	BOOL	fSuccess = FALSE;	// assume failure

	// Windows 9x has a special mechanism to move files after reboot

	if ( dwFlags & MOVEFILE_DELAY_UNTIL_REBOOT )
	{
		CHAR	szExistingFileNameA[MAX_PATH];
		CHAR	szNewFileNameA[MAX_PATH] = "NUL";

		// Path names in WININIT.INI must be in short path name form

		if (
			GetShortPathNameA( lpExistingFileNameA, szExistingFileNameA, MAX_PATH ) &&
			(!lpNewFileNameA || GetShortPathNameA( lpNewFileNameA, szNewFileNameA, MAX_PATH ))
			)
		{
			CHAR	szBuffer[32767];	// The buffer size must not exceed 32K
			DWORD	dwBufLen = GetPrivateProfileSectionA( RENAME_SECTION, szBuffer, elementsof(szBuffer), WININIT_FILENAME );

			CHAR	szRename[MAX_PATH];	// This is enough for at most to times 67 chracters
			strcpy( szRename, szNewFileNameA );
			strcat( szRename, "=" );
			strcat( szRename, szExistingFileNameA );
			size_t	lnRename = strlen(szRename);

			if ( dwBufLen + lnRename + 2 <= elementsof(szBuffer) )
			{
				CopyMemory( &szBuffer[dwBufLen], szRename, lnRename );
				szBuffer[dwBufLen + lnRename ] = 0;
				szBuffer[dwBufLen + lnRename + 1 ] = 0;

				fSuccess = WritePrivateProfileSectionA( RENAME_SECTION, szBuffer, WININIT_FILENAME );
			}
			else
				SetLastError( ERROR_BUFFER_OVERFLOW );
		}
	}
	else
	{

		fSuccess = MoveFileA( lpExistingFileNameA, lpNewFileNameA );

		if ( !fSuccess && GetLastError() != ERROR_ACCESS_DENIED &&
			0 != (dwFlags & (MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING)) )
		{
			BOOL	bFailIfExist = 0 == (dwFlags & MOVEFILE_REPLACE_EXISTING);

			fSuccess = CopyFileA( lpExistingFileNameA, lpNewFileNameA, bFailIfExist );

			if ( fSuccess )
				fSuccess = DeleteFileA( lpExistingFileNameA );
		}

	}

	return fSuccess;
}

static BOOL MoveFileExImpl( LPCSTR lpExistingFileNameA, LPCSTR lpNewFileNameA, DWORD dwFlags )
{
	if ( 0 > ((LONG)GetVersion())) // High order bit indicates Win 9x
		return MoveFileEx9x( lpExistingFileNameA, lpNewFileNameA, dwFlags );
	else
		return MoveFileExA( lpExistingFileNameA, lpNewFileNameA, dwFlags );
}

static bool SwapFiles( const std::_tstring& sFileName1, const std::_tstring& sFileName2 )
{
	std::_tstring	sTempFileName = sFileName1 + TEXT(".tmp");

	bool fSuccess = true;

	//Try to move the original file to a temp file
	fSuccess = MoveFileExImpl( sFileName1.c_str(), sTempFileName.c_str(), MOVEFILE_REPLACE_EXISTING);

	std::_tstring	mystr;

	if ( fSuccess )
	{
		fSuccess = MoveFileExImpl( sFileName2.c_str(), sFileName1.c_str(), MOVEFILE_REPLACE_EXISTING );

		if ( fSuccess )
		{
			fSuccess = MoveFileExImpl( sTempFileName.c_str(), sFileName2.c_str(),
										MOVEFILE_REPLACE_EXISTING );
			if ( !fSuccess )
			{
				MoveFileExImpl( sFileName1.c_str(), sFileName2.c_str(), MOVEFILE_REPLACE_EXISTING );
			}
		}
		else
		{
			MoveFileExImpl( sTempFileName.c_str(), sFileName1.c_str(), MOVEFILE_REPLACE_EXISTING  );
		}
	}
	else
	{
		//It could be that there is no original file and therefore copying the original to a temp
		// file failed. Examine if there is no original and if so then move file2 to file1

		WIN32_FIND_DATA data;
		HANDLE hdl = FindFirstFile(sFileName1.c_str(), &data);
		if (hdl == INVALID_HANDLE_VALUE)
		{
			fSuccess = MoveFileExImpl( sFileName2.c_str(), sFileName1.c_str(), MOVEFILE_REPLACE_EXISTING );

			// if ( fSuccess )
			// {
			//	mystr = "Success";
			//	MessageBox( NULL, mystr.c_str(), "Titel", MB_OK );
			// }
			// else
			// {
			//	char buff[256];
			//	wsprintf(buff, "Failure %d", GetLastError());
			//	MessageBox( NULL, buff, "Titel", MB_OK );
			// }
		}
		else
		{
			FindClose(hdl);
		}
	}

	OutputDebugStringFormat( TEXT("%s <-> %s: %s"), sFileName1.c_str(), sFileName2.c_str(), fSuccess ? TEXT("OK") : TEXT("FAILED") );

	if (!fSuccess )
	{
		DWORD	dwError = GetLastError();
		LPVOID lpMsgBuf;
		if ( FormatMessage(
			FORMAT_MESSAGE_ALLOCATE_BUFFER |
			FORMAT_MESSAGE_FROM_SYSTEM |
			FORMAT_MESSAGE_IGNORE_INSERTS,
			NULL,
			GetLastError(),
			MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
			(LPTSTR) &lpMsgBuf,
			0,
			NULL ))
		{
			OutputDebugStringFormat( TEXT("Error Code %d: %s"), dwError, lpMsgBuf );
			LocalFree( lpMsgBuf );
		}
		else
			OutputDebugStringFormat( TEXT("Error Code %d: Unknown"), dwError );
        SetMsiErrorCode( dwError );
	}

	return fSuccess;
}

static std::_tstring strip( const std::_tstring& s, _TCHAR c )
{
	std::_tstring	result = s;

	std::_tstring::size_type f;

	do
	{
		f = result.find( c );
		if ( f != std::_tstring::npos )
			result.erase( f, 1 );
	} while ( f != std::_tstring::npos );

	return result;
}

static std::_tstring trim( const std::_tstring& rString )
{
	std::_tstring temp = rString;

	while ( temp.length() && temp[0] == ' ' || temp[0] == '\t' )
		temp.erase( 0, 1 );

	std::_tstring::size_type	len = temp.length();

	while ( len && temp[len-1] == ' ' || temp[len-1] == '\t' )
	{
		temp.erase( len - 1, 1 );
		len = temp.length();
	}

	return temp;
}

static bool readLine( FILE *fp, std::_tstring& rLine )
{
	_TCHAR szBuffer[1024];
	bool	bSuccess = false;
	bool	bEOL = false;
	std::_tstring	line;


	while ( !bEOL && _fgetts( szBuffer, sizeof(szBuffer), fp ) )
	{
		int	len = _tcslen(szBuffer);

		bSuccess = true;

		while ( len && szBuffer[len - 1] == '\n' )
		{
			szBuffer[--len] = 0;
			bEOL = true;
		}

		line.append( szBuffer );
	}

	rLine = line;
	return bSuccess;
}


static std::_tstring getProfileString(
	const std::_tstring& aFileName,
	const std::_tstring& aSectionName,
	const std::_tstring& aKeyName,
	const std::_tstring& aDefault = _T("") )
{
	FILE	*fp = _tfopen( aFileName.c_str(), _T("r") );
	std::_tstring	retValue = aDefault.length() ? aDefault : _T("");

	if ( fp )
	{
		std::_tstring line;
		std::_tstring section;

		while ( readLine( fp, line ) )
		{
			line = trim( line );

			if ( line.length() && line[0] == '[' )
			{
				line.erase( 0, 1 );
				std::_tstring::size_type end = line.find( ']', 0 );

				if ( std::_tstring::npos != end )
					section = trim( line.substr( 0, end ) );
			}
			else
			{

				std::_tstring::size_type iEqualSign = line.find( '=', 0 );

				if ( iEqualSign != std::_tstring::npos )
				{
					std::_tstring	keyname = line.substr( 0, iEqualSign );
					keyname = trim( keyname );

					std::_tstring	value = line.substr( iEqualSign + 1 /*, std::_tstring::npos */ );
					value = trim( value );

					if (
						0 == _tcsicmp( section.c_str(), aSectionName.c_str() ) &&
						0 == _tcsicmp( keyname.c_str(), aKeyName.c_str() )
						 )
					{
						retValue = value;
						break;
					}
				}
			}
		}

		fclose( fp );
	}

	return retValue;
}

static std::queue< std::_tstring > getProfileSections( const std::_tstring& aFileName )
{
	FILE	*fp = _tfopen( aFileName.c_str(), _T("r") );
	std::queue< std::_tstring >	aResult;

	OutputDebugStringFormat( TEXT("*** Retrieving Section Names ****") );

	if ( fp )
	{
		std::_tstring line;
		std::_tstring section;

		while ( readLine( fp, line ) )
		{
			line = trim( line );

			if ( line.length() && line[0] == '[' )
			{
				line.erase( 0, 1 );
				std::_tstring::size_type end = line.find( ']', 0 );

				if ( std::_tstring::npos != end )
					section = trim( line.substr( 0, end ) );

				aResult.push( section );

				OutputDebugStringFormat( TEXT("Section: %s"), section.c_str() );

			}
		}

		fclose( fp );
	}

	OutputDebugStringFormat( TEXT("*** Done Section Names ***") );

	return aResult;
}

static std::queue< std::_tstring > getProfileKeys( const std::_tstring& aFileName, const std::_tstring& aSectionName )
{
	FILE	*fp = _tfopen( aFileName.c_str(), _T("r") );
	std::queue< std::_tstring >	aResult;

	OutputDebugStringFormat( TEXT("*** Retrieving Key Names for [%s] ***"), aSectionName.c_str() );

	if ( fp )
	{
		std::_tstring line;
		std::_tstring section;

		while ( readLine( fp, line ) )
		{
			line = trim( line );

			if ( line.length() && line[0] == '[' )
			{
				line.erase( 0, 1 );
				std::_tstring::size_type end = line.find( ']', 0 );

				if ( std::_tstring::npos != end )
					section = trim( line.substr( 0, end ) );
			}
			else
			{

				std::_tstring::size_type iEqualSign = line.find( '=', 0 );

				if ( iEqualSign != std::_tstring::npos )
				{
					std::_tstring	keyname = line.substr( 0, iEqualSign );
					keyname = trim( keyname );

					if ( 0 == _tcsicmp( section.c_str(), aSectionName.c_str() ) )
					{
						aResult.push( keyname );

						OutputDebugStringFormat( keyname.c_str() );

					}
				}
			}
		}

		fclose( fp );
	}

	OutputDebugStringFormat( TEXT("*** Done Key Names for [%s] ***"), aSectionName.c_str() );

	return aResult;
}

extern "C" UINT __stdcall InstallPatchedFiles( MSIHANDLE handle )
{
	std::_tstring	sInstDir = GetMsiProperty( handle, TEXT("INSTALLLOCATION") );
//	std::_tstring	sProgramDir = sInstDir + TEXT("Basis\\program\\");
	std::_tstring	sProgramDir = sInstDir + TEXT("program\\");
	std::_tstring	sPatchFile = sProgramDir + TEXT("patchlist.txt");

	std::queue< std::_tstring > aSectionNames;
	std::queue< std::_tstring > aKeyNames;

	OutputDebugStringA( "Starting Custom Action" );

	// std::_tstring	mystr;
	// mystr = "Patchfile: " + sPatchFile;
	// MessageBox( NULL, mystr.c_str(), "Patchfile", MB_OK );

	aSectionNames = getProfileSections( sPatchFile );
	while ( !aSectionNames.empty() )
	{
		std::_tstring	sSectionName = aSectionNames.front();
		if ( std::_tstring(TEXT("_root")) == sSectionName ) { sSectionName = TEXT(""); }
		// mystr = "Section: " + sSectionName;
		// MessageBox( NULL, mystr.c_str(), "Titel", MB_OK );

		aKeyNames = getProfileKeys( sPatchFile, sSectionName );
		while ( !aKeyNames.empty() )
		{
			std::_tstring	sKeyName = aKeyNames.front();
			std::_tstring	sValue = getProfileString( sPatchFile, sSectionName, sKeyName );

			if ( sValue.length() )
			{
				std::_tstring	sFileName1 = sKeyName;
				std::_tstring	sExtension = sValue;
				std::_tstring	sFileName2;

				sFileName1 = strip( sFileName1, '\"' );
				sExtension = strip( sExtension, '\"' );

				sFileName1 = sInstDir + sSectionName + sFileName1;
				sFileName2 = sFileName1 + sExtension;

				// mystr = "Convert: " + sFileName1 + " to " + sFileName2;
				// MessageBox( NULL, mystr.c_str(), "Titel", MB_OK );

				SwapFiles( sFileName1, sFileName2 );
			}

			aKeyNames.pop();
		}

		aSectionNames.pop();
	}

	return ERROR_SUCCESS;
}

extern "C" UINT __stdcall UninstallPatchedFiles( MSIHANDLE handle )
{
	TCHAR	szValue[8192];
	DWORD	nValueSize = sizeof(szValue);
	HKEY	hKey;

	std::_tstring	sInstDir;

	std::_tstring	sProductKey = GetMsiProperty( handle, TEXT("FINDPRODUCT") );

	if ( ERROR_SUCCESS == RegOpenKey( HKEY_CURRENT_USER,  sProductKey.c_str(), &hKey ) )
	{
		if ( ERROR_SUCCESS == RegQueryValueEx( hKey, TEXT("INSTALLLOCATION"), NULL, NULL, (LPBYTE)szValue, &nValueSize ) )
		{
			sInstDir = szValue;
		}
		RegCloseKey( hKey );
	}
	else if ( ERROR_SUCCESS == RegOpenKey( HKEY_LOCAL_MACHINE,  sProductKey.c_str(), &hKey ) )
	{
		if ( ERROR_SUCCESS == RegQueryValueEx( hKey, TEXT("INSTALLLOCATION"), NULL, NULL, (LPBYTE)szValue, &nValueSize ) )
		{
			sInstDir = szValue;
		}
		RegCloseKey( hKey );
	}
	else
		return ERROR_SUCCESS;

//	std::_tstring	sProgramDir = sInstDir + TEXT("Basis\\program\\");
	std::_tstring	sProgramDir = sInstDir + TEXT("program\\");
	std::_tstring	sPatchFile = sProgramDir + TEXT("patchlist.txt");

	std::queue< std::_tstring >	aSectionNames;
	std::queue< std::_tstring >	aKeyNames;

	// std::_tstring	mystr;
	// mystr = "Patchfile: " + sPatchFile;
	// MessageBox( NULL, mystr.c_str(), "Titel", MB_OK );

	aSectionNames = getProfileSections( sPatchFile );
	while ( !aSectionNames.empty() )
	{
		std::_tstring	sSectionName = aSectionNames.front();
		if ( std::_tstring(TEXT("_root")) == sSectionName ) { sSectionName = TEXT(""); }
		// mystr = "Section: " + sSectionName;
		// MessageBox( NULL, mystr.c_str(), "Titel", MB_OK );

		aKeyNames = getProfileKeys( sPatchFile, sSectionName );
		while( !aKeyNames.empty() )
		{
			std::_tstring	sKeyName = aKeyNames.front();
			std::_tstring	sValue = getProfileString( sPatchFile, sSectionName, sKeyName );

			if ( sValue.length() )
			{
				std::_tstring	sFileName1 = sKeyName;
				std::_tstring	sExtension = sValue;
				std::_tstring	sFileName2;

				sFileName1 = strip( sFileName1, '\"' );
				sExtension = strip( sExtension, '\"' );

				sFileName1 = sInstDir + sSectionName + sFileName1;
				sFileName2 = sFileName1 + sExtension;

				// mystr = "Convert: " + sFileName1 + " to " + sFileName2;
				// MessageBox( NULL, mystr.c_str(), "Titel", MB_OK );

				SwapFiles( sFileName2, sFileName1 );
			}

			aKeyNames.pop();
		}

		aSectionNames.pop();
	}

	return ERROR_SUCCESS;
}

extern "C" UINT __stdcall IsOfficeRunning( MSIHANDLE handle )
{
	std::_tstring	sInstDir = GetMsiProperty( handle, TEXT("INSTALLLOCATION") );
//	std::_tstring	sResourceDir = sInstDir + TEXT("Basis\\program\\resource\\");
	std::_tstring	sResourceDir = sInstDir + TEXT("program\\resource\\");
	std::_tstring	sPattern = sResourceDir + TEXT("vcl*.res");

	WIN32_FIND_DATA	aFindFileData;
	HANDLE	hFind = FindFirstFile( sPattern.c_str(), &aFindFileData );

	if ( IsValidHandle(hFind) )
	{
		BOOL	fSuccess = false;
		bool	fRenameSucceeded;

		do
		{
			std::_tstring	sResourceFile = sResourceDir + aFindFileData.cFileName;
			std::_tstring	sIntermediate = sResourceFile + TEXT(".tmp");

			fRenameSucceeded = MoveFileExImpl( sResourceFile.c_str(), sIntermediate.c_str(), MOVEFILE_REPLACE_EXISTING );
			if ( fRenameSucceeded )
			{
				MoveFileExImpl( sIntermediate.c_str(), sResourceFile.c_str(), 0 );
				fSuccess = FindNextFile( hFind, &aFindFileData );
			}
		} while ( fSuccess && fRenameSucceeded );

		if ( !fRenameSucceeded )
        {
			MsiSetProperty(handle, TEXT("OFFICERUNS"), TEXT("1"));
            SetMsiErrorCode( MSI_ERROR_OFFICE_IS_RUNNING );
        }

		FindClose( hFind );
	}


	return ERROR_SUCCESS;
}

extern "C" UINT __stdcall SetFeatureState( MSIHANDLE handle )
{
	std::_tstring	mystr;

	// 1. Reading Product Code from setup.ini of installed Office

	std::_tstring sInstallPath = GetMsiProperty(handle, TEXT("INSTALLLOCATION"));
	// MessageBox(NULL, sInstallPath.c_str(), "INSTALLLOCATION", MB_OK);
	std::_tstring sSetupiniPath = sInstallPath + TEXT("program\\setup.ini");

	TCHAR szProductCode[32767];

	GetPrivateProfileString(
		TEXT("Bootstrap"),
		TEXT("ProductCode"),
		TEXT("NOTFOUND"),
		szProductCode,
		elementsof(szProductCode),
		sSetupiniPath.c_str()
		);

	if ( !_tcsicmp( szProductCode, TEXT("NOTFOUND") ) )
	{
		// No setup.ini or no "ProductCode" in setup.ini. This is an invalid directory.
		// MessageBox(NULL, "NOTFOUND set", "DEBUG", MB_OK);
		return ERROR_SUCCESS;
	}

	// 2. Converting Product code

	std::_tstring productCode = TEXT(szProductCode);
	productCode = ConvertGuid(std::_tstring(productCode.c_str() + 1, productCode.length() - 2));
	mystr = TEXT("Changed product code: ") + productCode;
	// MessageBox(NULL, mystr.c_str(), "ProductCode", MB_OK);

	// 3. Setting path in the Windows registry to find installed features

	std::_tstring registryKey;
	HKEY registryRoot;

	if ( IsSetMsiProperty(handle, TEXT("ALLUSERS")) )
	{
		registryRoot = HKEY_LOCAL_MACHINE;
		registryKey = TEXT("Software\\Classes\\Installer\\Features\\") + productCode;
		mystr = registryKey;
		// MessageBox( NULL, mystr.c_str(), "ALLUSERS", MB_OK );
	}
	else
	{
		registryRoot = HKEY_CURRENT_USER;
		registryKey = TEXT("Software\\Microsoft\\Installer\\Features\\") + productCode;
		mystr = registryKey;
		// MessageBox( NULL, mystr.c_str(), "ALLUSERS", MB_OK );
	}

	// 4. Collecting all installed features from Windows registry

	HKEY hKey;
	if (RegOpenKey(registryRoot, registryKey.c_str(), &hKey) == ERROR_SUCCESS)
	{
		int counter = 0;
		// DWORD counter = 0;
		LONG lEnumResult;

		do
		{
			TCHAR szValueName[8192];
			DWORD nValueNameSize = sizeof(szValueName);
			LPDWORD pValueNameSize = &nValueNameSize;
			TCHAR szValueData[8192];
			DWORD nValueDataSize = sizeof(szValueData);

			lEnumResult = RegEnumValue( hKey, counter, szValueName, pValueNameSize, NULL, NULL, (LPBYTE)szValueData, &nValueDataSize);

			if ( ERROR_SUCCESS == lEnumResult )
			{
				std::_tstring sValueName = szValueName;
				std::_tstring sValueData = szValueData;

				// mystr = sValueName;
				// MessageBox( NULL, mystr.c_str(), "ValueName", MB_OK );
				// mystr = sValueData;
				// MessageBox( NULL, mystr.c_str(), "ValueData", MB_OK );

				// Does this feature exist in this patch?
				if ( IsSetMsiProperty(handle, sValueName) )
				{
					// Feature is not installed, if szValueData starts with a "square" (ascii 6)
					if ( 6 == szValueData[0] )
					{
						MsiSetFeatureState(handle,sValueName.c_str(),INSTALLSTATE_ABSENT); // do not install this feature
						// mystr = TEXT("Do NOT install: ") + sValueName;
						// MessageBox( NULL, mystr.c_str(), "ValueName", MB_OK );
					}
					else
					{
						MsiSetFeatureState(handle,sValueName.c_str(),INSTALLSTATE_LOCAL); // do install this feature
						// mystr = TEXT("Do install: ") + sValueName;
						// MessageBox( NULL, mystr.c_str(), "ValueName", MB_OK );
					}
				}
			}

			counter = counter + 1;

		} while ( ERROR_SUCCESS == lEnumResult );

		RegCloseKey( hKey );
	}

	return ERROR_SUCCESS;
}

extern "C" UINT __stdcall SetNewFeatureState( MSIHANDLE handle )
{
	std::_tstring mystr;
    std::_tstring sValueName;

    sValueName = TEXT("gm_o_Onlineupdate");

    if (IsSetMsiProperty(handle, TEXT("SELECT_OU_FEATURE")))
    {
        MsiSetFeatureState(handle,sValueName.c_str(),INSTALLSTATE_LOCAL); // do install this feature
        // mystr = TEXT("OnlineUpdate wird installiert!");
        // MessageBox(NULL, mystr.c_str(), "INSTALLSTATE_LOCAL", MB_OK);
    }
    else
    {
        MsiSetFeatureState(handle,sValueName.c_str(),INSTALLSTATE_ABSENT); // do not install this feature
        // mystr = TEXT("OnlineUpdate wird NICHT installiert!");
        // MessageBox(NULL, mystr.c_str(), "INSTALLSTATE_ABSENT", MB_OK);
    }

	return ERROR_SUCCESS;
}

extern "C" UINT __stdcall ShowOnlineUpdateDialog( MSIHANDLE handle )
{
    // Checking existence of file "updchk.uno.dll", which shows, that
    // Online Update functionality is always available. Then the dialog
    // that offers the Online Update is superfluous.

    std::_tstring sInstDir = GetMsiProperty( handle, TEXT("INSTALLLOCATION") );
//    std::_tstring sProgramDir = sInstDir + TEXT("Basis\\program\\");
    std::_tstring sProgramDir = sInstDir + TEXT("program\\");
    std::_tstring sSearchFile = sProgramDir + TEXT("updchk.uno.dll");

    WIN32_FIND_DATA data;
    HANDLE hdl = FindFirstFile(sSearchFile.c_str(), &data);
    if (hdl != INVALID_HANDLE_VALUE)  // the file exists
    {
        // std::_tstring mystr;
        // mystr = "Found file: " + sSearchFile;
        // MessageBox( NULL, mystr.c_str(), "Found file", MB_OK );

        // And finally setting property SHOW_ONLINEUPDATE_DIALOG
        // to hide this dialog
        UnsetMsiProperty(handle, TEXT("SHOW_ONLINEUPDATE_DIALOG"));

        // Setting SELECT_OU_FEATURE to 1, which is probably superfluous
        // because this is already the default value. But only this
        // guarantees, that CustomAction SetNewFeatureState always sets
        // the correct FeatureState for "gm_o_Onlineupdate", if it is
        // already installed.
        SetMsiProperty(handle, TEXT("SELECT_OU_FEATURE"));
    }
    else
    {
        // std::_tstring mystr;
        // mystr = "Did not find file: " + sSearchFile;
        // MessageBox( NULL, mystr.c_str(), "File not found", MB_OK );

        // If the file does not exist, the Online Update dialog
        // has to be shown.
        SetMsiProperty(handle, TEXT("SHOW_ONLINEUPDATE_DIALOG"));
        FindClose(hdl);
    }

	return ERROR_SUCCESS;
}