20#include <freerdp/config.h>
23#include <winpr/assert.h>
25#if !defined(_WIN32) && !defined(__EMSCRIPTEN__) && defined(CHANNEL_RAIL_CLIENT)
27#include <freerdp/channels/channels.h>
39#include <winpr/cast.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>
49#define RAIL_IPC_NAME_PREFIX "freerdp-rail-v1-"
51struct rdp_client_rail_callbacks
54 pMonitoredDesktop MonitoredDesktop;
55 pNonMonitoredDesktop NonMonitoredDesktop;
58struct rdp_client_rail_ipc
60 RailClientContext* rail;
68 const rdpClientContext* cctx;
70 struct rdp_client_rail_callbacks client;
71 CRITICAL_SECTION lock;
74#if !defined(_WIN32) && !defined(__EMSCRIPTEN__) && defined(CHANNEL_RAIL_CLIENT)
76static void rail_ipc_stop(rdpClientRailIpc* ipc);
79static BOOL rail_ipc_start(rdpClientRailIpc* ipc);
82static BOOL rail_ipc_build_hash(
const rdpSettings* settings, BYTE* hash,
size_t len)
85 WINPR_DIGEST_CTX* digest =
nullptr;
87 WINPR_ASSERT(settings);
90 digest = winpr_Digest_New();
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 };
102 if (!winpr_Digest_Init(digest, WINPR_MD_SHA256))
104 for (
size_t x = 0; x < ARRAYSIZE(strings); x++)
109 if (!winpr_Digest_Update(digest, str, strlen(str)))
113 for (
size_t x = 0; x < ARRAYSIZE(integers); x++)
116 if (!winpr_Digest_Update(digest, &val,
sizeof(val)))
120 const UINT32 loadBalanceLength =
123 if (loadBalanceLength > 0)
125 if (!winpr_Digest_Update(digest, loadBalance, loadBalanceLength))
129 rc = winpr_Digest_Final(digest, hash, len);
132 winpr_Digest_Free(digest);
136static void rail_ipc_log_errno(
const rdpClientRailIpc* ipc, DWORD level,
const char* operation,
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);
147static BOOL rail_ipc_build_names(rdpClientRailIpc* ipc,
const rdpSettings* settings)
149 BYTE hash[WINPR_SHA256_DIGEST_LENGTH] = WINPR_C_ARRAY_INIT;
150 char hex[WINPR_SHA256_DIGEST_LENGTH * 2U + 1U] = WINPR_C_ARRAY_INIT;
153 WINPR_ASSERT(settings);
155 if (!rail_ipc_build_hash(settings, hash,
sizeof(hash)) ||
156 (winpr_BinToHexStringBuffer(hash,
sizeof(hash), hex,
sizeof(hex), FALSE) !=
160 ipc->path = GetKnownSubPathV(KNOWN_PATH_XDG_RUNTIME_DIR, RAIL_IPC_NAME_PREFIX
"%s.fifo", hex);
161 return ipc->path !=
nullptr;
165static BOOL rail_ipc_open_fifo(rdpClientRailIpc* ipc)
170 if ((unlink(ipc->path) < 0) && (errno != ENOENT))
172 rail_ipc_log_errno(ipc, WLOG_ERROR,
"removing the stale launch FIFO", errno);
175 if (mkfifo(ipc->path, 0600) < 0)
177 rail_ipc_log_errno(ipc, WLOG_ERROR,
"creating the launch FIFO", errno);
180 ipc->fifoCreated = TRUE;
181 ipc->readFd = open(ipc->path, O_RDONLY | O_NONBLOCK | O_CLOEXEC | O_NOFOLLOW);
184 rail_ipc_log_errno(ipc, WLOG_ERROR,
"opening the launch FIFO for reading", errno);
187 ipc->writeFd = open(ipc->path, O_WRONLY | O_NONBLOCK | O_CLOEXEC | O_NOFOLLOW);
188 if (ipc->writeFd < 0)
190 rail_ipc_log_errno(ipc, WLOG_ERROR,
"opening the held launch FIFO writer", errno);
193 ipc->readEvent = CreateFileDescriptorEvent(
nullptr, FALSE, FALSE, ipc->readFd, WINPR_FD_READ);
196 WLog_Print(ipc->log, WLOG_ERROR,
"RAIL IPC could not create the launch FIFO event");
202static void rail_ipc_disable(rdpClientRailIpc* ipc)
207 (void)CloseHandle(ipc->readEvent);
208 ipc->readEvent =
nullptr;
210 if (ipc->writeFd >= 0)
212 (void)close(ipc->writeFd);
215 if (ipc->readFd >= 0)
217 (void)close(ipc->readFd);
220 if (ipc->fifoCreated)
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;
228static BOOL rail_ipc_on_event_int(rdpContext* context,
void* userdata)
230 rdpClientRailIpc* ipc = userdata;
231 WINPR_ASSERT(context);
234 if (freerdp_get_state(context) != CONNECTION_STATE_ACTIVE)
236 WINPR_ASSERT(ipc->rail);
237 WINPR_ASSERT(ipc->rail->ClientExecute);
239 const size_t RAIL_DECODER_BLOCK = 1024;
240 const size_t RAIL_DECODER_MAX = RAIL_DECODER_BLOCK * 32;
242 if (!Stream_EnsureRemainingCapacity(ipc->buffer, RAIL_DECODER_BLOCK))
244 const ssize_t count =
245 read(ipc->readFd, Stream_Pointer(ipc->buffer), Stream_GetRemainingCapacity(ipc->buffer));
250 if ((count < 0) && ((errno == EWOULDBLOCK) || (errno == EINTR)))
253 WLog_Print(ipc->log, WLOG_ERROR,
"RAIL IPC disabled after unexpected FIFO EOF");
255 rail_ipc_log_errno(ipc, WLOG_ERROR,
"reading the launch FIFO", errno);
259 if (!Stream_SafeSeek(ipc->buffer, WINPR_ASSERTING_INT_CAST(
size_t, count)))
262 const size_t pos = Stream_GetPosition(ipc->buffer);
263 if (pos > RAIL_DECODER_MAX)
265 WLog_Print(ipc->log, WLOG_ERROR,
266 "RAIL IPC read %" PRIuz
" bytes, but no valid data found. Discarding", pos);
268 Stream_ResetPosition(ipc->buffer);
278 if ((val >= 0) && (val <= UINT16_MAX))
279 exec.flags = (uint16_t)val;
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)
291 WLog_Print(ipc->log, WLOG_DEBUG,
"execute %s", exec.RemoteApplicationProgram);
292 if (ipc && ipc->rail)
294 const UINT rc = ipc->rail->ClientExecute(ipc->rail, &exec);
298 WLog_Print(ipc->log, WLOG_WARN,
"Failed to execute %s", str);
309 Stream_ResetPosition(ipc->buffer);
314static BOOL rail_ipc_on_event(rdpContext* context,
void* userdata)
316 rdpClientRailIpc* ipc = userdata;
317 WINPR_ASSERT(context);
320 EnterCriticalSection(&ipc->lock);
321 const BOOL rc = rail_ipc_on_event_int(context, userdata);
322 LeaveCriticalSection(&ipc->lock);
326static BOOL rail_ipc_monitored_desktop(rdpContext* context,
const WINDOW_ORDER_INFO* orderInfo,
329 WINPR_ASSERT(context);
331 rdpClientContext* cctx = (rdpClientContext*)context;
333 rdpClientRailIpc* ipc = cctx->railIpc;
335 EnterCriticalSection(&ipc->lock);
336 const BOOL rc = rail_ipc_start(ipc);
337 LeaveCriticalSection(&ipc->lock);
340 return IFCALLRESULT(TRUE, cctx->railIpc->client.MonitoredDesktop, context, orderInfo,
344static BOOL rail_ipc_non_monitored_desktop(rdpContext* context,
const WINDOW_ORDER_INFO* orderInfo)
346 WINPR_ASSERT(context);
348 rdpClientContext* cctx = (rdpClientContext*)context;
349 return IFCALLRESULT(TRUE, cctx->railIpc->client.NonMonitoredDesktop, context, orderInfo);
352static void rail_ipc_attach_int(rdpClientRailIpc* ipc, RailClientContext* rail,
353 rdpClientContext* cctx)
359 const rdpSettings* settings = cctx->context.settings;
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;
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;
377void rail_ipc_attach(rdpClientRailIpc* ipc, RailClientContext* rail, rdpClientContext* cctx)
380 EnterCriticalSection(&ipc->lock);
381 rail_ipc_attach_int(ipc, rail, cctx);
382 LeaveCriticalSection(&ipc->lock);
385static void rail_ipc_detach_int(rdpClientRailIpc* ipc, WINPR_ATTR_UNUSED RailClientContext* rail,
386 rdpClientContext* cctx)
392 const rdpSettings* settings = cctx->context.settings;
399 if (ipc->client.saved)
401 cctx->context.update->window->MonitoredDesktop = ipc->client.MonitoredDesktop;
402 cctx->context.update->window->NonMonitoredDesktop = ipc->client.NonMonitoredDesktop;
405 const struct rdp_client_rail_callbacks empty = WINPR_C_ARRAY_INIT;
411void rail_ipc_detach(rdpClientRailIpc* ipc, RailClientContext* rail, rdpClientContext* cctx)
414 EnterCriticalSection(&ipc->lock);
415 rail_ipc_detach_int(ipc, rail, cctx);
416 LeaveCriticalSection(&ipc->lock);
419BOOL rail_ipc_start(rdpClientRailIpc* ipc)
422 if (ipc->fifoCreated)
425 if (!rail_ipc_build_names(ipc, ipc->cctx->context.settings) || !rail_ipc_open_fifo(ipc))
428 if (!freerdp_client_channel_register(ipc->cctx->context.channels, ipc->readEvent,
429 rail_ipc_on_event, ipc))
432 WLog_Print(ipc->log, WLOG_INFO,
"RAIL launch FIFO available at %s", ipc->path);
439void rail_ipc_stop(rdpClientRailIpc* ipc)
444 freerdp_client_channel_unregister(ipc->cctx->context.channels, ipc->readEvent);
446 rail_ipc_disable(ipc);
454void rail_ipc_attach(WINPR_ATTR_UNUSED rdpClientRailIpc* ipc,
455 WINPR_ATTR_UNUSED RailClientContext* rail,
456 WINPR_ATTR_UNUSED rdpClientContext* cctx)
460void rail_ipc_detach(WINPR_ATTR_UNUSED rdpClientRailIpc* ipc,
461 WINPR_ATTR_UNUSED RailClientContext* rail,
462 WINPR_ATTR_UNUSED rdpClientContext* cctx)
468rdpClientRailIpc* rail_ipc_new(
void)
470 rdpClientRailIpc* ipc = calloc(1,
sizeof(rdpClientRailIpc));
473 ipc->buffer = Stream_New(
nullptr, 1024);
477 InitializeCriticalSection(&ipc->lock);
487void rail_ipc_free(rdpClientRailIpc* ipc)
491 DeleteCriticalSection(&ipc->lock);
492 Stream_Free(ipc->buffer, TRUE);
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.
WINPR_ATTR_NODISCARD WINPR_API INT64 WINPR_JSON_GetIntegerValue(const WINPR_JSON *item)
Return the Integer value of a JSON item.
WINPR_API WINPR_JSON * WINPR_JSON_ParseWithLength(const char *value, size_t buffer_length)
Parse a JSON string.
WINPR_ATTR_NODISCARD WINPR_API WINPR_JSON * WINPR_JSON_AddUIntegerToObject(WINPR_JSON *object, const char *name, uint64_t number)
WINPR_JSON_AddUIntegerToObject.
WINPR_API char * WINPR_JSON_PrintUnformatted(WINPR_JSON *item)
Serialize a JSON instance to string without formatting for human readable formatted output see WINPR_...
WINPR_API void WINPR_JSON_Delete(WINPR_JSON *item)
Delete a WinPR JSON wrapper object.
WINPR_ATTR_NODISCARD WINPR_API const char * WINPR_JSON_GetStringValue(WINPR_JSON *item)
Return the String value of a JSON item.
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.