FreeRDP
Loading...
Searching...
No Matches
multitransport_server.c
1
17
18#include <stddef.h>
19#include <string.h>
20
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>
26
27#if !defined(_WIN32)
28#include <sys/socket.h>
29#include <netinet/in.h>
30#endif
31#include <freerdp/log.h>
32#include <freerdp/server/udp.h>
33
34#include "settings.h"
35#include "rdp.h"
36#include "transport.h"
37#include "rdpemt.h"
38#include "udplistener.h"
39#include "multitransport_internal.h"
40#include "../crypto/certificate.h"
41#include "../crypto/privatekey.h"
42
43#define TAG FREERDP_TAG("core.multitransport")
44
45/* Upper bound on tunnel data queued for the main loop. Since data is already acked and
46 * cannot be retransmitted, exceeding this limit ends the connection to prevent server
47 * memory exhaustion if the main loop is blocked (e.g. on a write). The tunnel stops taking
48 * data from the client at MULTITRANSPORT_SERVER_QUEUE_HOLD, so the limit is not reached. */
49#define MULTITRANSPORT_SERVER_QUEUE_LIMIT (32 * 1024 * 1024)
50/* Above this the tunnel accepts no more data from the client (rdpemt_set_receive_hold): a main
51 * loop that is busy or blocked then slows the client down as it would on TCP. */
52#define MULTITRANSPORT_SERVER_QUEUE_HOLD (MULTITRANSPORT_SERVER_QUEUE_LIMIT / 2)
53/* Per-event overhead (event, stream, and allocations) to ensure many small events do
54 * not exceed the memory limit. */
55#define MULTITRANSPORT_SERVER_EVENT_COST 128
56
57/* Request headerTypeId per [MS-RDPBCGR] 2.2.14.3 */
58#define TYPE_ID_AUTODETECT_REQUEST 0x00
59
60/* Invokes the application's callback hook; must be called from the main loop thread. */
61static void multitransport_server_notify_link_state(rdpMultitransport* multi,
62 FreeRDP_UdpLinkState state)
63{
64 WINPR_ASSERT(multi);
65 if (multi->udpCallbacks.LinkChanged)
66 multi->udpCallbacks.LinkChanged(multi->udpCustom, state);
67}
68
69/* What an event adds to serverQueuedBytes. */
70WINPR_ATTR_NODISCARD
71static LONG multitransport_server_event_cost(size_t length)
72{
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;
76}
77
78/* Runs on the tunnel thread before each client datagram. */
79WINPR_ATTR_NODISCARD
80static BOOL multitransport_server_receive_hold(void* custom)
81{
82 rdpMultitransport* multi = custom;
83 WINPR_ASSERT(multi);
84 return (InterlockedCompareExchange(&multi->serverQueuedBytes, 0, 0) >
85 MULTITRANSPORT_SERVER_QUEUE_HOLD) ||
86 (InterlockedCompareExchange(&multi->serverDataHold, 0, 0) != 0);
87}
88
89void multitransport_server_event_taken(rdpMultitransport* multi, const mt_event* ev)
90{
91 WINPR_ASSERT(multi);
92 WINPR_ASSERT(ev);
93 if ((ev->type != MT_EVENT_DATA) && (ev->type != MT_EVENT_AUTODETECT))
94 return;
95 if (!multitransport_is_server(multi))
96 return;
97
98 const LONG cost = multitransport_server_event_cost(ev->length);
99 LONG queued = InterlockedCompareExchange(&multi->serverQueuedBytes, 0, 0);
100 while (TRUE)
101 {
102 const LONG left = (queued > cost) ? queued - cost : 0;
103 const LONG seen = InterlockedCompareExchange(&multi->serverQueuedBytes, left, queued);
104 if (seen == queued)
105 break;
106 queued = seen;
107 }
108}
109
110void multitransport_hold_tunnel_data(rdpMultitransport* multi, BOOL hold)
111{
112 if (!multi)
113 return;
114 /* compare-exchange: WinPR's InterlockedExchange reads the old value non-atomically */
115 if (InterlockedCompareExchange(&multi->serverDataHold, hold ? 1 : 0, hold ? 0 : 1) ==
116 (hold ? 0 : 1))
117 WLog_DBG(TAG, "tunnel data from the client is %s", hold ? "held back" : "accepted again");
118}
119
120BOOL multitransport_tunnel_has_failed(rdpMultitransport* multi)
121{
122 if (!multi)
123 return FALSE;
124 EnterCriticalSection(&multi->lock);
125 const BOOL failed = multi->reliable && rdpemt_has_failed(multi->reliable);
126 LeaveCriticalSection(&multi->lock);
127 return failed;
128}
129
130/* Runs on the tunnel thread. SYN_RECEIVED and WRITABLE events only set flags that the main
131 * loop reads before processing queued events. */
132static void multitransport_server_tunnel_event(void* custom, rdpEmt* emt, RDPEMT_EVENT event,
133 const BYTE* data, size_t length)
134{
135 rdpMultitransport* multi = custom;
136 WINPR_ASSERT(multi);
137
138 switch (event)
139 {
140 case RDPEMT_EVENT_SYN_RECEIVED:
141 if (InterlockedCompareExchange(&multi->serverSynPending, 1, 0) != 0)
142 WLog_DBG(TAG,
143 "the main loop has not yet processed the previous SYN received event");
144 (void)SetEvent(multi->event);
145 break;
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);
150 break;
151 case RDPEMT_EVENT_RESPONSE_DUE:
152 /* Wakeup only; multitransport_tunnel_check handles the timeout. */
153 (void)SetEvent(multi->event);
154 break;
155 case RDPEMT_EVENT_DATA:
156 case RDPEMT_EVENT_AUTODETECT:
157 {
158 const LONG add = multitransport_server_event_cost(length);
159 /* Only increment if it fits to ensure the count stays within the limit. */
160 BOOL fits = TRUE;
161 LONG queued = InterlockedCompareExchange(&multi->serverQueuedBytes, 0, 0);
162 while (fits)
163 {
164 fits = (add <= MULTITRANSPORT_SERVER_QUEUE_LIMIT - queued);
165 if (!fits)
166 break;
167 const LONG seen =
168 InterlockedCompareExchange(&multi->serverQueuedBytes, queued + add, queued);
169 if (seen == queued)
170 break;
171 queued = seen;
172 }
173 if (!fits)
174 {
175 /* Data is lost; the main loop will terminate the connection. */
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);
179 break;
180 }
181 multitransport_tunnel_event(custom, emt, event, data, length);
182 break;
183 }
184 default:
185 multitransport_tunnel_event(custom, emt, event, data, length);
186 break;
187 }
188}
189
190/* Routes client datagrams associated with this cookie to the tunnel flow. */
191WINPR_ATTR_NODISCARD
192static BOOL multitransport_server_route_flow(rdpMultitransport* multi, rdpEmt* emt)
193{
194 WINPR_ASSERT(multi);
195 WINPR_ASSERT(emt);
196
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));
201
202 /* [MS-RDPEMT] 1.3: The client sends UDP datagrams to the TCP connection's address and
203 * port and only accepts replies from there. On multi-homed hosts, the socket must be
204 * bound to this exact address to prevent the routing table from picking a different
205 * source. */
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))
209 {
210 WLog_INFO(TAG, "UDP is not offered because the main connection is not using a TCP socket");
211 return FALSE;
212 }
213 if ((local.ss_family != AF_INET) && (local.ss_family != AF_INET6))
214 {
215 WLog_INFO(TAG, "UDP is not offered because the main connection is not over TCP/IP");
216 return FALSE;
217 }
218 return udplistener_add_flow_on_address((const struct sockaddr*)&local, localLength, flow);
219}
220
221static void multitransport_server_drop_pending_events(rdpMultitransport* multi);
222
223/* Creates the server end of the tunnel for the next request. Uses the main
224 * connection's certificate and key for the client to verify the tunnel's TLS session. */
225WINPR_ATTR_NODISCARD
226static BOOL multitransport_server_start_tunnel(rdpMultitransport* multi)
227{
228 WINPR_ASSERT(multi);
229 WINPR_ASSERT(multi->rdp);
230 rdpSettings* settings = multi->rdp->settings;
231 WINPR_ASSERT(settings);
232
233 rdpCertificate* cert =
234 freerdp_settings_get_pointer_writable(settings, FreeRDP_RdpServerCertificate);
235 const rdpPrivateKey* key = freerdp_settings_get_pointer(settings, FreeRDP_RdpServerRsaKey);
236 if (!cert || !key)
237 {
238 WLog_INFO(TAG, "UDP is not being offered because the server lacks a TLS certificate");
239 return FALSE;
240 }
241
242 X509* x509 = freerdp_certificate_get_x509(cert);
243 if (!x509)
244 {
245 WLog_INFO(TAG, "UDP not offered because the server certificate lacks X.509 format");
246 return FALSE;
247 }
248 EVP_PKEY* evp = freerdp_key_get_evp_pkey(key);
249 if (!evp)
250 return FALSE;
251 /* The tunnel's TLS signs with RSA or ECDSA on P-256 or P-384 (emt_start_tls). With another
252 * key every handshake would fail, after the client had spent its attempt. */
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))))
257 {
258 WLog_INFO(TAG, "UDP is not offered: the tunnel's TLS cannot use the server's key type");
259 EVP_PKEY_free(evp);
260 return FALSE;
261 }
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);
265 EVP_PKEY_free(evp);
266 if (!emt)
267 {
268 WLog_WARN(TAG, "unable to wait for a UDP tunnel, so one will not be offered");
269 return FALSE;
270 }
271 rdpemt_set_receive_hold(emt, multitransport_server_receive_hold);
272 /* Apply the main connection's TLS limits to the tunnel. */
273 if (!rdpemt_set_tls_settings(emt, freerdp_settings_get_uint16(settings, FreeRDP_TLSMinVersion),
274 freerdp_settings_get_uint16(settings, FreeRDP_TLSMaxVersion),
275 freerdp_settings_get_uint32(settings, FreeRDP_TlsSecLevel),
276 freerdp_settings_get_string(settings, FreeRDP_AllowedTlsCiphers)))
277 {
278 rdpemt_free(emt);
279 return FALSE;
280 }
281 /* Record start time before OfferTunnel (which may block). The response wakeup fires
282 * RDPEMT_SERVER_RESPONSE_TIMEOUT_MS later. */
283 multi->serverOfferTime = GetTickCount64();
284
285 if (!multitransport_server_route_flow(multi, emt))
286 {
287 WLog_WARN(TAG, "unable to reach client datagrams, not offering a UDP tunnel");
288 rdpemt_free(emt);
289 return FALSE;
290 }
291
292 EnterCriticalSection(&multi->lock);
293 /* One request per connection; free any existing tunnel to prevent leaks. */
294 rdpEmt* old = multi->reliable;
295 /* Under lock: freerdp_peer_set_udp_send_limit() may be called from another thread. */
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);
302 if (old)
303 {
304 /* Ensure the application stops using the old flow before it is freed. */
305 multitransport_server_notify_link_state(multi, FREERDP_UDP_LINK_NONE);
306 rdpemt_free(old);
307 multitransport_server_drop_pending_events(multi);
308 }
309 WLog_INFO(TAG, "proposing a reliable UDP tunnel, request %" PRIu32, multi->reliableReqId);
310 multitransport_server_notify_link_state(multi, FREERDP_UDP_LINK_OFFERED);
311 return TRUE;
312}
313
314/* This server only migrates channels to a tunnel via Soft-Sync on both sides, and
315 * only advertises Soft-Sync when configured to offer a tunnel. */
316WINPR_ATTR_NODISCARD
317static BOOL multitransport_server_has_tunnel(const rdpMultitransport* multi)
318{
319 WINPR_ASSERT(multi);
320 WINPR_ASSERT(multi->rdp);
321 const UINT32 flags =
322 freerdp_settings_get_uint32(multi->rdp->settings, FreeRDP_MultitransportFlags);
323 return rdpemt_is_supported() && ((flags & (UINT32)SOFTSYNC_TCP_TO_UDP) != 0);
324}
325
326MT_REQUEST_MODE multitransport_server_request_mode(rdpMultitransport* multi)
327{
328 WINPR_ASSERT(multi);
329
330 /* Without Soft-Sync, no tunnel is offered; the connection sequence waits for the client's
331 * response. */
332 if (!multitransport_server_has_tunnel(multi))
333 return MT_REQUEST_WAIT;
334
335 /* The tunnel waits for the client using this cookie. If it cannot be established, no
336 * request is sent and the connection continues over TCP. */
337 if (!multitransport_server_start_tunnel(multi))
338 return MT_REQUEST_NONE;
339
340 /* Mimicking Windows, continue the connection sequence immediately; per [MS-RDPBCGR] 1.3.1.1,
341 * the response may arrive in any later state. */
342 multi->serverTunnelOffered = TRUE;
343 multi->serverResponsePending = TRUE;
344 return MT_REQUEST_TUNNEL;
345}
346
347BOOL multitransport_is_server(const rdpMultitransport* multi)
348{
349 WINPR_ASSERT(multi);
350 WINPR_ASSERT(multi->rdp);
351 return freerdp_settings_get_bool(multi->rdp->settings, FreeRDP_ServerMode);
352}
353
354BOOL multitransport_server_tunnel_offered(const rdpMultitransport* multi)
355{
356 WINPR_ASSERT(multi);
357 return multi->serverTunnelOffered;
358}
359
360WINPR_ATTR_NODISCARD
361static BOOL multitransport_server_check_ready(rdpMultitransport* multi)
362{
363 WINPR_ASSERT(multi);
364
365 EnterCriticalSection(&multi->lock);
366 const BOOL ready = multi->reliable && multi->serverTunnelUp && multi->serverResponseOk &&
367 (multi->reliableState != FREERDP_MULTITRANSPORT_TUNNEL_READY);
368 if (ready)
369 multi->reliableState = FREERDP_MULTITRANSPORT_TUNNEL_READY;
370 LeaveCriticalSection(&multi->lock);
371
372 if (!ready)
373 return TRUE;
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);
377}
378
379/* Prevent pending flags of the freed tunnel from reaching the application after LinkChanged(NONE).
380 */
381static void multitransport_server_drop_pending_events(rdpMultitransport* multi)
382{
383 WINPR_ASSERT(multi);
384 /* clear both, a || would skip the second one when the first was set */
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");
389}
390
391BOOL multitransport_server_tunnel_ready(rdpMultitransport* multi, BOOL* rc)
392{
393 WINPR_ASSERT(multi);
394 WINPR_ASSERT(rc);
395
396 if (!multitransport_is_server(multi))
397 return FALSE;
398
399 EnterCriticalSection(&multi->lock);
400 const BOOL tunnel = multi->reliable != nullptr;
401 if (tunnel)
402 multi->serverTunnelUp = TRUE;
403 LeaveCriticalSection(&multi->lock);
404 if (tunnel)
405 multitransport_server_notify_link_state(multi, FREERDP_UDP_LINK_VERIFIED);
406 *rc = multitransport_server_check_ready(multi);
407 return TRUE;
408}
409
410void multitransport_server_tunnel_closed(rdpMultitransport* multi)
411{
412 WINPR_ASSERT(multi);
413 if (multitransport_is_server(multi))
414 {
415 multitransport_server_notify_link_state(multi, FREERDP_UDP_LINK_NONE);
416 multitransport_server_drop_pending_events(multi);
417 }
418}
419
420BOOL multitransport_server_response_failed(const rdpMultitransport* multi)
421{
422 WINPR_ASSERT(multi);
423 return multi->serverResponseFailed;
424}
425
426WINPR_ATTR_NODISCARD
427static state_run_t multitransport_server_process_response(rdpMultitransport* multi, UINT32 reqId,
428 UINT32 hrResponse)
429{
430 WINPR_ASSERT(multi);
431
432 /* The connection sequence does not wait for this PDU, so it may arrive in any state
433 * (the message channel remains open for the session). Only one answer per request is
434 * accepted; it does not change the connection state. */
435 if (!multi->serverResponsePending)
436 {
437 if (reqId == multi->reliableReqId)
438 {
439 WLog_DBG(TAG, "skipping a duplicate multi-transport response");
440 return STATE_RUN_SUCCESS;
441 }
442 WLog_WARN(TAG, "received an unexpected multi-transport response for request %" PRIu32,
443 reqId);
444 return STATE_RUN_FAILED;
445 }
446
447 if (reqId != multi->reliableReqId)
448 {
449 WLog_WARN(TAG,
450 "received multi-transport response for request %" PRIu32 ", but expected %" PRIu32
451 ", ignoring",
452 reqId, multi->reliableReqId);
453 return STATE_RUN_SUCCESS;
454 }
455 multi->serverResponsePending = FALSE;
456
457 EnterCriticalSection(&multi->lock);
458 rdpEmt* emt = multi->reliable;
459 const BOOL ok = emt && SUCCEEDED((HRESULT)hrResponse);
460 if (ok)
461 multi->serverResponseOk = TRUE;
462 else
463 {
464 multi->reliable = nullptr;
465 multi->reliableState = FREERDP_MULTITRANSPORT_TUNNEL_NONE;
466 }
467 LeaveCriticalSection(&multi->lock);
468
469 if (!ok && emt)
470 {
471 WLog_INFO(TAG, "client rejected the UDP tunnel, hrResponse 0x%08" PRIx32, hrResponse);
472 /* Application must stop using the flow before it is freed */
473 multitransport_server_notify_link_state(multi, FREERDP_UDP_LINK_NONE);
474 rdpemt_free(emt);
475 multitransport_server_drop_pending_events(multi);
476 }
477 else if (!ok)
478 WLog_DBG(TAG, "multi-transport response 0x%08" PRIx32 " received after the tunnel ended",
479 hrResponse);
480 else if (!multitransport_server_check_ready(multi))
481 return STATE_RUN_FAILED;
482
483 return STATE_RUN_SUCCESS;
484}
485
486state_run_t multitransport_server_tunnel_response(rdpMultitransport* multi, UINT32 reqId,
487 UINT32 hrResponse)
488{
489 const state_run_t rc = multitransport_server_process_response(multi, reqId, hrResponse);
490 if (state_run_failed(rc))
491 multi->serverResponseFailed = TRUE;
492 return rc;
493}
494
495void multitransport_tunnel_check(rdpMultitransport* multi)
496{
497 WINPR_ASSERT(multi);
498 WINPR_ASSERT(multi->rdp);
499
500 /* [MS-RDPBCGR] 3.2.5.17: Count tunnel data delivered directly to channels, as well as
501 * data dispatched from the queue by the main loop. */
502 /* Server locks to prevent the tunnel from being destroyed during the check (see
503 * multitransport_server_disconnect). On clients, only the main loop modifies the tunnel
504 * to avoid blocking on a sending thread. */
505 const BOOL server = multitransport_is_server(multi);
506 UINT32 direct = 0;
507 if (server)
508 EnterCriticalSection(&multi->lock);
509 if (multi->reliable)
510 direct = rdpemt_take_direct_bytes(multi->reliable);
511 if (server)
512 LeaveCriticalSection(&multi->lock);
513 rdpAutoDetect* autodetect = multi->rdp->autodetect;
514 if (autodetect && autodetect->bandwidthMeasureStarted)
515 autodetect->bandwidthMeasureByteCount += direct;
516
517 if (InterlockedCompareExchange(&multi->serverSynPending, 0, 1) != 0)
518 multitransport_server_notify_link_state(multi, FREERDP_UDP_LINK_SYN_RECEIVED);
519
520 /* Tear down the tunnel if the client fails to send the Initiate Multitransport
521 * Response within the timeout to avoid pinning a flow, thread, and TLS session. A late
522 * response will find no pending request. */
523 if (multitransport_is_server(multi) && multi->serverResponsePending &&
524 (GetTickCount64() - multi->serverOfferTime > RDPEMT_SERVER_RESPONSE_TIMEOUT_MS))
525 {
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);
532 if (emt)
533 {
534 WLog_INFO(TAG, "multi-transport response timed out; closing the UDP tunnel");
535 multitransport_server_notify_link_state(multi, FREERDP_UDP_LINK_NONE);
536 rdpemt_free(emt);
537 multitransport_server_drop_pending_events(multi);
538 }
539 }
540 if ((InterlockedCompareExchange(&multi->serverWritablePending, 0, 1) != 0) &&
541 multi->udpCallbacks.WriteUnblocked)
542 multi->udpCallbacks.WriteUnblocked(multi->udpCustom);
543}
544
545void multitransport_server_disconnect(rdpContext* context)
546{
547 if (!context || !context->rdp)
548 return;
549 rdpMultitransport* multi = context->rdp->multitransport;
550 if (!multi || !multitransport_is_server(multi))
551 return;
552
553 EnterCriticalSection(&multi->lock);
554 const BOOL tunnel = (multi->reliable != nullptr);
555 LeaveCriticalSection(&multi->lock);
556 if (!tunnel)
557 return;
558
559 /* Application must stop using the flow before it is freed */
560 multitransport_server_notify_link_state(multi, FREERDP_UDP_LINK_NONE);
561 multitransport_reset(multi);
562}
563
564BOOL multitransport_queue_dvc(rdpMultitransport* multi, const BYTE* data, size_t length)
565{
566 if (!multi)
567 return FALSE;
568
569 BOOL rc = FALSE;
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);
574 return rc;
575}
576
577BOOL multitransport_flush_dvc(rdpMultitransport* multi)
578{
579 if (!multi)
580 return FALSE;
581
582 BOOL rc = FALSE;
583 EnterCriticalSection(&multi->lock);
584 if (multi->reliable && (multi->reliableState == FREERDP_MULTITRANSPORT_TUNNEL_READY))
585 rc = rdpemt_flush(multi->reliable);
586 LeaveCriticalSection(&multi->lock);
587 return rc;
588}
589
590BOOL multitransport_server_send_autodetect(rdpMultitransport* multi, RDP_TRANSPORT_TYPE transport,
591 UINT16 sequenceNumber, UINT16 requestType, BOOL* rc)
592{
593 WINPR_ASSERT(multi);
594 WINPR_ASSERT(rc);
595
596 if (transport != RDP_TRANSPORT_UDP_R)
597 return FALSE;
598 /* Tunnel measurements are not sent over TCP to avoid reporting TCP results or
599 * obtaining mixed measurements if the tunnel activates between Start and Stop.
600 * The request fails if the tunnel is not ready. */
601 EnterCriticalSection(&multi->lock);
602 const BOOL ready =
603 multi->reliable && (multi->reliableState == FREERDP_MULTITRANSPORT_TUNNEL_READY);
604 LeaveCriticalSection(&multi->lock);
605 if (!ready)
606 {
607 WLog_DBG(TAG, "no UDP tunnel for the auto-detect request %" PRIu16, sequenceNumber);
608 *rc = FALSE;
609 return TRUE;
610 }
611
612 /* [MS-RDPBCGR] 2.2.14.1: Same PDU as on the main connection, wrapped in a subheader */
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); /* Header length */
617 Stream_Write_UINT8(s, TYPE_ID_AUTODETECT_REQUEST); /* Header type identifier */
618 Stream_Write_UINT16(s, sequenceNumber); /* The sequence number */
619 Stream_Write_UINT16(s, requestType); /* The request type */
620 *rc = multitransport_send_autodetect_response(multi, request, sizeof(request));
621 return TRUE;
622}
623
624DWORD multitransport_server_add_event(rdpMultitransport* multi, HANDLE* events, DWORD used,
625 DWORD count)
626{
627 WINPR_ASSERT(multi);
628 WINPR_ASSERT(events);
629
630 if (used == 0)
631 return used;
632
633 /* Let freerdp_peer_check_fds handle tunnel events triggered by client datagrams */
634 if (!multitransport_server_has_tunnel(multi))
635 return used;
636 if (used >= count)
637 {
638 /* as for the transport's handles: without this one, tunnel events would wait for
639 * activity on TCP */
640 WLog_ERR(TAG, "no room for the UDP tunnel's event handle, %" PRIu32 " given", count);
641 return 0;
642 }
643 events[used] = multitransport_get_event_handle(multi);
644 return used + 1;
645}
646
647WINPR_ATTR_NODISCARD
648static rdpMultitransport* multitransport_from_peer(const freerdp_peer* peer)
649{
650 if (!peer || !peer->context || !peer->context->rdp)
651 return nullptr;
652 return peer->context->rdp->multitransport;
653}
654
655BOOL freerdp_peer_set_udp_hooks(freerdp_peer* peer, const rdpUdpPeerHooks* hooks, void* custom)
656{
657 rdpMultitransport* multi = multitransport_from_peer(peer);
658 if (!multi)
659 return FALSE;
660
661 if (hooks)
662 multi->udpCallbacks = *hooks;
663 else
664 memset(&multi->udpCallbacks, 0, sizeof(multi->udpCallbacks));
665 multi->udpCustom = hooks ? custom : nullptr;
666 return TRUE;
667}
668
669BOOL freerdp_peer_set_udp_callbacks(freerdp_peer* peer, const FreeRDP_UdpPeerCallbacks* callbacks,
670 void* custom)
671{
672 if (!callbacks)
673 return freerdp_peer_set_udp_hooks(peer, nullptr, nullptr);
674
675 /* The callback structure for version 3.34.0 ends with the WriteUnblocked field. */
676 const size_t required =
677 offsetof(FreeRDP_UdpPeerCallbacks, WriteUnblocked) + sizeof(callbacks->WriteUnblocked);
678 if (callbacks->size < required)
679 {
680 WLog_ERR(TAG,
681 "FreeRDP_UdpPeerCallbacks size %" PRIuz " is too small, expected at least %" PRIuz,
682 callbacks->size, required);
683 return FALSE;
684 }
685
686 const rdpUdpPeerHooks hooks = { .LinkChanged = callbacks->LinkChanged,
687 .WriteUnblocked = callbacks->WriteUnblocked };
688 return freerdp_peer_set_udp_hooks(peer, &hooks, custom);
689}
690
691BOOL freerdp_peer_get_udp_send_state_full(freerdp_peer* peer, rdpUdpSendState* state)
692{
693 rdpMultitransport* multi = multitransport_from_peer(peer);
694 if (!multi || !state)
695 return FALSE;
696
697 EnterCriticalSection(&multi->lock);
698 const BOOL rc = multi->reliable != nullptr;
699 if (rc)
700 rdpemt_get_send_state(multi->reliable, state);
701 LeaveCriticalSection(&multi->lock);
702 return rc;
703}
704
706{
707 if (!state)
708 return FALSE;
709 /* The state structure version 3.34.0 ends with the rttMs field. */
710 const size_t required = offsetof(FreeRDP_UdpSendState, rttMs) + sizeof(state->rttMs);
711 if (state->size < required)
712 {
713 WLog_ERR(TAG,
714 "the size of FreeRDP_UdpSendState is %" PRIuz
715 ", but it should be at least %" PRIuz,
716 state->size, required);
717 return FALSE;
718 }
719
720 rdpUdpSendState full = WINPR_C_ARRAY_INIT;
721 if (!freerdp_peer_get_udp_send_state_full(peer, &full))
722 return FALSE;
723
724 FreeRDP_UdpSendState out = WINPR_C_ARRAY_INIT;
725 out.writeBlocked = full.writeBlocked;
726 out.rttMs = full.rttMs;
727 /* Update size to inform the caller how many bytes were filled */
728 const size_t size = (state->size < sizeof(out)) ? state->size : sizeof(out);
729 out.size = size;
730 memcpy(state, &out, size);
731 return TRUE;
732}
733
734BOOL freerdp_peer_set_udp_send_limit(freerdp_peer* peer, size_t limit)
735{
736 rdpMultitransport* multi = multitransport_from_peer(peer);
737 if (!multi)
738 return FALSE;
739
740 EnterCriticalSection(&multi->lock);
741 multi->udpSendLimit = limit;
742 if (multi->reliable)
743 rdpemt_set_send_limit(multi->reliable, limit);
744 LeaveCriticalSection(&multi->lock);
745 return TRUE;
746}
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...
Definition udplistener.h:82
Comprehensive UDP send state information, including additional metrics.
Definition udplistener.h:71
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
Definition udp.h:63
ALIGN64 UINT32 rttMs
Definition udp.h:65
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_peer_set_udp_callbacks(freerdp_peer *peer, const FreeRDP_UdpPeerCallbacks *callbacks, void *custom)
ALIGN64 size_t size
Definition udp.h:62
ALIGN64 size_t size
Definition udp.h:82
Per-peer UDP callbacks, executed on the thread running the freerdp_peer check. Set size to sizeof(Fre...
Definition udp.h:81
Link state for pacing encoders. Set size to sizeof(FreeRDP_UdpSendState) before calling....
Definition udp.h:61