seamlessrdp/ServerExe/main.c

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

   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 <windows.h>
#include <stdio.h>

#include "vchannel.h"

#include "resource.h"

#define APP_NAME "SeamlessRDP Shell"

/* Global data */
static HINSTANCE g_instance;

typedef void (*set_hooks_proc_t) ();
typedef void (*remove_hooks_proc_t) ();
typedef int (*get_instance_count_proc_t) ();

static void
message(const char *text)
{
        MessageBox(GetDesktopWindow(), text, "SeamlessRDP Shell", MB_OK);
}

static char *
get_token(char **s)
{
        char *comma, *head;
        head = *s;

        if (!head)
                return NULL;

        comma = strchr(head, ',');
        if (comma)
        {
                *comma = '\0';
                *s = comma + 1;
        }
        else
        {
                *s = NULL;
        }

        return head;
}

static BOOL CALLBACK
enum_cb(HWND hwnd, LPARAM lparam)
{
        RECT rect;
        char title[150];
        LONG styles;
        int state;

        styles = GetWindowLong(hwnd, GWL_STYLE);

        if (!(styles & WS_VISIBLE))
                return TRUE;

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

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

        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);

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

        /* FIXME: Strip title of dangerous characters */

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

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

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

        return TRUE;
}

static void
do_sync(void)
{
        vchannel_block();

        vchannel_write("SYNCBEGIN,0x0");

        EnumWindows(enum_cb, 0);

        vchannel_write("SYNCEND,0x0");

        vchannel_unblock();
}

static void
process_cmds(void)
{
        char line[VCHANNEL_MAX_LINE];
        int size;

        char *p, *tok1, *tok2, *tok3, *tok4, *tok5, *tok6, *tok7, *tok8;

        while ((size = vchannel_read(line, sizeof(line))) >= 0)
        {
                debug("Got: %s", line);

                p = line;

                tok1 = get_token(&p);
                tok2 = get_token(&p);
                tok3 = get_token(&p);
                tok4 = get_token(&p);
                tok5 = get_token(&p);
                tok6 = get_token(&p);
                tok7 = get_token(&p);
                tok8 = get_token(&p);

                if (strcmp(tok1, "SYNC") == 0)
                        do_sync();
        }
}

int WINAPI
WinMain(HINSTANCE instance, HINSTANCE prev_instance, LPSTR cmdline, int cmdshow)
{
        HMODULE hookdll;

        set_hooks_proc_t set_hooks_fn;
        remove_hooks_proc_t remove_hooks_fn;
        get_instance_count_proc_t instance_count_fn;

        g_instance = instance;

        hookdll = LoadLibrary("seamlessrdp.dll");
        if (!hookdll)
        {
                message("Could not load hook DLL. Unable to continue.");
                return -1;
        }

        set_hooks_fn = (set_hooks_proc_t) GetProcAddress(hookdll, "SetHooks");
        remove_hooks_fn = (remove_hooks_proc_t) GetProcAddress(hookdll, "RemoveHooks");
        instance_count_fn = (get_instance_count_proc_t) GetProcAddress(hookdll, "GetInstanceCount");

        if (!set_hooks_fn || !remove_hooks_fn || !instance_count_fn)
        {
                FreeLibrary(hookdll);
                message("Hook DLL doesn't contain the correct functions. Unable to continue.");
                return -1;
        }

        /* Check if the DLL is already loaded */
        if (instance_count_fn() != 1)
        {
                FreeLibrary(hookdll);
                message("Another running instance of Seamless RDP detected.");
                return -1;
        }

        vchannel_open();

        set_hooks_fn();

        /* Since we don't see the entire desktop we must resize windows
           immediatly. */
        SystemParametersInfo(SPI_SETDRAGFULLWINDOWS, TRUE, NULL, 0);

        /* Disable screen saver since we cannot catch its windows. */
        SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, FALSE, NULL, 0);

        if (strlen(cmdline) == 0)
        {
                message("No command line specified.");
                return -1;
        }
        else
        {
                BOOL result;
                DWORD exitcode;
                PROCESS_INFORMATION proc_info;
                STARTUPINFO startup_info;

                memset(&startup_info, 0, sizeof(STARTUPINFO));
                startup_info.cb = sizeof(STARTUPINFO);

                result = CreateProcess(NULL, cmdline, NULL, NULL, FALSE, 0,
                                       NULL, NULL, &startup_info, &proc_info);

                if (result)
                {
                        do
                        {
                                process_cmds();
                                Sleep(100);
                                GetExitCodeProcess(proc_info.hProcess, &exitcode);
                        }
                        while (exitcode == STILL_ACTIVE);

                        // Release handles
                        CloseHandle(proc_info.hProcess);
                        CloseHandle(proc_info.hThread);
                }
                else
                {
                        // CreateProcess failed.
                        char msg[256];
                        _snprintf(msg, sizeof(msg),
                                  "Unable to launch the requested application:\n%s", cmdline);
                        message(msg);
                }
        }

        remove_hooks_fn();

        FreeLibrary(hookdll);

        vchannel_close();

        return 1;
}
1	ossman_	1071	/* -- c-basic-offset: 8 --
2			rdesktop: A Remote Desktop Protocol client.
3			Seamless windows - Remote server executable
4	ossman_	1069
5	ossman_	1071	Based on code copyright (C) 2004-2005 Martin Wickett
6	ossman_	1069
7	ossman_	1071	Copyright (C) Peter Åstrand <astrand@cendio.se> 2005-2006
8			Copyright (C) Pierre Ossman <ossman@cendio.se> 2006
9	ossman_	1069
10	ossman_	1071	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	ossman_	1069
15	ossman_	1071	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	ossman_	1069
20	ossman_	1071	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	ossman_	1069
25	ossman_	1071	#include <windows.h>
26			#include <stdio.h>
27	ossman_	1069
28	ossman_	1074	#include "vchannel.h"
29
30	ossman_	1071	#include "resource.h"
31	ossman_	1069
32	ossman_	1071	#define APP_NAME "SeamlessRDP Shell"
33	ossman_	1069
34	ossman_	1071	/* Global data */
35			static HINSTANCE g_instance;
36	ossman_	1069
37	ossman_	1071	typedef void (*set_hooks_proc_t) ();
38			typedef void (*remove_hooks_proc_t) ();
39			typedef int (*get_instance_count_proc_t) ();
40	ossman_	1069
41	ossman_	1071	static void
42			message(const char *text)
43	ossman_	1069	{
44	ossman_	1071	MessageBox(GetDesktopWindow(), text, "SeamlessRDP Shell", MB_OK);
45	ossman_	1069	}
46
47	ossman_	1075	static char *
48			get_token(char **s)
49			{
50			char comma, head;
51			head = *s;
52
53			if (!head)
54			return NULL;
55
56			comma = strchr(head, ',');
57			if (comma)
58			{
59			*comma = '\0';
60			*s = comma + 1;
61			}
62			else
63			{
64			*s = NULL;
65			}
66
67			return head;
68			}
69
70	ossman_	1078	static BOOL CALLBACK
71			enum_cb(HWND hwnd, LPARAM lparam)
72	ossman_	1075	{
73			RECT rect;
74			char title[150];
75			LONG styles;
76			int state;
77
78			styles = GetWindowLong(hwnd, GWL_STYLE);
79
80			if (!(styles & WS_VISIBLE))
81			return TRUE;
82
83	astrand	1091	vchannel_write("CREATE,0x%p,0x%x", hwnd, 0);
84	ossman_	1075
85	ossman_	1078	if (!GetWindowRect(hwnd, &rect))
86			{
87	ossman_	1075	debug("GetWindowRect failed!");
88			return TRUE;
89			}
90
91	astrand	1091	vchannel_write("POSITION,0x%p,%d,%d,%d,%d,0x%x",
92	ossman_	1075	hwnd,
93	ossman_	1078	rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, 0);
94	ossman_	1075
95			GetWindowText(hwnd, title, sizeof(title));
96
97			/* FIXME: Strip title of dangerous characters */
98
99	ossman_	1096	vchannel_write("TITLE,0x%x,%s,0x%x", hwnd, title, 0);
100
101	ossman_	1075	if (styles & WS_MAXIMIZE)
102			state = 2;
103			else if (styles & WS_MINIMIZE)
104			state = 1;
105			else
106			state = 0;
107
108	ossman_	1096	vchannel_write("STATE,0x%p,0x%x,0x%x", hwnd, state, 0);
109	ossman_	1075
110			return TRUE;
111			}
112
113	ossman_	1074	static void
114	ossman_	1075	do_sync(void)
115			{
116			vchannel_block();
117
118			vchannel_write("SYNCBEGIN,0x0");
119
120			EnumWindows(enum_cb, 0);
121
122			vchannel_write("SYNCEND,0x0");
123
124			vchannel_unblock();
125			}
126
127			static void
128	ossman_	1074	process_cmds(void)
129			{
130			char line[VCHANNEL_MAX_LINE];
131			int size;
132
133	ossman_	1075	char p, tok1, tok2, tok3, tok4, tok5, tok6, tok7, *tok8;
134
135	ossman_	1078	while ((size = vchannel_read(line, sizeof(line))) >= 0)
136			{
137	ossman_	1074	debug("Got: %s", line);
138	ossman_	1075
139			p = line;
140
141			tok1 = get_token(&p);
142			tok2 = get_token(&p);
143			tok3 = get_token(&p);
144			tok4 = get_token(&p);
145			tok5 = get_token(&p);
146			tok6 = get_token(&p);
147			tok7 = get_token(&p);
148			tok8 = get_token(&p);
149
150			if (strcmp(tok1, "SYNC") == 0)
151			do_sync();
152	ossman_	1074	}
153			}
154
155	ossman_	1071	int WINAPI
156			WinMain(HINSTANCE instance, HINSTANCE prev_instance, LPSTR cmdline, int cmdshow)
157	ossman_	1069	{
158	ossman_	1071	HMODULE hookdll;
159	ossman_	1069
160	ossman_	1071	set_hooks_proc_t set_hooks_fn;
161			remove_hooks_proc_t remove_hooks_fn;
162			get_instance_count_proc_t instance_count_fn;
163	ossman_	1069
164	ossman_	1071	g_instance = instance;
165	ossman_	1069
166	ossman_	1084	hookdll = LoadLibrary("seamlessrdp.dll");
167	ossman_	1071	if (!hookdll)
168			{
169			message("Could not load hook DLL. Unable to continue.");
170			return -1;
171			}
172	ossman_	1069
173	ossman_	1071	set_hooks_fn = (set_hooks_proc_t) GetProcAddress(hookdll, "SetHooks");
174			remove_hooks_fn = (remove_hooks_proc_t) GetProcAddress(hookdll, "RemoveHooks");
175			instance_count_fn = (get_instance_count_proc_t) GetProcAddress(hookdll, "GetInstanceCount");
176	ossman_	1069
177	ossman_	1071	if (!set_hooks_fn \|\| !remove_hooks_fn \|\| !instance_count_fn)
178			{
179			FreeLibrary(hookdll);
180			message("Hook DLL doesn't contain the correct functions. Unable to continue.");
181			return -1;
182			}
183	ossman_	1069
184	ossman_	1071	/* Check if the DLL is already loaded */
185			if (instance_count_fn() != 1)
186			{
187			FreeLibrary(hookdll);
188			message("Another running instance of Seamless RDP detected.");
189			return -1;
190			}
191	ossman_	1069
192	ossman_	1074	vchannel_open();
193
194	ossman_	1071	set_hooks_fn();
195	ossman_	1069
196	ossman_	1077	/* Since we don't see the entire desktop we must resize windows
197			immediatly. */
198			SystemParametersInfo(SPI_SETDRAGFULLWINDOWS, TRUE, NULL, 0);
199
200	ossman_	1093	/* Disable screen saver since we cannot catch its windows. */
201			SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, FALSE, NULL, 0);
202
203	ossman_	1071	if (strlen(cmdline) == 0)
204			{
205			message("No command line specified.");
206			return -1;
207			}
208			else
209			{
210			BOOL result;
211			DWORD exitcode;
212			PROCESS_INFORMATION proc_info;
213			STARTUPINFO startup_info;
214	ossman_	1069
215	ossman_	1071	memset(&startup_info, 0, sizeof(STARTUPINFO));
216			startup_info.cb = sizeof(STARTUPINFO);
217	ossman_	1069
218	ossman_	1071	result = CreateProcess(NULL, cmdline, NULL, NULL, FALSE, 0,
219			NULL, NULL, &startup_info, &proc_info);
220	ossman_	1069
221	ossman_	1071	if (result)
222			{
223			do
224			{
225	ossman_	1074	process_cmds();
226			Sleep(100);
227	ossman_	1071	GetExitCodeProcess(proc_info.hProcess, &exitcode);
228			}
229			while (exitcode == STILL_ACTIVE);
230	ossman_	1069
231	ossman_	1071	// Release handles
232			CloseHandle(proc_info.hProcess);
233			CloseHandle(proc_info.hThread);
234			}
235			else
236			{
237			// CreateProcess failed.
238			char msg[256];
239			_snprintf(msg, sizeof(msg),
240			"Unable to launch the requested application:\n%s", cmdline);
241			message(msg);
242			}
243			}
244	ossman_	1069
245	ossman_	1071	remove_hooks_fn();
246	ossman_	1069
247	ossman_	1071	FreeLibrary(hookdll);
248	ossman_	1069
249	ossman_	1074	vchannel_close();
250
251	ossman_	1071	return 1;
252	ossman_	1069	}