xref: /AOO41X/main/desktop/win32/source/setup/setup.cpp (revision 13ac66067bb747a4eb70bcaea767c3d0442347d5)

/**************************************************************
 *
 * 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 WIN // scope W32 API

#if defined _MSC_VER
#pragma warning(push, 1)
#endif
#include <windows.h>
#if defined _MSC_VER
#pragma warning(pop)
#endif
#include <tchar.h>
#include <assert.h>
#include <shlwapi.h>
#include <new>
#include <time.h>
#include <mbctype.h>
#include <locale.h>
#include <Msiquery.h>
#include <MsiDefs.h>
#include "strsafe.h"

#include "setup.hxx"

#include "resource.h"

//--------------------------------------------------------------------------

#define MAX_STR_LENGTH     32000
#define MAX_TEXT_LENGTH     1024
#define MAX_LANGUAGE_LEN      80
#define MAX_STR_CAPTION      256
#define VERSION_SIZE          80
#define SECTION_SETUP       TEXT( "Setup" )
#define SECTION_LANGUAGE    TEXT( "Languages" )
#define PRODUCT_NAME_VAR    TEXT( "%PRODUCTNAME" )
#define PRODUCT_VERSION     TEXT( "ProductVersion" )
#define ERROR_SHOW_USAGE      -2
#define ERROR_SETUP_TO_OLD    -3
#define ERROR_SETUP_NOT_FOUND -4

#define PARAM_SETUP_USED    TEXT( " SETUP_USED=1 " )
#define PARAM_PACKAGE       TEXT( "/I " )
#define PARAM_MINOR_UPGRADE TEXT( "/FVOMUS " )
#define PARAM_ADMIN         TEXT( "/A " )
#define PARAM_TRANSFORM     TEXT( " TRANSFORMS=" )
#define PARAM_REBOOT        TEXT( " REBOOT=Force" )
#define PARAM_PATCH         TEXT( " /update " )
#define PARAM_REG_ALL_MSO_TYPES TEXT( "REGISTER_ALL_MSO_TYPES=1 " )
#define PARAM_REG_NO_MSO_TYPES  TEXT( "REGISTER_NO_MSO_TYPES=1 " )
#define PARAM_SILENTINSTALL     TEXT( " /QB" )

#define PARAM_RUNNING           TEXT( "ignore_running" )
#define CMDLN_REG_ALL_MSO_TYPES TEXT( "msoreg=1" )
#define CMDLN_REG_NO_MSO_TYPES  TEXT( "msoreg=0" )

#define MSI_DLL             TEXT( "msi.dll" )
#define ADVAPI32_DLL        TEXT( "advapi32.dll" )
#define PROFILE_NAME        TEXT( "setup.ini" )

#define RUNTIME_X64_NAME    TEXT( "redist\\vcredist_x64.exe" )
#define RUNTIME_X86_NAME    TEXT( "redist\\vcredist_x86.exe" )
#define PRODUCTCODE_X86     TEXT( "{E503B4BF-F7BB-3D5F-8BC8-F694B1CFF942}" )
#define PRODUCTCODE_X64     TEXT( "{350AA351-21FA-3270-8B7A-835434E766AD}" )

#define MSIAPI_DllGetVersion     "DllGetVersion"
#define ADVAPI32API_CheckTokenMembership "CheckTokenMembership"

typedef HRESULT (CALLBACK* PFnDllGetVersion)( DLLVERSIONINFO *pdvi);
typedef BOOL (WINAPI* PFnCheckTokenMembership)(HANDLE TokenHandle, PSID SidToCheck, PBOOL IsMember);

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

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

//--------------------------------------------------------------------------

const TCHAR sInstKey[]       = TEXT( "Software\\Microsoft\\Windows\\CurrentVersion\\Installer" );
const TCHAR sInstLocValue[]  = TEXT( "InstallerLocation" );
const TCHAR sMsiDll[]        = TEXT( "\\msi.dll" );
const TCHAR sMsiExe[]        = TEXT( "\\msiexec.exe" );
const TCHAR sDelayReboot[]   = TEXT( " /c:\"msiinst /delayreboot\"" );
const TCHAR sMsiQuiet[]      = TEXT( " /q" );
const TCHAR sMemMapName[]    = TEXT( "Global\\MsiErrorObject" );

//--------------------------------------------------------------------------
SetupAppX::SetupAppX()
{
    m_hInst     = NULL;
    m_hMapFile  = NULL;
    m_pAppTitle = NULL;
    m_pCmdLine  = NULL;

    m_pDatabase = NULL;
    m_pReqVersion   = NULL;
    m_pProductName  = NULL;
    m_pAdvertise    = NULL;
    m_pTmpName      = NULL;
    m_pLogFile      = NULL;
    m_pModuleFile   = NULL;
    m_pPatchFiles   = NULL;
    m_pMSIErrorCode = NULL;
    m_pUpgradeKey   = NULL;
    m_pProductVersion = NULL;

    m_pErrorText    = new TCHAR[ MAX_TEXT_LENGTH ];
    m_pErrorText[0] = '\0';

    m_nLanguageID     = 0;
    m_nLanguageCount  = 0;
    m_ppLanguageList  = NULL;

    m_bQuiet          = false;
    m_bRegNoMsoTypes  = false;
    m_bRegAllMsoTypes = false;
    m_bIsMinorUpgrade = false;
    m_bSupportsPatch  = false;

    m_bIgnoreAlreadyRunning = false;
}

//--------------------------------------------------------------------------
SetupAppX::~SetupAppX()
{
    if ( m_ppLanguageList )
    {
        for ( int i = 0; i < m_nLanguageCount; i++ )
            if ( m_ppLanguageList[i] )
                delete m_ppLanguageList[ i ];
        delete [] m_ppLanguageList;
    }

    time_t aTime;
    time( &aTime );
    tm *pTime = localtime( &aTime );   // Convert time to struct tm form

    Log( TEXT( "End: %s\n\r\n\r\n" ), _tasctime( pTime ) );

    if ( m_pLogFile ) fclose( m_pLogFile );

    if ( m_pTmpName )
    {
        _tremove( m_pTmpName );
        free( m_pTmpName );
    }

    if ( m_pMSIErrorCode ) UnmapViewOfFile( m_pMSIErrorCode );
    if ( m_hMapFile ) CloseHandle( m_hMapFile );

    if ( m_pAppTitle ) delete [] m_pAppTitle;
    if ( m_pDatabase ) delete [] m_pDatabase;
    if ( m_pReqVersion ) delete [] m_pReqVersion;
    if ( m_pProductName ) delete [] m_pProductName;
    if ( m_pAdvertise )   delete [] m_pAdvertise;
    if ( m_pLogFile )     delete [] m_pLogFile;
    if ( m_pErrorText )   delete [] m_pErrorText;
    if ( m_pModuleFile )  delete [] m_pModuleFile;
    if ( m_pPatchFiles )  delete [] m_pPatchFiles;
    if ( m_pUpgradeKey )  delete [] m_pUpgradeKey;
    if ( m_pProductVersion ) delete [] m_pProductVersion;
}

//--------------------------------------------------------------------------
boolean SetupAppX::Initialize( HINSTANCE hInst )
{
    m_pCmdLine  = WIN::GetCommandLine();
    m_hInst     = hInst;

    // Load our AppTitle (caption)
    m_pAppTitle     = new TCHAR[ MAX_STR_CAPTION ];
    m_pAppTitle[0]  = '\0';
    WIN::LoadString( hInst, IDS_APP_TITLE, m_pAppTitle, MAX_STR_CAPTION );

    // Obtain path we are running from
    m_pModuleFile       = new TCHAR[ MAX_PATH ];
    m_pModuleFile[ 0 ]  = '\0';

    if ( 0 == WIN::GetModuleFileName( hInst, m_pModuleFile, MAX_PATH ) )
    {
        SetError( WIN::GetLastError() );
        return false;
    }

    if ( ! GetCmdLineParameters( &m_pCmdLine ) )
        return false;

    m_hMapFile = CreateFileMapping(
                 INVALID_HANDLE_VALUE,      // use paging file
                 NULL,                      // default security
                 PAGE_READWRITE,            // read/write access
                 0,                         // max. object size
                 sizeof( int ),             // buffer size
                 sMemMapName );
    if ( m_hMapFile )
    {
        m_pMSIErrorCode = (int*) MapViewOfFile( m_hMapFile,  // handle to map object
                        FILE_MAP_ALL_ACCESS,   // read/write permission
                        0,
                        0,
                        sizeof( int ) );
        if ( m_pMSIErrorCode )
            *m_pMSIErrorCode = 0;
        else
            OutputDebugStringFormat( TEXT("Could not map view of file (%d).\n"), GetLastError() );
    }
    else
        OutputDebugStringFormat( TEXT("Could not create file mapping object (%d).\n"), GetLastError() );

    Log( TEXT("Starting: %s\r\n"), m_pModuleFile );
    Log( TEXT(" CommandLine=<%s>\r\n"), m_pCmdLine );

    if ( m_bQuiet )
        Log( TEXT(" Using quiet install mode\r\n") );

    time_t aTime;
    time( &aTime );
    tm* pTime = localtime( &aTime );
    Log( TEXT(" Begin: %s\n"), _tasctime( pTime ) );

    return true;
}

//--------------------------------------------------------------------------
boolean SetupAppX::GetProfileSection( LPCTSTR pFileName, LPCTSTR pSection,
                                      DWORD& rSize, LPTSTR *pRetBuf )
{
    if ( !rSize || !*pRetBuf )
    {
        rSize = 512;
        *pRetBuf = new TCHAR[ rSize ];
    }

    DWORD nRet = GetPrivateProfileSection( pSection, *pRetBuf, rSize, pFileName );

    if ( nRet && ( nRet + 2 > rSize ) ) // buffer was too small, retry with bigger one
    {
        if ( nRet < 32767 - 2 )
        {
            delete [] (*pRetBuf);
            rSize = nRet + 2;
            *pRetBuf = new TCHAR[ rSize ];

            nRet = GetPrivateProfileSection( pSection, *pRetBuf, rSize, pFileName );
        }
    }

    if ( !nRet )
    {
        SetError( WIN::GetLastError() );

        TCHAR sBuf[80];
        StringCchPrintf( sBuf, 80, TEXT("ERROR: GetPrivateProfileSection(): GetLastError returned %u\r\n"), GetError() );
        Log( sBuf );
        return false;
    }
    else if ( nRet + 2 > rSize )
    {
        SetError( ERROR_OUTOFMEMORY );
        Log( TEXT( "ERROR: GetPrivateProfileSection() out of memory\r\n" ) );
        return false;
    }

    Log( TEXT( " GetProfileSection read %s\r\n" ), pSection );

    return true;
}

//--------------------------------------------------------------------------
boolean SetupAppX::ReadProfile()
{
    boolean bRet = false;
    TCHAR *sProfilePath = 0;

    if ( GetPathToFile( PROFILE_NAME, &sProfilePath ) )
    {
        DWORD nSize = 0;
        LPTSTR pRetBuf = NULL;

        Log( TEXT( " Open ini file: <%s>\r\n" ), sProfilePath );

        bRet = GetProfileSection( sProfilePath, SECTION_SETUP, nSize, &pRetBuf );

        if ( !bRet )
        {
            LPTSTR pTmpFile = CopyIniFile( sProfilePath );
            delete [] sProfilePath;
            sProfilePath = pTmpFile;

            if ( sProfilePath )
            {
                SetError( ERROR_SUCCESS );

                Log( TEXT( " Could not open inifile, copied ini file to: <%s>\r\n" ), sProfilePath );
                bRet = GetProfileSection( sProfilePath, SECTION_SETUP, nSize, &pRetBuf );
            }
        }

        if ( bRet )
        {
            LPTSTR pCurLine = pRetBuf;
            while ( *pCurLine )
            {
                LPTSTR pName = 0;
                LPTSTR pValue = 0;

                pCurLine += GetNameValue( pCurLine, &pName, &pValue );

                if ( lstrcmpi( TEXT( "database" ), pName ) == 0 )
                {
                    m_pDatabase = pValue;
                    Log( TEXT( "    Database = %s\r\n" ), pValue );
                }
                else if ( lstrcmpi( TEXT( "msiversion" ), pName ) == 0 )
                {
                    m_pReqVersion = pValue;
                    Log( TEXT( "    msiversion = %s\r\n" ), pValue );
                }
                else if ( lstrcmpi( TEXT( "productname" ), pName ) == 0 )
                {
                    m_pProductName = pValue;
                    Log( TEXT( "    productname = %s\r\n" ), pValue );
                    m_pAppTitle = SetProdToAppTitle( m_pProductName );
                }
                else if ( lstrcmpi( TEXT( "upgradekey" ), pName ) == 0 )
                {
                    m_pUpgradeKey = pValue;
                    Log( TEXT( "    upgradekey = %s\r\n" ), pValue );
                }
                else if ( lstrcmpi( TEXT( "productversion" ), pName ) == 0 )
                {
                    m_pProductVersion = pValue;
                    Log( TEXT( "    productversion = %s\r\n" ), pValue );
                }
                else if ( lstrcmpi( TEXT( "productcode" ), pName ) == 0 )
                {
                    delete [] pValue;
                }
                else
                {
                    Log( TEXT( "Warning: unknown entry in profile <%s>\r\n" ), pName );
                    delete [] pValue;
                }
            }
        }

        if ( bRet && ( !m_pDatabase || !m_pReqVersion || !m_pProductName ) )
        {
            Log( TEXT( "ERROR: incomplete 'Setup' section in profile\r\n" ) );
            SetError( ERROR_INVALID_DATA );
            bRet = false;
        }

        if ( bRet )
            bRet = GetProfileSection( sProfilePath, SECTION_LANGUAGE, nSize, &pRetBuf );

        if ( bRet )
        {
            LPTSTR pName = 0;
            LPTSTR pValue = 0;
            LPTSTR pCurLine = pRetBuf;
            LPTSTR pLastChar;
            int  nNext = 0;

            // first line in this section should be the language count
            nNext = GetNameValue( pCurLine, &pName, &pValue );
            if ( lstrcmpi( TEXT( "count" ), pName ) == 0 )
            {
                Log( TEXT( "    Languages = %s\r\n" ), pValue );
                m_nLanguageCount = _tcstol( pValue, &pLastChar, 10 );
                pCurLine += nNext;
                delete [] pValue;
            }

            m_ppLanguageList = new LanguageDataX*[ m_nLanguageCount ];

            for ( int i=0; i < m_nLanguageCount; i++ )
            {
                if ( !*pCurLine )
                {
                    m_nLanguageCount = i;
                    break;
                }

                pCurLine += GetNameValue( pCurLine, &pName, &pValue );
                m_ppLanguageList[ i ] = new LanguageDataX( pValue );
                Log( TEXT( "    Language = %s\r\n" ), pValue );

                if ( m_ppLanguageList[ i ]->m_pTransform )
                    Log( TEXT( "      Transform = %s\r\n" ), m_ppLanguageList[ i ]->m_pTransform );

                delete [] pValue;
            }
        }

        if ( pRetBuf )
            delete [] pRetBuf;
    }

    if ( sProfilePath && ! m_pTmpName )
        delete [] sProfilePath;

    return bRet;
}

//--------------------------------------------------------------------------
void SetupAppX::AddFileToPatchList( TCHAR* pPath, TCHAR* pFile )
{
    if ( m_pPatchFiles == NULL )
    {
        m_pPatchFiles = new TCHAR[ MAX_STR_LENGTH ];
        StringCchCopy( m_pPatchFiles, MAX_STR_LENGTH, TEXT("\"") );
    }
    else
        StringCchCat( m_pPatchFiles, MAX_STR_LENGTH, TEXT(";") );

    StringCchCat( m_pPatchFiles, MAX_STR_LENGTH, pPath );
    StringCchCat( m_pPatchFiles, MAX_STR_LENGTH, pFile );
}

//--------------------------------------------------------------------------
boolean SetupAppX::GetPatches()
{
    boolean bRet = true;

    int nPatternLen = lstrlen( m_pModuleFile ) + 7; // 1 for null terminator, 1 for back slash, 5 for extensions
    TCHAR* pPattern = new TCHAR[ nPatternLen ];
    TCHAR* pBaseDir = new TCHAR[ nPatternLen ];

    // find 'setup.exe' in the path so we can remove it
    TCHAR *pFilePart = 0;
    if ( 0 == GetFullPathName( m_pModuleFile, nPatternLen, pPattern, &pFilePart ) )
    {
        SetError( WIN::GetLastError() );
        bRet = false;
    }
    else
    {
        if ( pFilePart )
            *pFilePart = '\0';
        StringCchCopy( pBaseDir, nPatternLen, pPattern );
        StringCchCat( pPattern, nPatternLen, TEXT("*.msp") );

        WIN32_FIND_DATA aFindFileData;

        HANDLE hFindPatches = FindFirstFile( pPattern, &aFindFileData );

        if ( hFindPatches != INVALID_HANDLE_VALUE )
        {
            if ( ! IsPatchInstalled( pBaseDir, aFindFileData.cFileName ) )
                AddFileToPatchList( pBaseDir, aFindFileData.cFileName );

            while ( FindNextFile( hFindPatches, &aFindFileData ) )
            {
                if ( ! IsPatchInstalled( pBaseDir, aFindFileData.cFileName ) )
                    AddFileToPatchList( pBaseDir, aFindFileData.cFileName );
            }

            if ( m_pPatchFiles != NULL )
                StringCchCat( m_pPatchFiles, MAX_STR_LENGTH, TEXT("\"") );

            FindClose( hFindPatches );
        }
    }

    delete [] pPattern;
    delete [] pBaseDir;

    return bRet;
}

//--------------------------------------------------------------------------
boolean SetupAppX::GetPathToFile( TCHAR* pFileName, TCHAR** pPath )
{
    // generate the path to the file =  szModuleFile + FileName
    //   note: FileName is a relative path

    boolean bRet = true;

    int nTempPath = lstrlen( m_pModuleFile ) + lstrlen( pFileName ) + 2; // 1 for null terminator, 1 for back slash
    TCHAR* pTempPath = new TCHAR[ nTempPath ];

    // find 'setup.exe' in the path so we can remove it
    TCHAR *pFilePart = 0;
    if ( 0 == GetFullPathName( m_pModuleFile, nTempPath, pTempPath, &pFilePart ) )
    {
        SetError( WIN::GetLastError() );
        bRet = false;
    }
    else
    {
        if ( pFilePart )
            *pFilePart = '\0';

        StringCchCat( pTempPath, nTempPath, pFileName );

        int nPath = 2 * nTempPath;
        *pPath = new TCHAR[ nPath ];

        // normalize the path
        int nReturn = GetFullPathName( pTempPath, nPath, *pPath, &pFilePart );

        if ( nReturn > nPath )
        {
            // try again, with larger buffer
            delete [] (*pPath);
            nPath = nReturn;
            *pPath = new TCHAR[ nPath ];

            nReturn = GetFullPathName( pTempPath, nPath, *pPath, &pFilePart );
        }

        if ( 0 == nReturn )
        {
            // error -- invalid path
            SetError( WIN::GetLastError() );
            bRet = false;
        }
    }

    if ( bRet ) // check for the file's existence
    {
        DWORD dwFileAttrib = GetFileAttributes( *pPath );

        if (0xFFFFFFFF == dwFileAttrib)
        {
            StringCchCopy( m_pErrorText, MAX_TEXT_LENGTH, pFileName );
            SetError( ERROR_FILE_NOT_FOUND );
            bRet = false;
        }
    }

    delete [] pTempPath;
    return bRet;
}

//--------------------------------------------------------------------------
int SetupAppX::GetNameValue( TCHAR* pLine, TCHAR** pName, TCHAR** pValue )
{
    int nRet = lstrlen( pLine ) + 1;
    *pValue = 0;

    if ( nRet == 1 )
        return nRet;

    LPTSTR  pChar = pLine;
    LPTSTR  pLast = NULL;

    // Skip leading spaces.
    while (' ' == *pChar || '\t' == *pChar)
        pChar = CharNext( pChar );

    *pName = pChar;

    // look for the end of the name
    while( *pChar && (' ' != *pChar) &&
           ( '\t' != *pChar ) && ( '=' != *pChar ) )
        pChar = CharNext( pChar );

    if ( ! *pChar )
        return nRet;

    pLast = pChar;
    pChar = CharNext( pChar );
    *pLast = '\0';

    // look for the start of the value
    while( ( ' ' == *pChar ) || ( '\t' == *pChar ) ||
           ( '=' == *pChar ) )
        pChar = CharNext( pChar );

    int nValueLen = lstrlen( pChar ) + 1;
    *pValue = new TCHAR[ nValueLen ];

    if ( *pValue )
        StringCchCopy( *pValue, nValueLen, pChar );

    return nRet;
}

//--------------------------------------------------------------------------
boolean SetupAppX::ChooseLanguage( long& rLanguage )
{
    rLanguage = 0;

    if ( m_bQuiet )
        return true;

    // When there are none or only one language, there is nothing
    // to do here
    if ( m_nLanguageCount > 1 )
    {
        TCHAR *sString = new TCHAR[ MAX_LANGUAGE_LEN ];

        LANGID nUserDefLang = GetUserDefaultLangID();
        LANGID nSysDefLang = GetSystemDefaultLangID();

        int nUserPrimary = PRIMARYLANGID( nUserDefLang );
        int nSysPrimary = PRIMARYLANGID( nSysDefLang );

        long nUserIndex = -1;
        long nUserPrimIndex = -1;
        long nSystemIndex = -1;
        long nSystemPrimIndex = -1;
        long nParamIndex = -1;

        for ( long i=0; i<GetLanguageCount(); i++ )
        {
            long nLanguage = GetLanguageID( i );
            int nPrimary = PRIMARYLANGID( nLanguage );
            GetLanguageName( nLanguage, sString );
            Log( TEXT( "    Info: found Language: %s\r\n" ), sString );

            if ( nLanguage == nUserDefLang )
                nUserIndex = i;
            if ( nPrimary == nUserPrimary )
                nUserPrimIndex = i;
            if ( nLanguage == nSysDefLang )
                nSystemIndex = i;
            if ( nPrimary == nSysPrimary )
                nSystemPrimIndex = i;
            if ( m_nLanguageID && ( nLanguage == m_nLanguageID ) )
                nParamIndex = i;
        }

        if ( m_nLanguageID && ( nParamIndex == -1 ) )
        {
            Log( TEXT( "Warning: Language chosen with parameter -lang not found.\r\n" ) );
        }

        if ( nParamIndex != -1 )
        {
            Log( TEXT( "Info: Found language chosen with parameter -lang.\r\n" ) );
            rLanguage = GetLanguageID( nParamIndex );
        }
        else if ( nUserIndex != -1 )
        {
            Log( TEXT( "Info: Found user default language.\r\n" ) );
            rLanguage = GetLanguageID( nUserIndex );
        }
        else if ( nUserPrimIndex != -1 )
        {
            Log( TEXT( "Info: Found user default primary language.\r\n" ) );
            rLanguage = GetLanguageID( nUserPrimIndex );
        }
        else if ( nSystemIndex != -1 )
        {
            Log( TEXT( "Info: Found system default language.\r\n" ) );
            rLanguage = GetLanguageID( nSystemIndex );
        }
        else if ( nSystemPrimIndex != -1 )
        {
            Log( TEXT( "Info: Found system default primary language.\r\n" ) );
            rLanguage = GetLanguageID( nSystemPrimIndex );
        }
        else
        {
            Log( TEXT( "Info: Use default language from ini file.\r\n" ) );
            rLanguage = GetLanguageID( 0 );
        }
        delete [] sString;
    }

    return true;
}

//--------------------------------------------------------------------------
HMODULE SetupAppX::LoadMsiLibrary()
{
    HMODULE hMsi = NULL;
    HKEY    hInstKey = NULL;

    // find registered location of Msi.dll
    if ( ERROR_SUCCESS == RegOpenKeyEx( HKEY_LOCAL_MACHINE, sInstKey, 0, KEY_READ, &hInstKey ) )
    {
        long    nRet = ERROR_SUCCESS;
        TCHAR  *sMsiFolder = new TCHAR[ MAX_PATH + 1 ];
        DWORD   dwMsiFolderSize = MAX_PATH + 1;
        DWORD   dwType = 0;

        if ( ERROR_MORE_DATA == ( nRet = RegQueryValueEx( hInstKey, sInstLocValue, NULL,
                                                          &dwType, (BYTE*)sMsiFolder, &dwMsiFolderSize ) ) )
        {
            // try again with larger buffer
            delete [] sMsiFolder;
            sMsiFolder = new TCHAR[ dwMsiFolderSize ];

            nRet = RegQueryValueEx( hInstKey, sInstLocValue, NULL, &dwType,
                                    (BYTE*)sMsiFolder, &dwMsiFolderSize );
        }

        if ( ERROR_SUCCESS == nRet && dwType == REG_SZ && dwMsiFolderSize > 0 )
        {
            // load Msi.dll from registered location
            int nLength = lstrlen( sMsiDll ) + dwMsiFolderSize + 1; // use StringCchLength ?
            TCHAR *pMsiLocation = new TCHAR[ nLength ];

            if ( SUCCEEDED( StringCchCopy( pMsiLocation, nLength, sMsiFolder ) ) &&
                 SUCCEEDED( StringCchCat( pMsiLocation, nLength, sMsiDll ) ) )
            {
                hMsi = LoadLibrary( pMsiLocation );
            }
        }
    }

    if ( !hMsi ) // use the default location
    {
        hMsi = LoadLibrary( sMsiDll );
    }

    return hMsi;
}

//--------------------------------------------------------------------------
LPCTSTR SetupAppX::GetPathToMSI()
{
    LPTSTR  sMsiPath = NULL;
    HKEY    hInstKey = NULL;
    TCHAR  *sMsiFolder = new TCHAR[ MAX_PATH + 1 ];
    DWORD   nMsiFolderSize = MAX_PATH + 1;

    sMsiFolder[0] = '\0';

    // find registered location of Msi.dll
    if ( ERROR_SUCCESS == RegOpenKeyEx( HKEY_LOCAL_MACHINE, sInstKey, 0, KEY_READ, &hInstKey ) )
    {
        LONG    nRet = ERROR_SUCCESS;
        DWORD   dwType = 0;

        if ( ERROR_MORE_DATA == ( nRet = RegQueryValueEx( hInstKey, sInstLocValue, NULL,
                                                          &dwType, (BYTE*)sMsiFolder, &nMsiFolderSize ) ) )
        {
            // try again with larger buffer
            delete [] sMsiFolder;
            sMsiFolder = new TCHAR[ nMsiFolderSize ];

            nRet = RegQueryValueEx( hInstKey, sInstLocValue, NULL, &dwType,
                                    (BYTE*)sMsiFolder, &nMsiFolderSize );
        }

        if ( ERROR_SUCCESS != nRet || dwType != REG_SZ || nMsiFolderSize == 0 )
            sMsiFolder[0] = '\0';
    }

    if ( sMsiFolder[0] == '\0' ) // use the default location
    {
        Log( TEXT( "  Could not find path to msiexec.exe in registry" ) );

        DWORD nRet = WIN::GetSystemDirectory( sMsiFolder, nMsiFolderSize );
        if ( nRet > nMsiFolderSize )
        {
            delete [] sMsiFolder;
            sMsiFolder = new TCHAR[ nRet ];
            nMsiFolderSize = nRet;

            nRet = WIN::GetSystemDirectory( sMsiFolder, nMsiFolderSize );
        }
        if ( 0 == nRet )
        {
            sMsiFolder[0] = '\0';
            SetError( WIN::GetLastError() );
        }
        nMsiFolderSize = nRet;
    }

    if ( sMsiFolder[0] != '\0' )
    {
        int nLength = lstrlen( sMsiExe ) + lstrlen( sMsiFolder ) + 1;
        sMsiPath = new TCHAR[ nLength ];

        if ( FAILED( StringCchCopy( sMsiPath, nLength, sMsiFolder ) ) ||
             FAILED( StringCchCat( sMsiPath, nLength, sMsiExe ) ) )
        {
            delete [] sMsiPath;
            sMsiPath = NULL;
        }
    }

    if ( ! sMsiPath )
        Log( TEXT( "ERROR: Can't build path to msiexec.exe!" ) );

    return sMsiPath;
}

//--------------------------------------------------------------------------
boolean SetupAppX::LaunchInstaller( LPCTSTR pParam )
{
    LPCTSTR sMsiPath = GetPathToMSI();

    if ( !sMsiPath )
    {
        Log( TEXT( "ERROR: msiexec not found!" ) );
        SetError( ERROR_FILE_NOT_FOUND );
        return false;
    }

    STARTUPINFO         aSUI;
    PROCESS_INFORMATION aPI;

    Log( TEXT( " Will install using <%s>\r\n" ), sMsiPath );
    Log( TEXT( "   Prameters are: %s\r\n" ), pParam );

    OutputDebugStringFormat( TEXT( " Will install using <%s>\r\n" ), sMsiPath );
    OutputDebugStringFormat( TEXT( "   Prameters are: %s\r\n" ), pParam );

    ZeroMemory( (void*)&aPI, sizeof( PROCESS_INFORMATION ) );
    ZeroMemory( (void*)&aSUI, sizeof( STARTUPINFO ) );

    aSUI.cb          = sizeof(STARTUPINFO);
    aSUI.dwFlags     = STARTF_USESHOWWINDOW;
    aSUI.wShowWindow = SW_SHOW;

    DWORD nCmdLineLength = lstrlen( sMsiPath ) + lstrlen( pParam ) + 2;
    TCHAR *sCmdLine = new TCHAR[ nCmdLineLength ];

    if ( FAILED( StringCchCopy( sCmdLine, nCmdLineLength, sMsiPath ) ) ||
         FAILED( StringCchCat(  sCmdLine, nCmdLineLength, TEXT( " " ) ) ) ||
         FAILED( StringCchCat(  sCmdLine, nCmdLineLength, pParam ) ) )
    {
        delete [] sCmdLine;
        SetError( ERROR_INSTALL_FAILURE );
        return false;
    }

    if ( !WIN::CreateProcess( NULL, sCmdLine, NULL, NULL, FALSE,
                              CREATE_DEFAULT_ERROR_MODE, NULL, NULL,
                              &aSUI, &aPI ) )
    {
        Log( TEXT( "ERROR: Could not create process %s.\r\n" ), sCmdLine );
        SetError( WIN::GetLastError() );
        delete [] sCmdLine;
        return false;
    }

    DWORD nResult = WaitForProcess( aPI.hProcess );
    bool bRet = true;

    if( ERROR_SUCCESS != nResult )
    {
        Log( TEXT( "ERROR: While waiting for %s.\r\n" ), sCmdLine );
        SetError( nResult );
        bRet = false;
    }
    else
    {
        GetExitCodeProcess( aPI.hProcess, &nResult );
        SetError( nResult );

        if ( nResult != ERROR_SUCCESS )
        {
            TCHAR sBuf[80];
            StringCchPrintf( sBuf, 80, TEXT("Warning: msiexec returned %u.\r\n"), nResult );
            Log( sBuf );
        }
        else
            Log( TEXT( " Installation completed successfully.\r\n" ) );
    }

    CloseHandle( aPI.hProcess );

    delete [] sCmdLine;

    return bRet;
}

//--------------------------------------------------------------------------
boolean SetupAppX::Install( long nLanguage )
{
    LPTSTR pTransform = NULL;

    if ( nLanguage ) // look for transformation
    {
        for ( int i = 0; i < m_nLanguageCount; i++ )
        {
            if ( m_ppLanguageList[i]->m_nLanguageID == nLanguage )
            {
                if ( m_ppLanguageList[i]->m_pTransform )
                {
                    if ( !GetPathToFile( m_ppLanguageList[i]->m_pTransform,
                                        &pTransform ) )
                    {
                        Log( TEXT( "ERROR: Could not find transform <%s\r\n" ), m_ppLanguageList[i]->m_pTransform );
                        return false;
                    }
                }
                break;
            }
        }
    }

    TCHAR *pDataBasePath = NULL;

    if ( ! GetPathToFile( m_pDatabase, &pDataBasePath ) )
    {
        Log( TEXT( "ERROR: Could not find database <%s\r\n" ), m_pDatabase );
        SetError( ERROR_INSTALL_SOURCE_ABSENT );
        return false;
    }

    // we will always use the parameter setup used
    int nParLen = lstrlen( PARAM_SETUP_USED );

    if ( m_bRegNoMsoTypes )
        nParLen += lstrlen( PARAM_REG_NO_MSO_TYPES );
    else if ( m_bRegAllMsoTypes )
        nParLen += lstrlen( PARAM_REG_ALL_MSO_TYPES );

    if ( m_pAdvertise )
        nParLen += lstrlen( m_pAdvertise ) + 1;     // one for the space
    else if ( m_bIsMinorUpgrade )
        nParLen += lstrlen( PARAM_MINOR_UPGRADE );
    else
        nParLen += lstrlen( PARAM_PACKAGE );

    nParLen += lstrlen( pDataBasePath ) + 3;        // two quotes, one null

    if ( NeedReboot() )
        nParLen += lstrlen( PARAM_REBOOT );

    if ( m_pPatchFiles )
    {
        nParLen += lstrlen( PARAM_PATCH );
        nParLen += lstrlen( m_pPatchFiles );
    }

    if ( pTransform )
    {
        nParLen += lstrlen( PARAM_TRANSFORM );
        nParLen += lstrlen( pTransform ) + 2;       // two quotes
    }

    if ( m_pCmdLine )
        nParLen += lstrlen( m_pCmdLine ) + 1;       // one for the space;

    TCHAR *pParams = new TCHAR[ nParLen ];

    StringCchCopy( pParams, nParLen, PARAM_SETUP_USED );

    if ( m_bRegNoMsoTypes )
        StringCchCat( pParams, nParLen, PARAM_REG_NO_MSO_TYPES );
    else if ( m_bRegAllMsoTypes )
        StringCchCat( pParams, nParLen, PARAM_REG_ALL_MSO_TYPES );

    if ( m_pAdvertise )
        StringCchCat( pParams, nParLen, m_pAdvertise );
    else if ( IsAdminInstall() )
        StringCchCat( pParams, nParLen, PARAM_ADMIN );
    else if ( m_bIsMinorUpgrade )
        StringCchCat( pParams, nParLen, PARAM_MINOR_UPGRADE );
    else
        StringCchCat( pParams, nParLen, PARAM_PACKAGE );

    StringCchCat( pParams, nParLen, TEXT( "\"" ) );
    StringCchCat( pParams, nParLen, pDataBasePath );
    StringCchCat( pParams, nParLen, TEXT( "\"" ) );

    if ( NeedReboot() )
        StringCchCat( pParams, nParLen, PARAM_REBOOT );

    if ( m_pPatchFiles )
    {
        StringCchCat( pParams, nParLen, PARAM_PATCH );
        StringCchCat( pParams, nParLen, m_pPatchFiles );
    }

    if ( pTransform )
    {
        StringCchCat( pParams, nParLen, PARAM_TRANSFORM );
        StringCchCat( pParams, nParLen, TEXT( "\"" ) );
        StringCchCat( pParams, nParLen, pTransform );
        StringCchCat( pParams, nParLen, TEXT( "\"" ) );
    }

    if ( m_pCmdLine )
    {
        StringCchCat( pParams, nParLen, TEXT( " " ) );
        StringCchCat( pParams, nParLen, m_pCmdLine );
    }

    return LaunchInstaller( pParams );
}

//--------------------------------------------------------------------------
UINT SetupAppX::GetError() const
{
    UINT nErr = 0;

    if ( m_pMSIErrorCode )
        nErr = (UINT) *m_pMSIErrorCode;

    if ( nErr == 0 )
        nErr = m_uiRet;

    if ( nErr != 0 )
        OutputDebugStringFormat( TEXT("Setup will return error (%d).\n"), nErr );
    return nErr;
}

//--------------------------------------------------------------------------
void SetupAppX::DisplayError( UINT nErr ) const
{
    TCHAR sError[ MAX_TEXT_LENGTH ] = {0};
    TCHAR sTmp[ MAX_TEXT_LENGTH ] = {0};

    UINT  nMsgType = MB_OK | MB_ICONERROR;

    switch ( nErr )
    {
        case ERROR_SUCCESS:     break;  // 0

        case ERROR_FILE_NOT_FOUND:  // 2
                                WIN::LoadString( m_hInst, IDS_FILE_NOT_FOUND, sTmp, MAX_TEXT_LENGTH );
                                StringCchPrintf( sError, MAX_TEXT_LENGTH, sTmp, m_pErrorText );
                                break;
        case ERROR_INVALID_DATA:    // 13
                                WIN::LoadString( m_hInst, IDS_INVALID_PROFILE, sError, MAX_TEXT_LENGTH );
                                break;
        case ERROR_OUTOFMEMORY: WIN::LoadString( m_hInst, IDS_OUTOFMEM, sError, MAX_TEXT_LENGTH );
                                break;
        case ERROR_INSTALL_USEREXIT:
                                WIN::LoadString( m_hInst, IDS_USER_CANCELLED, sError, MAX_TEXT_LENGTH );
                                break;
        case ERROR_INSTALL_ALREADY_RUNNING: // 1618
                                WIN::LoadString( m_hInst, IDS_ALREADY_RUNNING, sError, MAX_TEXT_LENGTH );
                                break;
        case ERROR_INSTALL_SOURCE_ABSENT:
                                WIN::LoadString( m_hInst, IDS_NOMSI, sError, MAX_TEXT_LENGTH );
                                break;
        case ERROR_DS_INSUFF_ACCESS_RIGHTS: // 8344
                                WIN::LoadString( m_hInst, IDS_REQUIRES_ADMIN_PRIV, sError, MAX_TEXT_LENGTH );
                                break;
        case E_ABORT:           WIN::LoadString( m_hInst, IDS_UNKNOWN_ERROR, sError, MAX_TEXT_LENGTH );
                                break;
        case ERROR_INVALID_PARAMETER:   // 87
                                WIN::LoadString( m_hInst, IDS_INVALID_PARAM, sTmp, MAX_TEXT_LENGTH );
                                StringCchPrintf( sError, MAX_TEXT_LENGTH, sTmp, m_pErrorText );
                                break;

        case ERROR_SETUP_TO_OLD:    // - 3
                                WIN::LoadString( m_hInst, IDS_SETUP_TO_OLD, sTmp, MAX_TEXT_LENGTH );
                                StringCchPrintf( sError, MAX_TEXT_LENGTH, sTmp, m_pReqVersion, m_pErrorText );
                                break;
        case ERROR_SETUP_NOT_FOUND: // - 4
                                WIN::LoadString( m_hInst, IDS_SETUP_NOT_FOUND, sTmp, MAX_TEXT_LENGTH );
                                StringCchPrintf( sError, MAX_TEXT_LENGTH, sTmp, m_pReqVersion );
                                break;
        case ERROR_SHOW_USAGE:      // - 2
                                nMsgType = MB_OK | MB_ICONINFORMATION;
                                WIN::LoadString( m_hInst, IDS_USAGE, sError, MAX_TEXT_LENGTH );
                                break;

        default:                WIN::LoadString( m_hInst, IDS_UNKNOWN_ERROR, sError, MAX_TEXT_LENGTH );
                                break;
    }

    if ( sError[0] )
    {
        if ( !m_bQuiet )
        {
            ConvertNewline( sError );
            WIN::MessageBox( NULL, sError, m_pAppTitle, nMsgType );
        }

        Log( TEXT( "ERROR: %s\r\n" ), sError );
    }
}

//--------------------------------------------------------------------------
long SetupAppX::GetLanguageID( long nIndex ) const
{
    if ( nIndex >=0 && nIndex < m_nLanguageCount )
        return m_ppLanguageList[ nIndex ]->m_nLanguageID;
    else
        return 0;
}

//--------------------------------------------------------------------------
void SetupAppX::GetLanguageName( long nLanguage, LPTSTR sName ) const
{
    switch ( nLanguage )
    {
        case 1028: WIN::LoadString( m_hInst, IDS_LANGUAGE_ZH_TW, sName, MAX_LANGUAGE_LEN ); break;
        case 1029: WIN::LoadString( m_hInst, IDS_LANGUAGE_CS,    sName, MAX_LANGUAGE_LEN ); break;
        case 1030: WIN::LoadString( m_hInst, IDS_LANGUAGE_DA,    sName, MAX_LANGUAGE_LEN ); break;
        case 1031: WIN::LoadString( m_hInst, IDS_LANGUAGE_DE_DE, sName, MAX_LANGUAGE_LEN ); break;
        case 1032: WIN::LoadString( m_hInst, IDS_LANGUAGE_EL,    sName, MAX_LANGUAGE_LEN ); break;
        case 1033: WIN::LoadString( m_hInst, IDS_LANGUAGE_EN_US, sName, MAX_LANGUAGE_LEN ); break;
        case 1034: WIN::LoadString( m_hInst, IDS_LANGUAGE_ES,    sName, MAX_LANGUAGE_LEN ); break;
        case 1035: WIN::LoadString( m_hInst, IDS_LANGUAGE_FI,    sName, MAX_LANGUAGE_LEN ); break;
        case 1036: WIN::LoadString( m_hInst, IDS_LANGUAGE_FR_FR, sName, MAX_LANGUAGE_LEN ); break;
        case 1037: WIN::LoadString( m_hInst, IDS_LANGUAGE_HE,    sName, MAX_LANGUAGE_LEN ); break;
        case 1038: WIN::LoadString( m_hInst, IDS_LANGUAGE_HU,    sName, MAX_LANGUAGE_LEN ); break;
        case 1040: WIN::LoadString( m_hInst, IDS_LANGUAGE_IT_IT, sName, MAX_LANGUAGE_LEN ); break;
        case 1041: WIN::LoadString( m_hInst, IDS_LANGUAGE_JA,    sName, MAX_LANGUAGE_LEN ); break;
        case 1042: WIN::LoadString( m_hInst, IDS_LANGUAGE_KO,    sName, MAX_LANGUAGE_LEN ); break;
        case 1043: WIN::LoadString( m_hInst, IDS_LANGUAGE_NL_NL, sName, MAX_LANGUAGE_LEN ); break;
        case 1044: WIN::LoadString( m_hInst, IDS_LANGUAGE_NO_NO, sName, MAX_LANGUAGE_LEN ); break;
        case 1045: WIN::LoadString( m_hInst, IDS_LANGUAGE_PL,    sName, MAX_LANGUAGE_LEN ); break;
        case 1046: WIN::LoadString( m_hInst, IDS_LANGUAGE_PT_BR, sName, MAX_LANGUAGE_LEN ); break;
        case 1049: WIN::LoadString( m_hInst, IDS_LANGUAGE_RU,    sName, MAX_LANGUAGE_LEN ); break;
        case 1051: WIN::LoadString( m_hInst, IDS_LANGUAGE_SK,    sName, MAX_LANGUAGE_LEN ); break;
        case 1053: WIN::LoadString( m_hInst, IDS_LANGUAGE_SV_SE, sName, MAX_LANGUAGE_LEN ); break;
        case 1054: WIN::LoadString( m_hInst, IDS_LANGUAGE_TH,    sName, MAX_LANGUAGE_LEN ); break;
        case 1055: WIN::LoadString( m_hInst, IDS_LANGUAGE_TR,    sName, MAX_LANGUAGE_LEN ); break;
        case 1061: WIN::LoadString( m_hInst, IDS_LANGUAGE_ET,    sName, MAX_LANGUAGE_LEN ); break;
        case 2052: WIN::LoadString( m_hInst, IDS_LANGUAGE_ZH_CN, sName, MAX_LANGUAGE_LEN ); break;
        case 2070: WIN::LoadString( m_hInst, IDS_LANGUAGE_PT_PT, sName, MAX_LANGUAGE_LEN ); break;

        default:
            {
                TCHAR sTmp[ MAX_LANGUAGE_LEN ] = {0};

                WIN::LoadString( m_hInst, IDS_UNKNOWN_LANG, sTmp, MAX_LANGUAGE_LEN );
                StringCchPrintf( sName, MAX_LANGUAGE_LEN, sTmp, nLanguage );
            }
    }
}

//--------------------------------------------------------------------------
boolean SetupAppX::CheckVersion()
{
    boolean bRet = false;
    HMODULE hMsi = LoadMsiLibrary();

    Log( TEXT( " Looking for installed MSI with version >= %s\r\n" ), m_pReqVersion );

    if ( !hMsi )
    {
        Log( TEXT( "Error: No MSI found!\r\n" ) );
        SetError( (UINT) ERROR_SETUP_NOT_FOUND );
    }
    else
    {
        PFnDllGetVersion pDllGetVersion = (PFnDllGetVersion) GetProcAddress( hMsi, MSIAPI_DllGetVersion );

        if ( pDllGetVersion )
        {
            DLLVERSIONINFO aInfo;

            aInfo.cbSize = sizeof( DLLVERSIONINFO );
            if ( NOERROR == pDllGetVersion( &aInfo ) )
            {
                TCHAR pMsiVersion[ VERSION_SIZE ];
                StringCchPrintf( pMsiVersion, VERSION_SIZE, TEXT("%d.%d.%4d"),
                                 aInfo.dwMajorVersion,
                                 aInfo.dwMinorVersion,
                                 aInfo.dwBuildNumber );
                if ( _tcsncmp( pMsiVersion, m_pReqVersion, _tcslen( pMsiVersion ) ) < 0 )
                {
                    StringCchCopy( m_pErrorText, MAX_TEXT_LENGTH, pMsiVersion );
                    SetError( (UINT) ERROR_SETUP_TO_OLD );
                    Log( TEXT( "Warning: Old MSI version found <%s>, update needed!\r\n" ), pMsiVersion );
                }
                else
                {
                    Log( TEXT( " Found MSI version <%s>, no update needed\r\n" ), pMsiVersion );
                    bRet = true;
                }
                if ( aInfo.dwMajorVersion >= 3 )
                    m_bSupportsPatch = true;
                else
                    Log( TEXT("Warning: Patching not supported! MSI-Version <%s>\r\n"), pMsiVersion );
            }
        }

        FreeLibrary( hMsi );
    }

    return bRet;
}

//--------------------------------------------------------------------------
boolean SetupAppX::CheckForUpgrade()
{
    // When we have patch files we will never try an Minor upgrade
    if ( m_pPatchFiles ) return true;

    if ( !m_pUpgradeKey || ( _tcslen( m_pUpgradeKey ) == 0 ) )
    {
        Log( TEXT( "    No Upgrade Key Found -> continue with standard installation!\r\n" ) );
        return true;
    }

    HKEY hInstKey = NULL;

    if ( ERROR_SUCCESS == RegOpenKeyEx( HKEY_LOCAL_MACHINE, m_pUpgradeKey, 0, KEY_READ, &hInstKey ) )
    {
        Log( TEXT( " Found Upgrade Key in Registry (HKLM) -> will try minor upgrade!\r\n" ) );
        m_bIsMinorUpgrade = true;
    }
    else if ( ERROR_SUCCESS == RegOpenKeyEx( HKEY_CURRENT_USER, m_pUpgradeKey, 0, KEY_READ, &hInstKey ) )
    {
        Log( TEXT( " Found Upgrade Key in Registry (HKCU) -> will try minor upgrade!\r\n" ) );
        m_bIsMinorUpgrade = true;
    }
    else
    {
        Log( TEXT( " Didn't Find Upgrade Key in Registry -> continue with standard installation!\r\n" ) );
        return true;
    }

    if ( m_pProductVersion && ( _tcslen( m_pProductVersion ) > 0 ) )
    {
        TCHAR  *sProductVersion = new TCHAR[ MAX_PATH + 1 ];
        DWORD   nSize = MAX_PATH + 1;

        sProductVersion[0] = '\0';

        // get product version
        if ( ERROR_SUCCESS == RegQueryValueEx( hInstKey, PRODUCT_VERSION, NULL, NULL, (LPBYTE)sProductVersion, &nSize ) )
        {
            if ( lstrcmpi( sProductVersion, m_pProductVersion ) == 0 )
            {
                Log( TEXT( " Same Product Version already installed, no minor upgrade!\r\n" ) );
                m_bIsMinorUpgrade = false;
            }
        }

        delete [] sProductVersion;
    }

    return true;
}

//--------------------------------------------------------------------------
boolean SetupAppX::IsTerminalServerInstalled() const
{
    boolean bIsTerminalServer = false;

    const TCHAR sSearchStr[]   = TEXT("Terminal Server");
    const TCHAR sKey[]         = TEXT("System\\CurrentControlSet\\Control\\ProductOptions");
    const TCHAR sValue[]       = TEXT("ProductSuite");

    DWORD dwSize = 0;
    HKEY  hKey = 0;
    DWORD dwType = 0;

    if ( ERROR_SUCCESS == RegOpenKeyEx( HKEY_LOCAL_MACHINE, sKey, 0, KEY_READ, &hKey ) &&
         ERROR_SUCCESS == RegQueryValueEx( hKey, sValue, NULL, &dwType, NULL, &dwSize ) &&
         dwSize > 0 &&
         REG_MULTI_SZ == dwType )
    {
        TCHAR* sSuiteList = new TCHAR[ (dwSize*sizeof(byte)/sizeof(TCHAR)) + 1 ];

        ZeroMemory(sSuiteList, dwSize);

        if ( ERROR_SUCCESS == RegQueryValueEx( hKey, sValue, NULL, &dwType, (LPBYTE)sSuiteList, &dwSize) )
        {
            DWORD nMulti = 0;
            DWORD nSrch  = lstrlen( sSearchStr );
            const TCHAR *sSubString = sSuiteList;

            while (*sSubString)
            {
                nMulti = lstrlen( sSubString );
                if ( nMulti == nSrch && 0 == lstrcmp( sSearchStr, sSubString ) )
                {
                    bIsTerminalServer = true;
                    break;
                }

                sSubString += (nMulti + 1);
            }
        }
        delete [] sSuiteList;
    }

    if ( hKey )
        RegCloseKey( hKey );

    return bIsTerminalServer;
}

//--------------------------------------------------------------------------
boolean SetupAppX::AlreadyRunning() const
{
    if ( m_bIgnoreAlreadyRunning )
    {
        Log( TEXT("Ignoring already running MSI instance!\r\n") );
        return false;
    }

    const TCHAR *sMutexName    = NULL;
    const TCHAR sGUniqueName[] = TEXT( "Global\\_MSISETUP_{EA8130C1-8D3D-4338-9309-1A52D530D846}" );
    const TCHAR sUniqueName[]  = TEXT( "_MSISETUP_{EA8130C1-8D3D-4338-9309-1A52D530D846}" );

    if ( IsWin9x() )
        sMutexName = sUniqueName;
    else if ( ( GetOSVersion() < 5 ) && ! IsTerminalServerInstalled() )
        sMutexName = sUniqueName;
    else
        sMutexName = sGUniqueName;

    HANDLE hMutex = 0;

    hMutex = WIN::CreateMutex( NULL, FALSE, sMutexName );

    if ( !hMutex || ERROR_ALREADY_EXISTS == WIN::GetLastError() )
    {
        if ( !hMutex )
            Log( TEXT( "ERROR: AlreadyRunning() could not create mutex!\r\n" ) );
        else
            Log( TEXT( "ERROR: There's already a setup running!\r\n" ) );

        return true;
    }
    Log( TEXT( " No running Setup found\r\n" ) );

    return false;
}

//--------------------------------------------------------------------------
DWORD SetupAppX::WaitForProcess( HANDLE hHandle )
{
    DWORD nResult = NOERROR;
    boolean bLoop = true;

    MSG aMsg;
    ZeroMemory( (void*) &aMsg, sizeof(MSG) );

    while ( bLoop )
    {
        switch ( WIN::MsgWaitForMultipleObjects( 1, &hHandle, false,
                                                 INFINITE, QS_ALLINPUT ) )
        {
            case WAIT_OBJECT_0: bLoop = false;
                break;

            case (WAIT_OBJECT_0 + 1):
            {
                if ( WIN::PeekMessage( &aMsg, NULL, NULL, NULL, PM_REMOVE ) )
                {
                    WIN::TranslateMessage( &aMsg );
                    WIN::DispatchMessage( &aMsg );
                }
                break;
            }

            default:
            {
                nResult = WIN::GetLastError();
                bLoop = false;
            }
        }
    }

    return nResult;
}

//--------------------------------------------------------------------------
void SetupAppX::Log( LPCTSTR pMessage, LPCTSTR pText ) const
{
    if ( m_pLogFile )
    {
        static boolean bInit = false;

        if ( !bInit )
        {
            bInit = true;
            if ( ! IsWin9x() )
                _ftprintf( m_pLogFile, TEXT("%c"), 0xfeff );

            _tsetlocale( LC_ALL, TEXT("") );
            _ftprintf( m_pLogFile, TEXT("\nCodepage=%s\nMultiByte Codepage=[%d]\n"),
                                   _tsetlocale( LC_ALL, NULL ), _getmbcp() );
        }
        if ( pText )
        {
            _ftprintf( m_pLogFile, pMessage, pText );
            OutputDebugStringFormat( pMessage, pText );
        }
        else
        {
            _ftprintf( m_pLogFile, pMessage );
            OutputDebugStringFormat( pMessage );
        }

        fflush( m_pLogFile );
    }
}

//--------------------------------------------------------------------------
DWORD SetupAppX::GetNextArgument( LPCTSTR pStr, LPTSTR *pArg, LPTSTR *pNext,
                                  boolean bStripQuotes )
{
    boolean bInQuotes = false;
    boolean bFoundArgEnd = false;
    LPCTSTR pChar = pStr;
    LPCTSTR pFirst = NULL;

    if ( NULL == pChar )
        return ERROR_NO_MORE_ITEMS;

    while ( ' ' == (*pChar) || '\t' == (*pChar) )
        pChar = CharNext( pChar );

    if ( '\0' == (*pChar) )
        return ERROR_NO_MORE_ITEMS;

    int nCount = 1;
    pFirst = pChar;

    while ( ! bFoundArgEnd )
    {
        if ( '\0' == (*pChar) )
            bFoundArgEnd = true;
        else if ( !bInQuotes && ' ' == (*pChar) )
            bFoundArgEnd = true;
        else if ( !bInQuotes && '\t' == (*pChar) )
            bFoundArgEnd = true;
        else
        {
            if ( '\"' == (*pChar) )
            {
                bInQuotes = !bInQuotes;
                if ( bStripQuotes )
                {
                    if ( pChar == pFirst )
                        pFirst = CharNext( pFirst );
                    nCount -= 1;
                }
            }

            pChar = CharNext( pChar );
            nCount += 1;
        }
    }

    if ( pArg )
    {
        *pArg = new TCHAR[ nCount ];
        StringCchCopyN ( *pArg, nCount, pFirst, nCount-1 );
    }

    if ( pNext )
        *pNext = CharNext( pChar );

    return ERROR_SUCCESS;
}

//--------------------------------------------------------------------------
boolean SetupAppX::GetCmdLineParameters( LPTSTR *pCmdLine )
{
    int    nRet   = ERROR_SUCCESS;
    LPTSTR pStart = NULL;
    LPTSTR pNext  = NULL;

    if ( GetNextArgument( *pCmdLine, NULL, &pNext ) != ERROR_SUCCESS )
    {
        SetError( ERROR_NO_MORE_ITEMS );
        return false;
    }

    int    nSize = lstrlen( *pCmdLine ) + 2;
    TCHAR *pNewCmdLine = new TCHAR[ nSize ];
    pNewCmdLine[0] = '\0';

    while ( GetNextArgument( pNext, &pStart, &pNext ) == ERROR_SUCCESS )
    {
        boolean bDeleteStart = true;

        if ( (*pStart) == '/' || (*pStart) == '-' )
        {
            LPTSTR pSub = CharNext( pStart );
            if ( (*pSub) == 'l' || (*pSub) == 'L' )
            {
                pSub = CharNext( pSub );
                if ( (*pSub) == 'a' || (*pSub) == 'A' )
                {   // --- handle the lang parameter ---
                    LPTSTR pLanguage = NULL;
                    LPTSTR pLastChar;
                    if ( GetNextArgument( pNext, &pLanguage, &pNext, true ) != ERROR_SUCCESS )
                    {
                        StringCchCopy( m_pErrorText, MAX_TEXT_LENGTH, pStart );
                        nRet = ERROR_INVALID_PARAMETER;
                        break;
                    }

                    m_nLanguageID = _tcstol( pLanguage, &pLastChar, 10 );
                    delete [] pLanguage;
                }
                else
                {   // --- handle the l(og) parameter ---
                    boolean bAppend = false;
                    LPTSTR  pFileName = NULL;

                    while ( *pSub )
                    {
                        if ( *pSub == '+' )
                        {
                            bAppend = true;
                            break;
                        }
                        pSub = CharNext( pSub );
                    }

                    if ( GetNextArgument( pNext, &pFileName, &pNext, true ) != ERROR_SUCCESS )
                    {
                        StringCchCopy( m_pErrorText, MAX_TEXT_LENGTH, pStart );
                        nRet = ERROR_INVALID_PARAMETER;
                        break;
                    }

                    if ( FAILED( StringCchCat( pNewCmdLine, nSize, pStart ) ) )
                    {
                        nRet = ERROR_OUTOFMEMORY;
                        break;
                    }
                    // we need to append a '+' otherwise msiexec would overwrite our log file
                    if ( !bAppend && FAILED( StringCchCat( pNewCmdLine, nSize, TEXT( "+" ) ) ) )
                    {
                        nRet = ERROR_OUTOFMEMORY;
                        break;
                    }
                    if ( FAILED( StringCchCat( pNewCmdLine, nSize, TEXT( " \"" ) ) ) ||
                        FAILED( StringCchCat( pNewCmdLine, nSize, pFileName ) ) ||
                        FAILED( StringCchCat( pNewCmdLine, nSize, TEXT( "\" " ) ) ) )
                    {
                        nRet = ERROR_OUTOFMEMORY;
                        break;
                    }

                    if ( bAppend )
                        m_pLogFile = _tfopen( pFileName, TEXT( "ab" ) );
                    else
                        m_pLogFile = _tfopen( pFileName, TEXT( "wb" ) );

                    delete [] pFileName;
                }
            }
            else if ( (*pSub) == 'q' || (*pSub) == 'Q' )
            {   // --- Handle quiet file parameter ---
                pSub = CharNext( pSub );
                if ( ! (*pSub) || (*pSub) == 'n' || (*pSub) == 'N' )
                    m_bQuiet = true;

                if ( FAILED( StringCchCat( pNewCmdLine, nSize, pStart ) ) ||
                     FAILED( StringCchCat( pNewCmdLine, nSize, TEXT( " " ) ) ) )
                {
                    nRet = ERROR_OUTOFMEMORY;
                    break;
                }
            }
            else if ( _tcsnicmp( pSub, PARAM_RUNNING, _tcslen( PARAM_RUNNING ) ) == 0 )
            {
                m_bIgnoreAlreadyRunning = true;
            }
            else if ( _tcsnicmp( pSub, CMDLN_REG_ALL_MSO_TYPES, _tcslen( CMDLN_REG_ALL_MSO_TYPES ) ) == 0 )
            {
                m_bRegAllMsoTypes = true;
            }
            else if ( _tcsnicmp( pSub, CMDLN_REG_NO_MSO_TYPES, _tcslen( CMDLN_REG_NO_MSO_TYPES ) ) == 0 )
            {
                m_bRegNoMsoTypes = true;
            }
            else if ( (*pSub) == 'i' || (*pSub) == 'I' || (*pSub) == 'f' || (*pSub) == 'F' ||
                      (*pSub) == 'p' || (*pSub) == 'P' || (*pSub) == 'x' || (*pSub) == 'X' ||
                      (*pSub) == 'y' || (*pSub) == 'Y' || (*pSub) == 'z' || (*pSub) == 'Z' )
            {
                StringCchCopy( m_pErrorText, MAX_TEXT_LENGTH, pStart );
                nRet = ERROR_INVALID_PARAMETER;
                break;
            }
            else if ( (*pSub) == 'a' || (*pSub) == 'A' )
            {   // --- Handle Adminstrative Installation ---
                SetAdminInstall( true );
            }
            else if ( (*pSub) == 'j' || (*pSub) == 'J' )
            {   // --- Handle Adminstrative Installation ---
                m_pAdvertise = pStart;
                m_bQuiet     = true;
                bDeleteStart = false;
            }
            else if ( (*pSub) == '?' || (*pSub) == 'h' || (*pSub) == 'H' )
            {   // --- Handle Show Usage ---
                nRet = ERROR_SHOW_USAGE;
                break;
            }
            else
            {
                if ( FAILED( StringCchCat( pNewCmdLine, nSize, pStart ) ) ||
                     FAILED( StringCchCat( pNewCmdLine, nSize, TEXT( " " ) ) ) )
                {
                    nRet = ERROR_OUTOFMEMORY;
                    break;
                }
            }
        }
        else
        {
            if ( FAILED( StringCchCat( pNewCmdLine, nSize, pStart ) ) ||
                 FAILED( StringCchCat( pNewCmdLine, nSize, TEXT( " " ) ) ) )
            {
                nRet = ERROR_OUTOFMEMORY;
                break;
            }
        }

        if ( bDeleteStart ) delete [] pStart;
        pStart = NULL;
    }

    if ( pStart ) delete [] pStart;

    *pCmdLine = pNewCmdLine;

    if ( nRet != ERROR_SUCCESS )
    {
        SetError( nRet );
        return false;
    }
    else
        return true;;
}

//--------------------------------------------------------------------------
boolean SetupAppX::IsAdmin()
{
    if ( IsWin9x() )
        return true;

    PSID aPsidAdmin;
    SID_IDENTIFIER_AUTHORITY aAuthority = SECURITY_NT_AUTHORITY;

    if ( !AllocateAndInitializeSid( &aAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID,
                                    DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0,
                                    &aPsidAdmin ) )
        return false;

    BOOL bIsAdmin = FALSE;

    if ( GetOSVersion() >= 5 )
    {
        HMODULE hAdvapi32 = LoadLibrary( ADVAPI32_DLL );

        if ( !hAdvapi32 )
            bIsAdmin = FALSE;
        else
        {
            PFnCheckTokenMembership pfnCheckTokenMembership = (PFnCheckTokenMembership) GetProcAddress( hAdvapi32, ADVAPI32API_CheckTokenMembership);
            if ( !pfnCheckTokenMembership || !pfnCheckTokenMembership( NULL, aPsidAdmin, &bIsAdmin ) )
                bIsAdmin = FALSE;
        }
        FreeLibrary( hAdvapi32 );
    }
    else
    {
        // NT4, check groups of user
        HANDLE hAccessToken = 0;
        UCHAR *szInfoBuffer = new UCHAR[ 1024 ]; // may need to resize if TokenInfo too big
        DWORD dwInfoBufferSize = 1024;
        DWORD dwRetInfoBufferSize = 0;
        UINT i=0;

        if ( WIN::OpenProcessToken( WIN::GetCurrentProcess(), TOKEN_READ, &hAccessToken ) )
        {
            bool bSuccess = false;
            bSuccess = WIN::GetTokenInformation( hAccessToken, TokenGroups,
                                                 szInfoBuffer, dwInfoBufferSize,
                                                 &dwRetInfoBufferSize ) == TRUE;

            if( dwRetInfoBufferSize > dwInfoBufferSize )
            {
                delete [] szInfoBuffer;
                szInfoBuffer = new UCHAR[ dwRetInfoBufferSize ];
                dwInfoBufferSize = dwRetInfoBufferSize;
                bSuccess = WIN::GetTokenInformation( hAccessToken, TokenGroups,
                                                     szInfoBuffer, dwInfoBufferSize,
                                                     &dwRetInfoBufferSize ) == TRUE;
            }

            WIN::CloseHandle( hAccessToken );

            if ( bSuccess )
            {
                PTOKEN_GROUPS pGroups = (PTOKEN_GROUPS)(UCHAR*) szInfoBuffer;
                for( i=0; i<pGroups->GroupCount; i++ )
                {
                    if( WIN::EqualSid( aPsidAdmin, pGroups->Groups[i].Sid ) )
                    {
                        bIsAdmin = TRUE;
                        break;
                    }
                }
            }

            delete [] szInfoBuffer;
        }
    }

    WIN::FreeSid( aPsidAdmin );

    return bIsAdmin ? true : false;
}

//--------------------------------------------------------------------------
LPTSTR SetupAppX::CopyIniFile( LPCTSTR pIniFile )
{
    m_pTmpName = _ttempnam( TEXT( "C:\\" ), TEXT( "Setup" ) );

    if ( !m_pTmpName )
    {
        Log( TEXT( "ERROR: Could not create temp file\n" ) );
        return NULL;
    }

    FILE *pOut  = _tfopen( m_pTmpName, TEXT( "wb" ) );
    FILE *pIn   = _tfopen( pIniFile, TEXT( "rb" ) );

    if ( pOut && pIn )
    {
        size_t  nRead, nWritten;
        BYTE    pBuf[1024];

        nRead = fread( pBuf, sizeof( BYTE ), 1024, pIn );
        while ( nRead && !ferror( pIn ) )
        {
            nWritten = fwrite( pBuf, sizeof( BYTE ), nRead, pOut );
            if ( nWritten != nRead )
            {
                Log( TEXT( "ERROR: Could not write all bytes to temp file\n" ) );
                break;
            }
            nRead = fread( pBuf, sizeof( BYTE ), 1024, pIn );
        }
    }

    if ( pOut ) fclose( pOut );
    if ( pIn ) fclose( pIn );

    return m_pTmpName;
}

//--------------------------------------------------------------------------
void SetupAppX::ConvertNewline( LPTSTR pText ) const
{
    int i=0;

    while ( pText[i] != 0 )
    {
        if ( ( pText[i] == '\\' ) && ( pText[i+1] == 'n' ) )
        {
            pText[i] = 0x0d;
            pText[i+1] = 0x0a;
            i+=2;
        }
        else
            i+=1;
    }
}

//--------------------------------------------------------------------------
LPTSTR SetupAppX::SetProdToAppTitle( LPCTSTR pProdName )
{
    if ( !pProdName ) return m_pAppTitle;

    LPTSTR pAppProdTitle = new TCHAR[ MAX_STR_CAPTION ];
           pAppProdTitle[0]  = '\0';

    WIN::LoadString( m_hInst, IDS_APP_PROD_TITLE, pAppProdTitle, MAX_STR_CAPTION );

    int nAppLen = lstrlen( pAppProdTitle );
    int nProdLen = lstrlen( pProdName );

    if ( ( nAppLen == 0 ) || ( nProdLen == 0 ) )
    {
        delete [] pAppProdTitle;
        return m_pAppTitle;
    }

    int nLen = nAppLen + nProdLen + 3;

    if ( nLen > STRSAFE_MAX_CCH ) return m_pAppTitle;

    LPTSTR pIndex = _tcsstr( pAppProdTitle, PRODUCT_NAME_VAR );

    if ( pIndex )
    {
        int nOffset = pIndex - pAppProdTitle;
        int nVarLen = lstrlen( PRODUCT_NAME_VAR );

        LPTSTR pNewTitle = new TCHAR[ nLen ];
        pNewTitle[0] = '\0';

        if ( nOffset > 0 )
        {
            StringCchCopyN( pNewTitle, nLen, pAppProdTitle, nOffset );
        }

        StringCchCat( pNewTitle, nLen, pProdName );

        if ( nOffset + nVarLen < nAppLen )
        {
            StringCchCat( pNewTitle, nLen, pIndex + nVarLen );
        }

        delete [] m_pAppTitle;
        m_pAppTitle = pNewTitle;
    }

    delete [] pAppProdTitle;

    return m_pAppTitle;
}


//--------------------------------------------------------------------------
boolean SetupAppX::IsPatchInstalled( TCHAR* pBaseDir, TCHAR* pFileName )
{
    if ( !m_bSupportsPatch )
        return false;

    PMSIHANDLE hSummaryInfo;
    int nLen = lstrlen( pBaseDir ) + lstrlen( pFileName ) + 1;
    TCHAR *szDatabasePath = new TCHAR [ nLen ];
    TCHAR sBuf[80];

    StringCchCopy( szDatabasePath, nLen, pBaseDir );
    StringCchCat( szDatabasePath, nLen, pFileName );

    UINT nRet = MsiGetSummaryInformation( NULL, szDatabasePath, 0, &hSummaryInfo );

    if ( nRet != ERROR_SUCCESS )
    {
        StringCchPrintf( sBuf, 80, TEXT("ERROR: IsPatchInstalled: MsiGetSummaryInformation returned %u.\r\n"), nRet );
        Log( sBuf );
        return false;
    }

    UINT    uiDataType;
    LPTSTR  szPatchID = new TCHAR[ 64 ];
    DWORD   cchValueBuf = 64;
    nRet = MsiSummaryInfoGetProperty( hSummaryInfo, PID_REVNUMBER, &uiDataType, NULL, NULL, szPatchID, &cchValueBuf );

    if ( nRet != ERROR_SUCCESS )
    {
        StringCchPrintf( sBuf, 80, TEXT("ERROR: IsPatchInstalled: MsiSummaryInfoGetProperty returned %u.\r\n"), nRet );
        Log( sBuf );
        return false;
    }

	nRet = MsiGetPatchInfo( szPatchID, INSTALLPROPERTY_LOCALPACKAGE, NULL, NULL );

    StringCchPrintf( sBuf, 80, TEXT("  GetPatchInfo for (%s) returned (%u)\r\n"), szPatchID, nRet );
    Log( sBuf );

	delete []szPatchID;

    if ( nRet == ERROR_BAD_CONFIGURATION )
        return false;
    else if ( nRet == ERROR_INVALID_PARAMETER )
        return false;
    else if ( nRet == ERROR_MORE_DATA )
        return true;
    else if ( nRet == ERROR_SUCCESS )
        return true;
    else if ( nRet == ERROR_UNKNOWN_PRODUCT )
        return false;
    else if ( nRet == ERROR_UNKNOWN_PROPERTY )
        return false;
    else return false;

	return false;
}

//--------------------------------------------------------------------------
boolean SetupAppX::InstallRuntimes( TCHAR *sProductCode, TCHAR *sRuntimePath )
{
    INSTALLSTATE  nRet = MsiQueryProductState( sProductCode );
    OutputDebugStringFormat( TEXT( "MsiQueryProductState returned <%d>\r\n" ), nRet );
    if ( nRet == INSTALLSTATE_DEFAULT )
        return true;

    Log( TEXT( " Will install runtime <%s>\r\n" ), sRuntimePath );
    OutputDebugStringFormat( TEXT( " Will install runtime <%s>\r\n" ), sRuntimePath );

    STARTUPINFO         aSUI;
    PROCESS_INFORMATION aPI;

    ZeroMemory( (void*)&aPI, sizeof( PROCESS_INFORMATION ) );
    ZeroMemory( (void*)&aSUI, sizeof( STARTUPINFO ) );

    aSUI.cb          = sizeof(STARTUPINFO);
    aSUI.dwFlags     = STARTF_USESHOWWINDOW;
    aSUI.wShowWindow = SW_SHOW;

    DWORD nCmdLineLength = lstrlen( sRuntimePath ) + lstrlen( PARAM_SILENTINSTALL ) + 2;
    TCHAR *sCmdLine = new TCHAR[ nCmdLineLength ];

    if ( FAILED( StringCchCopy( sCmdLine, nCmdLineLength, sRuntimePath ) ) ||
         FAILED( StringCchCat(  sCmdLine, nCmdLineLength, PARAM_SILENTINSTALL ) ) )
    {
        delete [] sCmdLine;
        SetError( ERROR_INSTALL_FAILURE );
        return false;
    }

    if ( !WIN::CreateProcess( NULL, sCmdLine, NULL, NULL, FALSE,
                              CREATE_DEFAULT_ERROR_MODE, NULL, NULL,
                              &aSUI, &aPI ) )
    {
        Log( TEXT( "ERROR: Could not create process %s.\r\n" ), sCmdLine );
        SetError( WIN::GetLastError() );
        delete [] sCmdLine;
        return false;
    }

    DWORD nResult = WaitForProcess( aPI.hProcess );
    bool bRet = true;

    if( ERROR_SUCCESS != nResult )
    {
        Log( TEXT( "ERROR: While waiting for %s.\r\n" ), sCmdLine );
        SetError( nResult );
        bRet = false;
    }
    else
    {
        GetExitCodeProcess( aPI.hProcess, &nResult );
        SetError( nResult );

        if ( nResult != ERROR_SUCCESS )
        {
            TCHAR sBuf[80];
            StringCchPrintf( sBuf, 80, TEXT("Warning: install runtime returned %u.\r\n"), nResult );
            Log( sBuf );
        }
        else
            Log( TEXT( " Installation of runtime completed successfully.\r\n" ) );
    }

    CloseHandle( aPI.hProcess );

    delete [] sCmdLine;

    return bRet;
}

//--------------------------------------------------------------------------
boolean SetupAppX::InstallRuntimes()
{
    TCHAR *sRuntimePath = 0;
    SYSTEM_INFO siSysInfo;

    HMODULE hKernel32 = ::LoadLibrary(_T("Kernel32.dll"));
    if ( hKernel32 != NULL )
    {
        typedef void (CALLBACK* pfnGetNativeSystemInfo_t)(LPSYSTEM_INFO);
        pfnGetNativeSystemInfo_t pfnGetNativeSystemInfo;
        pfnGetNativeSystemInfo = (pfnGetNativeSystemInfo_t)::GetProcAddress(hKernel32, "GetNativeSystemInfo");
        if ( pfnGetNativeSystemInfo != NULL )
        {
            pfnGetNativeSystemInfo(&siSysInfo);
        }
        else
        {
            // GetNativeSystemInfo does not exist. Maybe the code is running under Windows 2000.
            // Use GetSystemInfo instead.
            GetSystemInfo(&siSysInfo);
        }
        FreeLibrary(hKernel32);
    }
    else
    {
        // Failed to check Kernel32.dll. There may be something wrong.
        // Use GetSystemInfo instead anyway.
        GetSystemInfo(&siSysInfo);
    }

    OutputDebugStringFormat( TEXT( "found architecture<%d>\r\n" ), siSysInfo.wProcessorArchitecture );

    if ( siSysInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64 )
    {
        if ( GetPathToFile( RUNTIME_X64_NAME, &sRuntimePath ) )
            InstallRuntimes( PRODUCTCODE_X64, sRuntimePath );
        else
            Log( TEXT( "ERROR: no installer for x64 runtime libraries found!" ) );

        if ( sRuntimePath )
        {
            delete [] sRuntimePath;
            sRuntimePath = 0;
        }
    }

    if ( GetPathToFile( RUNTIME_X86_NAME, &sRuntimePath ) )
        InstallRuntimes( PRODUCTCODE_X86, sRuntimePath );
    else
        Log( TEXT( "ERROR: no installer for x86 runtime libraries found!" ) );

    if ( sRuntimePath )
        delete [] sRuntimePath;

    return true;
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
LanguageDataX::LanguageDataX( LPTSTR pData )
{
    m_nLanguageID = 0;
    m_pTransform = NULL;

    LPTSTR pLastChar;

    m_nLanguageID = _tcstol( pData, &pLastChar, 10 );

    if ( *pLastChar == ',' )
    {
        pLastChar += 1;
        int nLen = lstrlen( pLastChar ) + 1;
        m_pTransform = new TCHAR [ nLen ];
        StringCchCopy( m_pTransform, nLen, pLastChar );
    }
}

//--------------------------------------------------------------------------
LanguageDataX::~LanguageDataX()
{
    if ( m_pTransform ) delete [] m_pTransform;
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
SetupApp* Create_SetupAppX()
{
    return new SetupAppX;
}

//--------------------------------------------------------------------------