FreeRDP
Loading...
Searching...
No Matches
rail_ipc.c
1
19
20#include <freerdp/config.h>
21#include "rail_ipc.h"
22
23#include <winpr/assert.h>
24
25#if !defined(_WIN32) && !defined(__EMSCRIPTEN__) && defined(CHANNEL_RAIL_CLIENT)
26
27#include <freerdp/channels/channels.h>
28
29#include <errno.h>
30#include <stdlib.h>
31#include <string.h>
32#include <fcntl.h>
33#include <sys/file.h>
34#include <sys/stat.h>
35#include <unistd.h>
36
37#endif
38
39#include <winpr/cast.h>
40#include <winpr/crt.h>
41#include <winpr/custom-crypto.h>
42#include <winpr/endian.h>
43#include <winpr/environment.h>
44#include <winpr/path.h>
45#include <winpr/print.h>
46#include <winpr/string.h>
47#include <winpr/synch.h>
48
49#define RAIL_IPC_NAME_PREFIX "freerdp-rail-v1-"
50
51struct rdp_client_rail_callbacks
52{
53 BOOL saved;
54 pMonitoredDesktop MonitoredDesktop;
55 pNonMonitoredDesktop NonMonitoredDesktop;
56};
57
58struct rdp_client_rail_ipc
59{
60 RailClientContext* rail;
61 wLog* log;
62 char* path;
63 int readFd;
64 int writeFd;
65 HANDLE readEvent;
66 BOOL fifoCreated;
67
68 const rdpClientContext* cctx;
69 wStream* buffer;
70 struct rdp_client_rail_callbacks client;
71 CRITICAL_SECTION lock;
72};
73
74#if !defined(_WIN32) && !defined(__EMSCRIPTEN__) && defined(CHANNEL_RAIL_CLIENT)
75
76static void rail_ipc_stop(rdpClientRailIpc* ipc);
77
78WINPR_ATTR_NODISCARD
79static BOOL rail_ipc_start(rdpClientRailIpc* ipc);
80
81WINPR_ATTR_NODISCARD
82static BOOL rail_ipc_build_hash(const rdpSettings* settings, BYTE* hash, size_t len)
83{
84 BOOL rc = FALSE;
85 WINPR_DIGEST_CTX* digest = nullptr;
86
87 WINPR_ASSERT(settings);
88 WINPR_ASSERT(hash);
89
90 digest = winpr_Digest_New();
91 if (!digest)
92 return FALSE;
93
94 static const FreeRDP_Settings_Keys_String strings[] = { FreeRDP_ServerHostname,
95 FreeRDP_UserSpecifiedServerName,
96 FreeRDP_Username, FreeRDP_Domain,
97 FreeRDP_PreconnectionBlob };
98 static const FreeRDP_Settings_Keys_UInt32 integers[] = { FreeRDP_ServerPort,
99 FreeRDP_RedirectedSessionId,
100 FreeRDP_PreconnectionId };
101
102 if (!winpr_Digest_Init(digest, WINPR_MD_SHA256))
103 goto out;
104 for (size_t x = 0; x < ARRAYSIZE(strings); x++)
105 {
106 const char* str = freerdp_settings_get_string(settings, strings[x]);
107 if (str)
108 {
109 if (!winpr_Digest_Update(digest, str, strlen(str)))
110 goto out;
111 }
112 }
113 for (size_t x = 0; x < ARRAYSIZE(integers); x++)
114 {
115 const UINT32 val = freerdp_settings_get_uint32(settings, integers[x]);
116 if (!winpr_Digest_Update(digest, &val, sizeof(val)))
117 goto out;
118 }
119
120 const UINT32 loadBalanceLength =
121 freerdp_settings_get_uint32(settings, FreeRDP_LoadBalanceInfoLength);
122 const void* loadBalance = freerdp_settings_get_pointer(settings, FreeRDP_LoadBalanceInfo);
123 if (loadBalanceLength > 0)
124 {
125 if (!winpr_Digest_Update(digest, loadBalance, loadBalanceLength))
126 goto out;
127 }
128
129 rc = winpr_Digest_Final(digest, hash, len);
130
131out:
132 winpr_Digest_Free(digest);
133 return rc;
134}
135
136static void rail_ipc_log_errno(const rdpClientRailIpc* ipc, DWORD level, const char* operation,
137 int error)
138{
139 WINPR_ASSERT(ipc);
140 WINPR_ASSERT(operation);
141 char ebuffer[256] = WINPR_C_ARRAY_INIT;
142 WLog_Print(ipc->log, level, "RAIL IPC %s failed: %s [%d]", operation,
143 winpr_strerror(error, ebuffer, sizeof(ebuffer)), error);
144}
145
146WINPR_ATTR_NODISCARD
147static BOOL rail_ipc_build_names(rdpClientRailIpc* ipc, const rdpSettings* settings)
148{
149 BYTE hash[WINPR_SHA256_DIGEST_LENGTH] = WINPR_C_ARRAY_INIT;
150 char hex[WINPR_SHA256_DIGEST_LENGTH * 2U + 1U] = WINPR_C_ARRAY_INIT;
151
152 WINPR_ASSERT(ipc);
153 WINPR_ASSERT(settings);
154
155 if (!rail_ipc_build_hash(settings, hash, sizeof(hash)) ||
156 (winpr_BinToHexStringBuffer(hash, sizeof(hash), hex, sizeof(hex), FALSE) !=
157 sizeof(hash) * 2U))
158 return FALSE;
159
160 ipc->path = GetKnownSubPathV(KNOWN_PATH_XDG_RUNTIME_DIR, RAIL_IPC_NAME_PREFIX "%s.fifo", hex);
161 return ipc->path != nullptr;
162}
163
164WINPR_ATTR_NODISCARD
165static BOOL rail_ipc_open_fifo(rdpClientRailIpc* ipc)
166{
167 WINPR_ASSERT(ipc);
168
169 /* Ownership is locked before replacing a stale FIFO. */
170 if ((unlink(ipc->path) < 0) && (errno != ENOENT))
171 {
172 rail_ipc_log_errno(ipc, WLOG_ERROR, "removing the stale launch FIFO", errno);
173 return FALSE;
174 }
175 if (mkfifo(ipc->path, 0600) < 0)
176 {
177 rail_ipc_log_errno(ipc, WLOG_ERROR, "creating the launch FIFO", errno);
178 return FALSE;
179 }
180 ipc->fifoCreated = TRUE;
181 ipc->readFd = open(ipc->path, O_RDONLY | O_NONBLOCK | O_CLOEXEC | O_NOFOLLOW);
182 if (ipc->readFd < 0)
183 {
184 rail_ipc_log_errno(ipc, WLOG_ERROR, "opening the launch FIFO for reading", errno);
185 return FALSE;
186 }
187 ipc->writeFd = open(ipc->path, O_WRONLY | O_NONBLOCK | O_CLOEXEC | O_NOFOLLOW);
188 if (ipc->writeFd < 0)
189 {
190 rail_ipc_log_errno(ipc, WLOG_ERROR, "opening the held launch FIFO writer", errno);
191 return FALSE;
192 }
193 ipc->readEvent = CreateFileDescriptorEvent(nullptr, FALSE, FALSE, ipc->readFd, WINPR_FD_READ);
194 if (!ipc->readEvent)
195 {
196 WLog_Print(ipc->log, WLOG_ERROR, "RAIL IPC could not create the launch FIFO event");
197 return FALSE;
198 }
199 return TRUE;
200}
201
202static void rail_ipc_disable(rdpClientRailIpc* ipc)
203{
204 WINPR_ASSERT(ipc);
205 if (ipc->readEvent)
206 {
207 (void)CloseHandle(ipc->readEvent);
208 ipc->readEvent = nullptr;
209 }
210 if (ipc->writeFd >= 0)
211 {
212 (void)close(ipc->writeFd);
213 ipc->writeFd = -1;
214 }
215 if (ipc->readFd >= 0)
216 {
217 (void)close(ipc->readFd);
218 ipc->readFd = -1;
219 }
220 if (ipc->fifoCreated)
221 {
222 if ((unlink(ipc->path) < 0) && (errno != ENOENT))
223 rail_ipc_log_errno(ipc, WLOG_WARN, "removing the launch FIFO", errno);
224 ipc->fifoCreated = FALSE;
225 }
226}
227
228static BOOL rail_ipc_on_event_int(rdpContext* context, void* userdata)
229{
230 rdpClientRailIpc* ipc = userdata;
231 WINPR_ASSERT(context);
232 WINPR_ASSERT(ipc);
233
234 if (freerdp_get_state(context) != CONNECTION_STATE_ACTIVE)
235 return TRUE;
236 WINPR_ASSERT(ipc->rail);
237 WINPR_ASSERT(ipc->rail->ClientExecute);
238
239 const size_t RAIL_DECODER_BLOCK = 1024;
240 const size_t RAIL_DECODER_MAX = RAIL_DECODER_BLOCK * 32;
241
242 if (!Stream_EnsureRemainingCapacity(ipc->buffer, RAIL_DECODER_BLOCK))
243 return FALSE;
244 const ssize_t count =
245 read(ipc->readFd, Stream_Pointer(ipc->buffer), Stream_GetRemainingCapacity(ipc->buffer));
246 if (count <= 0)
247 {
248 if (errno == EAGAIN)
249 return TRUE;
250 if ((count < 0) && ((errno == EWOULDBLOCK) || (errno == EINTR)))
251 return TRUE;
252 if (count == 0)
253 WLog_Print(ipc->log, WLOG_ERROR, "RAIL IPC disabled after unexpected FIFO EOF");
254 else
255 rail_ipc_log_errno(ipc, WLOG_ERROR, "reading the launch FIFO", errno);
256 return TRUE;
257 }
258
259 if (!Stream_SafeSeek(ipc->buffer, WINPR_ASSERTING_INT_CAST(size_t, count)))
260 return FALSE;
261
262 const size_t pos = Stream_GetPosition(ipc->buffer);
263 if (pos > RAIL_DECODER_MAX)
264 {
265 WLog_Print(ipc->log, WLOG_ERROR,
266 "RAIL IPC read %" PRIuz " bytes, but no valid data found. Discarding", pos);
267
268 Stream_ResetPosition(ipc->buffer);
269 return TRUE;
270 }
271
272 WINPR_JSON* input = WINPR_JSON_ParseWithLength(Stream_BufferAs(ipc->buffer, char), pos);
273 if (input)
274 {
275 RAIL_EXEC_ORDER exec = WINPR_C_ARRAY_INIT;
276 const INT64 val =
278 if ((val >= 0) && (val <= UINT16_MAX))
279 exec.flags = (uint16_t)val;
280 else
281 WLog_Print(ipc->log, WLOG_WARN,
282 "JSON: flags: %" PRId64 " out of range, expected in range[0,65535]", val);
283 exec.RemoteApplicationProgram =
285 exec.RemoteApplicationWorkingDir =
287 exec.RemoteApplicationArguments =
289 if (ipc->rail->ClientExecute)
290 {
291 WLog_Print(ipc->log, WLOG_DEBUG, "execute %s", exec.RemoteApplicationProgram);
292 if (ipc && ipc->rail)
293 {
294 const UINT rc = ipc->rail->ClientExecute(ipc->rail, &exec);
295 (void)WINPR_JSON_AddUIntegerToObject(input, "ClientExecuteReturn", rc);
296 char* str = WINPR_JSON_PrintUnformatted(input);
297 if (rc != 0)
298 WLog_Print(ipc->log, WLOG_WARN, "Failed to execute %s", str);
299
300 if (str)
301 {
302 // TODO: write(ipc->writeFd, str, strlen(str));
303 free(str);
304 }
305 }
306 }
307 WINPR_JSON_Delete(input);
308 }
309 Stream_ResetPosition(ipc->buffer);
310
311 return TRUE;
312}
313
314static BOOL rail_ipc_on_event(rdpContext* context, void* userdata)
315{
316 rdpClientRailIpc* ipc = userdata;
317 WINPR_ASSERT(context);
318 WINPR_ASSERT(ipc);
319
320 EnterCriticalSection(&ipc->lock);
321 const BOOL rc = rail_ipc_on_event_int(context, userdata);
322 LeaveCriticalSection(&ipc->lock);
323 return rc;
324}
325
326static BOOL rail_ipc_monitored_desktop(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
327 const MONITORED_DESKTOP_ORDER* monitored_desktop)
328{
329 WINPR_ASSERT(context);
330
331 rdpClientContext* cctx = (rdpClientContext*)context;
332
333 rdpClientRailIpc* ipc = cctx->railIpc;
334 WINPR_ASSERT(ipc);
335 EnterCriticalSection(&ipc->lock);
336 const BOOL rc = rail_ipc_start(ipc);
337 LeaveCriticalSection(&ipc->lock);
338 if (!rc)
339 return rc;
340 return IFCALLRESULT(TRUE, cctx->railIpc->client.MonitoredDesktop, context, orderInfo,
341 monitored_desktop);
342}
343
344static BOOL rail_ipc_non_monitored_desktop(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo)
345{
346 WINPR_ASSERT(context);
347
348 rdpClientContext* cctx = (rdpClientContext*)context;
349 return IFCALLRESULT(TRUE, cctx->railIpc->client.NonMonitoredDesktop, context, orderInfo);
350}
351
352static void rail_ipc_attach_int(rdpClientRailIpc* ipc, RailClientContext* rail,
353 rdpClientContext* cctx)
354{
355 WINPR_ASSERT(ipc);
356 WINPR_ASSERT(rail);
357 WINPR_ASSERT(cctx);
358
359 const rdpSettings* settings = cctx->context.settings;
360 if (!freerdp_settings_get_bool(settings, FreeRDP_RemoteApplicationExecFromPipe))
361 return;
362
363 // Back up client context and callbacks
364 WINPR_ASSERT(!ipc->client.saved);
365 ipc->client.saved = TRUE;
366 ipc->client.MonitoredDesktop = cctx->context.update->window->MonitoredDesktop;
367 ipc->client.NonMonitoredDesktop = cctx->context.update->window->NonMonitoredDesktop;
368 ipc->rail = rail;
369
370 // Register our own wrappers
371 ipc->cctx = cctx;
372 ipc->log = cctx->context.log;
373 cctx->context.update->window->MonitoredDesktop = rail_ipc_monitored_desktop;
374 cctx->context.update->window->NonMonitoredDesktop = rail_ipc_non_monitored_desktop;
375}
376
377void rail_ipc_attach(rdpClientRailIpc* ipc, RailClientContext* rail, rdpClientContext* cctx)
378{
379 WINPR_ASSERT(ipc);
380 EnterCriticalSection(&ipc->lock);
381 rail_ipc_attach_int(ipc, rail, cctx);
382 LeaveCriticalSection(&ipc->lock);
383}
384
385static void rail_ipc_detach_int(rdpClientRailIpc* ipc, WINPR_ATTR_UNUSED RailClientContext* rail,
386 rdpClientContext* cctx)
387{
388 WINPR_ASSERT(ipc);
389 WINPR_ASSERT(rail);
390 WINPR_ASSERT(cctx);
391
392 const rdpSettings* settings = cctx->context.settings;
393 if (!freerdp_settings_get_bool(settings, FreeRDP_RemoteApplicationExecFromPipe))
394 return;
395
396 rail_ipc_stop(ipc);
397
398 // restore client context and callbacks
399 if (ipc->client.saved)
400 {
401 cctx->context.update->window->MonitoredDesktop = ipc->client.MonitoredDesktop;
402 cctx->context.update->window->NonMonitoredDesktop = ipc->client.NonMonitoredDesktop;
403 }
404
405 const struct rdp_client_rail_callbacks empty = WINPR_C_ARRAY_INIT;
406 ipc->client = empty;
407 ipc->cctx = nullptr;
408 ipc->log = nullptr;
409}
410
411void rail_ipc_detach(rdpClientRailIpc* ipc, RailClientContext* rail, rdpClientContext* cctx)
412{
413 WINPR_ASSERT(ipc);
414 EnterCriticalSection(&ipc->lock);
415 rail_ipc_detach_int(ipc, rail, cctx);
416 LeaveCriticalSection(&ipc->lock);
417}
418
419BOOL rail_ipc_start(rdpClientRailIpc* ipc)
420{
421 WINPR_ASSERT(ipc);
422 if (ipc->fifoCreated)
423 return TRUE;
424
425 if (!rail_ipc_build_names(ipc, ipc->cctx->context.settings) || !rail_ipc_open_fifo(ipc))
426 goto fail;
427
428 if (!freerdp_client_channel_register(ipc->cctx->context.channels, ipc->readEvent,
429 rail_ipc_on_event, ipc))
430 goto fail;
431
432 WLog_Print(ipc->log, WLOG_INFO, "RAIL launch FIFO available at %s", ipc->path);
433 return TRUE;
434fail:
435 rail_ipc_stop(ipc);
436 return FALSE;
437}
438
439void rail_ipc_stop(rdpClientRailIpc* ipc)
440{
441 if (!ipc)
442 return;
443
444 freerdp_client_channel_unregister(ipc->cctx->context.channels, ipc->readEvent);
445
446 rail_ipc_disable(ipc);
447
448 free(ipc->path);
449 ipc->path = nullptr;
450}
451
452#else
453
454void rail_ipc_attach(WINPR_ATTR_UNUSED rdpClientRailIpc* ipc,
455 WINPR_ATTR_UNUSED RailClientContext* rail,
456 WINPR_ATTR_UNUSED rdpClientContext* cctx)
457{
458}
459
460void rail_ipc_detach(WINPR_ATTR_UNUSED rdpClientRailIpc* ipc,
461 WINPR_ATTR_UNUSED RailClientContext* rail,
462 WINPR_ATTR_UNUSED rdpClientContext* cctx)
463{
464}
465
466#endif
467
468rdpClientRailIpc* rail_ipc_new(void)
469{
470 rdpClientRailIpc* ipc = calloc(1, sizeof(rdpClientRailIpc));
471 if (!ipc)
472 return nullptr;
473 ipc->buffer = Stream_New(nullptr, 1024);
474 if (!ipc->buffer)
475 goto fail;
476
477 InitializeCriticalSection(&ipc->lock);
478 ipc->readFd = -1;
479 ipc->writeFd = -1;
480 return ipc;
481
482fail:
483 rail_ipc_free(ipc);
484 return nullptr;
485}
486
487void rail_ipc_free(rdpClientRailIpc* ipc)
488{
489 if (!ipc)
490 return;
491 DeleteCriticalSection(&ipc->lock);
492 Stream_Free(ipc->buffer, TRUE);
493 free(ipc);
494}
WINPR_ATTR_NODISCARD WINPR_API WINPR_JSON * WINPR_JSON_GetObjectItemCaseSensitive(const WINPR_JSON *object, const char *string)
Same as WINPR_JSON_GetObjectItem but with case sensitive matching.
Definition c-json.c:127
WINPR_ATTR_NODISCARD WINPR_API INT64 WINPR_JSON_GetIntegerValue(const WINPR_JSON *item)
Return the Integer value of a JSON item.
Definition c-json.c:152
WINPR_API WINPR_JSON * WINPR_JSON_ParseWithLength(const char *value, size_t buffer_length)
Parse a JSON string.
Definition c-json.c:98
WINPR_ATTR_NODISCARD WINPR_API WINPR_JSON * WINPR_JSON_AddUIntegerToObject(WINPR_JSON *object, const char *name, uint64_t number)
WINPR_JSON_AddUIntegerToObject.
Definition c-json.c:281
WINPR_API char * WINPR_JSON_PrintUnformatted(WINPR_JSON *item)
Serialize a JSON instance to string without formatting for human readable formatted output see WINPR_...
Definition c-json.c:330
WINPR_API void WINPR_JSON_Delete(WINPR_JSON *item)
Delete a WinPR JSON wrapper object.
Definition c-json.c:103
WINPR_ATTR_NODISCARD WINPR_API const char * WINPR_JSON_GetStringValue(WINPR_JSON *item)
Return the String value of a JSON item.
Definition c-json.c:142
WINPR_ATTR_NODISCARD FREERDP_API const void * freerdp_settings_get_pointer(const rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id)
Returns a immutable pointer settings value.
WINPR_ATTR_NODISCARD FREERDP_API const char * freerdp_settings_get_string(const rdpSettings *settings, FreeRDP_Settings_Keys_String id)
Returns a immutable string settings value.
WINPR_ATTR_NODISCARD FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.