ctfmon.cpp File Reference

#include "precomp.h"
#include "CRegWatcher.h"
#include "CLoaderWnd.h"

Include dependency graph for ctfmon.cpp:

Go to the source code of this file.

Typedefs
typedef BOOL(WINAPI *	FN_SetProcessShutdownParameters) (DWORD, DWORD)
typedef UINT(WINAPI *	FN_GetSystemWow64DirectoryA) (LPSTR, UINT)
typedef UINT(WINAPI *	FN_GetSystemWow64DirectoryW) (LPWSTR, UINT)

Functions
static VOID	ParseCommandLine (_In_ LPCTSTR pszCmdLine)
static VOID	WriteRegRun (VOID)
static HRESULT	GetGlobalCompartment (_In_ REFGUID guid, _Inout_ ITfCompartment **ppComp)
static HRESULT	SetGlobalCompartmentDWORD (_In_ REFGUID guid, _In_ DWORD dwValue)
static BOOL	CheckX64System (_In_ LPTSTR lpCmdLine)
static BOOL	InitApp (_In_ HINSTANCE hInstance, _In_ LPTSTR lpCmdLine)
VOID	UninitApp (VOID)
static INT	DoMainLoop (VOID)
EXTERN_C INT WINAPI	_tWinMain (HINSTANCE hInstance, HINSTANCE hPrevInst, LPTSTR lpCmdLine, INT nCmdShow)

Variables
FN_SetProcessShutdownParameters	g_fnSetProcessShutdownParameters = NULL
FN_GetSystemWow64DirectoryA	g_fnGetSystemWow64DirectoryA = NULL
FN_GetSystemWow64DirectoryW	g_fnGetSystemWow64DirectoryW = NULL
HINSTANCE	g_hInst = NULL
HINSTANCE	g_hKernel32 = NULL
UINT	g_uACP = CP_ACP
BOOL	g_fWinLogon = FALSE
HANDLE	g_hCicMutex = NULL
BOOL	g_bOnWow64 = FALSE
BOOL	g_fNoRunKey = FALSE
BOOL	g_fJustRunKey = FALSE
DWORD	g_dwOsInfo = 0
CLoaderWnd *	g_pLoaderWnd = NULL

Typedef Documentation

FN_GetSystemWow64DirectoryA

typedef UINT(WINAPI * FN_GetSystemWow64DirectoryA) (LPSTR, UINT)

Definition at line 17 of file ctfmon.cpp.

FN_GetSystemWow64DirectoryW

typedef UINT(WINAPI * FN_GetSystemWow64DirectoryW) (LPWSTR, UINT)

Definition at line 20 of file ctfmon.cpp.

FN_SetProcessShutdownParameters

typedef BOOL(WINAPI * FN_SetProcessShutdownParameters) (DWORD, DWORD)

Definition at line 13 of file ctfmon.cpp.

Function Documentation

_tWinMain()

EXTERN_C INT WINAPI _tWinMain	(	HINSTANCE	hInstance,
		HINSTANCE	hPrevInst,
		LPTSTR	lpCmdLine,
		INT	nCmdShow
	)

Definition at line 324 of file ctfmon.cpp.

{
    UNREFERENCED_PARAMETER(hPrevInst);
    UNREFERENCED_PARAMETER(nCmdShow);
 
    // Parse command line
    ParseCommandLine(lpCmdLine);
 
    if (g_fJustRunKey) // If "/R" option is specified
    {
        // Just write registry and exit
        WriteRegRun();
        return 1;
    }
 
    // Initialize the application
    if (!InitApp(hInstance, lpCmdLine))
        return 0;
 
    // The main loop
    INT ret = DoMainLoop();
 
    // Clean up the loader
    if (g_pLoaderWnd)
    {
        delete g_pLoaderWnd;
        g_pLoaderWnd = NULL;
    }
 
    // Un-initialize app and text framework
    if (!CLoaderWnd::s_bUninitedSystem)
    {
        UninitApp();
        TF_UninitSystem();
    }
 
    return ret;
}

CheckX64System()

static BOOL CheckX64System ( _In_ LPTSTR  lpCmdLine )

static

Definition at line 139 of file ctfmon.cpp.

{
    // Is the system x64?
    SYSTEM_INFO SystemInfo;
    ::GetSystemInfo(&SystemInfo);
    if (SystemInfo.wProcessorArchitecture != PROCESSOR_ARCHITECTURE_IA64 ||
        SystemInfo.wProcessorArchitecture != PROCESSOR_ARCHITECTURE_AMD64)
    {
        return FALSE;
    }
 
    // Get GetSystemWow64DirectoryW function
    g_hKernel32 = cicGetSystemModuleHandle(TEXT("kernel32.dll"), FALSE);
#ifdef UNICODE
    g_fnGetSystemWow64DirectoryW =
        (FN_GetSystemWow64DirectoryW)::GetProcAddress(g_hKernel32, "GetSystemWow64DirectoryW");
    if (!g_fnGetSystemWow64DirectoryW)
        return FALSE;
#else
    g_fnGetSystemWow64DirectoryA =
        (FN_GetSystemWow64DirectoryA)::GetProcAddress(g_hKernel32, "GetSystemWow64DirectoryA");
    if (!g_fnGetSystemWow64DirectoryA)
        return FALSE;
#endif
 
    // Build WoW64 ctfmon.exe pathname
    TCHAR szPath[MAX_PATH];
#ifdef UNICODE
    UINT cchPath = g_fnGetSystemWow64DirectoryW(szPath, _countof(szPath));
#else
    UINT cchPath = g_fnGetSystemWow64DirectoryA(szPath, _countof(szPath));
#endif
    if (!cchPath && FAILED(StringCchCat(szPath, _countof(szPath), TEXT("\\ctfmon.exe"))))
        return FALSE;
 
    // Create a WoW64 ctfmon.exe process
    PROCESS_INFORMATION pi;
    STARTUPINFO si = { sizeof(si) };
    si.wShowWindow = SW_SHOWMINNOACTIVE;
    if (!::CreateProcess(szPath, lpCmdLine, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
        return FALSE;
 
    ::CloseHandle(pi.hThread);
    ::CloseHandle(pi.hProcess);
    return TRUE;
}

Referenced by InitApp().

DoMainLoop()

static INT DoMainLoop ( VOID  )

static

Definition at line 261 of file ctfmon.cpp.

{
    MSG msg;
 
    if (g_bOnWow64) // Is the current process on WoW64?
    {
        // Just a simple message loop
        while (::GetMessage(&msg, NULL, 0, 0))
        {
            ::TranslateMessage(&msg);
            ::DispatchMessage(&msg);
        }
        return (INT)msg.wParam;
    }
 
    // Open the existing event by the name
    HANDLE hSwitchEvent = ::OpenEvent(SYNCHRONIZE, FALSE, TEXT("WinSta0_DesktopSwitch"));
 
    // The target events to watch
    HANDLE ahEvents[WATCHENTRY_MAX + 1];
 
    // Borrow some handles from CRegWatcher
    CopyMemory(ahEvents, CRegWatcher::s_ahWatchEvents, WATCHENTRY_MAX * sizeof(HANDLE));
 
    ahEvents[WI_DESKTOP_SWITCH] = hSwitchEvent; // Add it
 
    // Another message loop
    for (;;)
    {
        // Wait for target signal
        DWORD dwWait = ::MsgWaitForMultipleObjects(_countof(ahEvents), ahEvents, 0, INFINITE,
                                                   QS_ALLINPUT);
        if (dwWait == (WAIT_OBJECT_0 + _countof(ahEvents))) // Is input available?
        {
            // Do the events
            while (::PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
            {
                if (msg.message == WM_QUIT)
                    goto Quit;
 
                ::TranslateMessage(&msg);
                ::DispatchMessage(&msg);
            }
        }
        else if (dwWait == (WAIT_OBJECT_0 + WI_DESKTOP_SWITCH)) // Desktop switch?
        {
            SetGlobalCompartmentDWORD(GUID_COMPARTMENT_SPEECH_OPENCLOSE, 0);
            ::ResetEvent(hSwitchEvent);
        }
        else // Do the other events
        {
            CRegWatcher::OnEvent(dwWait - WAIT_OBJECT_0);
        }
    }
 
Quit:
    ::CloseHandle(hSwitchEvent);
 
    return (INT)msg.wParam;
}

Referenced by _tWinMain().

GetGlobalCompartment()

static HRESULT GetGlobalCompartment ( _In_ REFGUID  guid, _Inout_ ITfCompartment **  ppComp  )

static

Definition at line 98 of file ctfmon.cpp.

{
    *ppComp = NULL;
 
    ITfCompartmentMgr *pCompMgr = NULL;
    HRESULT hr = TF_GetGlobalCompartment(&pCompMgr);
    if (FAILED(hr))
        return hr;
 
    if (!pCompMgr)
        return E_FAIL;
 
    hr = pCompMgr->GetCompartment(guid, ppComp);
    pCompMgr->Release();
    return hr;
}

Referenced by SetGlobalCompartmentDWORD().

InitApp()

static BOOL InitApp ( _In_ HINSTANCE  hInstance, _In_ LPTSTR  lpCmdLine  )

static

Definition at line 188 of file ctfmon.cpp.

{
    g_hInst     = hInstance;    // Save the instance handle
 
    g_bOnWow64  = cicIsWow64();   // Is the current process on WoW64?
    cicGetOSInfo(&g_uACP, &g_dwOsInfo); // Get OS info
 
    // Create a mutex for Cicero
    g_hCicMutex = TF_CreateCicLoadMutex(&g_fWinLogon);
    if (!g_hCicMutex)
        return FALSE;
 
    // Write to "Run" registry key for starting up
    WriteRegRun();
 
    // Call SetProcessShutdownParameters if possible
    if (g_dwOsInfo & CIC_OSINFO_NT)
    {
        g_hKernel32 = cicGetSystemModuleHandle(TEXT("kernel32.dll"), FALSE);
        g_fnSetProcessShutdownParameters =
            (FN_SetProcessShutdownParameters)
                ::GetProcAddress(g_hKernel32, "SetProcessShutdownParameters");
        if (g_fnSetProcessShutdownParameters)
            g_fnSetProcessShutdownParameters(0xF0, SHUTDOWN_NORETRY);
    }
 
    // Start text framework
    TF_InitSystem();
 
    // Start watching registry if x86/x64 native
    if (!g_bOnWow64)
        CRegWatcher::Init();
 
    // Create Tipbar loader window
    g_pLoaderWnd = new(cicNoThrow) CLoaderWnd();
    if (!g_pLoaderWnd || !g_pLoaderWnd->Init())
        return FALSE;
 
    if (g_pLoaderWnd->CreateWnd())
    {
        // Go to the bottom of the hell
        ::SetWindowPos(g_pLoaderWnd->m_hWnd, HWND_BOTTOM, 0, 0, 0, 0,
                       SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
    }
 
    // Display Tipbar Popup if x86/x64 native and necessary
    if (!g_bOnWow64)
        GetPopupTipbar(g_pLoaderWnd->m_hWnd, g_fWinLogon);
 
    // Do x64 stuffs
    CheckX64System(lpCmdLine);
 
    return TRUE;
}

Referenced by _tWinMain().

ParseCommandLine()

static VOID ParseCommandLine ( _In_ LPCTSTR  pszCmdLine )

static

Definition at line 35 of file ctfmon.cpp.

{
    g_fNoRunKey = g_fJustRunKey = FALSE;
 
    for (LPCTSTR pch = pszCmdLine; *pch; ++pch)
    {
        // Skip space
        while (*pch == TEXT(' '))
            ++pch;
 
        if (*pch == TEXT('\0'))
            return;
 
        if ((*pch == TEXT('-')) || (*pch == TEXT('/')))
        {
            ++pch;
            switch (*pch)
            {
                case TEXT('N'): case TEXT('n'): // Found "/N" option
                    g_fNoRunKey = TRUE;
                    break;
 
                case TEXT('R'): case TEXT('r'): // Found "/R" option
                    g_fJustRunKey = TRUE;
                    break;
 
                case UNICODE_NULL:
                    return;
 
                default:
                    break;
            }
        }
    }
}

Referenced by _tWinMain().

SetGlobalCompartmentDWORD()

static HRESULT SetGlobalCompartmentDWORD ( _In_ REFGUID  guid, _In_ DWORD  dwValue  )

static

Definition at line 118 of file ctfmon.cpp.

{
    HRESULT hr;
    VARIANT vari;
    ITfCompartment *pComp;
 
    hr = GetGlobalCompartment(guid, &pComp);
    if (FAILED(hr))
        return hr;
 
    V_VT(&vari) = VT_I4;
    V_I4(&vari) = dwValue;
    hr = pComp->SetValue(0, &vari);
 
    pComp->Release();
    return hr;
}

Referenced by DoMainLoop().

UninitApp()

VOID UninitApp

(

VOID

)

Definition at line 246 of file ctfmon.cpp.

{
    // Close Tipbar Popup
    ClosePopupTipbar();
 
    // Close the mutex
    ::CloseHandle(g_hCicMutex);
    g_hCicMutex = NULL;
 
    // Quit watching registry if x86/x64 native
    if (!g_bOnWow64)
        CRegWatcher::Uninit();
}

Referenced by _tWinMain(), and CLoaderWnd::WindowProc().

WriteRegRun()

static VOID WriteRegRun ( VOID  )

static

Definition at line 73 of file ctfmon.cpp.

{
    if (g_fNoRunKey) // If "/N" option is specified
        return; // Don't write
 
    // Open "Run" key
    HKEY hKey;
    LSTATUS error = ::RegCreateKey(HKEY_CURRENT_USER,
                                   TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Run"),
                                   &hKey);
    if (error != ERROR_SUCCESS)
        return;
 
    // Write the module path
    CicSystemModulePath ModPath;
    if (ModPath.Init(TEXT("ctfmon.exe"), FALSE))
    {
        DWORD cbData = (ModPath.m_cchPath + 1) * sizeof(TCHAR);
        ::RegSetValueEx(hKey, TEXT("ctfmon.exe"), 0, REG_SZ, (BYTE*)ModPath.m_szPath, cbData);
    }
 
    ::RegCloseKey(hKey);
}

Referenced by _tWinMain(), and InitApp().

Variable Documentation

g_bOnWow64

BOOL g_bOnWow64 = FALSE

Definition at line 28 of file ctfmon.cpp.

Referenced by DoMainLoop(), InitApp(), UninitApp(), and CLoaderWnd::WindowProc().

g_dwOsInfo

DWORD g_dwOsInfo = 0

Definition at line 31 of file ctfmon.cpp.

Referenced by CRegWatcher::Init(), InitApp(), and CLoaderWnd::WindowProc().

g_fJustRunKey

BOOL g_fJustRunKey = FALSE

Definition at line 30 of file ctfmon.cpp.

Referenced by _tWinMain(), and ParseCommandLine().

g_fnGetSystemWow64DirectoryA

FN_GetSystemWow64DirectoryA g_fnGetSystemWow64DirectoryA = NULL

Definition at line 18 of file ctfmon.cpp.

Referenced by CheckX64System().

g_fnGetSystemWow64DirectoryW

FN_GetSystemWow64DirectoryW g_fnGetSystemWow64DirectoryW = NULL

Definition at line 21 of file ctfmon.cpp.

Referenced by CheckX64System().

g_fNoRunKey

BOOL g_fNoRunKey = FALSE

Definition at line 29 of file ctfmon.cpp.

Referenced by ParseCommandLine(), and WriteRegRun().

g_fnSetProcessShutdownParameters

FN_SetProcessShutdownParameters g_fnSetProcessShutdownParameters = NULL

Definition at line 14 of file ctfmon.cpp.

Referenced by InitApp().

g_fWinLogon

BOOL g_fWinLogon = FALSE

Definition at line 26 of file ctfmon.cpp.

Referenced by InitApp(), and CLoaderWnd::WindowProc().

g_hCicMutex

HANDLE g_hCicMutex = NULL

Definition at line 27 of file ctfmon.cpp.

Referenced by InitApp(), and UninitApp().

g_hInst

HINSTANCE g_hInst = NULL

Definition at line 23 of file ctfmon.cpp.

Referenced by InitApp().

g_hKernel32

HINSTANCE g_hKernel32 = NULL

Definition at line 24 of file ctfmon.cpp.

Referenced by CheckX64System(), and InitApp().

g_pLoaderWnd

CLoaderWnd* g_pLoaderWnd = NULL

Definition at line 32 of file ctfmon.cpp.

Referenced by _tWinMain(), and InitApp().

g_uACP

UINT g_uACP = CP_ACP

Definition at line 25 of file ctfmon.cpp.

Referenced by InitApp().