trunk/PTD/PTD.cpp

/* PTD.cpp - Privacy Tray Dynamic
 *      Copyright (C) 2002-2009, 2012 Timo Schulz
 *
 * This file is part of WinPT.
 *
 * WinPT is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * WinPT is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <windows.h>
#include <stdio.h>

/* Reference to the DLL module handle */
HINSTANCE glob_hinst;

/* We need a special section in the DLL for storing our shared data.
   This shared data is required by the hook function because that
   function is called in the context of the actual thread running the
   hook and thus we need a way to communicate the result of our hook
   function back to us.  We use a shared data segment for this. */
#ifdef __GNUC__
#define ATTR_SEC __attribute__((section (".SHARDAT"), shared))
#else
#define ATTR_SEC
#pragma data_seg(".SHARDAT")
#endif
static HHOOK cbt_hook      ATTR_SEC = NULL; /* CTB hook handle. */
static DWORD tray_proc_id  ATTR_SEC = 0;    /* WinPT PID */
static HWND  shell_traywnd ATTR_SEC = 0;    /* Tray window handle. */
static HWND  curr_focus    ATTR_SEC = NULL; /* Current window focus handle. */
static HWND  rebar_w32     ATTR_SEC = NULL;
static HWND  mstask_swc    ATTR_SEC = NULL;
static HWND  systab_c32    ATTR_SEC = NULL;
#ifndef __GNUC__
#pragma data_seg()
#endif
#undef ATTR_SEC

/* Static variables that are used to record and replay key strokes */
static unsigned *journ_keys = 0;
static unsigned keyidx = 0;
static unsigned nkeys = 0;
static HHOOK journ_hook = NULL;  /* Journaling hook  handle. */


/* Callback function for the Computer Based Training (CBT) hook */
static LRESULT CALLBACK
PTD_CBT_proc (int code, WPARAM wparam, LPARAM lparam)
{
    HWND curr_hwnd;
    DWORD proc_id;
    
    if (code >= 0 && code == HCBT_SETFOCUS) {
        /* A window is about to receive the keyboard focus */           
        
        proc_id = 0;
        curr_hwnd = (HWND)wparam;
        GetWindowThreadProcessId (curr_hwnd, &proc_id);
        /* Only if the current window is different from this window list,
           we set the new focus. For more information read the hint in 
           PTD_initialize. */
        if ((proc_id != tray_proc_id) &&
            (curr_hwnd != NULL) &&
            (curr_hwnd != curr_focus) &&
            (curr_hwnd != shell_traywnd) &&
            (curr_hwnd != systab_c32) &&
            (curr_hwnd != mstask_swc) &&
            (curr_hwnd != rebar_w32)) {
            curr_focus = curr_hwnd;
        }
    }
    
    return  CallNextHookEx (cbt_hook , code, wparam, lparam);
}


/* Return the last selected window */
extern "C" HWND
PTD_get_current_window (void)
{
    return curr_focus;
}


/* Initialize CTB hook and try to find the system windows. */
extern "C" BOOL
PTD_initialize (void)
{
    tray_proc_id = GetCurrentProcessId ();
    cbt_hook = SetWindowsHookEx (WH_CBT, PTD_CBT_proc, glob_hinst, 0);
    if (cbt_hook == NULL)
        return FALSE;
    
    /* Okay, what are we doing here:
     * In the past I used the Spy++ application to find out why the old current 
     * window doesn't work on so much systems. Now we try to use the computer 
     * based training hook, more precisely the HCBT_SETFOCUS to find out the 
     * last window focus. But to succeed we need to ignore some windows 
     * because otherwise our own window or a window from the taskbar
     * would be recognized.
     *
     * Here is what the Spy++ says about the windows order:
     * Shell_TrayWnd
     *  \ ReBarWindow32
     *                \ MSTaskSwWClass
     *                               \ SysTabControl32
     * 
     * As a result we need to ignore those windows to prevent failured 
     * in the code.
     */
    
    // FIXME: I doubt this is working for Windows 7
    shell_traywnd = FindWindowEx (NULL, NULL, "Shell_TrayWnd", NULL);
    rebar_w32 = FindWindowEx (shell_traywnd, NULL, "ReBarWindow32", NULL);
    mstask_swc = FindWindowEx (rebar_w32, NULL, "MSTaskSwWClass", NULL);
    systab_c32 = FindWindowEx (mstask_swc, NULL, "SysTabControl32", NULL);
        
    return TRUE;
}


/* Remove the CTB hook from the system and reset all variables. */
extern "C" void
PTD_delete_hook (void)
{
    if (!cbt_hook)
        return;
    UnhookWindowsHookEx (cbt_hook);
    cbt_hook = NULL;
    shell_traywnd = NULL;
    tray_proc_id = 0;
}


/* Return if the CTB hook is currently used. */
extern "C" int
PTD_is_hook_used (void)
{
    return shell_traywnd && cbt_hook;
}

/* From the MSDN:
 * "Typically, an application uses this function to play back a series
 * of mouse and keyboard messages recorded previously by the
 * JournalRecordProc hook procedure. As long as a JournalPlaybackProc
 * hook procedure is installed, regular mouse and keyboard input is disabled."
 */
static LRESULT CALLBACK 
PTD_playback_proc (int code, WPARAM wparam, LPARAM lparam)
{
    LPEVENTMSG em;
    
    if (code == HC_SKIP) {
        keyidx++;
        if (keyidx >= nkeys) {
            UnhookWindowsHookEx (journ_hook);
            journ_hook = NULL;
        }
        return 0;
    }
    else if (code == HC_GETNEXT) {
        /* Here is an overview what the event message struct can contain:
         * message - WM_KEYUP, WM_KEYDOWN, WM_SYSKEYUP, WM_SYSKEYDOWN:
         * paramL - specifies the virtual key code of the key that was pressed.
         * paramH - specifies the scan code.                            
         */
        em = (LPEVENTMSG )lparam;
        if (journ_keys[keyidx] & 0x8000)
            em->message = journ_keys[keyidx] & 0x4000 ? WM_SYSKEYDOWN : WM_KEYDOWN;
        else 
            em->message = journ_keys[keyidx] & 0x4000 ? WM_SYSKEYUP : WM_KEYUP;
        em->paramL = LOBYTE (journ_keys[keyidx])
            | (MapVirtualKey (LOBYTE (journ_keys[keyidx]), 0) << 8);
        em->paramH = 1;
        em->time = GetTickCount ();
        return 0;
    }
    
    return CallNextHookEx (journ_hook, code, wparam, lparam);
}


extern "C" BOOL
PTD_keyboard_send_keys (UINT *keys, UINT n_keys)
{
    MSG msg;
    journ_keys = keys;
    keyidx = 0;
    nkeys = n_keys;
    
    /* Return immediately if there is an active hook */
    if (journ_hook)
        return FALSE;
    
    while (GetAsyncKeyState (VK_MENU) & 0x8000 ||
           GetAsyncKeyState (VK_SHIFT) & 0x8000 ||
           GetAsyncKeyState (VK_CONTROL) & 0x8000) {
        if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) {
            if (msg.message == WM_QUIT) {
                PostMessage (msg.hwnd, msg.message, msg.wParam, msg.lParam);
                return FALSE;
            }
            TranslateMessage (&msg);
            DispatchMessage (&msg);
        }
    }
    journ_hook = SetWindowsHookEx (WH_JOURNALPLAYBACK,
                                   (HOOKPROC)PTD_playback_proc,
                                   glob_hinst, 0);
    if (journ_hook == NULL)
        return FALSE;
    
    while (journ_hook) {
        if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) {
            if (msg.message == WM_QUIT) {
                if (journ_hook)
                    UnhookWindowsHookEx (journ_hook);
                PostMessage (msg.hwnd, msg.message, msg.wParam, msg.wParam);
            }
            TranslateMessage (&msg);
            DispatchMessage (&msg);
        }
    }
    
    return TRUE;
}


/* Main entry point for the DLL */
extern "C" BOOL WINAPI 
DllMain (HINSTANCE hinst, DWORD reason, LPVOID reserv)
{
    switch (reason)  {
    case DLL_PROCESS_ATTACH:
        glob_hinst = hinst;
        break;
       
    case DLL_PROCESS_DETACH:
        break;
        
    case DLL_THREAD_ATTACH:  
    case DLL_THREAD_DETACH:  
        break;
        
    }
    
    return TRUE;
}
1	werner	46	/* PTD.cpp - Privacy Tray Dynamic
2	twoaday	412	* Copyright (C) 2002-2009, 2012 Timo Schulz
3	werner	46	*
4			* This file is part of WinPT.
5			*
6			* WinPT is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* WinPT is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*/
16			#ifdef HAVE_CONFIG_H
17			#include <config.h>
18			#endif
19
20			#include <windows.h>
21			#include <stdio.h>
22
23	twoaday	412	/* Reference to the DLL module handle */
24	werner	46	HINSTANCE glob_hinst;
25
26	werner	61	/* We need a special section in the DLL for storing our shared data.
27	twoaday	261	This shared data is required by the hook function because that
28	werner	61	function is called in the context of the actual thread running the
29			hook and thus we need a way to communicate the result of our hook
30			function back to us. We use a shared data segment for this. */
31			#ifdef __GNUC__
32			#define ATTR_SEC __attribute__((section (".SHARDAT"), shared))
33			#else
34			#define ATTR_SEC
35	werner	46	#pragma data_seg(".SHARDAT")
36	werner	61	#endif
37			static HHOOK cbt_hook ATTR_SEC = NULL; /* CTB hook handle. */
38			static DWORD tray_proc_id ATTR_SEC = 0; /* WinPT PID */
39			static HWND shell_traywnd ATTR_SEC = 0; /* Tray window handle. */
40			static HWND curr_focus ATTR_SEC = NULL; /* Current window focus handle. */
41			static HWND rebar_w32 ATTR_SEC = NULL;
42			static HWND mstask_swc ATTR_SEC = NULL;
43			static HWND systab_c32 ATTR_SEC = NULL;
44			#ifndef __GNUC__
45	werner	46	#pragma data_seg()
46	werner	61	#endif
47			#undef ATTR_SEC
48	werner	46
49	twoaday	412	/* Static variables that are used to record and replay key strokes */
50	werner	46	static unsigned *journ_keys = 0;
51	twoaday	305	static unsigned keyidx = 0;
52	werner	46	static unsigned nkeys = 0;
53	twoaday	273	static HHOOK journ_hook = NULL; /* Journaling hook handle. */
54	werner	46
55
56	twoaday	412	/* Callback function for the Computer Based Training (CBT) hook */
57	werner	46	static LRESULT CALLBACK
58			PTD_CBT_proc (int code, WPARAM wparam, LPARAM lparam)
59			{
60	twoaday	412	HWND curr_hwnd;
61			DWORD proc_id;
62	werner	46
63			if (code >= 0 && code == HCBT_SETFOCUS) {
64			/* A window is about to receive the keyboard focus */
65
66	twoaday	412	proc_id = 0;
67	werner	46	curr_hwnd = (HWND)wparam;
68	twoaday	273	GetWindowThreadProcessId (curr_hwnd, &proc_id);
69	werner	46	/* Only if the current window is different from this window list,
70			we set the new focus. For more information read the hint in
71			PTD_initialize. */
72	twoaday	412	if ((proc_id != tray_proc_id) &&
73			(curr_hwnd != NULL) &&
74			(curr_hwnd != curr_focus) &&
75			(curr_hwnd != shell_traywnd) &&
76			(curr_hwnd != systab_c32) &&
77			(curr_hwnd != mstask_swc) &&
78			(curr_hwnd != rebar_w32)) {
79	werner	46	curr_focus = curr_hwnd;
80			}
81			}
82
83			return CallNextHookEx (cbt_hook , code, wparam, lparam);
84			}
85
86
87			/* Return the last selected window */
88			extern "C" HWND
89	twoaday	334	PTD_get_current_window (void)
90	werner	46	{
91			return curr_focus;
92			}
93
94
95			/* Initialize CTB hook and try to find the system windows. */
96			extern "C" BOOL
97			PTD_initialize (void)
98			{
99			tray_proc_id = GetCurrentProcessId ();
100			cbt_hook = SetWindowsHookEx (WH_CBT, PTD_CBT_proc, glob_hinst, 0);
101			if (cbt_hook == NULL)
102			return FALSE;
103
104			/* Okay, what are we doing here:
105			* In the past I used the Spy++ application to find out why the old current
106			* window doesn't work on so much systems. Now we try to use the computer
107	twoaday	412	* based training hook, more precisely the HCBT_SETFOCUS to find out the
108	werner	46	* last window focus. But to succeed we need to ignore some windows
109			* because otherwise our own window or a window from the taskbar
110			* would be recognized.
111			*
112			* Here is what the Spy++ says about the windows order:
113			* Shell_TrayWnd
114			* \ ReBarWindow32
115			* \ MSTaskSwWClass
116			* \ SysTabControl32
117			*
118			* As a result we need to ignore those windows to prevent failured
119			* in the code.
120			*/
121	twoaday	334
122			// FIXME: I doubt this is working for Windows 7
123	werner	46	shell_traywnd = FindWindowEx (NULL, NULL, "Shell_TrayWnd", NULL);
124			rebar_w32 = FindWindowEx (shell_traywnd, NULL, "ReBarWindow32", NULL);
125			mstask_swc = FindWindowEx (rebar_w32, NULL, "MSTaskSwWClass", NULL);
126			systab_c32 = FindWindowEx (mstask_swc, NULL, "SysTabControl32", NULL);
127	twoaday	413
128	werner	46	return TRUE;
129			}
130
131
132			/* Remove the CTB hook from the system and reset all variables. */
133			extern "C" void
134	twoaday	334	PTD_delete_hook (void)
135	werner	46	{
136			if (!cbt_hook)
137			return;
138			UnhookWindowsHookEx (cbt_hook);
139			cbt_hook = NULL;
140			shell_traywnd = NULL;
141			tray_proc_id = 0;
142			}
143
144
145			/* Return if the CTB hook is currently used. */
146			extern "C" int
147	twoaday	334	PTD_is_hook_used (void)
148	werner	46	{
149			return shell_traywnd && cbt_hook;
150			}
151
152	twoaday	334	/* From the MSDN:
153			* "Typically, an application uses this function to play back a series
154			* of mouse and keyboard messages recorded previously by the
155			* JournalRecordProc hook procedure. As long as a JournalPlaybackProc
156			* hook procedure is installed, regular mouse and keyboard input is disabled."
157			*/
158	werner	46	static LRESULT CALLBACK
159			PTD_playback_proc (int code, WPARAM wparam, LPARAM lparam)
160			{
161			LPEVENTMSG em;
162
163			if (code == HC_SKIP) {
164	twoaday	305	keyidx++;
165	twoaday	334	if (keyidx >= nkeys) {
166	werner	46	UnhookWindowsHookEx (journ_hook);
167			journ_hook = NULL;
168			}
169			return 0;
170			}
171			else if (code == HC_GETNEXT) {
172			/* Here is an overview what the event message struct can contain:
173			* message - WM_KEYUP, WM_KEYDOWN, WM_SYSKEYUP, WM_SYSKEYDOWN:
174			* paramL - specifies the virtual key code of the key that was pressed.
175			* paramH - specifies the scan code.
176			*/
177			em = (LPEVENTMSG )lparam;
178	twoaday	305	if (journ_keys[keyidx] & 0x8000)
179			em->message = journ_keys[keyidx] & 0x4000 ? WM_SYSKEYDOWN : WM_KEYDOWN;
180	werner	46	else
181	twoaday	305	em->message = journ_keys[keyidx] & 0x4000 ? WM_SYSKEYUP : WM_KEYUP;
182	twoaday	334	em->paramL = LOBYTE (journ_keys[keyidx])
183	twoaday	305	\| (MapVirtualKey (LOBYTE (journ_keys[keyidx]), 0) << 8);
184	werner	46	em->paramH = 1;
185			em->time = GetTickCount ();
186			return 0;
187			}
188
189			return CallNextHookEx (journ_hook, code, wparam, lparam);
190	twoaday	248	}
191	werner	46
192
193
194			extern "C" BOOL
195	twoaday	334	PTD_keyboard_send_keys (UINT *keys, UINT n_keys)
196	werner	46	{
197			MSG msg;
198			journ_keys = keys;
199	twoaday	305	keyidx = 0;
200	twoaday	334	nkeys = n_keys;
201	werner	46
202	twoaday	334	/* Return immediately if there is an active hook */
203	werner	46	if (journ_hook)
204			return FALSE;
205
206	twoaday	334	while (GetAsyncKeyState (VK_MENU) & 0x8000 \|\|
207			GetAsyncKeyState (VK_SHIFT) & 0x8000 \|\|
208			GetAsyncKeyState (VK_CONTROL) & 0x8000) {
209	werner	46	if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) {
210			if (msg.message == WM_QUIT) {
211			PostMessage (msg.hwnd, msg.message, msg.wParam, msg.lParam);
212			return FALSE;
213			}
214			TranslateMessage (&msg);
215			DispatchMessage (&msg);
216			}
217			}
218			journ_hook = SetWindowsHookEx (WH_JOURNALPLAYBACK,
219			(HOOKPROC)PTD_playback_proc,
220			glob_hinst, 0);
221			if (journ_hook == NULL)
222			return FALSE;
223
224			while (journ_hook) {
225			if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) {
226			if (msg.message == WM_QUIT) {
227			if (journ_hook)
228			UnhookWindowsHookEx (journ_hook);
229			PostMessage (msg.hwnd, msg.message, msg.wParam, msg.wParam);
230			}
231			TranslateMessage (&msg);
232			DispatchMessage (&msg);
233			}
234			}
235
236			return TRUE;
237			}
238
239
240	twoaday	334	/* Main entry point for the DLL */
241	twoaday	248	extern "C" BOOL WINAPI
242	werner	46	DllMain (HINSTANCE hinst, DWORD reason, LPVOID reserv)
243			{
244			switch (reason) {
245	twoaday	334	case DLL_PROCESS_ATTACH:
246	twoaday	325	glob_hinst = hinst;
247	werner	46	break;
248	twoaday	325
249			case DLL_PROCESS_DETACH:
250			break;
251
252	werner	46	case DLL_THREAD_ATTACH:
253			case DLL_THREAD_DETACH:
254			break;
255	twoaday	325
256	werner	46	}
257	twoaday	325
258	werner	46	return TRUE;
259			}