ServerExe/HookDll/hookdll.c

/* -*- c-basic-offset: 8 -*-
   rdesktop: A Remote Desktop Protocol client.
   Seamless windows - Remote server hook DLL

   Based on code copyright (C) 2004-2005 Martin Wickett

   Copyright (C) Peter Åstrand <astrand@cendio.se> 2005-2006
   Copyright (C) Pierre Ossman <ossman@cendio.se> 2006

   This program 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.

   This program 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.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include <stdio.h>
#include <stdarg.h>

#include <windows.h>
#include <winuser.h>

#include "../vchannel.h"

#define DLL_EXPORT __declspec(dllexport)

// Shared DATA
#pragma data_seg ( "SHAREDDATA" )

// this is the total number of processes this dll is currently attached to
int g_instance_count = 0;

#pragma data_seg ()

#pragma comment(linker, "/section:SHAREDDATA,rws")

static HHOOK g_cbt_hook = NULL;
static HHOOK g_wndproc_hook = NULL;

static HINSTANCE g_instance = NULL;

static HANDLE g_mutex = NULL;

static void
update_position(HWND hwnd)
{
        RECT rect;

        if (!GetWindowRect(hwnd, &rect))
        {
                debug("GetWindowRect failed!\n");
                return;
        }

        vchannel_write("POSITION,0x%p,%d,%d,%d,%d,0x%x",
                       hwnd,
                       rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, 0);
}

static LRESULT CALLBACK
wndproc_hook_proc(int code, WPARAM cur_thread, LPARAM details)
{
        HWND hwnd, parent;
        UINT msg;
        WPARAM wparam;
        LPARAM lparam;

        LONG style;

        if (code < 0)
                goto end;

        hwnd = ((CWPSTRUCT *) details)->hwnd;
        msg = ((CWPSTRUCT *) details)->message;
        wparam = ((CWPSTRUCT *) details)->wParam;
        lparam = ((CWPSTRUCT *) details)->lParam;

        style = GetWindowLong(hwnd, GWL_STYLE);

        /* Docs say that WS_CHILD and WS_POPUP is an illegal combination,
           but they exist nonetheless. */
        if ((style & WS_CHILD) && !(style & WS_POPUP))
                goto end;

        if (style & WS_POPUP)
        {
                parent = (HWND) GetWindowLong(hwnd, GWL_HWNDPARENT);
                if (!parent)
                        parent = (HWND) - 1;
        }
        else
                parent = NULL;

        switch (msg)
        {

                case WM_WINDOWPOSCHANGED:
                        {
                                WINDOWPOS *wp = (WINDOWPOS *) lparam;

                                if (wp->flags & SWP_SHOWWINDOW)
                                {
                                        char title[150];
                                        int state;

                                        vchannel_write("CREATE,0x%p,0x%p,0x%x", hwnd, parent, 0);

                                        GetWindowText(hwnd, title, sizeof(title));

                                        vchannel_write("TITLE,0x%x,%s,0x%x", hwnd,
                                                       vchannel_strfilter(title), 0);

                                        if (style & WS_MAXIMIZE)
                                                state = 2;
                                        else if (style & WS_MINIMIZE)
                                                state = 1;
                                        else
                                                state = 0;

                                        update_position(hwnd);

                                        vchannel_write("STATE,0x%p,0x%x,0x%x", hwnd, state, 0);
                                }

                                if (wp->flags & SWP_HIDEWINDOW)
                                        vchannel_write("DESTROY,0x%p,0x%x", hwnd, 0);

                                if (!(style & WS_VISIBLE) || (style & WS_MINIMIZE))
                                        break;

                                if (!(wp->flags & SWP_NOMOVE && wp->flags & SWP_NOSIZE))
                                        update_position(hwnd);

                                if (!(wp->flags & SWP_NOZORDER))
                                {
                                        vchannel_write("ZCHANGE,0x%p,0x%p,0x%x",
                                                       hwnd,
                                                       wp->flags & SWP_NOACTIVATE ? wp->
                                                       hwndInsertAfter : 0, 0);
                                }

                                break;
                        }

                case WM_SIZE:
                        if (!(style & WS_VISIBLE) || (style & WS_MINIMIZE))
                                break;
                        update_position(hwnd);
                        break;

                case WM_MOVE:
                        if (!(style & WS_VISIBLE) || (style & WS_MINIMIZE))
                                break;
                        update_position(hwnd);
                        break;

                case WM_SETTEXT:
                        {
                                char *title;
                                if (!(style & WS_VISIBLE))
                                        break;
                                title = _strdup((char *) lparam);
                                vchannel_write("TITLE,0x%p,%s,0x%x", hwnd,
                                               vchannel_strfilter(title), 0);
                                free(title);
                                break;
                        }

                case WM_DESTROY:
                        if (!(style & WS_VISIBLE))
                                break;
                        vchannel_write("DESTROY,0x%p,0x%x", hwnd, 0);
                        break;

                default:
                        break;
        }

      end:
        return CallNextHookEx(g_wndproc_hook, code, cur_thread, details);
}

static LRESULT CALLBACK
cbt_hook_proc(int code, WPARAM wparam, LPARAM lparam)
{
        if (code < 0)
                goto end;

        switch (code)
        {
                case HCBT_MINMAX:
                        {
                                int show, state;

                                show = LOWORD(lparam);

                                if ((show == SW_NORMAL) || (show == SW_SHOWNORMAL)
                                    || (show == SW_RESTORE))
                                        state = 0;
                                else if ((show == SW_MINIMIZE) || (show == SW_SHOWMINIMIZED))
                                        state = 1;
                                else if ((show == SW_MAXIMIZE) || (show == SW_SHOWMAXIMIZED))
                                        state = 2;
                                else
                                {
                                        debug("Unexpected show: %d", show);
                                        break;
                                }
                                vchannel_write("STATE,0x%p,0x%x,0x%x", (HWND) wparam, state, 0);
                                break;
                        }

                default:
                        break;
        }

      end:
        return CallNextHookEx(g_cbt_hook, code, wparam, lparam);
}

DLL_EXPORT void
SetHooks(void)
{
        if (!g_cbt_hook)
                g_cbt_hook = SetWindowsHookEx(WH_CBT, cbt_hook_proc, g_instance, 0);

        if (!g_wndproc_hook)
                g_wndproc_hook = SetWindowsHookEx(WH_CALLWNDPROC, wndproc_hook_proc, g_instance, 0);
}

DLL_EXPORT void
RemoveHooks(void)
{
        if (g_cbt_hook)
                UnhookWindowsHookEx(g_cbt_hook);

        if (g_wndproc_hook)
                UnhookWindowsHookEx(g_wndproc_hook);
}

DLL_EXPORT int
GetInstanceCount()
{
        return g_instance_count;
}

BOOL APIENTRY
DllMain(HINSTANCE hinstDLL, DWORD ul_reason_for_call, LPVOID lpReserved)
{
        switch (ul_reason_for_call)
        {
                case DLL_PROCESS_ATTACH:
                        // remember our instance handle
                        g_instance = hinstDLL;

                        g_mutex = CreateMutex(NULL, FALSE, "Local\\SeamlessDLL");
                        if (!g_mutex)
                                return FALSE;

                        WaitForSingleObject(g_mutex, INFINITE);
                        ++g_instance_count;
                        ReleaseMutex(g_mutex);

                        vchannel_open();

                        break;

                case DLL_THREAD_ATTACH:
                        break;

                case DLL_THREAD_DETACH:
                        break;

                case DLL_PROCESS_DETACH:
                        WaitForSingleObject(g_mutex, INFINITE);
                        --g_instance_count;
                        ReleaseMutex(g_mutex);

                        vchannel_close();

                        CloseHandle(g_mutex);

                        break;
        }

        return TRUE;
}
1	ossman_	1071	/* -- c-basic-offset: 8 --
2			rdesktop: A Remote Desktop Protocol client.
3			Seamless windows - Remote server hook DLL
4	ossman_	1069
5	ossman_	1071	Based on code copyright (C) 2004-2005 Martin Wickett
6
7			Copyright (C) Peter Åstrand <astrand@cendio.se> 2005-2006
8			Copyright (C) Pierre Ossman <ossman@cendio.se> 2006
9
10			This program is free software; you can redistribute it and/or modify
11			it under the terms of the GNU General Public License as published by
12			the Free Software Foundation; either version 2 of the License, or
13			(at your option) any later version.
14
15			This program is distributed in the hope that it will be useful,
16			but WITHOUT ANY WARRANTY; without even the implied warranty of
17			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18			GNU General Public License for more details.
19
20			You should have received a copy of the GNU General Public License
21			along with this program; if not, write to the Free Software
22			Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23			*/
24
25	ossman_	1069	#include <stdio.h>
26			#include <stdarg.h>
27
28	ossman_	1071	#include <windows.h>
29			#include <winuser.h>
30	ossman_	1069
31	ossman_	1073	#include "../vchannel.h"
32	ossman_	1071
33	ossman_	1069	#define DLL_EXPORT __declspec(dllexport)
34
35			// Shared DATA
36			#pragma data_seg ( "SHAREDDATA" )
37
38			// this is the total number of processes this dll is currently attached to
39	ossman_	1071	int g_instance_count = 0;
40	ossman_	1069
41			#pragma data_seg ()
42
43			#pragma comment(linker, "/section:SHAREDDATA,rws")
44
45	ossman_	1071	static HHOOK g_cbt_hook = NULL;
46			static HHOOK g_wndproc_hook = NULL;
47	ossman_	1069
48	ossman_	1071	static HINSTANCE g_instance = NULL;
49	ossman_	1069
50	ossman_	1071	static HANDLE g_mutex = NULL;
51	ossman_	1069
52	ossman_	1081	static void
53			update_position(HWND hwnd)
54			{
55			RECT rect;
56
57			if (!GetWindowRect(hwnd, &rect))
58			{
59			debug("GetWindowRect failed!\n");
60			return;
61			}
62
63	astrand	1091	vchannel_write("POSITION,0x%p,%d,%d,%d,%d,0x%x",
64	ossman_	1081	hwnd,
65			rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, 0);
66			}
67
68	ossman_	1071	static LRESULT CALLBACK
69			wndproc_hook_proc(int code, WPARAM cur_thread, LPARAM details)
70	ossman_	1069	{
71	ossman_	1097	HWND hwnd, parent;
72	ossman_	1079	UINT msg;
73			WPARAM wparam;
74			LPARAM lparam;
75	ossman_	1069
76	ossman_	1079	LONG style;
77	ossman_	1069
78	ossman_	1071	if (code < 0)
79			goto end;
80	ossman_	1069
81	ossman_	1079	hwnd = ((CWPSTRUCT *) details)->hwnd;
82			msg = ((CWPSTRUCT *) details)->message;
83			wparam = ((CWPSTRUCT *) details)->wParam;
84			lparam = ((CWPSTRUCT *) details)->lParam;
85
86			style = GetWindowLong(hwnd, GWL_STYLE);
87
88	ossman_	1082	/* Docs say that WS_CHILD and WS_POPUP is an illegal combination,
89			but they exist nonetheless. */
90			if ((style & WS_CHILD) && !(style & WS_POPUP))
91	ossman_	1079	goto end;
92
93	ossman_	1097	if (style & WS_POPUP)
94	ossman_	1109	{
95	ossman_	1097	parent = (HWND) GetWindowLong(hwnd, GWL_HWNDPARENT);
96	ossman_	1109	if (!parent)
97			parent = (HWND) - 1;
98			}
99	ossman_	1097	else
100			parent = NULL;
101
102	ossman_	1071	switch (msg)
103			{
104	ossman_	1069
105	ossman_	1071	case WM_WINDOWPOSCHANGED:
106	ossman_	1079	{
107			WINDOWPOS wp = (WINDOWPOS ) lparam;
108	ossman_	1069
109	ossman_	1079	if (wp->flags & SWP_SHOWWINDOW)
110			{
111	ossman_	1099	char title[150];
112			int state;
113
114	ossman_	1097	vchannel_write("CREATE,0x%p,0x%p,0x%x", hwnd, parent, 0);
115	ossman_	1069
116	ossman_	1099	GetWindowText(hwnd, title, sizeof(title));
117	ossman_	1069
118	ossman_	1113	vchannel_write("TITLE,0x%x,%s,0x%x", hwnd,
119			vchannel_strfilter(title), 0);
120	ossman_	1099
121			if (style & WS_MAXIMIZE)
122			state = 2;
123			else if (style & WS_MINIMIZE)
124			state = 1;
125			else
126			state = 0;
127
128	ossman_	1081	update_position(hwnd);
129	ossman_	1099
130	ossman_	1131	vchannel_write("STATE,0x%p,0x%x,0x%x", hwnd, state, 0);
131	ossman_	1079	}
132	ossman_	1069
133	ossman_	1079	if (wp->flags & SWP_HIDEWINDOW)
134	astrand	1091	vchannel_write("DESTROY,0x%p,0x%x", hwnd, 0);
135	ossman_	1079
136	ossman_	1108	if (!(style & WS_VISIBLE) \|\| (style & WS_MINIMIZE))
137	ossman_	1079	break;
138
139	ossman_	1080	if (!(wp->flags & SWP_NOMOVE && wp->flags & SWP_NOSIZE))
140	ossman_	1081	update_position(hwnd);
141	ossman_	1079
142			if (!(wp->flags & SWP_NOZORDER))
143	ossman_	1080	{
144	astrand	1091	vchannel_write("ZCHANGE,0x%p,0x%p,0x%x",
145	ossman_	1079	hwnd,
146			wp->flags & SWP_NOACTIVATE ? wp->
147			hwndInsertAfter : 0, 0);
148	ossman_	1080	}
149	ossman_	1069
150	ossman_	1071	break;
151	ossman_	1079	}
152	ossman_	1069
153	ossman_	1081	case WM_SIZE:
154	ossman_	1108	if (!(style & WS_VISIBLE) \|\| (style & WS_MINIMIZE))
155	ossman_	1083	break;
156	ossman_	1081	update_position(hwnd);
157			break;
158
159			case WM_MOVE:
160	ossman_	1108	if (!(style & WS_VISIBLE) \|\| (style & WS_MINIMIZE))
161	ossman_	1083	break;
162	ossman_	1081	update_position(hwnd);
163			break;
164
165	ossman_	1102	case WM_SETTEXT:
166	ossman_	1113	{
167			char *title;
168			if (!(style & WS_VISIBLE))
169			break;
170			title = _strdup((char *) lparam);
171			vchannel_write("TITLE,0x%p,%s,0x%x", hwnd,
172			vchannel_strfilter(title), 0);
173			free(title);
174	ossman_	1102	break;
175	ossman_	1113	}
176	ossman_	1102
177	ossman_	1071	case WM_DESTROY:
178	ossman_	1083	if (!(style & WS_VISIBLE))
179			break;
180	astrand	1091	vchannel_write("DESTROY,0x%p,0x%x", hwnd, 0);
181	ossman_	1071	break;
182	ossman_	1069
183	ossman_	1071	default:
184			break;
185			}
186
187			end:
188			return CallNextHookEx(g_wndproc_hook, code, cur_thread, details);
189	ossman_	1069	}
190
191	ossman_	1071	static LRESULT CALLBACK
192			cbt_hook_proc(int code, WPARAM wparam, LPARAM lparam)
193	ossman_	1069	{
194	ossman_	1071	if (code < 0)
195			goto end;
196	ossman_	1069
197	ossman_	1071	switch (code)
198			{
199			case HCBT_MINMAX:
200			{
201	ossman_	1079	int show, state;
202	ossman_	1069
203	ossman_	1071	show = LOWORD(lparam);
204	ossman_	1069
205	ossman_	1128	if ((show == SW_NORMAL) \|\| (show == SW_SHOWNORMAL)
206			\|\| (show == SW_RESTORE))
207	ossman_	1079	state = 0;
208	ossman_	1106	else if ((show == SW_MINIMIZE) \|\| (show == SW_SHOWMINIMIZED))
209	ossman_	1079	state = 1;
210	ossman_	1106	else if ((show == SW_MAXIMIZE) \|\| (show == SW_SHOWMAXIMIZED))
211	ossman_	1079	state = 2;
212	ossman_	1100	else
213	ossman_	1106	{
214			debug("Unexpected show: %d", show);
215	ossman_	1100	break;
216	ossman_	1106	}
217	ossman_	1096	vchannel_write("STATE,0x%p,0x%x,0x%x", (HWND) wparam, state, 0);
218	ossman_	1071	break;
219			}
220	ossman_	1069
221	ossman_	1071	default:
222			break;
223			}
224	ossman_	1069
225	ossman_	1071	end:
226			return CallNextHookEx(g_cbt_hook, code, wparam, lparam);
227	ossman_	1069	}
228
229	ossman_	1071	DLL_EXPORT void
230			SetHooks(void)
231	ossman_	1069	{
232	ossman_	1071	if (!g_cbt_hook)
233			g_cbt_hook = SetWindowsHookEx(WH_CBT, cbt_hook_proc, g_instance, 0);
234	ossman_	1069
235	ossman_	1071	if (!g_wndproc_hook)
236			g_wndproc_hook = SetWindowsHookEx(WH_CALLWNDPROC, wndproc_hook_proc, g_instance, 0);
237	ossman_	1069	}
238
239	ossman_	1071	DLL_EXPORT void
240			RemoveHooks(void)
241	ossman_	1069	{
242	ossman_	1071	if (g_cbt_hook)
243			UnhookWindowsHookEx(g_cbt_hook);
244	ossman_	1069
245	ossman_	1071	if (g_wndproc_hook)
246			UnhookWindowsHookEx(g_wndproc_hook);
247	ossman_	1069	}
248
249	ossman_	1071	DLL_EXPORT int
250			GetInstanceCount()
251	ossman_	1069	{
252	ossman_	1071	return g_instance_count;
253	ossman_	1069	}
254
255	ossman_	1071	BOOL APIENTRY
256			DllMain(HINSTANCE hinstDLL, DWORD ul_reason_for_call, LPVOID lpReserved)
257	ossman_	1069	{
258	ossman_	1071	switch (ul_reason_for_call)
259			{
260			case DLL_PROCESS_ATTACH:
261			// remember our instance handle
262			g_instance = hinstDLL;
263	ossman_	1069
264	ossman_	1073	g_mutex = CreateMutex(NULL, FALSE, "Local\\SeamlessDLL");
265	ossman_	1071	if (!g_mutex)
266			return FALSE;
267	ossman_	1069
268	ossman_	1071	WaitForSingleObject(g_mutex, INFINITE);
269			++g_instance_count;
270			ReleaseMutex(g_mutex);
271	ossman_	1069
272	ossman_	1071	vchannel_open();
273	ossman_	1069
274	ossman_	1071	break;
275	ossman_	1069
276	ossman_	1071	case DLL_THREAD_ATTACH:
277			break;
278	ossman_	1069
279	ossman_	1071	case DLL_THREAD_DETACH:
280			break;
281	ossman_	1069
282	ossman_	1071	case DLL_PROCESS_DETACH:
283			WaitForSingleObject(g_mutex, INFINITE);
284			--g_instance_count;
285			ReleaseMutex(g_mutex);
286	ossman_	1069
287	ossman_	1071	vchannel_close();
288	ossman_	1069
289	ossman_	1071	CloseHandle(g_mutex);
290	ossman_	1069
291	ossman_	1071	break;
292			}
293	ossman_	1069
294	ossman_	1071	return TRUE;
295	ossman_	1069	}