FreeRDP
Loading...
Searching...
No Matches
TestUdpListener.c
1
17
18#include <stdio.h>
19#include <string.h>
20
21#include <winpr/crt.h>
22#include <winpr/interlocked.h>
23#include <winpr/stream.h>
24#include <winpr/synch.h>
25#include <winpr/sysinfo.h>
26#include <winpr/winsock.h>
27
28#if !defined(_WIN32)
29#include <sys/socket.h>
30#include <sys/wait.h>
31#include <netinet/in.h>
32#include <arpa/inet.h>
33#include <unistd.h>
34#endif
35
36#include <freerdp/crypto/certificate.h>
37#include <freerdp/crypto/privatekey.h>
38#include <freerdp/peer.h>
39#include <freerdp/server/udp.h>
40
41#include "../multitransport_internal.h"
42#include "../rdp.h"
43#include "../rdpemt.h"
44#include "../rdpudp.h"
45#include "../udplistener.h"
46#include "../udplistener_internal.h"
47#include "../../crypto/certificate.h"
48
49#if defined(WITH_WINPR_TOOLS)
50#include "TestFuzzServerCerts.h"
51#endif
52
53#define SYN_LENGTH 1232
54
55#define TEST(cond) \
56 do \
57 { \
58 if (!(cond)) \
59 { \
60 (void)printf("%s:%d: %s failed\n", __func__, __LINE__, #cond); \
61 return FALSE; \
62 } \
63 } while (0)
64
65/* [MS-RDPEUDP] 2.2.2.1, 2.2.2.5, 2.2.2.9: version 3 SYN with cookie hash, zero-padded to MTU */
66static void make_syn(BYTE syn[SYN_LENGTH], const BYTE hash[32])
67{
68 memset(syn, 0, SYN_LENGTH);
69 wStream sbuffer = WINPR_C_ARRAY_INIT;
70 wStream* s = Stream_StaticInit(&sbuffer, syn, SYN_LENGTH);
71 Stream_Write_UINT32_BE(s, 0xFFFFFFFF); /* Source acknowledgement number (snSourceAck) */
72 Stream_Write_UINT16_BE(s, 64); /* The receive window size */
73 Stream_Write_UINT16_BE(s,
74 0x0001 | 0x1000); /* Set RDPUDP_FLAG_SYN and RDPUDP_FLAG_SYNEX flags */
75 Stream_Write_UINT32_BE(s, 1000); /* Initial sequence number */
76 Stream_Write_UINT16_BE(s, SYN_LENGTH); /* Upstream MTU */
77 Stream_Write_UINT16_BE(s, SYN_LENGTH); /* Downstream MTU */
78 Stream_Write_UINT16_BE(s, 0x0001); /* Set the RDPUDP_VERSION_INFO_VALID flag */
79 Stream_Write_UINT16_BE(s, RDPUDP_PROTOCOL_VERSION_3);
80 Stream_Write(s, hash, 32);
81}
82
83static SOCKET open_client(UINT16 port)
84{
85 SOCKET sockfd = _socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
86 if (sockfd == INVALID_SOCKET)
87 return INVALID_SOCKET;
88 struct sockaddr_in addr = { 0 };
89 addr.sin_family = AF_INET;
90 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
91 addr.sin_port = htons(port);
92 if (_connect(sockfd, (const struct sockaddr*)&addr, sizeof(addr)) != 0)
93 {
94 closesocket(sockfd);
95 return INVALID_SOCKET;
96 }
97 return sockfd;
98}
99
100/* Loopback socket on an ephemeral port; the listener takes ownership. */
101static SOCKET open_server(UINT16* port)
102{
103 SOCKET sockfd = _socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
104 if (sockfd == INVALID_SOCKET)
105 return INVALID_SOCKET;
106 struct sockaddr_in addr = { 0 };
107 addr.sin_family = AF_INET;
108 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
109 socklen_t length = sizeof(addr);
110 if ((_bind(sockfd, (const struct sockaddr*)&addr, sizeof(addr)) != 0) ||
111 (_getsockname(sockfd, (struct sockaddr*)&addr, &length) != 0))
112 {
113 closesocket(sockfd);
114 return INVALID_SOCKET;
115 }
116 *port = ntohs(addr.sin_port);
117 return sockfd;
118}
119
120/* Polls the listener until a datagram is queued in the flow. */
121static BOOL pump(freerdp_udp_listener* listener, rdpUdpFlow* flow, BYTE* data, size_t* length)
122{
123 for (size_t x = 0; x < 200; x++)
124 {
125 if (listener && !freerdp_udp_listener_check(listener))
126 return FALSE;
127 if (udpflow_read(flow, data, length))
128 return TRUE;
129 Sleep(5);
130 }
131 return FALSE;
132}
133
134static BOOL sorts_by_cookie_hash_then_address(void)
135{
136 BYTE hashA[32] = { 1 };
137 BYTE hashB[32] = { 2 };
138 BYTE hashC[32] = { 3 };
139 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
140 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
141 size_t length = 0;
142
143 UINT16 port = 0;
144 const SOCKET server = open_server(&port);
145 TEST(server != INVALID_SOCKET);
146 freerdp_udp_listener* listener = freerdp_udp_listener_new();
147 TEST(listener);
148 TEST(freerdp_udp_listener_open_from_socket(listener, (int)server));
149
150 rdpUdpFlow* a = freerdp_udp_flow_new(hashA);
151 rdpUdpFlow* b = freerdp_udp_flow_new(hashB);
152 TEST(a && b);
153 TEST(freerdp_udp_listener_add_flow(listener, a));
154 TEST(freerdp_udp_listener_add_flow(listener, b));
155 TEST(!freerdp_udp_listener_add_flow(listener, a));
156
157 const SOCKET clientA = open_client(port);
158 const SOCKET clientB = open_client(port);
159 const SOCKET stranger = open_client(port);
160 TEST((clientA != INVALID_SOCKET) && (clientB != INVALID_SOCKET) &&
161 (stranger != INVALID_SOCKET));
162
163 /* Send junk and a SYN with an unknown hash; the listener should maintain no state. */
164 TEST(_send(stranger, "junk", 4, 0) == 4);
165 make_syn(syn, hashC);
166 TEST(_send(stranger, (const char*)syn, sizeof(syn), 0) == sizeof(syn));
167
168 make_syn(syn, hashB);
169 TEST(_send(clientB, (const char*)syn, sizeof(syn), 0) == sizeof(syn));
170 TEST(pump(listener, b, data, &length));
171 TEST((length == sizeof(syn)) && (memcmp(data, syn, length) == 0));
172 TEST(!udpflow_read(a, data, &length));
173
174 make_syn(syn, hashA);
175 TEST(_send(clientA, (const char*)syn, sizeof(syn), 0) == sizeof(syn));
176 TEST(pump(listener, a, data, &length));
177
178 /* After SYN match, route datagrams by source address. */
179 TEST(_send(clientB, "abc", 3, 0) == 3);
180 TEST(_send(clientA, "de", 2, 0) == 2);
181 TEST(pump(listener, b, data, &length));
182 TEST((length == 3) && (memcmp(data, "abc", 3) == 0));
183 TEST(pump(listener, a, data, &length));
184 TEST((length == 2) && (memcmp(data, "de", 2) == 0));
185
186 /* Replies are sent via the listener's socket. */
187 TEST(freerdp_udp_flow_send(a, (const BYTE*)"reply", 5));
188 char reply[8] = WINPR_C_ARRAY_INIT;
189 TEST(_recv(clientA, reply, sizeof(reply), 0) == 5);
190 TEST(memcmp(reply, "reply", 5) == 0);
191
192 freerdp_udp_flow_free(a);
193 /* Keep flow b registered to verify the listener releases it. */
194 freerdp_udp_listener_free(listener);
195 freerdp_udp_flow_free(b);
196 closesocket(clientA);
197 closesocket(clientB);
198 closesocket(stranger);
199 return TRUE;
200}
201
202/* Forgetting a flow on a non-owning listener is a no-op. The flow remains registered
203 * with its owner until freed. */
204static BOOL remove_flow_on_another_listener_is_a_no_op(void)
205{
206 const BYTE hash[32] = { 50 };
207 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
208 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
209 size_t length = 0;
210
211 UINT16 port = 0;
212 const SOCKET server = open_server(&port);
213 TEST(server != INVALID_SOCKET);
214 freerdp_udp_listener* a = freerdp_udp_listener_new();
215 freerdp_udp_listener* b = freerdp_udp_listener_new();
216 TEST(a && b);
217 TEST(freerdp_udp_listener_open_from_socket(a, (int)server));
218 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
219 TEST(flow);
220 TEST(freerdp_udp_listener_add_flow(a, flow));
221
222 const SOCKET client = open_client(port);
223 TEST(client != INVALID_SOCKET);
224 make_syn(syn, hash);
225 TEST(_send(client, (const char*)syn, sizeof(syn), 0) == sizeof(syn));
226 TEST(pump(a, flow, data, &length));
227
228 freerdp_udp_listener_remove_flow(b, flow);
229 TEST(!freerdp_udp_listener_add_flow(b, flow)); /* Flow is still owned by listener a. */
230 TEST(_send(client, "abc", 3, 0) == 3);
231 TEST(pump(a, flow, data, &length));
232 TEST((length == 3) && (memcmp(data, "abc", 3) == 0));
233
234 /* Freeing the flow removes it from listener a; the hash can be reused and
235 * subsequent client datagrams are dropped. */
236 freerdp_udp_flow_free(flow);
237 TEST(_send(client, "def", 3, 0) == 3);
238 Sleep(20);
239 TEST(freerdp_udp_listener_check(a));
240 rdpUdpFlow* again = freerdp_udp_flow_new(hash);
241 TEST(again);
242 TEST(freerdp_udp_listener_add_flow(a, again));
243
244 freerdp_udp_flow_free(again);
245 freerdp_udp_listener_free(a);
246 freerdp_udp_listener_free(b);
247 closesocket(client);
248 return TRUE;
249}
250
251/* Valid SYNs are padded to MTU; a truncated SYN with a known hash should not
252 * hijack the flow, allowing the legitimate client to connect. */
253static BOOL a_short_syn_is_ignored(void)
254{
255 const BYTE hash[32] = { 40 };
256 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
257 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
258 size_t length = 0;
259
260 UINT16 port = 0;
261 const SOCKET server = open_server(&port);
262 TEST(server != INVALID_SOCKET);
263 freerdp_udp_listener* listener = freerdp_udp_listener_new();
264 TEST(listener);
265 TEST(freerdp_udp_listener_open_from_socket(listener, (int)server));
266 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
267 TEST(flow);
268 TEST(freerdp_udp_listener_add_flow(listener, flow));
269
270 const SOCKET spoofer = open_client(port);
271 const SOCKET client = open_client(port);
272 TEST((spoofer != INVALID_SOCKET) && (client != INVALID_SOCKET));
273 make_syn(syn, hash);
274 TEST(_send(spoofer, (const char*)syn, 64, 0) == 64);
275 TEST(_send(client, (const char*)syn, sizeof(syn), 0) == sizeof(syn));
276 TEST(pump(listener, flow, data, &length));
277 TEST(length == sizeof(syn));
278 TEST(!udpflow_read(flow, data, &length));
279
280 freerdp_udp_flow_free(flow);
281 freerdp_udp_listener_free(listener);
282 closesocket(spoofer);
283 closesocket(client);
284 return TRUE;
285}
286
287static BOOL a_bound_address_rejects_another_cookie_hash(void)
288{
289 BYTE hashA[32] = { 1 };
290 BYTE hashB[32] = { 2 };
291 BYTE synA[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
292 BYTE synB[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
293 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
294 size_t length = 0;
295
296 UINT16 port = 0;
297 const SOCKET server = open_server(&port);
298 TEST(server != INVALID_SOCKET);
299 freerdp_udp_listener* listener = freerdp_udp_listener_new();
300 TEST(listener);
301 TEST(freerdp_udp_listener_open_from_socket(listener, (int)server));
302
303 rdpUdpFlow* a = freerdp_udp_flow_new(hashA);
304 rdpUdpFlow* b = freerdp_udp_flow_new(hashB);
305 TEST(a && b);
306 TEST(freerdp_udp_listener_add_flow(listener, a));
307 TEST(freerdp_udp_listener_add_flow(listener, b));
308
309 const SOCKET bound = open_client(port);
310 const SOCKET other = open_client(port);
311 TEST((bound != INVALID_SOCKET) && (other != INVALID_SOCKET));
312
313 make_syn(synA, hashA);
314 make_syn(synB, hashB);
315 TEST(_send(bound, (const char*)synA, sizeof(synA), 0) == sizeof(synA));
316 TEST(pump(listener, a, data, &length));
317
318 /* SYN with hash B from address A is dropped; repeated SYN for A still arrives. */
319 TEST(_send(bound, (const char*)synB, sizeof(synB), 0) == sizeof(synB));
320 TEST(_send(bound, (const char*)synA, sizeof(synA), 0) == sizeof(synA));
321 TEST(pump(listener, a, data, &length));
322 TEST((length == sizeof(synA)) && (memcmp(data, synA, length) == 0));
323 TEST(!udpflow_read(b, data, &length));
324
325 /* Flow b remains available to its own client. */
326 TEST(_send(other, (const char*)synB, sizeof(synB), 0) == sizeof(synB));
327 TEST(pump(listener, b, data, &length));
328 TEST((length == sizeof(synB)) && (memcmp(data, synB, length) == 0));
329
330 freerdp_udp_flow_free(a);
331 freerdp_udp_listener_free(listener);
332 freerdp_udp_flow_free(b);
333 closesocket(bound);
334 closesocket(other);
335 return TRUE;
336}
337
338static BOOL a_full_flow_drops_new_datagrams(void)
339{
340 const BYTE hash[32] = { 4 };
341 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
342 size_t length = 0;
343
344 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
345 TEST(flow);
346 HANDLE event = freerdp_udp_flow_get_event(flow);
347 TEST(WaitForSingleObject(event, 0) == WAIT_TIMEOUT);
348
349 size_t taken = 0;
350 for (UINT32 x = 0; x < 1000; x++)
351 {
352 BYTE number[4] = WINPR_C_ARRAY_INIT;
353 memcpy(number, &x, sizeof(x));
354 if (freerdp_udp_flow_deliver(flow, number, sizeof(number)))
355 taken++;
356 }
357 TEST((taken > 0) && (taken < 1000));
358 TEST(!freerdp_udp_flow_deliver(flow, data, sizeof(data))); /* The flow buffer is now full. */
359 TEST(WaitForSingleObject(event, 0) == WAIT_OBJECT_0);
360
361 /* Verify queued datagrams are read in order. */
362 for (UINT32 x = 0; x < taken; x++)
363 {
364 UINT32 number = UINT32_MAX;
365 TEST(udpflow_read(flow, data, &length));
366 TEST(length == sizeof(number));
367 memcpy(&number, data, sizeof(number));
368 TEST(number == x);
369 }
370 TEST(!udpflow_read(flow, data, &length));
371 TEST(WaitForSingleObject(event, 0) == WAIT_TIMEOUT);
372
373 /* Exceeds maximum allowed datagram size */
374 BYTE large[UDPFLOW_MAX_DATAGRAM + 1] = WINPR_C_ARRAY_INIT;
375 TEST(!freerdp_udp_flow_deliver(flow, large, sizeof(large)));
376 freerdp_udp_flow_free(flow);
377 return TRUE;
378}
379
380typedef struct
381{
382 const BYTE* data;
383 size_t length;
384 size_t calls;
385} SendTrace;
386
387static BOOL trace_send(void* custom, const BYTE* data, size_t length)
388{
389 SendTrace* trace = custom;
390 trace->data = data;
391 trace->length = length;
392 trace->calls++;
393 return TRUE;
394}
395
396static BOOL a_flow_sends_through_each_path(void)
397{
398 const BYTE hash[32] = { 5 };
399 SendTrace trace = WINPR_C_ARRAY_INIT;
400
401 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
402 TEST(flow);
403 TEST(memcmp(freerdp_udp_flow_get_cookie_hash(flow), hash, sizeof(hash)) == 0);
404 /* Flow with no bound client cannot send */
405 TEST(!freerdp_udp_flow_send(flow, hash, sizeof(hash)));
406
407 freerdp_udp_flow_set_send(flow, trace_send, &trace);
408 TEST(freerdp_udp_flow_send(flow, hash, sizeof(hash)));
409 TEST((trace.calls == 1) && (trace.data == hash) && (trace.length == sizeof(hash)));
410 freerdp_udp_flow_free(flow);
411 return TRUE;
412}
413
414static BOOL a_listener_runs_on_its_own_thread(void)
415{
416 const BYTE hash[32] = { 6 };
417 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
418 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
419 size_t length = 0;
420
421 UINT16 port = 0;
422 const SOCKET server = open_server(&port);
423 TEST(server != INVALID_SOCKET);
424 freerdp_udp_listener* listener = freerdp_udp_listener_new();
425 TEST(listener);
426 TEST(freerdp_udp_listener_open_from_socket(listener, (int)server));
427 HANDLE events[4] = WINPR_C_ARRAY_INIT;
428 TEST(freerdp_udp_listener_get_event_handles(listener, events, ARRAYSIZE(events)) == 1);
429 TEST(freerdp_udp_listener_start(listener));
430
431 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
432 TEST(flow);
433 TEST(freerdp_udp_listener_add_flow(listener, flow));
434
435 const SOCKET client = open_client(port);
436 TEST(client != INVALID_SOCKET);
437 make_syn(syn, hash);
438 TEST(_send(client, (const char*)syn, sizeof(syn), 0) == sizeof(syn));
439 TEST(WaitForSingleObject(freerdp_udp_flow_get_event(flow), 2000) == WAIT_OBJECT_0);
440 TEST(udpflow_read(flow, data, &length));
441 TEST(length == sizeof(syn));
442
443 freerdp_udp_flow_free(flow);
444 freerdp_udp_listener_free(listener);
445 closesocket(client);
446 return TRUE;
447}
448
449/* Shared listener opens on the first flow and closes when the last flow is freed. */
450static BOOL the_shared_listener_opens_and_closes_with_its_flows(void)
451{
452 const BYTE hash[32] = { 7 };
453 const BYTE otherHash[32] = { 9 };
454 UINT16 port = 0;
455 const SOCKET probe = open_server(&port);
456 TEST(probe != INVALID_SOCKET);
457 closesocket(probe);
458
459 rdpUdpFlow* first = freerdp_udp_flow_new(hash);
460 rdpUdpFlow* second = freerdp_udp_flow_new(otherHash);
461 rdpUdpFlow* same = freerdp_udp_flow_new(hash);
462 TEST(first && second && same);
463 struct sockaddr_in addr = { 0 };
464 addr.sin_family = AF_INET;
465 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
466 addr.sin_port = htons(port);
467 const struct sockaddr* local = (const struct sockaddr*)&addr;
468 TEST(udplistener_add_flow_on_address(local, sizeof(addr), first));
469 TEST(udplistener_add_flow_on_address(local, sizeof(addr), second));
470 /* A cookie hash must have a unique owner */
471 TEST(!udplistener_add_flow_on_address(local, sizeof(addr), same));
472 freerdp_udp_flow_free(same);
473
474 /* IPv4-mapped addresses from dual-stack sockets should resolve to the same socket */
475 struct sockaddr_in6 mapped = { 0 };
476 mapped.sin6_family = AF_INET6;
477 mapped.sin6_port = htons(port);
478 mapped.sin6_addr.s6_addr[10] = 0xFF;
479 mapped.sin6_addr.s6_addr[11] = 0xFF;
480 memcpy(&mapped.sin6_addr.s6_addr[12], &addr.sin_addr, sizeof(addr.sin_addr));
481 const BYTE mappedHash[32] = { 11 };
482 rdpUdpFlow* viaMapped = freerdp_udp_flow_new(mappedHash);
483 TEST(viaMapped);
484 TEST(udplistener_add_flow_on_address((const struct sockaddr*)&mapped, sizeof(mapped),
485 viaMapped));
486 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
487 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
488 size_t length = 0;
489 make_syn(syn, mappedHash);
490 const SOCKET client = open_client(port);
491 TEST(client != INVALID_SOCKET);
492 TEST(_send(client, (const char*)syn, sizeof(syn), 0) == sizeof(syn));
493 TEST(WaitForSingleObject(freerdp_udp_flow_get_event(viaMapped), 2000) == WAIT_OBJECT_0);
494 TEST(udpflow_read(viaMapped, data, &length));
495 TEST(freerdp_udp_flow_send(viaMapped, (const BYTE*)"hi", 2));
496 char reply[4] = WINPR_C_ARRAY_INIT;
497 TEST(_recv(client, reply, sizeof(reply), 0) == 2);
498 closesocket(client);
499 freerdp_udp_flow_free(viaMapped);
500
501 /* Ensure no other socket can bind the port and intercept datagrams */
502 SOCKET other = _socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
503 TEST(other != INVALID_SOCKET);
504 TEST(_bind(other, (const struct sockaddr*)&addr, sizeof(addr)) != 0);
505
506 freerdp_udp_flow_free(first);
507 TEST(_bind(other, (const struct sockaddr*)&addr, sizeof(addr)) != 0);
508 freerdp_udp_flow_free(second);
509 TEST(_bind(other, (const struct sockaddr*)&addr, sizeof(addr)) == 0);
510 closesocket(other);
511 return TRUE;
512}
513
514/* Verify that a relay supports bidirectional communication and that freeing the flow
515 * releases the cookie hash. */
516static BOOL a_relay_forwards_both_directions(void)
517{
518 const BYTE hash[32] = { 12 };
519 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
520 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
521 size_t length = 0;
522
523 UINT16 port = 0;
524 const SOCKET server = open_server(&port);
525 TEST(server != INVALID_SOCKET);
526 freerdp_udp_listener* listener = freerdp_udp_listener_new();
527 TEST(listener);
528 TEST(freerdp_udp_listener_open_from_socket(listener, (int)server));
529 TEST(freerdp_udp_listener_start(listener));
530
531 int pair[2] = { -1, -1 };
532 TEST(freerdp_udp_socket_pair(pair));
533 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
534 TEST(flow);
535 TEST(freerdp_udp_flow_set_socket(flow, pair[0]));
536 TEST(freerdp_udp_listener_add_relay(listener, hash, pair[1]));
537
538 const SOCKET client = open_client(port);
539 TEST(client != INVALID_SOCKET);
540 make_syn(syn, hash);
541 TEST(_send(client, (const char*)syn, sizeof(syn), 0) == sizeof(syn));
542 TEST(WaitForSingleObject(freerdp_udp_flow_get_event(flow), 2000) == WAIT_OBJECT_0);
543 TEST(pump(nullptr, flow, data, &length));
544 TEST(length == sizeof(syn));
545 TEST(freerdp_udp_flow_send(flow, (const BYTE*)"back", 4));
546 char reply[8] = WINPR_C_ARRAY_INIT;
547 TEST(_recv(client, reply, sizeof(reply), 0) == 4);
548 TEST(memcmp(reply, "back", 4) == 0);
549
550 /* Freeing the flow terminates the relay and releases the hash */
551 freerdp_udp_flow_free(flow);
552 BOOL free_again = FALSE;
553 for (size_t x = 0; !free_again && (x < 200); x++)
554 {
555 int next[2] = { -1, -1 };
556 TEST(freerdp_udp_socket_pair(next));
557 free_again = freerdp_udp_listener_add_relay(listener, hash, next[1]);
558 if (!free_again)
559 {
560 closesocket((SOCKET)next[1]);
561 Sleep(5);
562 }
563 closesocket((SOCKET)next[0]);
564 }
565 TEST(free_again);
566
567 freerdp_udp_listener_free(listener);
568 closesocket(client);
569 return TRUE;
570}
571
572/* Verify concurrent clients reach their respective flows via hash, then source address. */
573static BOOL many_clients_reach_their_own_flows(void)
574{
575 enum
576 {
577 CLIENTS = 64
578 };
579 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
580 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
581 size_t length = 0;
582 rdpUdpFlow* flows[CLIENTS] = WINPR_C_ARRAY_INIT;
583 SOCKET clients[CLIENTS] = WINPR_C_ARRAY_INIT;
584
585 UINT16 port = 0;
586 const SOCKET server = open_server(&port);
587 TEST(server != INVALID_SOCKET);
588 freerdp_udp_listener* listener = freerdp_udp_listener_new();
589 TEST(listener);
590 TEST(freerdp_udp_listener_open_from_socket(listener, (int)server));
591
592 for (size_t x = 0; x < CLIENTS; x++)
593 {
594 BYTE hash[32] = { 0x40, (BYTE)x };
595 flows[x] = freerdp_udp_flow_new(hash);
596 TEST(flows[x]);
597 TEST(freerdp_udp_listener_add_flow(listener, flows[x]));
598 clients[x] = open_client(port);
599 TEST(clients[x] != INVALID_SOCKET);
600 }
601
602 /* Send SYNs in reverse order, followed by one datagram per client */
603 for (size_t x = CLIENTS; x > 0; x--)
604 {
605 const BYTE hash[32] = { 0x40, (BYTE)(x - 1) };
606 make_syn(syn, hash);
607 TEST(_send(clients[x - 1], (const char*)syn, sizeof(syn), 0) == sizeof(syn));
608 TEST(pump(listener, flows[x - 1], data, &length));
609 TEST(length == sizeof(syn));
610 }
611 for (size_t x = 0; x < CLIENTS; x++)
612 {
613 const BYTE id = (BYTE)x;
614 TEST(_send(clients[x], (const char*)&id, 1, 0) == 1);
615 }
616 for (size_t x = 0; x < CLIENTS; x++)
617 {
618 TEST(pump(listener, flows[x], data, &length));
619 TEST((length == 1) && (data[0] == (BYTE)x));
620 }
621
622 /* Freeing a flow also removes its associated address binding */
623 freerdp_udp_flow_free(flows[0]);
624 flows[0] = nullptr;
625 TEST(_send(clients[0], "x", 1, 0) == 1);
626 TEST(_send(clients[1], "y", 1, 0) == 1);
627 TEST(pump(listener, flows[1], data, &length));
628 TEST((length == 1) && (data[0] == 'y'));
629
630 freerdp_udp_listener_free(listener);
631 for (size_t x = 0; x < CLIENTS; x++)
632 {
633 freerdp_udp_flow_free(flows[x]);
634 closesocket(clients[x]);
635 }
636 return TRUE;
637}
638
639/* Wait until the listener accepts a new relay for the hash (i.e., old relay has ended). */
640static BOOL relay_hash_is_free(freerdp_udp_listener* listener, const BYTE hash[32])
641{
642 for (size_t x = 0; x < 200; x++)
643 {
644 int next[2] = { -1, -1 };
645 if (!freerdp_udp_socket_pair(next))
646 return FALSE;
647 const BOOL taken = freerdp_udp_listener_add_relay(listener, hash, next[1]);
648 if (!taken)
649 closesocket((SOCKET)next[1]);
650 closesocket((SOCKET)next[0]);
651 if (taken)
652 return TRUE;
653 Sleep(5);
654 }
655 return FALSE;
656}
657
658/* Relay ends on request. Oversized datagrams are dropped. */
659static BOOL removing_a_relay_ends_it(void)
660{
661 const BYTE hash[32] = { 60 };
662 const BYTE unknown[32] = { 61 };
663 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
664 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
665 size_t length = 0;
666
667 UINT16 port = 0;
668 const SOCKET server = open_server(&port);
669 TEST(server != INVALID_SOCKET);
670 freerdp_udp_listener* listener = freerdp_udp_listener_new();
671 TEST(listener);
672 TEST(freerdp_udp_listener_open_from_socket(listener, (int)server));
673 TEST(freerdp_udp_listener_start(listener));
674
675 int pair[2] = { -1, -1 };
676 TEST(freerdp_udp_socket_pair(pair));
677 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
678 TEST(flow);
679 TEST(freerdp_udp_flow_set_socket(flow, pair[0]));
680 TEST(freerdp_udp_listener_add_relay(listener, hash, pair[1]));
681
682 const SOCKET client = open_client(port);
683 TEST(client != INVALID_SOCKET);
684 make_syn(syn, hash);
685 TEST(_send(client, (const char*)syn, sizeof(syn), 0) == sizeof(syn));
686 TEST(WaitForSingleObject(freerdp_udp_flow_get_event(flow), 2000) == WAIT_OBJECT_0);
687 TEST(pump(nullptr, flow, data, &length));
688
689 static BYTE large[UDPFLOW_MAX_DATAGRAM + 1];
690 TEST(_send(client, (const char*)large, sizeof(large), 0) == sizeof(large));
691 TEST(_send(client, "small", 5, 0) == 5);
692 TEST(WaitForSingleObject(freerdp_udp_flow_get_event(flow), 2000) == WAIT_OBJECT_0);
693 TEST(pump(nullptr, flow, data, &length));
694 TEST((length == 5) && (memcmp(data, "small", 5) == 0));
695
696 /* Waking the relayed flow's worker sends nothing to the client. */
697 udpflow_wake(flow);
698 HANDLE events[2] = WINPR_C_ARRAY_INIT;
699 const DWORD count = udpflow_get_events(flow, events);
700 TEST(count == 2);
701 TEST(WaitForMultipleObjects(count, events, FALSE, 1000) == WAIT_OBJECT_0);
702#if !defined(_WIN32)
703 Sleep(100);
704 char junk[16] = WINPR_C_ARRAY_INIT;
705 TEST(recv((int)client, junk, sizeof(junk), MSG_DONTWAIT) < 0);
706#endif
707
708#if !defined(_WIN32)
709 /* Stream sockets are rejected as they do not preserve datagram boundaries. */
710 int stream[2] = { -1, -1 };
711 TEST(socketpair(AF_UNIX, SOCK_STREAM, 0, stream) == 0);
712 TEST(!freerdp_udp_listener_add_relay(listener, unknown, stream[1]));
713 close(stream[0]);
714 close(stream[1]);
715#endif
716
717 TEST(!freerdp_udp_listener_remove_relay(listener, unknown));
718 TEST(freerdp_udp_listener_remove_relay(listener, hash));
719 TEST(relay_hash_is_free(listener, hash));
720
721 freerdp_udp_listener_free(listener);
722 freerdp_udp_flow_free(flow);
723 closesocket(client);
724 return TRUE;
725}
726
727#if !defined(_WIN32)
728/* SOCK_DGRAM socket pairs do not provide EOF on close; the relay ends only when a send to the
729 * closed end fails. */
730static BOOL a_datagram_relay_ends_when_its_peer_closes(void)
731{
732 const BYTE hash[32] = { 62 };
733 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
734
735 UINT16 port = 0;
736 const SOCKET server = open_server(&port);
737 TEST(server != INVALID_SOCKET);
738 freerdp_udp_listener* listener = freerdp_udp_listener_new();
739 TEST(listener);
740 TEST(freerdp_udp_listener_open_from_socket(listener, (int)server));
741 TEST(freerdp_udp_listener_start(listener));
742
743 int pair[2] = { -1, -1 };
744 TEST(socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) == 0);
745 TEST(freerdp_udp_listener_add_relay(listener, hash, pair[1]));
746 close(pair[0]); /* The peer disconnects without sending the empty end-of-relay datagram. */
747
748 const SOCKET client = open_client(port);
749 TEST(client != INVALID_SOCKET);
750 make_syn(syn, hash);
751 TEST(_send(client, (const char*)syn, sizeof(syn), 0) == sizeof(syn));
752 TEST(relay_hash_is_free(listener, hash));
753
754 freerdp_udp_listener_free(listener);
755 closesocket(client);
756 return TRUE;
757}
758#endif
759
760/* A single relay thread serves multiple relays concurrently. */
761static BOOL relays_share_one_thread(void)
762{
763 const BYTE hashA[32] = { 20 };
764 const BYTE hashB[32] = { 21 };
765 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
766 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
767 size_t length = 0;
768
769 UINT16 port = 0;
770 const SOCKET server = open_server(&port);
771 TEST(server != INVALID_SOCKET);
772 freerdp_udp_listener* listener = freerdp_udp_listener_new();
773 TEST(listener);
774 TEST(freerdp_udp_listener_open_from_socket(listener, (int)server));
775 TEST(freerdp_udp_listener_start(listener));
776
777 int pairA[2] = { -1, -1 };
778 int pairB[2] = { -1, -1 };
779 TEST(freerdp_udp_socket_pair(pairA));
780 TEST(freerdp_udp_socket_pair(pairB));
781 rdpUdpFlow* a = freerdp_udp_flow_new(hashA);
782 rdpUdpFlow* b = freerdp_udp_flow_new(hashB);
783 TEST(a && b);
784 TEST(freerdp_udp_flow_set_socket(a, pairA[0]));
785 TEST(freerdp_udp_flow_set_socket(b, pairB[0]));
786 TEST(freerdp_udp_listener_add_relay(listener, hashA, pairA[1]));
787 TEST(freerdp_udp_listener_add_relay(listener, hashB, pairB[1]));
788
789 const SOCKET clientA = open_client(port);
790 const SOCKET clientB = open_client(port);
791 TEST((clientA != INVALID_SOCKET) && (clientB != INVALID_SOCKET));
792 make_syn(syn, hashA);
793 TEST(_send(clientA, (const char*)syn, sizeof(syn), 0) == sizeof(syn));
794 make_syn(syn, hashB);
795 TEST(_send(clientB, (const char*)syn, sizeof(syn), 0) == sizeof(syn));
796 TEST(WaitForSingleObject(freerdp_udp_flow_get_event(a), 2000) == WAIT_OBJECT_0);
797 TEST(pump(nullptr, a, data, &length));
798 TEST(WaitForSingleObject(freerdp_udp_flow_get_event(b), 2000) == WAIT_OBJECT_0);
799 TEST(pump(nullptr, b, data, &length));
800
801 /* Empty datagrams must be dropped to avoid being mistaken for the end of the relay. */
802 TEST(_send(clientA, "", 0, 0) == 0);
803 TEST(_send(clientA, "after", 5, 0) == 5);
804 TEST(WaitForSingleObject(freerdp_udp_flow_get_event(a), 2000) == WAIT_OBJECT_0);
805 TEST(pump(nullptr, a, data, &length));
806 TEST((length == 5) && (memcmp(data, "after", 5) == 0));
807
808 TEST(freerdp_udp_flow_send(b, (const BYTE*)"to b", 4));
809 TEST(freerdp_udp_flow_send(a, (const BYTE*)"to a", 4));
810 char reply[8] = WINPR_C_ARRAY_INIT;
811 TEST(_recv(clientA, reply, sizeof(reply), 0) == 4);
812 TEST(memcmp(reply, "to a", 4) == 0);
813 TEST(_recv(clientB, reply, sizeof(reply), 0) == 4);
814 TEST(memcmp(reply, "to b", 4) == 0);
815
816 /* Ending one relay should not affect others. */
817 freerdp_udp_flow_free(a);
818 Sleep(50);
819 TEST(freerdp_udp_flow_send(b, (const BYTE*)"more", 4));
820 TEST(_recv(clientB, reply, sizeof(reply), 0) == 4);
821 TEST(memcmp(reply, "more", 4) == 0);
822
823 freerdp_udp_listener_free(listener);
824 freerdp_udp_flow_free(b);
825 closesocket(clientA);
826 closesocket(clientB);
827 return TRUE;
828}
829
830#if defined(__linux__)
831/* When the listener binds to the wildcard address, the reply must use the destination address
832 * of the request. On Linux, 127.0.0.0/8 is local, but the return route typically selects
833 * 127.0.0.1. */
834static BOOL a_reply_uses_the_request_destination_address(void)
835{
836 const BYTE hash[32] = { 30 };
837 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
838 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
839 size_t length = 0;
840
841 /* Find a free port for the wildcard address. */
842 UINT16 port = 0;
843 const SOCKET probe = open_server(&port);
844 TEST(probe != INVALID_SOCKET);
845 closesocket(probe);
846 freerdp_udp_listener* listener = freerdp_udp_listener_new();
847 TEST(listener);
848 TEST(freerdp_udp_listener_open(listener, "0.0.0.0", port));
849
850 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
851 TEST(flow);
852 TEST(freerdp_udp_listener_add_flow(listener, flow));
853
854 const SOCKET client = _socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
855 TEST(client != INVALID_SOCKET);
856 struct sockaddr_in server = { 0 };
857 server.sin_family = AF_INET;
858 server.sin_addr.s_addr = htonl(INADDR_LOOPBACK + 1);
859 server.sin_port = htons(port);
860 make_syn(syn, hash);
861 TEST(_sendto(client, (const char*)syn, sizeof(syn), 0, (const struct sockaddr*)&server,
862 sizeof(server)) == sizeof(syn));
863 TEST(pump(listener, flow, data, &length));
864
865 TEST(freerdp_udp_flow_send(flow, (const BYTE*)"reply", 5));
866 char reply[8] = WINPR_C_ARRAY_INIT;
867 struct sockaddr_in from = { 0 };
868 socklen_t fromLength = sizeof(from);
869 TEST(_recvfrom(client, reply, sizeof(reply), 0, (struct sockaddr*)&from, &fromLength) == 5);
870 TEST(from.sin_addr.s_addr == htonl(INADDR_LOOPBACK + 1));
871 TEST(from.sin_port == htons(port));
872
873 freerdp_udp_flow_free(flow);
874 freerdp_udp_listener_free(listener);
875 closesocket(client);
876 return TRUE;
877}
878#endif
879
880#if !defined(_WIN32)
881/* Child process side of a server serving clients from a process other than the port owner;
882 * uses a flow on one end of a socket pair, similar to OfferTunnel. */
883static int relay_child(int fd, const BYTE hash[32])
884{
885 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
886 if (!flow)
887 return 1;
888 if (!freerdp_udp_flow_set_socket(flow, fd))
889 return 2;
890
891 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
892 size_t length = 0;
893 if (WaitForSingleObject(freerdp_udp_flow_get_event(flow), 5000) != WAIT_OBJECT_0)
894 return 3;
895 if (!udpflow_read(flow, data, &length) || (length != SYN_LENGTH))
896 return 4;
897 if (!freerdp_udp_flow_send(flow, (const BYTE*)"child", 5))
898 return 5;
899 if (WaitForSingleObject(freerdp_udp_flow_get_event(flow), 5000) != WAIT_OBJECT_0)
900 return 6;
901 if (!udpflow_read(flow, data, &length) || (length != 3) || (memcmp(data, "abc", 3) != 0))
902 return 7;
903 freerdp_udp_flow_free(flow); /* Freeing the flow closes the socket, ending the relay. */
904 return 0;
905}
906
907static BOOL a_forked_process_serves_a_client_through_a_relay(void)
908{
909 const BYTE hash[32] = { 8 };
910 const BYTE otherHash[32] = { 10 };
911 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
912
913 int pair[2] = { -1, -1 };
914 TEST(freerdp_udp_socket_pair(pair));
915 const pid_t child = fork();
916 TEST(child >= 0);
917 if (child == 0)
918 {
919 close(pair[0]);
920 _exit(relay_child(pair[1], hash));
921 }
922 close(pair[1]);
923
924 UINT16 port = 0;
925 const SOCKET server = open_server(&port);
926 TEST(server != INVALID_SOCKET);
927 freerdp_udp_listener* listener = freerdp_udp_listener_new();
928 TEST(listener);
929 TEST(freerdp_udp_listener_open_from_socket(listener, (int)server));
930 TEST(freerdp_udp_listener_start(listener));
931 TEST(freerdp_udp_listener_add_relay(listener, hash, pair[0]));
932
933 /* A second process cannot claim an existing hash; a refused relay must not close the
934 * provided socket. */
935 int other[2] = { -1, -1 };
936 TEST(freerdp_udp_socket_pair(other));
937 TEST(!freerdp_udp_listener_add_relay(listener, hash, other[0]));
938 TEST(freerdp_udp_listener_add_relay(listener, otherHash, other[0]));
939
940 const SOCKET client = open_client(port);
941 TEST(client != INVALID_SOCKET);
942 make_syn(syn, hash);
943 TEST(_send(client, (const char*)syn, sizeof(syn), 0) == sizeof(syn));
944
945 /* The child's reply is relayed and appears to come from the server's address. */
946 char reply[8] = WINPR_C_ARRAY_INIT;
947 TEST(_recv(client, reply, sizeof(reply), 0) == 5);
948 TEST(memcmp(reply, "child", 5) == 0);
949 TEST(_send(client, "abc", 3, 0) == 3);
950
951 int status = -1;
952 TEST(waitpid(child, &status, 0) == child);
953 TEST(WIFEXITED(status) && (WEXITSTATUS(status) == 0));
954
955 /* Once the child process exits, the relay ends and the hash becomes available. */
956 BOOL free_again = FALSE;
957 for (size_t x = 0; !free_again && (x < 200); x++)
958 {
959 int next[2] = { -1, -1 };
960 TEST(freerdp_udp_socket_pair(next));
961 free_again = freerdp_udp_listener_add_relay(listener, hash, next[0]);
962 if (!free_again)
963 {
964 close(next[0]);
965 Sleep(5);
966 }
967 close(next[1]);
968 }
969 TEST(free_again);
970
971 freerdp_udp_listener_free(listener);
972 closesocket(client);
973 close(other[1]);
974 return TRUE;
975}
976
977/* A child that forks without exec closes its copies of the listener's sockets with
978 * freerdp_udp_listener_close_after_fork() and keeps running. The parent's listener still serves
979 * its flows, and once the parent frees it nothing holds the port any more. */
980static BOOL a_forked_child_closes_its_copy_of_the_listener(void)
981{
982 const BYTE hash[32] = { 12 };
983 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
984 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
985 size_t length = 0;
986 int closed[2] = { -1, -1 };
987 int go[2] = { -1, -1 };
988 TEST((pipe(closed) == 0) && (pipe(go) == 0));
989
990 UINT16 port = 0;
991 const SOCKET server = open_server(&port);
992 TEST(server != INVALID_SOCKET);
993 freerdp_udp_listener* listener = freerdp_udp_listener_new();
994 TEST(listener);
995 TEST(freerdp_udp_listener_open_from_socket(listener, (int)server));
996 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
997 TEST(flow);
998 TEST(freerdp_udp_listener_add_flow(listener, flow));
999 TEST(freerdp_udp_listener_start(listener));
1000
1001 const pid_t child = fork();
1002 TEST(child >= 0);
1003 if (child == 0)
1004 {
1005 freerdp_udp_listener_close_after_fork(listener);
1006 char c = 0;
1007 _exit(((write(closed[1], "c", 1) == 1) && (read(go[0], &c, 1) == 1)) ? 0 : 1);
1008 }
1009 char c = 0;
1010 TEST(read(closed[0], &c, 1) == 1);
1011
1012 const SOCKET client = open_client(port);
1013 TEST(client != INVALID_SOCKET);
1014 make_syn(syn, hash);
1015 TEST(_send(client, (const char*)syn, sizeof(syn), 0) == sizeof(syn));
1016 TEST(pump(nullptr, flow, data, &length) && (length == sizeof(syn)));
1017
1018 freerdp_udp_listener_free(listener);
1019 freerdp_udp_flow_free(flow);
1020 const SOCKET again = _socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
1021 struct sockaddr_in addr = { 0 };
1022 addr.sin_family = AF_INET;
1023 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
1024 addr.sin_port = htons(port);
1025 const BOOL rebound = (again != INVALID_SOCKET) &&
1026 (_bind(again, (const struct sockaddr*)&addr, sizeof(addr)) == 0);
1027 closesocket(again);
1028
1029 int status = -1;
1030 TEST(write(go[1], "g", 1) == 1);
1031 TEST(waitpid(child, &status, 0) == child);
1032 closesocket(client);
1033 for (size_t x = 0; x < 2; x++)
1034 {
1035 close(closed[x]);
1036 close(go[x]);
1037 }
1038 if (!rebound)
1039 (void)printf("%s: the child still holds the listener's socket\n", __func__);
1040 TEST(rebound);
1041 TEST(WIFEXITED(status) && (WEXITSTATUS(status) == 0));
1042 return TRUE;
1043}
1044#endif
1045
1046static BOOL offer_nothing(WINPR_ATTR_UNUSED void* custom, WINPR_ATTR_UNUSED rdpUdpFlow* flow,
1047 WINPR_ATTR_UNUSED const BYTE cookieHash[32])
1048{
1049 return FALSE;
1050}
1051
1052static freerdp_peer* test_peer_new(void)
1053{
1054 freerdp_peer* peer = calloc(1, sizeof(freerdp_peer));
1055 if (!peer)
1056 return nullptr;
1057 peer->ContextSize = sizeof(rdpContext);
1058 if (!freerdp_peer_context_new(peer))
1059 {
1060 free(peer);
1061 return nullptr;
1062 }
1063 return peer;
1064}
1065
1066static void test_peer_free(freerdp_peer* peer)
1067{
1068 if (!peer)
1069 return;
1070 freerdp_peer_context_free(peer);
1071 free(peer);
1072}
1073
1074static void link_nothing(WINPR_ATTR_UNUSED void* custom,
1075 WINPR_ATTR_UNUSED FreeRDP_UdpLinkState state)
1076{
1077}
1078
1079/* Peer UDP settings: public callbacks (minimum size 3.34.0) replace internal hooks and
1080 * are cleared with nullptr. The send limit is retained for the next tunnel, and no
1081 * send state exists without a tunnel. */
1082static BOOL peer_udp_settings_without_a_tunnel(void)
1083{
1084 FreeRDP_UdpPeerCallbacks callbacks = WINPR_C_ARRAY_INIT;
1085 rdpUdpPeerHooks hooks = WINPR_C_ARRAY_INIT;
1086 FreeRDP_UdpSendState state = WINPR_C_ARRAY_INIT;
1087 rdpUdpSendState full = WINPR_C_ARRAY_INIT;
1088 int custom = 0;
1089 const size_t required =
1090 offsetof(FreeRDP_UdpPeerCallbacks, WriteUnblocked) + sizeof(callbacks.WriteUnblocked);
1091
1092 TEST(!freerdp_peer_set_udp_callbacks(nullptr, nullptr, nullptr));
1093 TEST(!freerdp_peer_set_udp_send_limit(nullptr, 1));
1094 state.size = sizeof(state);
1095 TEST(!freerdp_peer_get_udp_send_state(nullptr, &state));
1096
1097 freerdp_peer* peer = test_peer_new();
1098 TEST(peer);
1099 rdpMultitransport* multi = peer->context->rdp->multitransport;
1100 TEST(multi);
1101
1102 TEST(sizeof(FreeRDP_UdpPeerCallbacks) == 64 * sizeof(UINT64));
1103 TEST(sizeof(FreeRDP_UdpSendState) == 64 * sizeof(UINT64));
1104
1105 hooks.OfferTunnel = offer_nothing;
1106 hooks.ManualWorker = TRUE;
1107 TEST(freerdp_peer_set_udp_hooks(peer, &hooks, &custom));
1108 TEST((multi->udpCallbacks.OfferTunnel == offer_nothing) && multi->udpCallbacks.ManualWorker);
1109 TEST(multi->udpCustom == &custom);
1110
1111 callbacks.LinkChanged = link_nothing;
1112 callbacks.size = required - 1;
1113 TEST(!freerdp_peer_set_udp_callbacks(peer, &callbacks, &custom));
1114 TEST(multi->udpCallbacks.OfferTunnel == offer_nothing);
1115
1116 callbacks.size = required;
1117 TEST(freerdp_peer_set_udp_callbacks(peer, &callbacks, &custom));
1118 TEST((multi->udpCallbacks.LinkChanged == link_nothing) && !multi->udpCallbacks.OfferTunnel &&
1119 !multi->udpCallbacks.ManualWorker);
1120 TEST(multi->udpCustom == &custom);
1121
1122 TEST(freerdp_peer_set_udp_callbacks(peer, nullptr, nullptr));
1123 TEST(!multi->udpCallbacks.LinkChanged && !multi->udpCustom);
1124
1125 TEST(freerdp_peer_set_udp_send_limit(peer, 12345));
1126 TEST(multi->udpSendLimit == 12345);
1127 TEST(freerdp_peer_set_udp_send_limit(peer, 0));
1128 TEST(multi->udpSendLimit == 0);
1129
1130 state.size = offsetof(FreeRDP_UdpSendState, rttMs);
1131 TEST(!freerdp_peer_get_udp_send_state(peer, &state));
1132 state.size = sizeof(state);
1133 TEST(!freerdp_peer_get_udp_send_state(peer, &state));
1134 TEST(!freerdp_peer_get_udp_send_state_full(peer, &full));
1135
1136 test_peer_free(peer);
1137 return TRUE;
1138}
1139
1140/* The tunnel test requires a certificate and key; these are generated by makecert from
1141 * winpr-tools. */
1142#if defined(WITH_WINPR_TOOLS)
1143
1144typedef struct
1145{
1146 volatile LONG events;
1147 volatile LONG ready;
1148 volatile LONG failed;
1149 DWORD owner; /* 0, or the only thread its events may come on */
1150 volatile LONG foreignThread; /* an event came on another thread than owner */
1151 char data[16];
1152 volatile LONG dataLength;
1153} TunnelEnd;
1154
1155/* Reads a TunnelEnd field set by a tunnel thread using a full barrier.
1156 * InterlockedCompareExchange is used for both reading and writing because
1157 * WinPR's InterlockedExchange reads the old value non-atomically. */
1158static LONG tunnel_end_get(volatile LONG* value)
1159{
1160 return InterlockedCompareExchange(value, 0, 0);
1161}
1162
1163static void tunnel_event(void* custom, WINPR_ATTR_UNUSED rdpEmt* emt, RDPEMT_EVENT event,
1164 const BYTE* data, size_t length)
1165{
1166 TunnelEnd* end = custom;
1167 (void)InterlockedIncrement(&end->events);
1168 if (end->owner && (end->owner != GetCurrentThreadId()))
1169 (void)InterlockedCompareExchange(&end->foreignThread, 1, 0);
1170 if (event == RDPEMT_EVENT_READY)
1171 (void)InterlockedCompareExchange(&end->ready, 1, 0);
1172 else if (event == RDPEMT_EVENT_FAILED)
1173 (void)InterlockedCompareExchange(&end->failed, 1, 0);
1174 else if ((event == RDPEMT_EVENT_DATA) && (length < sizeof(end->data)))
1175 {
1176 memcpy(end->data, data, length);
1177 (void)InterlockedCompareExchange(&end->dataLength, (LONG)length, 0);
1178 }
1179}
1180
1181/* One pass of an application event loop that owns both the listener and a ManualWorker tunnel:
1182 * wait on their events, then let each do its work. */
1183static BOOL drive(freerdp_udp_listener* listener, rdpUdpFlow* flow)
1184{
1185 HANDLE events[8] = WINPR_C_ARRAY_INIT;
1186 DWORD count = freerdp_udp_listener_get_event_handles(listener, events, ARRAYSIZE(events) - 1);
1187 TEST(count > 0);
1188 /* re-fetched before each wait, see freerdp_udp_flow_get_event() */
1189 events[count++] = freerdp_udp_flow_get_event(flow);
1190 TEST(events[count - 1]);
1191 UINT32 timeout = freerdp_udp_flow_get_timeout(flow);
1192 if (timeout > 20)
1193 timeout = 20;
1194 TEST(WaitForMultipleObjects(count, events, FALSE, timeout) != WAIT_FAILED);
1195 TEST(freerdp_udp_listener_check(listener));
1196 TEST(freerdp_udp_flow_check(flow));
1197 return TRUE;
1198}
1199
1200/* With ManualWorker the server end of a tunnel has no thread of its own: the application drives
1201 * it through freerdp_udp_flow_get_event(), _get_timeout() and _check(). A FreeRDP client tunnel
1202 * sets up TLS and the Tunnel Create Request with it, and data then crosses in both directions. */
1203static BOOL a_manual_tunnel_runs_on_the_application_thread(void)
1204{
1205 const UINT32 requestId = 0x01020304;
1206 const BYTE cookie[16] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
1207 TunnelEnd serverEnd = WINPR_C_ARRAY_INIT;
1208 TunnelEnd clientEnd = WINPR_C_ARRAY_INIT;
1209 BOOL rc = FALSE;
1210 char* certDir = nullptr;
1211 char* certFile = nullptr;
1212 char* keyFile = nullptr;
1213 rdpCertificate* cert = nullptr;
1214 rdpPrivateKey* key = nullptr;
1215 BYTE* publicKey = nullptr;
1216 DWORD publicKeyLength = 0;
1217 freerdp_udp_listener* listener = nullptr;
1218 rdpEmt* server = nullptr;
1219 rdpEmt* client = nullptr;
1220 rdpUdpFlow* flow = nullptr;
1221 freerdp_peer* peer = nullptr;
1222 rdpMultitransport* multi = nullptr;
1223 FreeRDP_UdpSendState state = WINPR_C_ARRAY_INIT;
1224 rdpUdpSendState full = WINPR_C_ARRAY_INIT;
1225 UINT16 port = 0;
1226 SOCKET sockfd = INVALID_SOCKET;
1227 struct sockaddr_in addr = WINPR_C_ARRAY_INIT;
1228 const UINT64 deadline = GetTickCount64() + 10000;
1229
1230 certDir = GetKnownSubPath(KNOWN_PATH_TEMP, "TestUdpListener");
1231 if (certDir && server_create_certificate(certDir, "TestUdpListener"))
1232 {
1233 certFile = GetCombinedPathV(certDir, "%s.%s", "TestUdpListener", "crt");
1234 keyFile = GetCombinedPathV(certDir, "%s.%s", "TestUdpListener", "key");
1235 }
1236 cert = certFile ? freerdp_certificate_new_from_file(certFile) : nullptr;
1237 key = keyFile ? freerdp_key_new_from_file(keyFile) : nullptr;
1238 if (!cert || !key || !freerdp_certificate_get_public_key(cert, &publicKey, &publicKeyLength))
1239 {
1240 (void)printf("%s: no test certificate from makecert\n", __func__);
1241 goto out;
1242 }
1243
1244 sockfd = open_server(&port);
1245 listener = freerdp_udp_listener_new();
1246 if ((sockfd == INVALID_SOCKET) || !listener ||
1247 !freerdp_udp_listener_open_from_socket(listener, (int)sockfd))
1248 goto out;
1249
1250 server = rdpemt_new_server(WLog_Get("com.freerdp.core.test.udplistener"), requestId, cookie,
1251 cert, key, TRUE, tunnel_event, &serverEnd);
1252 flow = server ? rdpemt_get_flow(server) : nullptr;
1253 if (!flow || !freerdp_udp_listener_add_flow(listener, flow))
1254 goto out;
1255
1256 client = rdpemt_new(WLog_Get("com.freerdp.core.test.udplistener"), requestId, cookie,
1257 "localhost", publicKey, publicKeyLength, tunnel_event, &clientEnd);
1258 addr.sin_family = AF_INET;
1259 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
1260 addr.sin_port = htons(port);
1261 serverEnd.owner = GetCurrentThreadId();
1262 if (!client || !rdpemt_start(client, (const struct sockaddr*)&addr, sizeof(addr)))
1263 goto out;
1264
1265 /* The listener hands the client's SYN to the flow, but without freerdp_udp_flow_check() the
1266 * server end does nothing: there is no thread of its own to answer it. */
1267 for (UINT64 idle = GetTickCount64() + 500; GetTickCount64() < idle;)
1268 {
1269 HANDLE events[8] = WINPR_C_ARRAY_INIT;
1270 const DWORD count =
1271 freerdp_udp_listener_get_event_handles(listener, events, ARRAYSIZE(events));
1272 if ((count == 0) || (WaitForMultipleObjects(count, events, FALSE, 20) == WAIT_FAILED) ||
1273 !freerdp_udp_listener_check(listener))
1274 goto out;
1275 }
1276 if (tunnel_end_get(&serverEnd.events) != 0)
1277 {
1278 (void)printf("%s: the server end ran without freerdp_udp_flow_check()\n", __func__);
1279 goto out;
1280 }
1281
1282 /* SYN, TLS handshake, Tunnel Create Request and Response, all driven from here */
1283 while (!tunnel_end_get(&serverEnd.ready) || !tunnel_end_get(&clientEnd.ready))
1284 {
1285 if ((GetTickCount64() > deadline) || tunnel_end_get(&serverEnd.failed) ||
1286 tunnel_end_get(&clientEnd.failed) || !drive(listener, flow))
1287 {
1288 (void)printf("%s: tunnel setup failed\n", __func__);
1289 goto out;
1290 }
1291 }
1292
1293 if (!rdpemt_send_data(client, (const BYTE*)"to server", 9))
1294 goto out;
1295 while (tunnel_end_get(&serverEnd.dataLength) != 9)
1296 {
1297 if ((GetTickCount64() > deadline) || !drive(listener, flow))
1298 goto out;
1299 }
1300 if ((memcmp(serverEnd.data, "to server", 9) != 0) ||
1301 !rdpemt_send_data(server, (const BYTE*)"to client", 9) || !rdpemt_flush(server))
1302 goto out;
1303 while (tunnel_end_get(&clientEnd.dataLength) != 9)
1304 {
1305 if ((GetTickCount64() > deadline) || !drive(listener, flow))
1306 goto out;
1307 }
1308 if (memcmp(clientEnd.data, "to client", 9) != 0)
1309 {
1310 (void)printf("%s: data did not arrive intact\n", __func__);
1311 goto out;
1312 }
1313 /* every event of the server end came inside freerdp_udp_flow_check(), on this thread */
1314 if (tunnel_end_get(&serverEnd.foreignThread))
1315 {
1316 (void)printf("%s: a server event came on another thread\n", __func__);
1317 goto out;
1318 }
1319
1320 /* A peer whose tunnel this is reports its send state, and takes a new send limit. */
1321 peer = test_peer_new();
1322 if (!peer)
1323 goto out;
1324 multi = peer->context->rdp->multitransport;
1325 if (!multi)
1326 goto out;
1327 EnterCriticalSection(&multi->lock);
1328 multi->reliable = server;
1329 LeaveCriticalSection(&multi->lock);
1330 state.size = sizeof(state);
1331 rc = freerdp_peer_get_udp_send_state(peer, &state) && (state.size == sizeof(state)) &&
1332 !state.writeBlocked && (state.rttMs > 0) &&
1333 freerdp_peer_get_udp_send_state_full(peer, &full) && !full.writeBlocked &&
1334 (full.queuedBytes == 0) && (full.rttMs > 0) && (full.rateBytesPerSecond > 0) &&
1335 freerdp_peer_set_udp_send_limit(peer, 1u << 20);
1336 if (!rc)
1337 (void)printf("%s: no send state for a ready tunnel\n", __func__);
1338out:
1339 if (multi)
1340 {
1341 EnterCriticalSection(&multi->lock);
1342 multi->reliable = nullptr;
1343 LeaveCriticalSection(&multi->lock);
1344 }
1345 test_peer_free(peer);
1346 rdpemt_free(client);
1347 if (listener && flow)
1348 freerdp_udp_listener_remove_flow(listener, flow);
1349 rdpemt_free(server);
1350 freerdp_udp_listener_free(listener);
1351 free(publicKey);
1352 freerdp_certificate_free(cert);
1353 freerdp_key_free(key);
1354 free(certDir);
1355 free(certFile);
1356 free(keyFile);
1357 return rc;
1358}
1359
1360#endif /* WITH_WINPR_TOOLS */
1361
1362/* A session on a second local address ends: the shared listener closes that socket without
1363 * stopping its thread, so the sessions left keep their reader. */
1364static BOOL a_socket_no_session_uses_closes_without_a_restart(void)
1365{
1366 const BYTE hashA[32] = { 70 };
1367 const BYTE hashB[32] = { 71 };
1368 UINT16 port = 0;
1369 const SOCKET probe = open_server(&port);
1370 TEST(probe != INVALID_SOCKET);
1371 closesocket(probe);
1372
1373 struct sockaddr_in addrA = { 0 };
1374 addrA.sin_family = AF_INET;
1375 addrA.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
1376 addrA.sin_port = htons(port);
1377 struct sockaddr_in addrB = addrA;
1378 addrB.sin_addr.s_addr = htonl(INADDR_LOOPBACK + 1); /* 127.0.0.2 */
1379
1380 /* skip where the host does not answer on 127.0.0.2 */
1381 SOCKET test = _socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
1382 TEST(test != INVALID_SOCKET);
1383 const BOOL second = (_bind(test, (const struct sockaddr*)&addrB, sizeof(addrB)) == 0);
1384 closesocket(test);
1385 if (!second)
1386 return TRUE;
1387
1388 rdpUdpFlow* a = freerdp_udp_flow_new(hashA);
1389 rdpUdpFlow* b = freerdp_udp_flow_new(hashB);
1390 TEST(a && b);
1391 TEST(udplistener_add_flow_on_address((const struct sockaddr*)&addrA, sizeof(addrA), a));
1392 TEST(udplistener_add_flow_on_address((const struct sockaddr*)&addrB, sizeof(addrB), b));
1393 freerdp_udp_listener* listener = a->listener;
1394 TEST(listener && (b->listener == listener) && listener->thread);
1395 const HANDLE thread = listener->thread;
1396
1397 freerdp_udp_flow_free(b);
1398 TEST(listener->thread == thread);
1399
1400 /* the thread closes the socket on 127.0.0.2 when it builds its next wait set */
1401 BOOL closed = FALSE;
1402 for (size_t x = 0; !closed && (x < 200); x++)
1403 {
1404 test = _socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
1405 TEST(test != INVALID_SOCKET);
1406 closed = (_bind(test, (const struct sockaddr*)&addrB, sizeof(addrB)) == 0);
1407 closesocket(test);
1408 if (!closed)
1409 Sleep(10);
1410 }
1411 TEST(closed);
1412
1413 /* the session on 127.0.0.1 still gets its datagrams */
1414 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
1415 make_syn(syn, hashA);
1416 const SOCKET client = open_client(port);
1417 TEST(client != INVALID_SOCKET);
1418 TEST(_send(client, (const char*)syn, sizeof(syn), 0) == sizeof(syn));
1419 TEST(WaitForSingleObject(freerdp_udp_flow_get_event(a), 2000) == WAIT_OBJECT_0);
1420 TEST(listener->thread == thread);
1421
1422 closesocket(client);
1423 freerdp_udp_flow_free(a);
1424 return TRUE;
1425}
1426
1427typedef struct
1428{
1429 rdpUdpFlow* flow;
1430 HANDLE start;
1431} udpFreeArg;
1432
1433static DWORD WINAPI free_flow_thread(LPVOID arg)
1434{
1435 udpFreeArg* job = arg;
1436 (void)WaitForSingleObject(job->start, INFINITE);
1437 freerdp_udp_flow_free(job->flow);
1438 return 0;
1439}
1440
1441/* Peers free their flows while the application frees the listener; with the sanitizers this
1442 * finds a listener or entry used after it was freed. */
1443static BOOL a_listener_and_its_flows_free_on_different_threads(void)
1444{
1445 for (size_t round = 0; round < 200; round++)
1446 {
1447 HANDLE start = CreateEvent(nullptr, TRUE, FALSE, nullptr);
1448 freerdp_udp_listener* listener = freerdp_udp_listener_new();
1449 TEST(start && listener);
1450
1451 udpFreeArg args[4] = WINPR_C_ARRAY_INIT;
1452 HANDLE threads[ARRAYSIZE(args)] = WINPR_C_ARRAY_INIT;
1453 for (size_t x = 0; x < ARRAYSIZE(args); x++)
1454 {
1455 const BYTE hash[32] = { (BYTE)(x + 1) };
1456 args[x].flow = freerdp_udp_flow_new(hash);
1457 args[x].start = start;
1458 TEST(args[x].flow && freerdp_udp_listener_add_flow(listener, args[x].flow));
1459 threads[x] = CreateThread(nullptr, 0, free_flow_thread, &args[x], 0, nullptr);
1460 TEST(threads[x]);
1461 }
1462 (void)SetEvent(start);
1463 freerdp_udp_listener_free(listener);
1464 for (size_t x = 0; x < ARRAYSIZE(threads); x++)
1465 {
1466 (void)WaitForSingleObject(threads[x], INFINITE);
1467 (void)CloseHandle(threads[x]);
1468 }
1469 (void)CloseHandle(start);
1470 }
1471 return TRUE;
1472}
1473
1474typedef struct
1475{
1476 LONG inCall;
1477 HANDLE entered;
1478 rdpUdpFlow* flow;
1479} udpSlowCallback;
1480
1481static BOOL slow_callback(void* custom, WINPR_ATTR_UNUSED const BYTE* data,
1482 WINPR_ATTR_UNUSED size_t length)
1483{
1484 udpSlowCallback* slow = custom;
1485 (void)InterlockedIncrement(&slow->inCall);
1486 (void)SetEvent(slow->entered);
1487 Sleep(100);
1488 (void)InterlockedDecrement(&slow->inCall);
1489 return TRUE;
1490}
1491
1492static DWORD WINAPI slow_send_thread(LPVOID arg)
1493{
1494 udpSlowCallback* slow = arg;
1495 if (!freerdp_udp_flow_send(slow->flow, (const BYTE*)"x", 1))
1496 (void)printf("the send callback failed\n");
1497 return 0;
1498}
1499
1500/* After set_send and set_receive return, the previous callback is no longer running, so its
1501 * custom may be freed. */
1502static BOOL setting_a_callback_waits_for_a_running_one(void)
1503{
1504 const BYTE hash[32] = { 60 };
1505 udpSlowCallback slow = WINPR_C_ARRAY_INIT;
1506 slow.entered = CreateEvent(nullptr, TRUE, FALSE, nullptr);
1507 slow.flow = freerdp_udp_flow_new(hash);
1508 TEST(slow.entered && slow.flow);
1509
1510 freerdp_udp_flow_set_send(slow.flow, slow_callback, &slow);
1511 HANDLE thread = CreateThread(nullptr, 0, slow_send_thread, &slow, 0, nullptr);
1512 TEST(thread);
1513 TEST(WaitForSingleObject(slow.entered, 5000) == WAIT_OBJECT_0);
1514 freerdp_udp_flow_set_send(slow.flow, nullptr, nullptr);
1515 TEST(InterlockedCompareExchange(&slow.inCall, 0, 0) == 0);
1516 (void)WaitForSingleObject(thread, INFINITE);
1517 (void)CloseHandle(thread);
1518
1519 /* the receive callback runs on the listener's thread */
1520 (void)ResetEvent(slow.entered);
1521 UINT16 port = 0;
1522 const SOCKET server = open_server(&port);
1523 TEST(server != INVALID_SOCKET);
1524 freerdp_udp_listener* listener = freerdp_udp_listener_new();
1525 TEST(listener);
1526 TEST(freerdp_udp_listener_open_from_socket(listener, (int)server));
1527 TEST(freerdp_udp_listener_add_flow(listener, slow.flow));
1528 freerdp_udp_flow_set_receive(slow.flow, slow_callback, &slow);
1529 TEST(freerdp_udp_listener_start(listener));
1530 const SOCKET client = open_client(port);
1531 TEST(client != INVALID_SOCKET);
1532 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
1533 make_syn(syn, hash);
1534 TEST(_send(client, (const char*)syn, sizeof(syn), 0) == sizeof(syn));
1535 TEST(WaitForSingleObject(slow.entered, 5000) == WAIT_OBJECT_0);
1536 freerdp_udp_flow_set_receive(slow.flow, nullptr, nullptr);
1537 TEST(InterlockedCompareExchange(&slow.inCall, 0, 0) == 0);
1538
1539 freerdp_udp_flow_free(slow.flow);
1540 freerdp_udp_listener_free(listener);
1541 closesocket(client);
1542 (void)CloseHandle(slow.entered);
1543 return TRUE;
1544}
1545
1546typedef struct
1547{
1548 LONG inCall;
1549 HANDLE entered;
1550 rdpMultitransport* multi;
1551} udpSlowHook;
1552
1553static BOOL slow_state_changed(void* custom, WINPR_ATTR_UNUSED UINT32 tunnelType,
1554 WINPR_ATTR_UNUSED FreeRDP_MultitransportTunnelState state)
1555{
1556 udpSlowHook* slow = custom;
1557 (void)InterlockedIncrement(&slow->inCall);
1558 (void)SetEvent(slow->entered);
1559 Sleep(100);
1560 (void)InterlockedDecrement(&slow->inCall);
1561 return TRUE;
1562}
1563
1564static DWORD WINAPI notify_state_thread(LPVOID arg)
1565{
1566 udpSlowHook* slow = arg;
1567 if (!multitransport_notify_state(slow->multi, FREERDP_MULTITRANSPORT_TUNNEL_READY))
1568 (void)printf("the tunnel state hook failed\n");
1569 return 0;
1570}
1571
1572/* The channel manager may be closed on another thread than the peer's check: clearing the DVC
1573 * hooks waits for a hook that is running, so its custom can be freed afterwards. */
1574static BOOL clearing_the_dvc_hooks_waits_for_a_running_one(void)
1575{
1576 freerdp_peer* peer = test_peer_new();
1577 TEST(peer);
1578 udpSlowHook slow = WINPR_C_ARRAY_INIT;
1579 slow.entered = CreateEvent(nullptr, TRUE, FALSE, nullptr);
1580 slow.multi = peer->context->rdp->multitransport;
1581 TEST(slow.entered && slow.multi);
1582
1583 FreeRDP_MultitransportDvcCallbacks hooks = WINPR_C_ARRAY_INIT;
1584 hooks.TunnelStateChanged = slow_state_changed;
1585 TEST(freerdp_multitransport_set_dvc_callbacks(peer->context, &hooks, &slow));
1586 HANDLE thread = CreateThread(nullptr, 0, notify_state_thread, &slow, 0, nullptr);
1587 TEST(thread);
1588 TEST(WaitForSingleObject(slow.entered, 5000) == WAIT_OBJECT_0);
1589 TEST(freerdp_multitransport_set_dvc_callbacks(peer->context, nullptr, nullptr));
1590 TEST(InterlockedCompareExchange(&slow.inCall, 0, 0) == 0);
1591 (void)WaitForSingleObject(thread, INFINITE);
1592 (void)CloseHandle(thread);
1593
1594 (void)CloseHandle(slow.entered);
1595 test_peer_free(peer);
1596 return TRUE;
1597}
1598
1599int TestUdpListener(int argc, char* argv[])
1600{
1601 WINPR_UNUSED(argc);
1602 WINPR_UNUSED(argv);
1603
1604 WSADATA wsaData = WINPR_C_ARRAY_INIT;
1605 if (WSAStartup(0x0202, &wsaData) != 0)
1606 return -1;
1607
1608 int rc = -1;
1609 if (!sorts_by_cookie_hash_then_address())
1610 goto out;
1611 if (!a_bound_address_rejects_another_cookie_hash())
1612 goto out;
1613 if (!remove_flow_on_another_listener_is_a_no_op())
1614 goto out;
1615 if (!a_short_syn_is_ignored())
1616 goto out;
1617 if (!a_full_flow_drops_new_datagrams())
1618 goto out;
1619 if (!a_flow_sends_through_each_path())
1620 goto out;
1621 if (!a_listener_runs_on_its_own_thread())
1622 goto out;
1623 if (!the_shared_listener_opens_and_closes_with_its_flows())
1624 goto out;
1625 if (!a_socket_no_session_uses_closes_without_a_restart())
1626 goto out;
1627 if (!a_relay_forwards_both_directions())
1628 goto out;
1629 if (!many_clients_reach_their_own_flows())
1630 goto out;
1631 if (!removing_a_relay_ends_it())
1632 goto out;
1633#if !defined(_WIN32)
1634 if (!a_datagram_relay_ends_when_its_peer_closes())
1635 goto out;
1636#endif
1637 if (!relays_share_one_thread())
1638 goto out;
1639 if (!peer_udp_settings_without_a_tunnel())
1640 goto out;
1641#if defined(WITH_WINPR_TOOLS)
1642 if (!a_manual_tunnel_runs_on_the_application_thread())
1643 goto out;
1644#endif
1645 if (!a_listener_and_its_flows_free_on_different_threads())
1646 goto out;
1647 if (!setting_a_callback_waits_for_a_running_one())
1648 goto out;
1649 if (!clearing_the_dvc_hooks_waits_for_a_running_one())
1650 goto out;
1651#if defined(__linux__)
1652 if (!a_reply_uses_the_request_destination_address())
1653 goto out;
1654#endif
1655#if !defined(_WIN32)
1656 if (!a_forked_process_serves_a_client_through_a_relay())
1657 goto out;
1658 if (!a_forked_child_closes_its_copy_of_the_listener())
1659 goto out;
1660#endif
1661 rc = 0;
1662out:
1663 WSACleanup();
1664 return rc;
1665}
Dynamic virtual channel hooks of the client side tunnels.
WINPR_ATTR_NODISCARD BOOL(* TunnelStateChanged)(void *custom, UINT32 tunnelType, FreeRDP_MultitransportTunnelState state)
Callbacks from FreeRDP_UdpPeerCallbacks and internal hooks. Executed on the thread running the freerd...
Definition udplistener.h:82
WINPR_ATTR_NODISCARD BOOL(* OfferTunnel)(void *custom, rdpUdpFlow *flow, const BYTE cookieHash[32])
Definition udplistener.h:93
Comprehensive UDP send state information, including additional metrics.
Definition udplistener.h:71
UINT64 rateBytesPerSecond
Definition udplistener.h:75
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)
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: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