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

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("hookdll.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;
        }

        set_hooks_fn();

        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
                        {
                                Sleep(1000);
                                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);

        return 1;
}
1	/* -- c-basic-offset: 8 --
2	rdesktop: A Remote Desktop Protocol client.
3	Seamless windows - Remote server executable
4
5	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	#include <windows.h>
26	#include <stdio.h>
27
28	#include "resource.h"
29
30	#define APP_NAME "SeamlessRDP Shell"
31
32	/* Global data */
33	static HINSTANCE g_instance;
34
35	typedef void (*set_hooks_proc_t) ();
36	typedef void (*remove_hooks_proc_t) ();
37	typedef int (*get_instance_count_proc_t) ();
38
39	static void
40	message(const char *text)
41	{
42	MessageBox(GetDesktopWindow(), text, "SeamlessRDP Shell", MB_OK);
43	}
44
45	int WINAPI
46	WinMain(HINSTANCE instance, HINSTANCE prev_instance, LPSTR cmdline, int cmdshow)
47	{
48	HMODULE hookdll;
49
50	set_hooks_proc_t set_hooks_fn;
51	remove_hooks_proc_t remove_hooks_fn;
52	get_instance_count_proc_t instance_count_fn;
53
54	g_instance = instance;
55
56	hookdll = LoadLibrary("hookdll.dll");
57	if (!hookdll)
58	{
59	message("Could not load hook DLL. Unable to continue.");
60	return -1;
61	}
62
63	set_hooks_fn = (set_hooks_proc_t) GetProcAddress(hookdll, "SetHooks");
64	remove_hooks_fn = (remove_hooks_proc_t) GetProcAddress(hookdll, "RemoveHooks");
65	instance_count_fn = (get_instance_count_proc_t) GetProcAddress(hookdll, "GetInstanceCount");
66
67	if (!set_hooks_fn \|\| !remove_hooks_fn \|\| !instance_count_fn)
68	{
69	FreeLibrary(hookdll);
70	message("Hook DLL doesn't contain the correct functions. Unable to continue.");
71	return -1;
72	}
73
74	/* Check if the DLL is already loaded */
75	if (instance_count_fn() != 1)
76	{
77	FreeLibrary(hookdll);
78	message("Another running instance of Seamless RDP detected.");
79	return -1;
80	}
81
82	set_hooks_fn();
83
84	if (strlen(cmdline) == 0)
85	{
86	message("No command line specified.");
87	return -1;
88	}
89	else
90	{
91	BOOL result;
92	DWORD exitcode;
93	PROCESS_INFORMATION proc_info;
94	STARTUPINFO startup_info;
95
96	memset(&startup_info, 0, sizeof(STARTUPINFO));
97	startup_info.cb = sizeof(STARTUPINFO);
98
99	result = CreateProcess(NULL, cmdline, NULL, NULL, FALSE, 0,
100	NULL, NULL, &startup_info, &proc_info);
101
102	if (result)
103	{
104	do
105	{
106	Sleep(1000);
107	GetExitCodeProcess(proc_info.hProcess, &exitcode);
108	}
109	while (exitcode == STILL_ACTIVE);
110
111	// Release handles
112	CloseHandle(proc_info.hProcess);
113	CloseHandle(proc_info.hThread);
114	}
115	else
116	{
117	// CreateProcess failed.
118	char msg[256];
119	_snprintf(msg, sizeof(msg),
120	"Unable to launch the requested application:\n%s", cmdline);
121	message(msg);
122	}
123	}
124
125	remove_hooks_fn();
126
127	FreeLibrary(hookdll);
128
129	return 1;
130	}