FreeRDP
Loading...
Searching...
No Matches
rdp2tcp_main.c
1
20#include <stdio.h>
21#include <winpr/assert.h>
22
23#include <winpr/file.h>
24#include <winpr/pipe.h>
25#include <winpr/thread.h>
26
27#include <freerdp/freerdp.h>
28#include <freerdp/svc.h>
29#include <freerdp/channels/rdp2tcp.h>
30
31#include <freerdp/utils/warnings.h>
32
33#include <freerdp/log.h>
34#define TAG CLIENT_TAG(RDP2TCP_DVC_CHANNEL_NAME)
35
36typedef struct
37{
38 HANDLE hStdOutputRead;
39 HANDLE hStdInputWrite;
40 HANDLE hProcess;
41 HANDLE copyThread;
42 HANDLE writeComplete;
43 HANDLE writeTerminated;
44 DWORD openHandle;
45 void* initHandle;
46 CHANNEL_ENTRY_POINTS_FREERDP_EX channelEntryPoints;
47 char buffer[16 * 1024];
48 char* commandline;
49 UINT32 totalLength;
50} Plugin;
51
52static int init_external_addin(Plugin* plugin)
53{
54 int rc = -1;
55 SECURITY_ATTRIBUTES saAttr = WINPR_C_ARRAY_INIT;
56 STARTUPINFOA siStartInfo = WINPR_C_ARRAY_INIT; /* Using ANSI type to match CreateProcessA */
57 PROCESS_INFORMATION procInfo = WINPR_C_ARRAY_INIT;
58
59 WINPR_ASSERT(plugin);
60
61 saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
62 saAttr.bInheritHandle = TRUE;
63 saAttr.lpSecurityDescriptor = nullptr;
64 siStartInfo.cb = sizeof(STARTUPINFO);
65 siStartInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
66 siStartInfo.dwFlags = STARTF_USESTDHANDLES;
67
68 // Create pipes
69 if (!CreatePipe(&plugin->hStdOutputRead, &siStartInfo.hStdOutput, &saAttr, 0))
70 {
71 WLog_ERR(TAG, "stdout CreatePipe");
72 goto fail;
73 }
74
75 if (!SetHandleInformation(plugin->hStdOutputRead, HANDLE_FLAG_INHERIT, 0))
76 {
77 WLog_ERR(TAG, "stdout SetHandleInformation");
78 goto fail;
79 }
80
81 if (!CreatePipe(&siStartInfo.hStdInput, &plugin->hStdInputWrite, &saAttr, 0))
82 {
83 WLog_ERR(TAG, "stdin CreatePipe");
84 goto fail;
85 }
86
87 if (!SetHandleInformation(plugin->hStdInputWrite, HANDLE_FLAG_INHERIT, 0))
88 {
89 WLog_ERR(TAG, "stdin SetHandleInformation");
90 goto fail;
91 }
92
93 // Execute plugin
94 const ADDIN_ARGV* args = (const ADDIN_ARGV*)plugin->channelEntryPoints.pExtendedData;
95 if (!args || (args->argc < 2))
96 {
97 WLog_ERR(TAG, "missing command line options");
98 goto fail;
99 }
100
101 plugin->commandline = _strdup(args->argv[1]);
102 if (!CreateProcessA(nullptr,
103 plugin->commandline, // command line
104 nullptr, // process security attributes
105 nullptr, // primary thread security attributes
106 TRUE, // handles are inherited
107 0, // creation flags
108 nullptr, // use parent's environment
109 nullptr, // use parent's current directory
110 &siStartInfo, // STARTUPINFO pointer
111 &procInfo // receives PROCESS_INFORMATION
112 ))
113 {
114 WLog_ERR(TAG, "fork for addin");
115 goto fail;
116 }
117
118 plugin->hProcess = procInfo.hProcess;
119
120 rc = 0;
121fail:
122 (void)CloseHandle(procInfo.hThread);
123 (void)CloseHandle(siStartInfo.hStdOutput);
124 (void)CloseHandle(siStartInfo.hStdInput);
125 return rc;
126}
127
128static DWORD WINAPI copyThread(void* data)
129{
130 DWORD status = WAIT_OBJECT_0;
131 Plugin* plugin = (Plugin*)data;
132 size_t const bufsize = 16ULL * 1024ULL;
133
134 WINPR_ASSERT(plugin);
135
136 while (status == WAIT_OBJECT_0)
137 {
138 (void)ResetEvent(plugin->writeComplete);
139
140 DWORD dwRead = 0;
141 char* buffer = calloc(bufsize, sizeof(char));
142
143 if (!buffer)
144 {
145 (void)fprintf(stderr, "rdp2tcp copyThread: malloc failed\n");
146 goto fail;
147 }
148
149 // if (!ReadFile(plugin->hStdOutputRead, plugin->buffer, sizeof plugin->buffer, &dwRead,
150 // nullptr))
151 if (!ReadFile(plugin->hStdOutputRead, buffer, bufsize, &dwRead, nullptr))
152 {
153 free(buffer);
154 goto fail;
155 }
156
157 if (plugin->channelEntryPoints.pVirtualChannelWriteEx(
158 plugin->initHandle, plugin->openHandle, buffer, dwRead, buffer) != CHANNEL_RC_OK)
159 {
160 free(buffer);
161 (void)fprintf(stderr, "rdp2tcp copyThread failed %i\n", (int)dwRead);
162 goto fail;
163 }
164
165 HANDLE handles[] = { plugin->writeComplete,
166 freerdp_abort_event(plugin->channelEntryPoints.context),
167 plugin->writeTerminated };
168 status = WaitForMultipleObjects(ARRAYSIZE(handles), handles, FALSE, INFINITE);
169 }
170
171fail:
172 ExitThread(0);
173 return 0;
174}
175
176static void closeChannel(Plugin* plugin)
177{
178 WINPR_ASSERT(plugin);
179 WINPR_ASSERT(plugin->channelEntryPoints.pVirtualChannelCloseEx);
180 plugin->channelEntryPoints.pVirtualChannelCloseEx(plugin->initHandle, plugin->openHandle);
181}
182
183static void dataReceived(Plugin* plugin, void* pData, UINT32 dataLength, UINT32 totalLength,
184 UINT32 dataFlags)
185{
186 DWORD dwWritten = 0;
187
188 WINPR_ASSERT(plugin);
189
190 if (dataFlags & CHANNEL_FLAG_SUSPEND)
191 return;
192
193 if (dataFlags & CHANNEL_FLAG_RESUME)
194 return;
195
196 if (dataFlags & CHANNEL_FLAG_FIRST)
197 {
198 plugin->totalLength = totalLength;
199 if (!WriteFile(plugin->hStdInputWrite, &totalLength, sizeof(totalLength), &dwWritten,
200 nullptr))
201 closeChannel(plugin);
202 }
203
204 if (!WriteFile(plugin->hStdInputWrite, pData, dataLength, &dwWritten, nullptr))
205 closeChannel(plugin);
206}
207
208static void VCAPITYPE VirtualChannelOpenEventEx(LPVOID lpUserParam,
209 WINPR_ATTR_UNUSED DWORD openHandle, UINT event,
210 LPVOID pData, UINT32 dataLength, UINT32 totalLength,
211 UINT32 dataFlags)
212{
213 Plugin* plugin = (Plugin*)lpUserParam;
214
215 WINPR_ASSERT(plugin);
216 switch (event)
217 {
218 case CHANNEL_EVENT_DATA_RECEIVED:
219 dataReceived(plugin, pData, dataLength, totalLength, dataFlags);
220 break;
221
222 case CHANNEL_EVENT_WRITE_CANCELLED:
223 free(pData);
224 break;
225 case CHANNEL_EVENT_WRITE_COMPLETE:
226 (void)SetEvent(plugin->writeComplete);
227 free(pData);
228 break;
229 default:
230 break;
231 }
232}
233
234static void channel_terminated(Plugin* plugin)
235{
236 if (!plugin)
237 return;
238
239 if (plugin->writeTerminated)
240 SetEvent(plugin->writeTerminated);
241
242 if (plugin->copyThread)
243 {
244 (void)WaitForSingleObject(plugin->copyThread, INFINITE);
245 (void)CloseHandle(plugin->copyThread);
246 }
247 if (plugin->writeComplete)
248 (void)CloseHandle(plugin->writeComplete);
249 if (plugin->writeTerminated)
250 (void)CloseHandle(plugin->writeTerminated);
251
252 (void)CloseHandle(plugin->hStdInputWrite);
253 (void)CloseHandle(plugin->hStdOutputRead);
254 TerminateProcess(plugin->hProcess, 0);
255 (void)CloseHandle(plugin->hProcess);
256 free(plugin->commandline);
257 free(plugin);
258}
259
260static void channel_initialized(Plugin* plugin)
261{
262 WINPR_ASSERT(plugin);
263 WINPR_ASSERT(!plugin->writeComplete);
264 plugin->writeComplete = CreateEvent(nullptr, TRUE, FALSE, nullptr);
265 WINPR_ASSERT(plugin->writeComplete);
266
267 WINPR_ASSERT(!plugin->writeTerminated);
268 plugin->writeTerminated = CreateEvent(nullptr, TRUE, FALSE, nullptr);
269 WINPR_ASSERT(plugin->writeTerminated);
270
271 WINPR_ASSERT(!plugin->copyThread);
272 plugin->copyThread = CreateThread(nullptr, 0, copyThread, plugin, 0, nullptr);
273 WINPR_ASSERT(plugin->copyThread);
274}
275
276static VOID VCAPITYPE VirtualChannelInitEventEx(LPVOID lpUserParam, LPVOID pInitHandle, UINT event,
277 WINPR_ATTR_UNUSED LPVOID pData,
278 WINPR_ATTR_UNUSED UINT dataLength)
279{
280 Plugin* plugin = (Plugin*)lpUserParam;
281
282 WINPR_ASSERT(plugin);
283
284 switch (event)
285 {
286 case CHANNEL_EVENT_INITIALIZED:
287 channel_initialized(plugin);
288 break;
289
290 case CHANNEL_EVENT_CONNECTED:
291 WINPR_ASSERT(plugin);
292 WINPR_ASSERT(plugin->channelEntryPoints.pVirtualChannelOpenEx);
293 if (plugin->channelEntryPoints.pVirtualChannelOpenEx(
294 pInitHandle, &plugin->openHandle, RDP2TCP_DVC_CHANNEL_NAME,
295 VirtualChannelOpenEventEx) != CHANNEL_RC_OK)
296 return;
297
298 break;
299
300 case CHANNEL_EVENT_DISCONNECTED:
301 closeChannel(plugin);
302 break;
303
304 case CHANNEL_EVENT_TERMINATED:
305 channel_terminated(plugin);
306 break;
307 default:
308 break;
309 }
310}
311
312#define VirtualChannelEntryEx rdp2tcp_VirtualChannelEntryEx
313FREERDP_ENTRY_POINT(BOOL VCAPITYPE VirtualChannelEntryEx(PCHANNEL_ENTRY_POINTS_EX pEntryPoints,
314 PVOID pInitHandle))
315{
316 CHANNEL_ENTRY_POINTS_FREERDP_EX* pEntryPointsEx =
317 (CHANNEL_ENTRY_POINTS_FREERDP_EX*)pEntryPoints;
318 WINPR_ASSERT(pEntryPointsEx);
319 WINPR_ASSERT(pEntryPointsEx->cbSize >= sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX) &&
320 pEntryPointsEx->MagicNumber == FREERDP_CHANNEL_MAGIC_NUMBER);
321
322 freerdp_warn_unmaintained(WLog_Get(TAG), "CHANNEL_RDP2TCP_CLIENT");
323
324 Plugin* plugin = (Plugin*)calloc(1, sizeof(Plugin));
325
326 if (!plugin)
327 return FALSE;
328
329 plugin->initHandle = pInitHandle;
330 plugin->channelEntryPoints = *pEntryPointsEx;
331
332 if (init_external_addin(plugin) < 0)
333 {
334 channel_terminated(plugin);
335 return FALSE;
336 }
337
338 CHANNEL_DEF channelDef = WINPR_C_ARRAY_INIT;
339 strncpy(channelDef.name, RDP2TCP_DVC_CHANNEL_NAME, sizeof(channelDef.name));
340 channelDef.options =
341 CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP | CHANNEL_OPTION_COMPRESS_RDP;
342
343 if (pEntryPointsEx->pVirtualChannelInitEx(plugin, nullptr, pInitHandle, &channelDef, 1,
344 VIRTUAL_CHANNEL_VERSION_WIN2000,
345 VirtualChannelInitEventEx) != CHANNEL_RC_OK)
346 {
347 channel_terminated(plugin);
348 return FALSE;
349 }
350
351 return TRUE;
352}
Definition svc.h:60