20#include <winpr/assert.h>
21#include <winpr/cast.h>
22#include <winpr/collections.h>
24#include <winpr/stream.h>
26#include <freerdp/log.h>
27#include <freerdp/multitransport.h>
28#include <freerdp/channels/drdynvc.h>
29#include <freerdp/utils/drdynvc.h>
33#include "server_tunnel.h"
35#define TAG FREERDP_TAG("core.server")
41#define SOFT_SYNC_HOLD_BACKLOG 1024
42#define SOFT_SYNC_HOLD_BACKLOG_BYTES (1024ull * 1024ull)
46#define SOFT_SYNC_MAX_BACKLOG ((size_t)256 * 1024)
47#define SOFT_SYNC_MAX_BACKLOG_BYTES (48ull * 1024ull * 1024ull)
51#define SOFT_SYNC_MAX_WAIT_MS 10000
54typedef enum WINPR_C23_ENUM_TYPE(uint32_t)
66 if (!MessageQueue_Post(vcm->queue,
nullptr, WTS_QUEUE_WAKE,
nullptr,
nullptr))
67 WLog_WARN(TAG,
"unable to wake the channel manager for Soft-Sync");
71typedef enum WINPR_C23_ENUM_TYPE(uint8_t)
73 SOFT_SYNC_STATE_NONE = 0,
74 SOFT_SYNC_STATE_SENT =
76 SOFT_SYNC_STATE_ANSWERED = 2,
84 wtsTunnelReadPduFn readPdu;
87 UINT64 softSyncWaitStart;
89 WTS_SOFT_SYNC_STATE softSyncState;
98static BOOL wts_queue_item(rdpPeerChannel* channel, BYTE* buffer, UINT32 length, BOOL tunnel)
100 WINPR_ASSERT(channel);
101 WINPR_ASSERT(channel->vcm);
102 WINPR_ASSERT(channel->channelId <= UINT16_MAX);
104 const UINT16 channelId = (UINT16)channel->channelId;
105 const WTS_QUEUE_ID
id = tunnel ? WTS_QUEUE_TUNNEL : WTS_QUEUE_TCP;
106 return MessageQueue_Post(channel->vcm->queue, (
void*)(UINT_PTR)channelId,
id, (
void*)buffer,
107 (
void*)(UINT_PTR)length);
116 WINPR_ASSERT(vcm->drdynvc_channel);
117 WINPR_ASSERT(data || (length == 0));
118 if ((length == 0) || (length > UINT32_MAX))
120 BYTE* buffer = malloc(length);
123 memcpy(buffer, data, length);
124 if (!wts_queue_item(vcm->drdynvc_channel, buffer, WINPR_ASSERTING_INT_CAST(UINT32, length),
140 WINPR_ASSERT(data || (length == 0));
141 if (!vcm->drdynvc_channel || (vcm->drdynvc_state != DRDYNVC_STATE_READY) || (length < 1))
144 wStream buffer = WINPR_C_ARRAY_INIT;
145 wStream* s = Stream_StaticConstInit(&buffer, data, length);
148 const UINT8 value = Stream_Get_UINT8(s);
149 const UINT8 Cmd = (UINT8)((value & 0xf0u) >> 4u);
150 const UINT8 Sp = (UINT8)((value & 0x0cu) >> 2u);
151 const UINT8 cbChId = (UINT8)(value & 0x03u);
154 case CAPABILITY_REQUEST_PDU:
155 case SOFT_SYNC_REQUEST_PDU:
156 case SOFT_SYNC_RESPONSE_PDU:
157 WLog_WARN(TAG,
"encountered %s on the tunnel, terminating the connection",
158 drdynvc_get_packet_type(Cmd));
161 return vcm->tunnel->readPdu(vcm->drdynvc_channel, s, Cmd, Sp, cbChId, TRUE);
170 if (!vcm->client || !vcm->client->context || !vcm->client->context->rdp)
172 return vcm->client->context->rdp->multitransport;
184 HashTable_Lock(vcm->dynamicVirtualChannels);
185 const BOOL expected = (vcm->tunnel->softSyncState == SOFT_SYNC_STATE_SENT);
186 HashTable_Unlock(vcm->dynamicVirtualChannels);
189 WLog_WARN(TAG,
"received an unexpected Soft-Sync response");
193 if (!Stream_CheckAndLogRequiredLength(TAG, s, 5))
195 Stream_Seek_UINT8(s);
196 const UINT32 count = Stream_Get_UINT32(s);
197 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, count,
sizeof(UINT32)))
199 BOOL reliable = FALSE;
200 for (UINT32 x = 0; x < count; x++)
202 if (Stream_Get_UINT32(s) == TUNNELTYPE_UDPFECR)
207 HashTable_Lock(vcm->dynamicVirtualChannels);
209 if (vcm->tunnel->softSyncState != SOFT_SYNC_STATE_SENT)
211 WLog_WARN(TAG,
"received an unexpected Soft-Sync response");
215 vcm->tunnel->softSyncState = SOFT_SYNC_STATE_ANSWERED;
216 vcm->tunnel->clientOnTunnel = reliable;
217 WLog_INFO(TAG,
"Soft-Sync Response: the client %s the reliable UDP tunnel",
218 reliable ?
"writes on" :
"does not use");
223 if (!reliable && (Queue_Count(vcm->tunnel->tunnelBacklog) > 0))
225 WLog_ERR(TAG,
"client wrote to a tunnel not named in its Soft-Sync Response");
231 vcm->tunnel->backlogBytes = 0;
232 while (rc && (held = Queue_Dequeue(vcm->tunnel->tunnelBacklog)))
234 rc = wts_read_tunnel_pdu(vcm, Stream_Buffer(held), Stream_Length(held));
235 Stream_Release(held);
238 HashTable_Unlock(vcm->dynamicVirtualChannels);
240 multitransport_hold_tunnel_data(wts_tunnel_multitransport(vcm), FALSE);
253 if (!InterlockedCompareExchange(&vcm->tunnel->tunnelReady, 0, 0) || !vcm->drdynvc_channel ||
254 (vcm->drdynvc_state != DRDYNVC_STATE_READY))
259 if (multitransport_tunnel_has_failed(wts_tunnel_multitransport(vcm)))
263 ULONG_PTR* keys =
nullptr;
264 rdpPeerChannel** channels =
nullptr;
265 rdpPeerChannel** moving =
nullptr;
271 HashTable_Lock(vcm->dynamicVirtualChannels);
274 if ((vcm->tunnel->softSyncState != SOFT_SYNC_STATE_NONE) ||
275 !InterlockedCompareExchange(&vcm->tunnel->tunnelReady, 0, 0))
280 const UINT64 waitStart = vcm->tunnel->softSyncWaitStart;
281 const BOOL waitedLong =
282 (waitStart != 0) && (GetTickCount64() - waitStart > SOFT_SYNC_MAX_WAIT_MS);
283 const size_t total = HashTable_GetKeys(vcm->dynamicVirtualChannels, &keys);
286 channels = (rdpPeerChannel**)calloc(total,
sizeof(rdpPeerChannel*));
290 for (
size_t x = 0; x < total; x++)
292 rdpPeerChannel* channel =
293 HashTable_GetItemValue(vcm->dynamicVirtualChannels, (
void*)keys[x]);
296 if (channel && (channel->dvc_open_state == DVC_OPEN_STATE_NONE))
301 vcm->tunnel->softSyncWaitStart = GetTickCount64();
305 WLog_WARN(TAG,
"missing Create Response for channel %" PRIu32
", it stays on TCP",
308 if (channel && (channel->dvc_open_state == DVC_OPEN_STATE_SUCCEEDED))
309 channels[count++] = channel;
316 vcm->tunnel->softSyncWaitStart = 0;
321 if (count > UINT16_MAX)
323 WLog_ERR(TAG,
"%" PRIuz
" dynamic channels are too many for a Soft-Sync Request", count);
329 for (
size_t x = 0; x < count; x++)
330 EnterCriticalSection(&channels[x]->writeLock);
331 moving = (rdpPeerChannel**)calloc(count,
sizeof(rdpPeerChannel*));
335 for (
size_t x = 0; x < count; x++)
337 if (!channels[x]->closing)
338 moving[moves++] = channels[x];
341 if (!moving || (moves == 0))
343 rc = (moving !=
nullptr);
348 const size_t listLength = 4 + 2 +
sizeof(UINT32) * moves;
349 s = Stream_New(
nullptr, 2 + 4 + 2 + 2 + listLength);
353 const UINT8 header = (UINT8)((UINT32)SOFT_SYNC_REQUEST_PDU << 4u);
355 (UINT16)((UINT32)SOFT_SYNC_TCP_FLUSHED | (UINT32)SOFT_SYNC_CHANNEL_LIST_PRESENT);
356 const UINT32 length = WINPR_ASSERTING_INT_CAST(UINT32, 4 + 2 + 2 + listLength);
357 const UINT16 dvcs = WINPR_ASSERTING_INT_CAST(UINT16, moves);
358 Stream_Write_UINT8(s, header);
359 Stream_Write_UINT8(s, 0);
360 Stream_Write_UINT32(s, length);
361 Stream_Write_UINT16(s, flags);
362 Stream_Write_UINT16(s, 1);
363 Stream_Write_UINT32(s, TUNNELTYPE_UDPFECR);
364 Stream_Write_UINT16(s, dvcs);
365 for (
size_t x = 0; x < moves; x++)
366 Stream_Write_UINT32(s, moving[x]->channelId);
368 rc = wts_queue_drdynvc_pdu(vcm, Stream_Buffer(s), Stream_GetPosition(s), FALSE);
371 for (
size_t x = 0; x < moves; x++)
372 moving[x]->tunnel = TRUE;
373 vcm->tunnel->softSyncState = SOFT_SYNC_STATE_SENT;
374 vcm->tunnel->softSyncWaitStart = 0;
376 "Soft-Sync Request: %" PRIuz
" dynamic channel(s) are moving to the UDP tunnel",
378 for (
size_t x = 0; x < moves; x++)
379 WLog_DBG(TAG,
" %" PRIu32
" %s", moving[x]->channelId, moving[x]->channelName);
383 for (
size_t x = 0; x < count; x++)
384 LeaveCriticalSection(&channels[x]->writeLock);
387 HashTable_Unlock(vcm->dynamicVirtualChannels);
388 Stream_Free(s, TRUE);
390 free((
void*)channels);
396static BOOL wts_tunnel_data_received(
void* custom, UINT32 tunnelType,
wStream* s)
401 WINPR_UNUSED(tunnelType);
405 HashTable_Lock(vcm->dynamicVirtualChannels);
408 if (vcm->tunnel->softSyncState == SOFT_SYNC_STATE_NONE)
411 WLog_ERR(TAG,
"client wrote to the tunnel before a Soft-Sync Request");
413 else if (vcm->tunnel->softSyncState != SOFT_SYNC_STATE_ANSWERED)
415 const size_t length = Stream_Length(s);
417 WINPR_ASSERTING_INT_CAST(
size_t, Queue_Count(vcm->tunnel->tunnelBacklog));
418 hold = (held + 1 >= SOFT_SYNC_HOLD_BACKLOG) ||
419 (length >= SOFT_SYNC_HOLD_BACKLOG_BYTES - vcm->tunnel->backlogBytes) ||
420 (vcm->tunnel->backlogBytes >= SOFT_SYNC_HOLD_BACKLOG_BYTES);
421 if ((held >= SOFT_SYNC_MAX_BACKLOG) ||
422 (length > SOFT_SYNC_MAX_BACKLOG_BYTES - vcm->tunnel->backlogBytes))
423 WLog_ERR(TAG,
"tunnel data continues to arrive without a Soft-Sync Response");
424 else if (Queue_Enqueue(vcm->tunnel->tunnelBacklog, s))
427 vcm->tunnel->backlogBytes += length;
432 else if (!vcm->tunnel->clientOnTunnel)
433 WLog_ERR(TAG,
"the client wrote data on a tunnel that its Soft-Sync Response did not list");
435 rc = wts_read_tunnel_pdu(vcm, Stream_Buffer(s), Stream_Length(s));
436 HashTable_Unlock(vcm->dynamicVirtualChannels);
438 multitransport_hold_tunnel_data(wts_tunnel_multitransport(vcm), TRUE);
445static BOOL wts_tunnel_state_changed(
void* custom, UINT32 tunnelType,
446 FreeRDP_MultitransportTunnelState state)
450 if (tunnelType != TUNNELTYPE_UDPFECR)
452 const BOOL ready = (state == FREERDP_MULTITRANSPORT_TUNNEL_READY);
455 const LONG old = InterlockedCompareExchange(&vcm->tunnel->tunnelReady, 0, 0);
456 if (InterlockedCompareExchange(&vcm->tunnel->tunnelReady, ready ? 1 : 0, old) != old)
457 WLog_DBG(TAG,
"tunnel state was updated by another thread");
461 HashTable_Lock(vcm->dynamicVirtualChannels);
462 const BOOL moved = (vcm->tunnel->softSyncState != SOFT_SYNC_STATE_NONE);
463 HashTable_Unlock(vcm->dynamicVirtualChannels);
466 WLog_WARN(TAG,
"UDP tunnel carrying channels failed, terminating the connection");
469 return wts_soft_sync(vcm);
475 WINPR_ASSERT(vcm->dynamicVirtualChannels);
476 WINPR_ASSERT(readPdu);
478 vcm->tunnel = calloc(1,
sizeof(
struct s_wts_tunnel));
481 vcm->tunnel->readPdu = readPdu;
482 vcm->tunnel->tunnelBacklog = Queue_New(FALSE, -1, -1);
483 if (!vcm->tunnel->tunnelBacklog)
487 .TunnelDataReceived = wts_tunnel_data_received,
488 .TunnelStateChanged = wts_tunnel_state_changed,
490 if (!freerdp_multitransport_set_dvc_callbacks(context, &callbacks, vcm))
494 if ((freerdp_multitransport_get_tunnel_state(context, TUNNELTYPE_UDPFECR) ==
495 FREERDP_MULTITRANSPORT_TUNNEL_READY) &&
496 (InterlockedCompareExchange(&vcm->tunnel->tunnelReady, 1, 0) == 0))
497 WLog_DBG(TAG,
"the UDP tunnel was ready before the channel manager opened");
505 if (vcm->client && vcm->client->context &&
506 !freerdp_multitransport_set_dvc_callbacks(vcm->client->context,
nullptr,
nullptr))
507 WLog_WARN(TAG,
"failed to remove the multitransport callbacks");
508 multitransport_hold_tunnel_data(wts_tunnel_multitransport(vcm), FALSE);
511 if (vcm->tunnel->tunnelBacklog)
514 while ((held = Queue_Dequeue(vcm->tunnel->tunnelBacklog)))
515 Stream_Release(held);
516 Queue_Free(vcm->tunnel->tunnelBacklog);
519 vcm->tunnel =
nullptr;
525 WINPR_ASSERT(vcm->tunnel);
529 if (InterlockedIncrement(&vcm->tunnel->softSyncDue) == 1)
530 wts_tunnel_wake_drain(vcm);
533BOOL wts_tunnel_is_soft_sync_response(UINT8 Cmd)
535 return Cmd == SOFT_SYNC_RESPONSE_PDU;
541 WINPR_ASSERT(vcm->tunnel);
543 HashTable_Lock(vcm->dynamicVirtualChannels);
544 const UINT64 waitStart = vcm->tunnel->softSyncWaitStart;
545 HashTable_Unlock(vcm->dynamicVirtualChannels);
546 const BOOL waitedLong =
547 (waitStart != 0) && (GetTickCount64() - waitStart > SOFT_SYNC_MAX_WAIT_MS);
549 LONG due = InterlockedCompareExchange(&vcm->tunnel->softSyncDue, 0, 0);
552 const LONG seen = InterlockedCompareExchange(&vcm->tunnel->softSyncDue, 0, due);
557 if ((due == 0) && !waitedLong)
559 return wts_soft_sync(vcm);
563 UINT32 length, BOOL* status)
566 WINPR_ASSERT(vcm->tunnel);
567 WINPR_ASSERT(status);
569 if (
id == WTS_QUEUE_WAKE)
571 if (
id != WTS_QUEUE_TUNNEL)
574 WINPR_ASSERT(vcm->client);
575 WINPR_ASSERT(vcm->client->context);
576 if (multitransport_queue_dvc(vcm->client->context->rdp->multitransport, buffer, length))
577 vcm->tunnel->written = TRUE;
580 WLog_ERR(TAG,
"unable to write a dynamic channel PDU to the UDP tunnel");
589 WINPR_ASSERT(vcm->tunnel);
593 if (InterlockedCompareExchange(&vcm->tunnel->softSyncDue, 0, 0) != 0)
594 wts_tunnel_wake_drain(vcm);
597 const BOOL written = vcm->tunnel->written;
598 vcm->tunnel->written = FALSE;
599 if (!status || !written)
602 WINPR_ASSERT(vcm->client->context->rdp);
603 if (!multitransport_flush_dvc(vcm->client->context->rdp->multitransport))
605 WLog_ERR(TAG,
"unable to write dynamic channel PDUs over the UDP tunnel");
615 WINPR_ASSERT(vcm->tunnel);
616 WINPR_ASSERT(channel);
618 WINPR_ASSERT(onTunnel);
622 HashTable_Lock(vcm->dynamicVirtualChannels);
623 channel->tunnel = (vcm->tunnel->softSyncState != SOFT_SYNC_STATE_NONE) &&
624 InterlockedCompareExchange(&vcm->tunnel->tunnelReady, 0, 0);
625 *onTunnel = channel->tunnel;
627 rc = wts_queue_drdynvc_pdu(vcm, Stream_Buffer(s), Stream_GetPosition(s), TRUE);
628 HashTable_Unlock(vcm->dynamicVirtualChannels);
632BOOL wts_tunnel_close_request(rdpPeerChannel* channel,
const BYTE* data,
size_t length,
635 WINPR_ASSERT(channel);
636 WINPR_ASSERT(status);
640 channel->closing = TRUE;
641 if (!channel->tunnel)
643 *status = wts_queue_drdynvc_pdu(channel->vcm, data, length, TRUE);
647BOOL wts_tunnel_queue_send_item(rdpPeerChannel* channel, BYTE* buffer, UINT32 length, BOOL* status)
649 WINPR_ASSERT(channel);
650 WINPR_ASSERT(channel->vcm);
651 WINPR_ASSERT(status);
653 if (!channel->tunnel)
655 *status = wts_queue_item(channel->vcm->drdynvc_channel, buffer, length, TRUE);
Dynamic virtual channel hooks of the client side tunnels.