在软件中控制 Windows 防火墙

在安装程序中，往往需要安装一个本地的网络服务，但是在开了 Windows 防火墙的机器上，安装了服务后即使启动了该服务，别的机器仍然无法连接，这是因为服务是在 system 账号中启动的，不会提示用户是否让该服务通过 Windows 防火墙，因此服务启动了，但是网络端口却被 Windows 防火墙屏蔽了，因此安装程序应该能够自己检测到 Windows 防火墙是否开启，如果开启应该自动将安装的服务增加到 Windows 防火墙的例外程序列表中，控制 Windows 防火墙其实很简单使用微软提供的 COM 接口就可以了，下面就是封装的类：

//==================================================================================================
//                MSI 安装函数封装类（ Microsoft Installer Wrapper Template Class ）
//
//    作者：王志科                                        版权没有，随意转载（请保留该文件头部信息）
//==================================================================================================

#pragma once

#include "msi.h"
#include "MsiDefs.h"
#include "MsiQuery.h"

#pragma comment(lib,"msi")

#ifndef CHK_EXP_RET
#define CHK_EXP_RET(exp,ret) if(exp){ return ret; }
#define CHK_EXP_RUN(exp,run) if(exp){ run; }
#endif

namespace MSI
{
    //==============================================================================================
    //
    template<bool tManage = true> class HandlerT
    {
    public:
        HandlerT(MSIHANDLE hMsi = NULL) : m_hMsi(hMsi) { }
        ~HandlerT() { if(tManage){ Close(); } }

    public:
        void Close(){ if(m_hMsi){ MsiCloseHandle(m_hMsi); m_hMsi = NULL; } }

    public:
        void Attach(MSIHANDLE hMsi){ ATLASSERT(m_hMsi != NULL); m_hMsi = hMsi; }
        MSIHANDLE Detach(){ MSIHANDLE hMsi = m_hMsi; m_hMsi = NULL; return hMsi; }

    public:
        void operator =(MSIHANDLE hMsi){ Close(); m_hMsi = hMsi; }
        MSIHANDLE* operator &() { Close(); return &m_hMsi; }
        operator MSIHANDLE() { return m_hMsi; }

    protected:
        MSIHANDLE m_hMsi;
    };

    //==============================================================================================
    //
    template<bool tManage = true> class DatabaseT : public HandlerT<tManage>
    {
    public:
        DatabaseT(MSIHANDLE hDatabase = NULL)
        {
            m_hMsi = hDatabase;
        }

        DatabaseT(LPCTSTR lpszDatabase, LPCTSTR szPersist)
        {
            Open(lpszDatabase, szPersist);
        }

    public:
        UINT Open(LPCTSTR lpszDatabase, LPCTSTR szPersist)
        {
            return MsiOpenDatabase(lpszDatabase, szPersist, &m_hMsi);
        }

        VOID Close(BOOL bCommit = FALSE)
        {
            if(bCommit) Commit();
            HandlerT::Close();
        }

        UINT Commit()
        {
            return MsiDatabaseCommit(m_hMsi);
        }

        UINT Import(LPCTSTR szFolderPath,LPCTSTR szFileName)
        {
            return MsiDatabaseImport(m_hMsi,szFolderPath,szFileName);
        }

        UINT Export(LPCTSTR szTableName,LPCTSTR szFolderPath,LPCTSTR szFileName)
        {
            return MsiDatabaseExport(m_hMsi,szTableName,szFolderPath,szFileName);
        }

        UINT Merge(MSIHANDLE hDatabase, LPCTSTR szTableName)
        {
            return MsiDatabaseMerge(m_hMsi,hDatabase,szTableName);
        }

        UINT GenerateTransform(MSIHANDLE hDatabase, LPCTSTR szTransformFile)
        {
            return MsiDatabaseGenerateTransform(m_hMsi,hDatabase,szTransformFile,0,0);
        }

        UINT ApplyTransform(LPCTSTR szTransformFile, INT iErrorConditions)
        {
            return MsiDatabaseApplyTransform(m_hMsi,szTransformFile,iErrorConditions);
        }

        MSIDBSTATE GetState()
        {
            return MsiGetDatabaseState(m_hMsi);
        }

        MSICONDITION TableExists(LPCTSTR szTableName)
        {
            return MsiDatabaseIsTablePersistent(m_hMsi,szTableName);
        }

        MSICONDITION IsTablePersistent(LPCTSTR szTableName)
        {
            return MsiDatabaseIsTablePersistent(m_hMsi,szTableName);
        }

        // RecordT
        UINT PrimaryKeys(LPCTSTR szTableName, MSIHANDLE& hRecord)
        {
            return MsiDatabaseGetPrimaryKeys(m_hMsi,szTableName,&hRecord);
        }

        // View
        UINT OpenView(LPCTSTR szQuery, MSIHANDLE* pView)
        {
            return MsiDatabaseOpenView(m_hMsi,szQuery, pView);
        }

        // View
        UINT OpenExecuteView(LPCTSTR szQuery, MSIHANDLE* pView)
        {
            UINT nCaller = OpenView(szQuery, pView);
            CHK_EXP_RET(nCaller != ERROR_SUCCESS , nCaller);
            return MsiViewExecute(*pView, NULL);
        }
    };

    //==============================================================================================
    //
    template<bool tManage = true> class RecordT : public HandlerT<tManage>
    {
    public:
        RecordT(UINT cParams = 3)
        {
            m_hMsi = MsiCreateRecord(cParams);
        }

    public:
        UINT GetFieldCount()
        {
            return MsiRecordGetFieldCount(m_hMsi);
        }

        BOOL IsNull(UINT iField)
        {
            return MsiRecordIsNull(m_hMsi,iField);
        }

        UINT SetNumber(UINT iField, INT iValue)
        {
            return MsiRecordSetInteger(m_hMsi,iField,iValue);
        }

        INT GetNumber(UINT iField)
        {
            return MsiRecordGetInteger(m_hMsi,iField);
        }

        BOOL GetString(UINT iField, CString& strValue)
        {
            DWORD dwValue = 4096;
            LPTSTR szValue = strValue.GetBuffer(dwValue);
            UINT nCaller = MsiRecordGetString(m_hMsi,iField,szValue,&dwValue);
            if(nCaller == ERROR_MORE_DATA)
            {
                dwValue += 2;
                strValue.ReleaseBuffer();
                szValue = strValue.GetBuffer(dwValue);
                nCaller = MsiRecordGetString(m_hMsi,iField,szValue,&dwValue);
            }

            strValue.ReleaseBuffer();
            return nCaller == ERROR_SUCCESS;
        }

        UINT GetString(UINT iField, LPTSTR szValue, LPDWORD dwValue)
        {
            return MsiRecordGetString(m_hMsi,iField,szValue,dwValue);
        }

        UINT SetString(UINT iField, LPCTSTR szValue)
        {
            return MsiRecordSetString(m_hMsi,iField,szValue);
        }

        UINT GetStream(UINT iField, LPSTR szBuffer,LPDWORD dwBuffer)
        {
            return MsiRecordReadStream(m_hMsi,iField,szBuffer,dwBuffer);
        }

        UINT SetStream(UINT iField, LPCTSTR szFilePath)
        {
            return MsiRecordSetStream(m_hMsi,iField,szFilePath);
        }
    };

    //==============================================================================================
    //
    template<bool tManage = true> class ViewT : public HandlerT<tManage>
    {
    public:
        ViewT(MSIHANDLE hView = NULL)
        {
            m_hMsi = hView;
        }

        ViewT(MSIHANDLE hDatabase, LPCTSTR szQuery)
        {
            Open(hDatabase, szQuery);
        }

    public:
        UINT Open(MSIHANDLE hDatabase, LPCTSTR szQuery)
        {
            return MsiDatabaseOpenView(hDatabase,szQuery,&m_hMsi);
        }

        BOOL Execute(MSIHANDLE hRecord = NULL)
        {
            return MsiViewExecute(m_hMsi, hRecord);
        }

        UINT Fetch(MSIHANDLE& hRecord)
        {
            return MsiViewFetch(m_hMsi, &hRecord);
        }

        UINT Modify(MSIMODIFY eModify, MSIHANDLE hRecord)
        {
            return MsiViewModify(m_hMsi,eModify,hRecord);
        }

        UINT GetColumnInfo(MSICOLINFO eColumnInfo,MSIHANDLE& hRecord)
        {
            return MsiViewGetColumnInfo(m_hMsi,eColumnInfo,&hRecord);
        }

        // 执行了 Execute 之后，那么在下一次执行 Execute 之前必须调用该函数
        UINT Release()
        {
            return MsiViewClose(m_hMsi);
        }
    };

    template<bool tManage = true> class SummaryInformationT : public HandlerT<tManage>
    {
    public:
        SummaryInformationT(MSIHANDLE hDatabase, LPCTSTR szDatabase = NULL, UINT uiUpdateCount = 20)
        {
            Open(hDatabase,szDatabase, uiUpdateCount);
        }

    public:
        UINT GetPropertyCount(PUINT puiPropertyCount)
        {
            return MsiSummaryInfoGetPropertyCount(m_hMsi, puiPropertyCount);
        }

        UINT GetProperty(UINT uProperty,PUINT puiDataType,PINT piValue,PFILETIME pFileTime,LPTSTR szValue,LPDWORD dwValue)
        {
            return MsiSummaryInfoGetProperty(m_hMsi,uProperty,puiDataType,piValue,pFileTime,szValue,dwValue);
        }

        UINT SetProperty(UINT uProperty,UINT uDataType,INT iValue,PFILETIME pFileTime,LPTSTR szValue)
        {
            return MsiSummaryInfoSetProperty(m_hMsi,uProperty,uDataType,iValue,pFileTime,szValue);
        }

        UINT Open(MSIHANDLE hDatabase, LPCTSTR szDatabase = NULL, UINT uiUpdateCount = 20)
        {
            return MsiGetSummaryInformation(hDatabase,szDatabase, uiUpdateCount, &m_hMsi);
        }

        UINT Commit()
        {
            return MsiSummaryInfoPersist(m_hMsi);
        }

    public:
        UINT GetPropertyInteger(UINT uProperty,PINT piValue)
        {
            UINT uiDataType = VT_I4;
            return GetProperty(uProperty,&uiDataType,piValue,NULL,NULL,0);
        }

        UINT GetPropertyFiletime(UINT uProperty,PFILETIME pFileTime)
        {
            UINT uiDataType = VT_FILETIME;
            return GetProperty(uProperty,&uiDataType,NULL,pFileTime,NULL,0);
        }

        UINT GetPropertyString(UINT uProperty,LPTSTR szValue,LPDWORD dwValue)
        {
            UINT uiDataType = VT_LPSTR;
            return GetProperty(uProperty,&uiDataType,NULL,NULL,szValue,dwValue);
        }

        UINT SetPropertyInteger(UINT uProperty,INT iValue)
        {
            return SetProperty(uProperty,VT_I4,iValue,NULL,NULL);
        }

        UINT SetPropertyString(UINT uProperty,LPWSTR szValue)
        {
            return SetProperty(uProperty, VT_LPSTR, 0, NULL, szValue);
        }

        UINT SetPropertyFiletime(UINT uProperty,PFILETIME pFileTime)
        {
            return SetProperty(uProperty,VT_FILETIME,0,pFileTime,NULL);
        }

    public:
        VOID Close(BOOL bCommit = FALSE)
        {
            if(bCommit) Commit();
            HandlerT::Close();
        }
    };

    //==============================================================================================
    //    安装控制函数
    template<typename T = CWindow > struct InstallerT
    {
    public:
        InstallerT()
        {
            MemberInitialize();
            m_nProgressBar = 0;
            m_nProcessInfo = 0;
        }

        ~InstallerT()
        {
            CancelInstaller();
        }
        
    public:
        VOID CancelInstaller()
        {
            m_bCancelInstall = FALSE;
        }

        VOID SetExternalUI(DWORD dwMsgFilter)
        {
            MsiSetExternalUI(InstallerCallback, dwMsgFilter, (LPVOID)this);
        }

        UINT SetInternalUI(INSTALLUILEVEL nInstallerLevel, HWND* pWindow = NULL)
        {
            return MsiSetInternalUI(nInstallerLevel, pWindow);
        }

        //    在命令行中可以设置动作和属性，例如下面将产品安装到 D:\LiveSystem
        //    TEXT("ACTION=INSTALL TARGETDIR=\"D:\\LiveSystem\"")
        UINT StartInstaller(LPCTSTR lpszPackage, LPCTSTR szCommandLine = NULL)
        {
            return MsiInstallProduct(lpszPackage, szCommandLine);
        }

        UINT SetControlID(UINT nProgressBar, UINT nProcessInfo = 0)
        {
            m_nProgressBar = nProgressBar;
            m_nProcessInfo = nProcessInfo;
            return ERROR_SUCCESS;
        }

        UINT SetScriptStringID(UINT nScriptStrID = 0)
        {
            m_nScriptStrID = nScriptStrID;
            return ERROR_SUCCESS;
        }

    public:
        // 采用默认参数安装指定的包
        UINT InstallPackage(LPCTSTR lpszPackage, LPCTSTR pszCommand = NULL)
        {
            // 准备参数变量
            DWORD dwUILevel = INSTALLUILEVEL_NONE|INSTALLUILEVEL_SOURCERESONLY;
            DWORD dwMessageFilter = INSTALLLOGMODE_USER | INSTALLLOGMODE_INFO
                | INSTALLLOGMODE_ACTIONDATA | INSTALLLOGMODE_OUTOFDISKSPACE
                | INSTALLLOGMODE_COMMONDATA | INSTALLLOGMODE_RESOLVESOURCE
                | INSTALLLOGMODE_INITIALIZE | INSTALLLOGMODE_ACTIONSTART
                | INSTALLLOGMODE_SHOWDIALOG | INSTALLLOGMODE_TERMINATE
                | INSTALLLOGMODE_FILESINUSE | INSTALLLOGMODE_PROGRESS
                | INSTALLLOGMODE_EXTRADEBUG | INSTALLLOGMODE_WARNING
                | INSTALLLOGMODE_FATALEXIT  | INSTALLLOGMODE_ERROR;

            MemberInitialize();
            SetExternalUI(dwMessageFilter);
            SetInternalUI((INSTALLUILEVEL)dwUILevel);
            return StartInstaller(lpszPackage, pszCommand);
        }

    public:
        // 下面的函数是消息回调
        enum InstallerProgress
        {
            PROGRESS_RESET        = 0,
            PROGRESS_ACTIONINFO    = 1,
            PROGRESS_REPORT        = 2,
            PROGRESS_ADDITION    = 3,
        };

        enum InstallerCommonData
        {
            COMMON_DATA_LANGUAGE    = 0,
            COMMON_DATA_CAPTION        = 1,
            COMMON_DATA_CANCELSHOW    = 2,
        };

        // premature termination, possibly fatal OOM
        INT OnInstallerFatalExit(UINT uFlags, LPCTSTR lpszMessage)
        {
            T* pT = static_cast<T*>(this);
            return pT->MessageBox(lpszMessage,m_strTitle, uFlags);
        }

        // formatted error message
        INT OnInstallerError(UINT uFlags, LPCTSTR lpszMessage)
        {
            T* pT = static_cast<T*>(this);
            return pT->MessageBox(lpszMessage, m_strTitle, uFlags);
        }

        // formatted warning message
        INT OnInstallerWarning(UINT uFlags, LPCTSTR lpszMessage)
        {
            T* pT = static_cast<T*>(this);
            return pT->MessageBox(lpszMessage, m_strTitle ,uFlags);
        }

        // user request message
        INT OnInstallerUser(UINT uFlags, LPCTSTR lpszMessage)
        {
            // 需要分析 uFlags 来确定返回 IDOK 或者 IDYES 或者其他值
            return (uFlags & 0x0F) == MB_YESNO ? IDYES : IDOK;
        }

        // informative message for log
        INT OnInstallerInfo(UINT uFlags, LPCTSTR lpszMessage)
        {
            return IDOK;
        }

        // list of files in use that need to be replaced
        INT OnInstallerFilesInuse(UINT uFlags, LPCTSTR lpszMessage)
        {
            // 显示文件被使用的对话框
            return ERROR_SUCCESS;
        }

        // request to determine a valid source location
        INT OnInstallerResolveSource(UINT uFlags, LPCTSTR lpszMessage)
        {
            return ERROR_SUCCESS;
        }

        // insufficient disk space message
        INT OnInstallerOutOfDiskSpace(UINT uFlags, LPCTSTR lpszMessage)
        {
            return IDOK;
        }

        // start of action: action name & description
        INT OnInstallerActionStart(UINT uFlags, LPCTSTR lpszMessage)
        {
            return IDOK;
        }

        // formatted data associated with individual action item
        INT OnInstallerActionData(UINT uFlags, LPCTSTR lpszMessage)
        {
            // 如果没有初始化进度条，直接返回
            CHK_EXP_RET( m_nProgressTotal == 0 , IDOK );

            T* pT = static_cast<T*>(this);
            pT->SetDlgItemText(m_nProcessInfo, lpszMessage);
            
            if( m_bEnableActionData && m_nProgressBar ) 
            {
                HWND hProgressBar = pT->GetDlgItem(m_nProgressBar);
                SendMessage(hProgressBar, PBM_STEPIT, 0, 0);
            }
            return IDOK;
        }

        // progress gauge info: units so far, total
        INT OnInstallerProgress(UINT uFlags, LPCTSTR lpszMessage)
        {
            T* pT = static_cast<T*>(this);
            HWND hProgressBar = pT->GetDlgItem(m_nProgressBar);

            LONG nData[4] = { 0 , 0 , 0 , 0 };
            if( ParseProgressString(lpszMessage, nData) )
            {
                if(nData[0] == PROGRESS_RESET)
                {
                    m_nProgressTotal = nData[1];
                    m_bProgressForward = (nData[2] == 0);
                    m_nProgress = m_bProgressForward ? 0 : m_nProgressTotal ;
                    // 设置进度条的工作长度
                    SendMessage(hProgressBar, PBM_SETRANGE32, 0, m_nProgressTotal);
                    // 如果在处理脚本结束进度条，否则重置
                    WPARAM nCurrentPos = m_bProgressScript ? m_nProgressTotal : m_nProgress;
                    SendMessage(hProgressBar, PBM_SETPOS, nCurrentPos , 0);
                    m_nPosition = 0;
                    // 检测新的状态
                    m_bProgressScript = (nData[3] == 1);
                    
                    if( m_bProgressScript && m_nProcessInfo && m_nScriptStrID )
                    {
                        TCHAR szScriptString[MAX_PATH] = { TEXT("") };
                        AtlLoadString(m_nScriptStrID, szScriptString, MAX_PATH);
                        pT->SetDlgItemText(m_nProcessInfo, szScriptString);
                    }
                }
                else if(nData[0] == PROGRESS_ACTIONINFO )
                {
                    if( nData[2] && m_nProgressBar )
                    {
                        WPARAM nStep =  m_bProgressForward ? nData[1] : -1 * nData[1] ;
                        SendMessage(hProgressBar, PBM_SETSTEP, nStep, 0);
                    }
                    m_bEnableActionData = nData[2] ? TRUE : FALSE ;
                }
                else if(nData[0] == PROGRESS_REPORT)
                {
                    if( m_nProgressTotal != 0 )
                    {
                        m_nPosition += nData[1];
                        WPARAM nCurrentPos = m_bProgressForward ? m_nPosition : -1 * m_nPosition;
                        SendMessage(hProgressBar, PBM_SETPOS, nCurrentPos, 0);
                    }
                }
                else if(nData[0] == PROGRESS_ADDITION)
                {

                }
            }

            return m_bCancelInstall ? IDCANCEL : IDOK ;
        }

        // product info for dialog: language Id, dialog caption
        INT OnInstallerCommonData(UINT uFlags, LPCTSTR lpszMessage)
        {
            ParseCommonDataString(lpszMessage);
            return IDOK;
        }

        // sent prior to UI initialization, no string data
        INT OnInstallerInitialize(UINT uFlags, LPCTSTR lpszMessage /* = NULL */)
        {
            return IDOK;
        }

        // sent after UI termination, no string data
        INT OnInstallerTerminate(UINT uFlags, LPCTSTR lpszMessage /* = NULL */)
        {
            return IDOK;
        }

        // sent prior to display or authored dialog or wizard
        INT OnInstallerShowDialog(UINT uFlags, LPCTSTR lpszMessage)
        {
            return IDOK;
        }

    public:
        INT OnInstallerPrepare(UINT uiMessageType, LPCTSTR lpszMessage)
        {
            if( m_bFirstTimeCall )
            {
                MsiSetInternalUI(INSTALLUILEVEL_BASIC, NULL);
                m_bFirstTimeCall = FALSE;
            }
        
            return ERROR_SUCCESS ;
        }

    public:
        // 消息回调的处理函数
        INT InstallerHandler(UINT uiMessageType, LPCTSTR lpszMessage)
        {
            T* pT = static_cast<T*>(this);

            // 首先允许进行特殊的消息处理
            INT nPrepare = pT->OnInstallerPrepare(uiMessageType, lpszMessage);
            CHK_EXP_RET( FAILED( nPrepare ) , nPrepare );

            // 根据消息类型进行分类处理
            UINT uFlags = (uiMessageType & 0x00FFFFFF);
            switch( (INSTALLMESSAGE)(0xFF000000 & uiMessageType) )
            {
                case INSTALLMESSAGE_FATALEXIT      : return pT->OnInstallerFatalExit     (uFlags, lpszMessage);
                case INSTALLMESSAGE_ERROR          : return pT->OnInstallerError         (uFlags, lpszMessage);
                case INSTALLMESSAGE_WARNING        : return pT->OnInstallerWarning       (uFlags, lpszMessage);
                case INSTALLMESSAGE_USER           : return pT->OnInstallerUser          (uFlags, lpszMessage);
                case INSTALLMESSAGE_INFO           : return pT->OnInstallerInfo          (uFlags, lpszMessage);
                case INSTALLMESSAGE_FILESINUSE     : return pT->OnInstallerFilesInuse    (uFlags, lpszMessage);
                case INSTALLMESSAGE_RESOLVESOURCE  : return pT->OnInstallerResolveSource (uFlags, lpszMessage);
                case INSTALLMESSAGE_OUTOFDISKSPACE : return pT->OnInstallerOutOfDiskSpace(uFlags, lpszMessage);
                case INSTALLMESSAGE_ACTIONSTART    : return pT->OnInstallerActionStart   (uFlags, lpszMessage);
                case INSTALLMESSAGE_ACTIONDATA     : return pT->OnInstallerActionData    (uFlags, lpszMessage);
                case INSTALLMESSAGE_PROGRESS       : return pT->OnInstallerProgress      (uFlags, lpszMessage);
                case INSTALLMESSAGE_COMMONDATA     : return pT->OnInstallerCommonData    (uFlags, lpszMessage);
                case INSTALLMESSAGE_INITIALIZE     : return pT->OnInstallerInitialize    (uFlags, lpszMessage);
                case INSTALLMESSAGE_TERMINATE      : return pT->OnInstallerTerminate     (uFlags, lpszMessage);
                case INSTALLMESSAGE_SHOWDIALOG     : return pT->OnInstallerShowDialog    (uFlags, lpszMessage);
            }

            return ERROR_SUCCESS;
        }

    protected:
        static INT CALLBACK InstallerCallback(LPVOID lpContext, UINT uiMessageType, LPCTSTR lpszMessage)
        {
            InstallerT< T >* lpInstaller = reinterpret_cast< InstallerT< T >* >(lpContext);
            return static_cast<T*>(lpInstaller)->InstallerHandler(uiMessageType,lpszMessage);
        }
    
    protected:
        void MemberInitialize()
        {
            m_bShowCancel = TRUE;
            m_wLanguage = LANG_NEUTRAL;
            m_wCodePage = GetACP();

            m_bProgressForward = TRUE;
            m_bProgressScript = FALSE;
            m_nProgressTotal = 0;
            m_nProgress = 0;
            m_nPosition = 0;

            m_bEnableActionData = FALSE;
            m_bCancelInstall = FALSE;
            m_bFirstTimeCall = TRUE;
        }

    protected:
        BOOL ParseCommonDataString(LPCTSTR lpString)
        {
            CHK_EXP_RET(lpString == NULL , FALSE );
            CHK_EXP_RET(lpString[0] == 0 , FALSE );
            
            // 分析字符串类型
            lpString = StrStr(lpString, TEXT("1:"));
            CHK_EXP_RET(lpString == NULL , FALSE);
            LONG nCommon = lpString[3] - TEXT('0');
            
            LPCTSTR lpStr2 = StrStr(lpString, TEXT("2:"));
            LPCTSTR lpStr3 = StrStr(lpString, TEXT("3:"));
    
            CHK_EXP_RET(lpStr2 == NULL , FALSE);

            if( nCommon == COMMON_DATA_CAPTION )
            {
                LPTSTR lpTail = (LPTSTR)lpStr3;
                if(lpTail != NULL){ *lpTail = 0; }
                m_strTitle = lpString + 2; //Skip "2:"
            }
            else if( nCommon == COMMON_DATA_LANGUAGE )
            {
                m_wLanguage = StrToLong(lpStr2 + 3);

                CHK_EXP_RET(lpStr3 == NULL , FALSE);
                m_wCodePage = StrToLong(lpStr3 + 3);
            }
            else if( nCommon == COMMON_DATA_CANCELSHOW )
            {
                LONG nShow = StrToLong(lpStr2 + 3);
                m_bShowCancel = nShow ? TRUE : FALSE;
            }

            return TRUE;
        }

        BOOL ParseProgressString(LPCTSTR lpString, LONG nData[4])
        {
            ZeroMemory( nData, sizeof(LONG) * 4 );

            CHK_EXP_RET(lpString == NULL , FALSE );
            CHK_EXP_RET(lpString[0] == 0 , FALSE );
            
            // 分析字符串类型
            lpString = StrStr(lpString, TEXT("1:"));
            CHK_EXP_RET(lpString == NULL , FALSE);
            nData[0] = lpString[3] - TEXT('0');

            // 第一个参数
            lpString = StrStr(lpString, TEXT("2:"));
            CHK_EXP_RET(lpString == NULL , TRUE);
            nData[1] = StrToLong(lpString + 3);

            // 第二个参数
            lpString = StrStr(lpString, TEXT("3:"));
            CHK_EXP_RET(lpString == NULL , TRUE);
            nData[2] = StrToLong(lpString + 3);

            // 第三个参数
            lpString = StrStr(lpString, TEXT("4:"));
            CHK_EXP_RET(lpString == NULL , TRUE);
            nData[3] = StrToLong(lpString + 3);

            return TRUE;
        }
        
    protected:
        // 下面是 CommonData 分析出的数据
        CString m_strTitle;            // 一般是安装的产品标题
        BOOL m_bShowCancel;            //    是否要显示“取消”按钮
        WORD m_wLanguage;            //    当前的语言 
        WORD m_wCodePage;            //    当前的代码页

        // 下面是 ProgressInfo 分析出的数据
        BOOL m_bProgressForward;    //    TRUE 表示当前处理进度条是增加的方式
        BOOL m_bProgressScript;        //    TRUE 表示在处理脚本，可以显示“请稍后”
        LONG m_nProgressTotal;        //    进度条总数
        LONG m_nProgress;            //    进度数
        LONG m_nPosition;            //    当前位置

        // 其他控制数据
        BOOL m_bEnableActionData;    //    TRUE 表示 INSTALLOGMODE_ACTIONDATA 消息发送进度信息
        BOOL m_bCancelInstall;        //    如果要取消安装将该值设置为 TRUE 
        BOOL m_bFirstTimeCall;        //    是否第一次调用外部界面接口

        // 窗口显示信息控件的ID
        UINT m_nProgressBar;        //    进度条控件
        UINT m_nProcessInfo;        //    显示处理信息的控件
        UINT m_nScriptStrID;        //    处理脚本，请稍后
    };

    //==============================================================================================
    //    全局的静态函数
    inline UINT GetFileHash(LPCTSTR lpszFileName, DWORD dwOptions, MSIFILEHASHINFO& rMsiFileHashInfo)
    {
        rMsiFileHashInfo.dwFileHashInfoSize = sizeof(MSIFILEHASHINFO);
        return MsiGetFileHash(lpszFileName, dwOptions, &rMsiFileHashInfo);
    }

    inline UINT GetLastError(CString& strErrorDescription)
    {
        strErrorDescription = TEXT("");
        MSIHANDLE hLastErrorRecord = MsiGetLastErrorRecord();
        CHK_EXP_RET(hLastErrorRecord == NULL , NO_ERROR);
        
        DWORD dwErrorLength = 4096;
        HandlerT<> hRecord(hLastErrorRecord);
        UINT nCaller = MsiFormatRecord(NULL,hRecord,NULL,&dwErrorLength);
        if(nCaller == ERROR_MORE_DATA)
        {
            dwErrorLength ++;
            LPTSTR lpszError = new TCHAR[dwErrorLength];
            nCaller = MsiFormatRecord(NULL,hRecord,lpszError,&dwErrorLength);
            if(nCaller == ERROR_SUCCESS) strErrorDescription = lpszError;
            delete [] lpszError;
        }
        return nCaller;
    }

    inline UINT GetFileVersion(LPCTSTR szFilePath, CString& strVersion, CString& strLanguage)
    {
        DWORD dwVersion = 32, dwLang = 32;
        LPTSTR lpszLang = strLanguage.GetBuffer(dwLang);
        LPTSTR lpszVersion = strVersion.GetBuffer(dwVersion);
        UINT nCaller = MsiGetFileVersion(szFilePath,lpszVersion, &dwVersion, lpszLang, &dwLang);
        if(nCaller == ERROR_MORE_DATA)
        {
            // 增加内存空间
            dwLang += 2; dwVersion += 2;
            strVersion.ReleaseBuffer(); lpszVersion = strVersion.GetBuffer(dwVersion);
            strLanguage.ReleaseBuffer(); lpszLang = strLanguage.GetBuffer(dwLang);
            nCaller = MsiGetFileVersion(szFilePath,lpszVersion, &dwVersion, lpszLang, &dwLang);
        }
        else if(nCaller == ERROR_FILE_INVALID)
        {
            // 文件没有版本信息
            nCaller = NO_ERROR;
        }

        strLanguage.ReleaseBuffer();
        strVersion.ReleaseBuffer();
        return nCaller;
    }
}