seamlessrdp/ServerExe/vchannel.c

/* -*- c-basic-offset: 8 -*-
   rdesktop: A Remote Desktop Protocol client.
   Seamless windows - Virtual channel handling

   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 <assert.h>
#include <stdio.h>
#include <stdarg.h>
#include <errno.h>

#include <windows.h>
#include <wtsapi32.h>
#include <cchannel.h>

#include "vchannel.h"

#define CHANNELNAME "seamrdp"

#define INVALID_CHARS ","
#define REPLACEMENT_CHAR '_'

static HANDLE g_mutex = NULL;
static HANDLE g_vchannel = NULL;

void
debug(char *format, ...)
{
        va_list argp;
        char buf[256];

        sprintf(buf, "DEBUG,");

        va_start(argp, format);
        _vsnprintf(buf + sizeof("DEBUG,") - 1, sizeof(buf) - sizeof("DEBUG,") + 1, format, argp);
        va_end(argp);

        vchannel_strfilter(buf + sizeof("DEBUG,"));

        vchannel_write(buf);
}


int
vchannel_open()
{
        g_vchannel = WTSVirtualChannelOpen(WTS_CURRENT_SERVER_HANDLE,
                                           WTS_CURRENT_SESSION, CHANNELNAME);

        if (g_vchannel == NULL)
                return -1;

        g_mutex = CreateMutex(NULL, FALSE, "Local\\SeamlessChannel");
        if (!g_mutex)
        {
                WTSVirtualChannelClose(g_vchannel);
                g_vchannel = NULL;
                return -1;
        }

        return 0;
}

void
vchannel_close()
{
        if (g_mutex)
                CloseHandle(g_mutex);

        if (g_vchannel)
                WTSVirtualChannelClose(g_vchannel);

        g_mutex = NULL;
        g_vchannel = NULL;
}

int
vchannel_is_open()
{
        if (g_vchannel == NULL)
                return 0;
        else
                return 1;
}

int
vchannel_read(char *line, size_t length)
{
        static BOOL overflow_mode = FALSE;
        static char buffer[VCHANNEL_MAX_LINE];
        static size_t size = 0;

        char *newline;
        int line_size;

        BOOL result;
        ULONG bytes_read;

        result = WTSVirtualChannelRead(g_vchannel, 0, buffer + size,
                                       sizeof(buffer) - size, &bytes_read);

        if (!result)
        {
                errno = EIO;
                return -1;
        }

        if (overflow_mode)
        {
                newline = strchr(buffer, '\n');
                if (newline && (newline - buffer) < bytes_read)
                {
                        size = bytes_read - (newline - buffer) - 1;
                        memmove(buffer, newline + 1, size);
                        overflow_mode = FALSE;
                }
        }
        else
                size += bytes_read;

        if (overflow_mode)
        {
                errno = -EAGAIN;
                return -1;
        }

        newline = strchr(buffer, '\n');
        if (!newline || (newline - buffer) >= size)
        {
                if (size == sizeof(buffer))
                {
                        overflow_mode = TRUE;
                        size = 0;
                }
                errno = -EAGAIN;
                return -1;
        }

        if ((newline - buffer) >= length)
        {
                errno = ENOMEM;
                return -1;
        }

        *newline = '\0';

        strcpy(line, buffer);
        line_size = newline - buffer;

        size -= newline - buffer + 1;
        memmove(buffer, newline + 1, size);

        return 0;
}

int
vchannel_write(const char *format, ...)
{
        BOOL result;
        va_list argp;
        char buf[VCHANNEL_MAX_LINE];
        int size;
        ULONG bytes_written;

        assert(vchannel_is_open());

        va_start(argp, format);
        size = _vsnprintf(buf, sizeof(buf), format, argp);
        va_end(argp);

        assert(size < sizeof(buf));

        WaitForSingleObject(g_mutex, INFINITE);
        result = WTSVirtualChannelWrite(g_vchannel, buf, (ULONG) strlen(buf), &bytes_written);
        result = WTSVirtualChannelWrite(g_vchannel, "\n", (ULONG) 1, &bytes_written);
        ReleaseMutex(g_mutex);

        if (!result)
                return -1;

        return bytes_written;
}

void
vchannel_block()
{
        WaitForSingleObject(g_mutex, INFINITE);
}

void
vchannel_unblock()
{
        ReleaseMutex(g_mutex);
}

const char *
vchannel_strfilter(char *string)
{
        char *c;

        for (c = string; *c != '\0'; c++)
        {
                if (((unsigned char) *c < 0x20) || (strchr(INVALID_CHARS, *c) != NULL))
                        *c = REPLACEMENT_CHAR;
        }

        return string;
}
1	ossman_	1073	/* -- c-basic-offset: 8 --
2			rdesktop: A Remote Desktop Protocol client.
3			Seamless windows - Virtual channel handling
4
5			Copyright (C) Pierre Ossman <ossman@cendio.se> 2006
6
7			This program is free software; you can redistribute it and/or modify
8			it under the terms of the GNU General Public License as published by
9			the Free Software Foundation; either version 2 of the License, or
10			(at your option) any later version.
11
12			This program is distributed in the hope that it will be useful,
13			but WITHOUT ANY WARRANTY; without even the implied warranty of
14			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			GNU General Public License for more details.
16
17			You should have received a copy of the GNU General Public License
18			along with this program; if not, write to the Free Software
19			Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20			*/
21
22			#include <assert.h>
23			#include <stdio.h>
24			#include <stdarg.h>
25	ossman_	1074	#include <errno.h>
26	ossman_	1073
27			#include <windows.h>
28			#include <wtsapi32.h>
29			#include <cchannel.h>
30
31			#include "vchannel.h"
32
33			#define CHANNELNAME "seamrdp"
34
35	ossman_	1113	#define INVALID_CHARS ","
36			#define REPLACEMENT_CHAR '_'
37
38	ossman_	1073	static HANDLE g_mutex = NULL;
39			static HANDLE g_vchannel = NULL;
40
41			void
42			debug(char *format, ...)
43			{
44			va_list argp;
45			char buf[256];
46
47	astrand	1091	sprintf(buf, "DEBUG,");
48	ossman_	1073
49			va_start(argp, format);
50	astrand	1091	_vsnprintf(buf + sizeof("DEBUG,") - 1, sizeof(buf) - sizeof("DEBUG,") + 1, format, argp);
51	ossman_	1073	va_end(argp);
52
53	ossman_	1113	vchannel_strfilter(buf + sizeof("DEBUG,"));
54
55	ossman_	1073	vchannel_write(buf);
56			}
57
58
59			int
60			vchannel_open()
61			{
62			g_vchannel = WTSVirtualChannelOpen(WTS_CURRENT_SERVER_HANDLE,
63			WTS_CURRENT_SESSION, CHANNELNAME);
64
65			if (g_vchannel == NULL)
66			return -1;
67
68			g_mutex = CreateMutex(NULL, FALSE, "Local\\SeamlessChannel");
69	ossman_	1078	if (!g_mutex)
70			{
71	ossman_	1073	WTSVirtualChannelClose(g_vchannel);
72			g_vchannel = NULL;
73			return -1;
74			}
75
76			return 0;
77			}
78
79			void
80			vchannel_close()
81			{
82			if (g_mutex)
83			CloseHandle(g_mutex);
84
85			if (g_vchannel)
86			WTSVirtualChannelClose(g_vchannel);
87
88			g_mutex = NULL;
89			g_vchannel = NULL;
90			}
91
92			int
93			vchannel_is_open()
94			{
95			if (g_vchannel == NULL)
96			return 0;
97			else
98			return 1;
99			}
100
101			int
102	ossman_	1074	vchannel_read(char *line, size_t length)
103	ossman_	1073	{
104	ossman_	1074	static BOOL overflow_mode = FALSE;
105			static char buffer[VCHANNEL_MAX_LINE];
106			static size_t size = 0;
107
108			char *newline;
109			int line_size;
110
111			BOOL result;
112			ULONG bytes_read;
113
114			result = WTSVirtualChannelRead(g_vchannel, 0, buffer + size,
115			sizeof(buffer) - size, &bytes_read);
116
117	ossman_	1078	if (!result)
118			{
119	ossman_	1074	errno = EIO;
120			return -1;
121			}
122
123	ossman_	1078	if (overflow_mode)
124			{
125	ossman_	1074	newline = strchr(buffer, '\n');
126	ossman_	1078	if (newline && (newline - buffer) < bytes_read)
127			{
128	ossman_	1074	size = bytes_read - (newline - buffer) - 1;
129			memmove(buffer, newline + 1, size);
130			overflow_mode = FALSE;
131			}
132			}
133			else
134			size += bytes_read;
135
136	ossman_	1078	if (overflow_mode)
137			{
138	ossman_	1074	errno = -EAGAIN;
139			return -1;
140			}
141
142			newline = strchr(buffer, '\n');
143	ossman_	1078	if (!newline \|\| (newline - buffer) >= size)
144			{
145			if (size == sizeof(buffer))
146			{
147	ossman_	1074	overflow_mode = TRUE;
148			size = 0;
149			}
150			errno = -EAGAIN;
151			return -1;
152			}
153
154	ossman_	1078	if ((newline - buffer) >= length)
155			{
156	ossman_	1074	errno = ENOMEM;
157			return -1;
158			}
159
160			*newline = '\0';
161
162			strcpy(line, buffer);
163			line_size = newline - buffer;
164
165			size -= newline - buffer + 1;
166			memmove(buffer, newline + 1, size);
167
168			return 0;
169	ossman_	1073	}
170
171			int
172	ossman_	1114	vchannel_write(const char *format, ...)
173	ossman_	1073	{
174			BOOL result;
175			va_list argp;
176	ossman_	1074	char buf[VCHANNEL_MAX_LINE];
177	ossman_	1073	int size;
178			ULONG bytes_written;
179
180			assert(vchannel_is_open());
181
182			va_start(argp, format);
183			size = _vsnprintf(buf, sizeof(buf), format, argp);
184			va_end(argp);
185
186			assert(size < sizeof(buf));
187
188			WaitForSingleObject(g_mutex, INFINITE);
189			result = WTSVirtualChannelWrite(g_vchannel, buf, (ULONG) strlen(buf), &bytes_written);
190			result = WTSVirtualChannelWrite(g_vchannel, "\n", (ULONG) 1, &bytes_written);
191			ReleaseMutex(g_mutex);
192
193			if (!result)
194			return -1;
195
196			return bytes_written;
197			}
198	ossman_	1075
199			void
200			vchannel_block()
201			{
202			WaitForSingleObject(g_mutex, INFINITE);
203			}
204
205			void
206			vchannel_unblock()
207			{
208			ReleaseMutex(g_mutex);
209			}
210	ossman_	1113
211			const char *
212			vchannel_strfilter(char *string)
213			{
214			char *c;
215
216			for (c = string; *c != '\0'; c++)
217			{
218	ossman_	1129	if (((unsigned char) c < 0x20) \|\| (strchr(INVALID_CHARS, c) != NULL))
219	ossman_	1113	*c = REPLACEMENT_CHAR;
220			}
221
222			return string;
223			}