21#include <winpr/assert.h>
22#include <winpr/interlocked.h>
23#include <winpr/synch.h>
24#include <winpr/winsock.h>
25#include <freerdp/config.h>
28#include <sys/socket.h>
29#include <netinet/in.h>
31#include <freerdp/log.h>
38#include "udplistener.h"
39#include "multitransport_internal.h"
40#include "../crypto/certificate.h"
41#include "../crypto/privatekey.h"
43#define TAG FREERDP_TAG("core.multitransport")
49#define MULTITRANSPORT_SERVER_QUEUE_LIMIT (32 * 1024 * 1024)
52#define MULTITRANSPORT_SERVER_QUEUE_HOLD (MULTITRANSPORT_SERVER_QUEUE_LIMIT / 2)
55#define MULTITRANSPORT_SERVER_EVENT_COST 128
58#define TYPE_ID_AUTODETECT_REQUEST 0x00
61static void multitransport_server_notify_link_state(rdpMultitransport* multi,
62 FreeRDP_UdpLinkState state)
65 if (multi->udpCallbacks.LinkChanged)
66 multi->udpCallbacks.LinkChanged(multi->udpCustom, state);
71static LONG multitransport_server_event_cost(
size_t length)
73 return (length > (
size_t)(MULTITRANSPORT_SERVER_QUEUE_LIMIT - MULTITRANSPORT_SERVER_EVENT_COST))
74 ? MULTITRANSPORT_SERVER_QUEUE_LIMIT + 1
75 : (LONG)length + MULTITRANSPORT_SERVER_EVENT_COST;
80static BOOL multitransport_server_receive_hold(
void* custom)
82 rdpMultitransport* multi = custom;
84 return (InterlockedCompareExchange(&multi->serverQueuedBytes, 0, 0) >
85 MULTITRANSPORT_SERVER_QUEUE_HOLD) ||
86 (InterlockedCompareExchange(&multi->serverDataHold, 0, 0) != 0);
89void multitransport_server_event_taken(rdpMultitransport* multi,
const mt_event* ev)
93 if ((ev->type != MT_EVENT_DATA) && (ev->type != MT_EVENT_AUTODETECT))
95 if (!multitransport_is_server(multi))
98 const LONG cost = multitransport_server_event_cost(ev->length);
99 LONG queued = InterlockedCompareExchange(&multi->serverQueuedBytes, 0, 0);
102 const LONG left = (queued > cost) ? queued - cost : 0;
103 const LONG seen = InterlockedCompareExchange(&multi->serverQueuedBytes, left, queued);
110void multitransport_hold_tunnel_data(rdpMultitransport* multi, BOOL hold)
115 if (InterlockedCompareExchange(&multi->serverDataHold, hold ? 1 : 0, hold ? 0 : 1) ==
117 WLog_DBG(TAG,
"tunnel data from the client is %s", hold ?
"held back" :
"accepted again");
120BOOL multitransport_tunnel_has_failed(rdpMultitransport* multi)
124 EnterCriticalSection(&multi->lock);
125 const BOOL failed = multi->reliable && rdpemt_has_failed(multi->reliable);
126 LeaveCriticalSection(&multi->lock);
132static void multitransport_server_tunnel_event(
void* custom, rdpEmt* emt, RDPEMT_EVENT event,
133 const BYTE* data,
size_t length)
135 rdpMultitransport* multi = custom;
140 case RDPEMT_EVENT_SYN_RECEIVED:
141 if (InterlockedCompareExchange(&multi->serverSynPending, 1, 0) != 0)
143 "the main loop has not yet processed the previous SYN received event");
144 (void)SetEvent(multi->event);
146 case RDPEMT_EVENT_WRITABLE:
147 if (InterlockedCompareExchange(&multi->serverWritablePending, 1, 0) != 0)
148 WLog_DBG(TAG,
"the main loop has not yet processed the previous writable event");
149 (void)SetEvent(multi->event);
151 case RDPEMT_EVENT_RESPONSE_DUE:
153 (void)SetEvent(multi->event);
155 case RDPEMT_EVENT_DATA:
156 case RDPEMT_EVENT_AUTODETECT:
158 const LONG add = multitransport_server_event_cost(length);
161 LONG queued = InterlockedCompareExchange(&multi->serverQueuedBytes, 0, 0);
164 fits = (add <= MULTITRANSPORT_SERVER_QUEUE_LIMIT - queued);
168 InterlockedCompareExchange(&multi->serverQueuedBytes, queued + add, queued);
176 if (InterlockedCompareExchange(&multi->tunnelEventLost, 1, 0) == 0)
177 WLog_ERR(TAG,
"client is sending more tunnel data than the server can process");
178 (void)SetEvent(multi->event);
181 multitransport_tunnel_event(custom, emt, event, data, length);
185 multitransport_tunnel_event(custom, emt, event, data, length);
192static BOOL multitransport_server_route_flow(rdpMultitransport* multi, rdpEmt* emt)
197 rdpUdpFlow* flow = rdpemt_get_flow(emt);
198 if (multi->udpCallbacks.OfferTunnel)
199 return multi->udpCallbacks.OfferTunnel(multi->udpCustom, flow,
200 freerdp_udp_flow_get_cookie_hash(flow));
206 struct sockaddr_storage local = WINPR_C_ARRAY_INIT;
207 size_t localLength = 0;
208 if (!transport_get_local_address(multi->rdp->transport, &local, &localLength))
210 WLog_INFO(TAG,
"UDP is not offered because the main connection is not using a TCP socket");
213 if ((local.ss_family != AF_INET) && (local.ss_family != AF_INET6))
215 WLog_INFO(TAG,
"UDP is not offered because the main connection is not over TCP/IP");
218 return udplistener_add_flow_on_address((
const struct sockaddr*)&local, localLength, flow);
221static void multitransport_server_drop_pending_events(rdpMultitransport* multi);
226static BOOL multitransport_server_start_tunnel(rdpMultitransport* multi)
229 WINPR_ASSERT(multi->rdp);
230 rdpSettings* settings = multi->rdp->settings;
231 WINPR_ASSERT(settings);
233 rdpCertificate* cert =
238 WLog_INFO(TAG,
"UDP is not being offered because the server lacks a TLS certificate");
242 X509* x509 = freerdp_certificate_get_x509(cert);
245 WLog_INFO(TAG,
"UDP not offered because the server certificate lacks X.509 format");
248 EVP_PKEY* evp = freerdp_key_get_evp_pkey(key);
253 const int keyType = EVP_PKEY_base_id(evp);
254 const int keyBits = EVP_PKEY_bits(evp);
255 if ((keyType != EVP_PKEY_RSA) &&
256 ((keyType != EVP_PKEY_EC) || ((keyBits != 256) && (keyBits != 384))))
258 WLog_INFO(TAG,
"UDP is not offered: the tunnel's TLS cannot use the server's key type");
262 rdpEmt* emt = rdpemt_new_server(WLog_Get(TAG), multi->reliableReqId, multi->reliableCookie,
263 cert, key, multi->udpCallbacks.ManualWorker,
264 multitransport_server_tunnel_event, multi);
268 WLog_WARN(TAG,
"unable to wait for a UDP tunnel, so one will not be offered");
271 rdpemt_set_receive_hold(emt, multitransport_server_receive_hold);
283 multi->serverOfferTime = GetTickCount64();
285 if (!multitransport_server_route_flow(multi, emt))
287 WLog_WARN(TAG,
"unable to reach client datagrams, not offering a UDP tunnel");
292 EnterCriticalSection(&multi->lock);
294 rdpEmt* old = multi->reliable;
296 rdpemt_set_send_limit(emt, multi->udpSendLimit);
297 multi->reliable = emt;
298 multi->reliableState = FREERDP_MULTITRANSPORT_TUNNEL_PENDING;
299 multi->serverTunnelUp = FALSE;
300 multi->serverResponseOk = FALSE;
301 LeaveCriticalSection(&multi->lock);
305 multitransport_server_notify_link_state(multi, FREERDP_UDP_LINK_NONE);
307 multitransport_server_drop_pending_events(multi);
309 WLog_INFO(TAG,
"proposing a reliable UDP tunnel, request %" PRIu32, multi->reliableReqId);
310 multitransport_server_notify_link_state(multi, FREERDP_UDP_LINK_OFFERED);
317static BOOL multitransport_server_has_tunnel(
const rdpMultitransport* multi)
320 WINPR_ASSERT(multi->rdp);
323 return rdpemt_is_supported() && ((flags & (UINT32)SOFTSYNC_TCP_TO_UDP) != 0);
326MT_REQUEST_MODE multitransport_server_request_mode(rdpMultitransport* multi)
332 if (!multitransport_server_has_tunnel(multi))
333 return MT_REQUEST_WAIT;
337 if (!multitransport_server_start_tunnel(multi))
338 return MT_REQUEST_NONE;
342 multi->serverTunnelOffered = TRUE;
343 multi->serverResponsePending = TRUE;
344 return MT_REQUEST_TUNNEL;
347BOOL multitransport_is_server(
const rdpMultitransport* multi)
350 WINPR_ASSERT(multi->rdp);
354BOOL multitransport_server_tunnel_offered(
const rdpMultitransport* multi)
357 return multi->serverTunnelOffered;
361static BOOL multitransport_server_check_ready(rdpMultitransport* multi)
365 EnterCriticalSection(&multi->lock);
366 const BOOL ready = multi->reliable && multi->serverTunnelUp && multi->serverResponseOk &&
367 (multi->reliableState != FREERDP_MULTITRANSPORT_TUNNEL_READY);
369 multi->reliableState = FREERDP_MULTITRANSPORT_TUNNEL_READY;
370 LeaveCriticalSection(&multi->lock);
374 WLog_INFO(TAG,
"client accepted the reliable UDP tunnel");
375 multitransport_server_notify_link_state(multi, FREERDP_UDP_LINK_READY);
376 return multitransport_notify_state(multi, FREERDP_MULTITRANSPORT_TUNNEL_READY);
381static void multitransport_server_drop_pending_events(rdpMultitransport* multi)
385 const LONG synPending = InterlockedCompareExchange(&multi->serverSynPending, 0, 1);
386 const LONG writable = InterlockedCompareExchange(&multi->serverWritablePending, 0, 1);
387 if ((synPending != 0) || (writable != 0))
388 WLog_DBG(TAG,
"dropped pending SYN and writable events for a terminated tunnel");
391BOOL multitransport_server_tunnel_ready(rdpMultitransport* multi, BOOL* rc)
396 if (!multitransport_is_server(multi))
399 EnterCriticalSection(&multi->lock);
400 const BOOL tunnel = multi->reliable !=
nullptr;
402 multi->serverTunnelUp = TRUE;
403 LeaveCriticalSection(&multi->lock);
405 multitransport_server_notify_link_state(multi, FREERDP_UDP_LINK_VERIFIED);
406 *rc = multitransport_server_check_ready(multi);
410void multitransport_server_tunnel_closed(rdpMultitransport* multi)
413 if (multitransport_is_server(multi))
415 multitransport_server_notify_link_state(multi, FREERDP_UDP_LINK_NONE);
416 multitransport_server_drop_pending_events(multi);
420BOOL multitransport_server_response_failed(
const rdpMultitransport* multi)
423 return multi->serverResponseFailed;
427static state_run_t multitransport_server_process_response(rdpMultitransport* multi, UINT32 reqId,
435 if (!multi->serverResponsePending)
437 if (reqId == multi->reliableReqId)
439 WLog_DBG(TAG,
"skipping a duplicate multi-transport response");
440 return STATE_RUN_SUCCESS;
442 WLog_WARN(TAG,
"received an unexpected multi-transport response for request %" PRIu32,
444 return STATE_RUN_FAILED;
447 if (reqId != multi->reliableReqId)
450 "received multi-transport response for request %" PRIu32
", but expected %" PRIu32
452 reqId, multi->reliableReqId);
453 return STATE_RUN_SUCCESS;
455 multi->serverResponsePending = FALSE;
457 EnterCriticalSection(&multi->lock);
458 rdpEmt* emt = multi->reliable;
459 const BOOL ok = emt && SUCCEEDED((HRESULT)hrResponse);
461 multi->serverResponseOk = TRUE;
464 multi->reliable =
nullptr;
465 multi->reliableState = FREERDP_MULTITRANSPORT_TUNNEL_NONE;
467 LeaveCriticalSection(&multi->lock);
471 WLog_INFO(TAG,
"client rejected the UDP tunnel, hrResponse 0x%08" PRIx32, hrResponse);
473 multitransport_server_notify_link_state(multi, FREERDP_UDP_LINK_NONE);
475 multitransport_server_drop_pending_events(multi);
478 WLog_DBG(TAG,
"multi-transport response 0x%08" PRIx32
" received after the tunnel ended",
480 else if (!multitransport_server_check_ready(multi))
481 return STATE_RUN_FAILED;
483 return STATE_RUN_SUCCESS;
486state_run_t multitransport_server_tunnel_response(rdpMultitransport* multi, UINT32 reqId,
489 const state_run_t rc = multitransport_server_process_response(multi, reqId, hrResponse);
490 if (state_run_failed(rc))
491 multi->serverResponseFailed = TRUE;
495void multitransport_tunnel_check(rdpMultitransport* multi)
498 WINPR_ASSERT(multi->rdp);
505 const BOOL server = multitransport_is_server(multi);
508 EnterCriticalSection(&multi->lock);
510 direct = rdpemt_take_direct_bytes(multi->reliable);
512 LeaveCriticalSection(&multi->lock);
513 rdpAutoDetect* autodetect = multi->rdp->autodetect;
514 if (autodetect && autodetect->bandwidthMeasureStarted)
515 autodetect->bandwidthMeasureByteCount += direct;
517 if (InterlockedCompareExchange(&multi->serverSynPending, 0, 1) != 0)
518 multitransport_server_notify_link_state(multi, FREERDP_UDP_LINK_SYN_RECEIVED);
523 if (multitransport_is_server(multi) && multi->serverResponsePending &&
524 (GetTickCount64() - multi->serverOfferTime > RDPEMT_SERVER_RESPONSE_TIMEOUT_MS))
526 multi->serverResponsePending = FALSE;
527 EnterCriticalSection(&multi->lock);
528 rdpEmt* emt = multi->reliable;
529 multi->reliable =
nullptr;
530 multi->reliableState = FREERDP_MULTITRANSPORT_TUNNEL_NONE;
531 LeaveCriticalSection(&multi->lock);
534 WLog_INFO(TAG,
"multi-transport response timed out; closing the UDP tunnel");
535 multitransport_server_notify_link_state(multi, FREERDP_UDP_LINK_NONE);
537 multitransport_server_drop_pending_events(multi);
540 if ((InterlockedCompareExchange(&multi->serverWritablePending, 0, 1) != 0) &&
541 multi->udpCallbacks.WriteUnblocked)
542 multi->udpCallbacks.WriteUnblocked(multi->udpCustom);
545void multitransport_server_disconnect(rdpContext* context)
547 if (!context || !context->rdp)
549 rdpMultitransport* multi = context->rdp->multitransport;
550 if (!multi || !multitransport_is_server(multi))
553 EnterCriticalSection(&multi->lock);
554 const BOOL tunnel = (multi->reliable !=
nullptr);
555 LeaveCriticalSection(&multi->lock);
560 multitransport_server_notify_link_state(multi, FREERDP_UDP_LINK_NONE);
561 multitransport_reset(multi);
564BOOL multitransport_queue_dvc(rdpMultitransport* multi,
const BYTE* data,
size_t length)
570 EnterCriticalSection(&multi->lock);
571 if (multi->reliable && (multi->reliableState == FREERDP_MULTITRANSPORT_TUNNEL_READY))
572 rc = rdpemt_send_data(multi->reliable, data, length);
573 LeaveCriticalSection(&multi->lock);
577BOOL multitransport_flush_dvc(rdpMultitransport* multi)
583 EnterCriticalSection(&multi->lock);
584 if (multi->reliable && (multi->reliableState == FREERDP_MULTITRANSPORT_TUNNEL_READY))
585 rc = rdpemt_flush(multi->reliable);
586 LeaveCriticalSection(&multi->lock);
590BOOL multitransport_server_send_autodetect(rdpMultitransport* multi, RDP_TRANSPORT_TYPE transport,
591 UINT16 sequenceNumber, UINT16 requestType, BOOL* rc)
596 if (transport != RDP_TRANSPORT_UDP_R)
601 EnterCriticalSection(&multi->lock);
603 multi->reliable && (multi->reliableState == FREERDP_MULTITRANSPORT_TUNNEL_READY);
604 LeaveCriticalSection(&multi->lock);
607 WLog_DBG(TAG,
"no UDP tunnel for the auto-detect request %" PRIu16, sequenceNumber);
613 BYTE request[6] = WINPR_C_ARRAY_INIT;
614 wStream sbuffer = WINPR_C_ARRAY_INIT;
615 wStream* s = Stream_StaticInit(&sbuffer, request,
sizeof(request));
616 Stream_Write_UINT8(s, 6);
617 Stream_Write_UINT8(s, TYPE_ID_AUTODETECT_REQUEST);
618 Stream_Write_UINT16(s, sequenceNumber);
619 Stream_Write_UINT16(s, requestType);
620 *rc = multitransport_send_autodetect_response(multi, request,
sizeof(request));
624DWORD multitransport_server_add_event(rdpMultitransport* multi, HANDLE* events, DWORD used,
628 WINPR_ASSERT(events);
634 if (!multitransport_server_has_tunnel(multi))
640 WLog_ERR(TAG,
"no room for the UDP tunnel's event handle, %" PRIu32
" given", count);
643 events[used] = multitransport_get_event_handle(multi);
648static rdpMultitransport* multitransport_from_peer(
const freerdp_peer* peer)
650 if (!peer || !peer->context || !peer->context->rdp)
652 return peer->context->rdp->multitransport;
655BOOL freerdp_peer_set_udp_hooks(freerdp_peer* peer,
const rdpUdpPeerHooks* hooks,
void* custom)
657 rdpMultitransport* multi = multitransport_from_peer(peer);
662 multi->udpCallbacks = *hooks;
664 memset(&multi->udpCallbacks, 0,
sizeof(multi->udpCallbacks));
665 multi->udpCustom = hooks ? custom :
nullptr;
673 return freerdp_peer_set_udp_hooks(peer,
nullptr,
nullptr);
676 const size_t required =
678 if (callbacks->
size < required)
681 "FreeRDP_UdpPeerCallbacks size %" PRIuz
" is too small, expected at least %" PRIuz,
682 callbacks->
size, required);
687 .WriteUnblocked = callbacks->WriteUnblocked };
688 return freerdp_peer_set_udp_hooks(peer, &hooks, custom);
691BOOL freerdp_peer_get_udp_send_state_full(freerdp_peer* peer,
rdpUdpSendState* state)
693 rdpMultitransport* multi = multitransport_from_peer(peer);
694 if (!multi || !state)
697 EnterCriticalSection(&multi->lock);
698 const BOOL rc = multi->reliable !=
nullptr;
700 rdpemt_get_send_state(multi->reliable, state);
701 LeaveCriticalSection(&multi->lock);
711 if (state->size < required)
714 "the size of FreeRDP_UdpSendState is %" PRIuz
715 ", but it should be at least %" PRIuz,
716 state->size, required);
721 if (!freerdp_peer_get_udp_send_state_full(peer, &full))
728 const size_t size = (state->size <
sizeof(out)) ? state->size :
sizeof(out);
730 memcpy(state, &out, size);
734BOOL freerdp_peer_set_udp_send_limit(freerdp_peer* peer,
size_t limit)
736 rdpMultitransport* multi = multitransport_from_peer(peer);
740 EnterCriticalSection(&multi->lock);
741 multi->udpSendLimit = limit;
743 rdpemt_set_send_limit(multi->reliable, limit);
744 LeaveCriticalSection(&multi->lock);
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 void * freerdp_settings_get_pointer_writable(rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id)
Returns a mutable pointer settings value.
WINPR_ATTR_NODISCARD FREERDP_API UINT16 freerdp_settings_get_uint16(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt16 id)
Returns a UINT16 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.
Callbacks from FreeRDP_UdpPeerCallbacks and internal hooks. Executed on the thread running the freerd...
Comprehensive UDP send state information, including additional metrics.
Pacing server output on the UDP tunnel for servers built with -DWITH_RDPEUDP_SERVER=ON.
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_peer_get_udp_send_state(freerdp_peer *peer, FreeRDP_UdpSendState *state)
ALIGN64 BOOL writeBlocked
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_peer_set_udp_callbacks(freerdp_peer *peer, const FreeRDP_UdpPeerCallbacks *callbacks, void *custom)
Per-peer UDP callbacks, executed on the thread running the freerdp_peer check. Set size to sizeof(Fre...
Link state for pacing encoders. Set size to sizeof(FreeRDP_UdpSendState) before calling....