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>
29#include <sys/socket.h>
31#include <netinet/in.h>
36#include <freerdp/crypto/certificate.h>
37#include <freerdp/crypto/privatekey.h>
38#include <freerdp/peer.h>
41#include "../multitransport_internal.h"
45#include "../udplistener.h"
46#include "../udplistener_internal.h"
47#include "../../crypto/certificate.h"
49#if defined(WITH_WINPR_TOOLS)
50#include "TestFuzzServerCerts.h"
53#define SYN_LENGTH 1232
60 (void)printf("%s:%d: %s failed\n", __func__, __LINE__, #cond); \
66static void make_syn(BYTE syn[SYN_LENGTH],
const BYTE hash[32])
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);
72 Stream_Write_UINT16_BE(s, 64);
73 Stream_Write_UINT16_BE(s,
75 Stream_Write_UINT32_BE(s, 1000);
76 Stream_Write_UINT16_BE(s, SYN_LENGTH);
77 Stream_Write_UINT16_BE(s, SYN_LENGTH);
78 Stream_Write_UINT16_BE(s, 0x0001);
79 Stream_Write_UINT16_BE(s, RDPUDP_PROTOCOL_VERSION_3);
80 Stream_Write(s, hash, 32);
83static SOCKET open_client(UINT16 port)
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)
95 return INVALID_SOCKET;
101static SOCKET open_server(UINT16* port)
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))
114 return INVALID_SOCKET;
116 *port = ntohs(addr.sin_port);
121static BOOL pump(freerdp_udp_listener* listener, rdpUdpFlow* flow, BYTE* data,
size_t* length)
123 for (
size_t x = 0; x < 200; x++)
125 if (listener && !freerdp_udp_listener_check(listener))
127 if (udpflow_read(flow, data, length))
134static BOOL sorts_by_cookie_hash_then_address(
void)
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;
144 const SOCKET server = open_server(&port);
145 TEST(server != INVALID_SOCKET);
146 freerdp_udp_listener* listener = freerdp_udp_listener_new();
148 TEST(freerdp_udp_listener_open_from_socket(listener, (
int)server));
150 rdpUdpFlow* a = freerdp_udp_flow_new(hashA);
151 rdpUdpFlow* b = freerdp_udp_flow_new(hashB);
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));
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));
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));
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));
174 make_syn(syn, hashA);
175 TEST(_send(clientA, (
const char*)syn,
sizeof(syn), 0) ==
sizeof(syn));
176 TEST(pump(listener, a, data, &length));
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));
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);
192 freerdp_udp_flow_free(a);
194 freerdp_udp_listener_free(listener);
195 freerdp_udp_flow_free(b);
196 closesocket(clientA);
197 closesocket(clientB);
198 closesocket(stranger);
204static BOOL remove_flow_on_another_listener_is_a_no_op(
void)
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;
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();
217 TEST(freerdp_udp_listener_open_from_socket(a, (
int)server));
218 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
220 TEST(freerdp_udp_listener_add_flow(a, flow));
222 const SOCKET client = open_client(port);
223 TEST(client != INVALID_SOCKET);
225 TEST(_send(client, (
const char*)syn,
sizeof(syn), 0) ==
sizeof(syn));
226 TEST(pump(a, flow, data, &length));
228 freerdp_udp_listener_remove_flow(b, flow);
229 TEST(!freerdp_udp_listener_add_flow(b, flow));
230 TEST(_send(client,
"abc", 3, 0) == 3);
231 TEST(pump(a, flow, data, &length));
232 TEST((length == 3) && (memcmp(data,
"abc", 3) == 0));
236 freerdp_udp_flow_free(flow);
237 TEST(_send(client,
"def", 3, 0) == 3);
239 TEST(freerdp_udp_listener_check(a));
240 rdpUdpFlow* again = freerdp_udp_flow_new(hash);
242 TEST(freerdp_udp_listener_add_flow(a, again));
244 freerdp_udp_flow_free(again);
245 freerdp_udp_listener_free(a);
246 freerdp_udp_listener_free(b);
253static BOOL a_short_syn_is_ignored(
void)
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;
261 const SOCKET server = open_server(&port);
262 TEST(server != INVALID_SOCKET);
263 freerdp_udp_listener* listener = freerdp_udp_listener_new();
265 TEST(freerdp_udp_listener_open_from_socket(listener, (
int)server));
266 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
268 TEST(freerdp_udp_listener_add_flow(listener, flow));
270 const SOCKET spoofer = open_client(port);
271 const SOCKET client = open_client(port);
272 TEST((spoofer != INVALID_SOCKET) && (client != INVALID_SOCKET));
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));
280 freerdp_udp_flow_free(flow);
281 freerdp_udp_listener_free(listener);
282 closesocket(spoofer);
287static BOOL a_bound_address_rejects_another_cookie_hash(
void)
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;
297 const SOCKET server = open_server(&port);
298 TEST(server != INVALID_SOCKET);
299 freerdp_udp_listener* listener = freerdp_udp_listener_new();
301 TEST(freerdp_udp_listener_open_from_socket(listener, (
int)server));
303 rdpUdpFlow* a = freerdp_udp_flow_new(hashA);
304 rdpUdpFlow* b = freerdp_udp_flow_new(hashB);
306 TEST(freerdp_udp_listener_add_flow(listener, a));
307 TEST(freerdp_udp_listener_add_flow(listener, b));
309 const SOCKET bound = open_client(port);
310 const SOCKET other = open_client(port);
311 TEST((bound != INVALID_SOCKET) && (other != INVALID_SOCKET));
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));
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));
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));
330 freerdp_udp_flow_free(a);
331 freerdp_udp_listener_free(listener);
332 freerdp_udp_flow_free(b);
338static BOOL a_full_flow_drops_new_datagrams(
void)
340 const BYTE hash[32] = { 4 };
341 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
344 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
346 HANDLE
event = freerdp_udp_flow_get_event(flow);
347 TEST(WaitForSingleObject(event, 0) == WAIT_TIMEOUT);
350 for (UINT32 x = 0; x < 1000; x++)
352 BYTE number[4] = WINPR_C_ARRAY_INIT;
353 memcpy(number, &x,
sizeof(x));
354 if (freerdp_udp_flow_deliver(flow, number,
sizeof(number)))
357 TEST((taken > 0) && (taken < 1000));
358 TEST(!freerdp_udp_flow_deliver(flow, data,
sizeof(data)));
359 TEST(WaitForSingleObject(event, 0) == WAIT_OBJECT_0);
362 for (UINT32 x = 0; x < taken; x++)
364 UINT32 number = UINT32_MAX;
365 TEST(udpflow_read(flow, data, &length));
366 TEST(length ==
sizeof(number));
367 memcpy(&number, data,
sizeof(number));
370 TEST(!udpflow_read(flow, data, &length));
371 TEST(WaitForSingleObject(event, 0) == WAIT_TIMEOUT);
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);
387static BOOL trace_send(
void* custom,
const BYTE* data,
size_t length)
389 SendTrace* trace = custom;
391 trace->length = length;
396static BOOL a_flow_sends_through_each_path(
void)
398 const BYTE hash[32] = { 5 };
399 SendTrace trace = WINPR_C_ARRAY_INIT;
401 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
403 TEST(memcmp(freerdp_udp_flow_get_cookie_hash(flow), hash,
sizeof(hash)) == 0);
405 TEST(!freerdp_udp_flow_send(flow, hash,
sizeof(hash)));
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);
414static BOOL a_listener_runs_on_its_own_thread(
void)
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;
422 const SOCKET server = open_server(&port);
423 TEST(server != INVALID_SOCKET);
424 freerdp_udp_listener* listener = freerdp_udp_listener_new();
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));
431 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
433 TEST(freerdp_udp_listener_add_flow(listener, flow));
435 const SOCKET client = open_client(port);
436 TEST(client != INVALID_SOCKET);
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));
443 freerdp_udp_flow_free(flow);
444 freerdp_udp_listener_free(listener);
450static BOOL the_shared_listener_opens_and_closes_with_its_flows(
void)
452 const BYTE hash[32] = { 7 };
453 const BYTE otherHash[32] = { 9 };
455 const SOCKET probe = open_server(&port);
456 TEST(probe != INVALID_SOCKET);
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));
471 TEST(!udplistener_add_flow_on_address(local,
sizeof(addr), same));
472 freerdp_udp_flow_free(same);
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);
484 TEST(udplistener_add_flow_on_address((
const struct sockaddr*)&mapped,
sizeof(mapped),
486 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
487 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
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);
499 freerdp_udp_flow_free(viaMapped);
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);
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);
516static BOOL a_relay_forwards_both_directions(
void)
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;
524 const SOCKET server = open_server(&port);
525 TEST(server != INVALID_SOCKET);
526 freerdp_udp_listener* listener = freerdp_udp_listener_new();
528 TEST(freerdp_udp_listener_open_from_socket(listener, (
int)server));
529 TEST(freerdp_udp_listener_start(listener));
531 int pair[2] = { -1, -1 };
532 TEST(freerdp_udp_socket_pair(pair));
533 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
535 TEST(freerdp_udp_flow_set_socket(flow, pair[0]));
536 TEST(freerdp_udp_listener_add_relay(listener, hash, pair[1]));
538 const SOCKET client = open_client(port);
539 TEST(client != INVALID_SOCKET);
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);
551 freerdp_udp_flow_free(flow);
552 BOOL free_again = FALSE;
553 for (
size_t x = 0; !free_again && (x < 200); x++)
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]);
560 closesocket((SOCKET)next[1]);
563 closesocket((SOCKET)next[0]);
567 freerdp_udp_listener_free(listener);
573static BOOL many_clients_reach_their_own_flows(
void)
579 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
580 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
582 rdpUdpFlow* flows[CLIENTS] = WINPR_C_ARRAY_INIT;
583 SOCKET clients[CLIENTS] = WINPR_C_ARRAY_INIT;
586 const SOCKET server = open_server(&port);
587 TEST(server != INVALID_SOCKET);
588 freerdp_udp_listener* listener = freerdp_udp_listener_new();
590 TEST(freerdp_udp_listener_open_from_socket(listener, (
int)server));
592 for (
size_t x = 0; x < CLIENTS; x++)
594 BYTE hash[32] = { 0x40, (BYTE)x };
595 flows[x] = freerdp_udp_flow_new(hash);
597 TEST(freerdp_udp_listener_add_flow(listener, flows[x]));
598 clients[x] = open_client(port);
599 TEST(clients[x] != INVALID_SOCKET);
603 for (
size_t x = CLIENTS; x > 0; x--)
605 const BYTE hash[32] = { 0x40, (BYTE)(x - 1) };
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));
611 for (
size_t x = 0; x < CLIENTS; x++)
613 const BYTE
id = (BYTE)x;
614 TEST(_send(clients[x], (
const char*)&
id, 1, 0) == 1);
616 for (
size_t x = 0; x < CLIENTS; x++)
618 TEST(pump(listener, flows[x], data, &length));
619 TEST((length == 1) && (data[0] == (BYTE)x));
623 freerdp_udp_flow_free(flows[0]);
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'));
630 freerdp_udp_listener_free(listener);
631 for (
size_t x = 0; x < CLIENTS; x++)
633 freerdp_udp_flow_free(flows[x]);
634 closesocket(clients[x]);
640static BOOL relay_hash_is_free(freerdp_udp_listener* listener,
const BYTE hash[32])
642 for (
size_t x = 0; x < 200; x++)
644 int next[2] = { -1, -1 };
645 if (!freerdp_udp_socket_pair(next))
647 const BOOL taken = freerdp_udp_listener_add_relay(listener, hash, next[1]);
649 closesocket((SOCKET)next[1]);
650 closesocket((SOCKET)next[0]);
659static BOOL removing_a_relay_ends_it(
void)
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;
668 const SOCKET server = open_server(&port);
669 TEST(server != INVALID_SOCKET);
670 freerdp_udp_listener* listener = freerdp_udp_listener_new();
672 TEST(freerdp_udp_listener_open_from_socket(listener, (
int)server));
673 TEST(freerdp_udp_listener_start(listener));
675 int pair[2] = { -1, -1 };
676 TEST(freerdp_udp_socket_pair(pair));
677 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
679 TEST(freerdp_udp_flow_set_socket(flow, pair[0]));
680 TEST(freerdp_udp_listener_add_relay(listener, hash, pair[1]));
682 const SOCKET client = open_client(port);
683 TEST(client != INVALID_SOCKET);
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));
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));
698 HANDLE events[2] = WINPR_C_ARRAY_INIT;
699 const DWORD count = udpflow_get_events(flow, events);
701 TEST(WaitForMultipleObjects(count, events, FALSE, 1000) == WAIT_OBJECT_0);
704 char junk[16] = WINPR_C_ARRAY_INIT;
705 TEST(recv((
int)client, junk,
sizeof(junk), MSG_DONTWAIT) < 0);
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]));
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));
721 freerdp_udp_listener_free(listener);
722 freerdp_udp_flow_free(flow);
730static BOOL a_datagram_relay_ends_when_its_peer_closes(
void)
732 const BYTE hash[32] = { 62 };
733 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
736 const SOCKET server = open_server(&port);
737 TEST(server != INVALID_SOCKET);
738 freerdp_udp_listener* listener = freerdp_udp_listener_new();
740 TEST(freerdp_udp_listener_open_from_socket(listener, (
int)server));
741 TEST(freerdp_udp_listener_start(listener));
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]));
748 const SOCKET client = open_client(port);
749 TEST(client != INVALID_SOCKET);
751 TEST(_send(client, (
const char*)syn,
sizeof(syn), 0) ==
sizeof(syn));
752 TEST(relay_hash_is_free(listener, hash));
754 freerdp_udp_listener_free(listener);
761static BOOL relays_share_one_thread(
void)
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;
770 const SOCKET server = open_server(&port);
771 TEST(server != INVALID_SOCKET);
772 freerdp_udp_listener* listener = freerdp_udp_listener_new();
774 TEST(freerdp_udp_listener_open_from_socket(listener, (
int)server));
775 TEST(freerdp_udp_listener_start(listener));
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);
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]));
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));
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));
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);
817 freerdp_udp_flow_free(a);
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);
823 freerdp_udp_listener_free(listener);
824 freerdp_udp_flow_free(b);
825 closesocket(clientA);
826 closesocket(clientB);
830#if defined(__linux__)
834static BOOL a_reply_uses_the_request_destination_address(
void)
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;
843 const SOCKET probe = open_server(&port);
844 TEST(probe != INVALID_SOCKET);
846 freerdp_udp_listener* listener = freerdp_udp_listener_new();
848 TEST(freerdp_udp_listener_open(listener,
"0.0.0.0", port));
850 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
852 TEST(freerdp_udp_listener_add_flow(listener, flow));
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);
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));
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));
873 freerdp_udp_flow_free(flow);
874 freerdp_udp_listener_free(listener);
883static int relay_child(
int fd,
const BYTE hash[32])
885 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
888 if (!freerdp_udp_flow_set_socket(flow, fd))
891 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
893 if (WaitForSingleObject(freerdp_udp_flow_get_event(flow), 5000) != WAIT_OBJECT_0)
895 if (!udpflow_read(flow, data, &length) || (length != SYN_LENGTH))
897 if (!freerdp_udp_flow_send(flow, (
const BYTE*)
"child", 5))
899 if (WaitForSingleObject(freerdp_udp_flow_get_event(flow), 5000) != WAIT_OBJECT_0)
901 if (!udpflow_read(flow, data, &length) || (length != 3) || (memcmp(data,
"abc", 3) != 0))
903 freerdp_udp_flow_free(flow);
907static BOOL a_forked_process_serves_a_client_through_a_relay(
void)
909 const BYTE hash[32] = { 8 };
910 const BYTE otherHash[32] = { 10 };
911 BYTE syn[SYN_LENGTH] = WINPR_C_ARRAY_INIT;
913 int pair[2] = { -1, -1 };
914 TEST(freerdp_udp_socket_pair(pair));
915 const pid_t child = fork();
920 _exit(relay_child(pair[1], hash));
925 const SOCKET server = open_server(&port);
926 TEST(server != INVALID_SOCKET);
927 freerdp_udp_listener* listener = freerdp_udp_listener_new();
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]));
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]));
940 const SOCKET client = open_client(port);
941 TEST(client != INVALID_SOCKET);
943 TEST(_send(client, (
const char*)syn,
sizeof(syn), 0) ==
sizeof(syn));
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);
952 TEST(waitpid(child, &status, 0) == child);
953 TEST(WIFEXITED(status) && (WEXITSTATUS(status) == 0));
956 BOOL free_again = FALSE;
957 for (
size_t x = 0; !free_again && (x < 200); x++)
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]);
971 freerdp_udp_listener_free(listener);
980static BOOL a_forked_child_closes_its_copy_of_the_listener(
void)
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;
986 int closed[2] = { -1, -1 };
987 int go[2] = { -1, -1 };
988 TEST((pipe(closed) == 0) && (pipe(go) == 0));
991 const SOCKET server = open_server(&port);
992 TEST(server != INVALID_SOCKET);
993 freerdp_udp_listener* listener = freerdp_udp_listener_new();
995 TEST(freerdp_udp_listener_open_from_socket(listener, (
int)server));
996 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
998 TEST(freerdp_udp_listener_add_flow(listener, flow));
999 TEST(freerdp_udp_listener_start(listener));
1001 const pid_t child = fork();
1005 freerdp_udp_listener_close_after_fork(listener);
1007 _exit(((write(closed[1],
"c", 1) == 1) && (read(go[0], &c, 1) == 1)) ? 0 : 1);
1010 TEST(read(closed[0], &c, 1) == 1);
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)));
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);
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++)
1039 (void)printf(
"%s: the child still holds the listener's socket\n", __func__);
1041 TEST(WIFEXITED(status) && (WEXITSTATUS(status) == 0));
1046static BOOL offer_nothing(WINPR_ATTR_UNUSED
void* custom, WINPR_ATTR_UNUSED rdpUdpFlow* flow,
1047 WINPR_ATTR_UNUSED
const BYTE cookieHash[32])
1052static freerdp_peer* test_peer_new(
void)
1054 freerdp_peer* peer = calloc(1,
sizeof(freerdp_peer));
1057 peer->ContextSize =
sizeof(rdpContext);
1058 if (!freerdp_peer_context_new(peer))
1066static void test_peer_free(freerdp_peer* peer)
1070 freerdp_peer_context_free(peer);
1074static void link_nothing(WINPR_ATTR_UNUSED
void* custom,
1075 WINPR_ATTR_UNUSED FreeRDP_UdpLinkState state)
1082static BOOL peer_udp_settings_without_a_tunnel(
void)
1089 const size_t required =
1093 TEST(!freerdp_peer_set_udp_send_limit(
nullptr, 1));
1094 state.size =
sizeof(state);
1097 freerdp_peer* peer = test_peer_new();
1099 rdpMultitransport* multi = peer->context->rdp->multitransport;
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);
1111 callbacks.LinkChanged = link_nothing;
1112 callbacks.
size = required - 1;
1114 TEST(multi->udpCallbacks.OfferTunnel == offer_nothing);
1116 callbacks.
size = required;
1118 TEST((multi->udpCallbacks.LinkChanged == link_nothing) && !multi->udpCallbacks.OfferTunnel &&
1119 !multi->udpCallbacks.ManualWorker);
1120 TEST(multi->udpCustom == &custom);
1123 TEST(!multi->udpCallbacks.LinkChanged && !multi->udpCustom);
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);
1132 state.size =
sizeof(state);
1134 TEST(!freerdp_peer_get_udp_send_state_full(peer, &full));
1136 test_peer_free(peer);
1142#if defined(WITH_WINPR_TOOLS)
1146 volatile LONG events;
1147 volatile LONG ready;
1148 volatile LONG failed;
1150 volatile LONG foreignThread;
1152 volatile LONG dataLength;
1158static LONG tunnel_end_get(
volatile LONG* value)
1160 return InterlockedCompareExchange(value, 0, 0);
1163static void tunnel_event(
void* custom, WINPR_ATTR_UNUSED rdpEmt* emt, RDPEMT_EVENT event,
1164 const BYTE* data,
size_t length)
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)))
1176 memcpy(end->data, data, length);
1177 (void)InterlockedCompareExchange(&end->dataLength, (LONG)length, 0);
1183static BOOL drive(freerdp_udp_listener* listener, rdpUdpFlow* flow)
1185 HANDLE events[8] = WINPR_C_ARRAY_INIT;
1186 DWORD count = freerdp_udp_listener_get_event_handles(listener, events, ARRAYSIZE(events) - 1);
1189 events[count++] = freerdp_udp_flow_get_event(flow);
1190 TEST(events[count - 1]);
1191 UINT32 timeout = freerdp_udp_flow_get_timeout(flow);
1194 TEST(WaitForMultipleObjects(count, events, FALSE, timeout) != WAIT_FAILED);
1195 TEST(freerdp_udp_listener_check(listener));
1196 TEST(freerdp_udp_flow_check(flow));
1203static BOOL a_manual_tunnel_runs_on_the_application_thread(
void)
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;
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;
1226 SOCKET sockfd = INVALID_SOCKET;
1227 struct sockaddr_in addr = WINPR_C_ARRAY_INIT;
1228 const UINT64 deadline = GetTickCount64() + 10000;
1230 certDir = GetKnownSubPath(KNOWN_PATH_TEMP,
"TestUdpListener");
1231 if (certDir && server_create_certificate(certDir,
"TestUdpListener"))
1233 certFile = GetCombinedPathV(certDir,
"%s.%s",
"TestUdpListener",
"crt");
1234 keyFile = GetCombinedPathV(certDir,
"%s.%s",
"TestUdpListener",
"key");
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))
1240 (void)printf(
"%s: no test certificate from makecert\n", __func__);
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))
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))
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)))
1267 for (UINT64 idle = GetTickCount64() + 500; GetTickCount64() < idle;)
1269 HANDLE events[8] = WINPR_C_ARRAY_INIT;
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))
1276 if (tunnel_end_get(&serverEnd.events) != 0)
1278 (void)printf(
"%s: the server end ran without freerdp_udp_flow_check()\n", __func__);
1283 while (!tunnel_end_get(&serverEnd.ready) || !tunnel_end_get(&clientEnd.ready))
1285 if ((GetTickCount64() > deadline) || tunnel_end_get(&serverEnd.failed) ||
1286 tunnel_end_get(&clientEnd.failed) || !drive(listener, flow))
1288 (void)printf(
"%s: tunnel setup failed\n", __func__);
1293 if (!rdpemt_send_data(client, (
const BYTE*)
"to server", 9))
1295 while (tunnel_end_get(&serverEnd.dataLength) != 9)
1297 if ((GetTickCount64() > deadline) || !drive(listener, flow))
1300 if ((memcmp(serverEnd.data,
"to server", 9) != 0) ||
1301 !rdpemt_send_data(server, (
const BYTE*)
"to client", 9) || !rdpemt_flush(server))
1303 while (tunnel_end_get(&clientEnd.dataLength) != 9)
1305 if ((GetTickCount64() > deadline) || !drive(listener, flow))
1308 if (memcmp(clientEnd.data,
"to client", 9) != 0)
1310 (void)printf(
"%s: data did not arrive intact\n", __func__);
1314 if (tunnel_end_get(&serverEnd.foreignThread))
1316 (void)printf(
"%s: a server event came on another thread\n", __func__);
1321 peer = test_peer_new();
1324 multi = peer->context->rdp->multitransport;
1327 EnterCriticalSection(&multi->lock);
1328 multi->reliable = server;
1329 LeaveCriticalSection(&multi->lock);
1330 state.size =
sizeof(state);
1332 !state.writeBlocked && (state.rttMs > 0) &&
1333 freerdp_peer_get_udp_send_state_full(peer, &full) && !full.
writeBlocked &&
1335 freerdp_peer_set_udp_send_limit(peer, 1u << 20);
1337 (void)printf(
"%s: no send state for a ready tunnel\n", __func__);
1341 EnterCriticalSection(&multi->lock);
1342 multi->reliable =
nullptr;
1343 LeaveCriticalSection(&multi->lock);
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);
1352 freerdp_certificate_free(cert);
1353 freerdp_key_free(key);
1364static BOOL a_socket_no_session_uses_closes_without_a_restart(
void)
1366 const BYTE hashA[32] = { 70 };
1367 const BYTE hashB[32] = { 71 };
1369 const SOCKET probe = open_server(&port);
1370 TEST(probe != INVALID_SOCKET);
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);
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);
1388 rdpUdpFlow* a = freerdp_udp_flow_new(hashA);
1389 rdpUdpFlow* b = freerdp_udp_flow_new(hashB);
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;
1397 freerdp_udp_flow_free(b);
1398 TEST(listener->thread == thread);
1401 BOOL closed = FALSE;
1402 for (
size_t x = 0; !closed && (x < 200); x++)
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);
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);
1422 closesocket(client);
1423 freerdp_udp_flow_free(a);
1433static DWORD WINAPI free_flow_thread(LPVOID arg)
1435 udpFreeArg* job = arg;
1436 (void)WaitForSingleObject(job->start, INFINITE);
1437 freerdp_udp_flow_free(job->flow);
1443static BOOL a_listener_and_its_flows_free_on_different_threads(
void)
1445 for (
size_t round = 0; round < 200; round++)
1447 HANDLE start = CreateEvent(
nullptr, TRUE, FALSE,
nullptr);
1448 freerdp_udp_listener* listener = freerdp_udp_listener_new();
1449 TEST(start && listener);
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++)
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);
1462 (void)SetEvent(start);
1463 freerdp_udp_listener_free(listener);
1464 for (
size_t x = 0; x < ARRAYSIZE(threads); x++)
1466 (void)WaitForSingleObject(threads[x], INFINITE);
1467 (void)CloseHandle(threads[x]);
1469 (void)CloseHandle(start);
1481static BOOL slow_callback(
void* custom, WINPR_ATTR_UNUSED
const BYTE* data,
1482 WINPR_ATTR_UNUSED
size_t length)
1484 udpSlowCallback* slow = custom;
1485 (void)InterlockedIncrement(&slow->inCall);
1486 (void)SetEvent(slow->entered);
1488 (void)InterlockedDecrement(&slow->inCall);
1492static DWORD WINAPI slow_send_thread(LPVOID arg)
1494 udpSlowCallback* slow = arg;
1495 if (!freerdp_udp_flow_send(slow->flow, (
const BYTE*)
"x", 1))
1496 (void)printf(
"the send callback failed\n");
1502static BOOL setting_a_callback_waits_for_a_running_one(
void)
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);
1510 freerdp_udp_flow_set_send(slow.flow, slow_callback, &slow);
1511 HANDLE thread = CreateThread(
nullptr, 0, slow_send_thread, &slow, 0,
nullptr);
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);
1520 (void)ResetEvent(slow.entered);
1522 const SOCKET server = open_server(&port);
1523 TEST(server != INVALID_SOCKET);
1524 freerdp_udp_listener* listener = freerdp_udp_listener_new();
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);
1539 freerdp_udp_flow_free(slow.flow);
1540 freerdp_udp_listener_free(listener);
1541 closesocket(client);
1542 (void)CloseHandle(slow.entered);
1550 rdpMultitransport* multi;
1553static BOOL slow_state_changed(
void* custom, WINPR_ATTR_UNUSED UINT32 tunnelType,
1554 WINPR_ATTR_UNUSED FreeRDP_MultitransportTunnelState state)
1556 udpSlowHook* slow = custom;
1557 (void)InterlockedIncrement(&slow->inCall);
1558 (void)SetEvent(slow->entered);
1560 (void)InterlockedDecrement(&slow->inCall);
1564static DWORD WINAPI notify_state_thread(LPVOID arg)
1566 udpSlowHook* slow = arg;
1567 if (!multitransport_notify_state(slow->multi, FREERDP_MULTITRANSPORT_TUNNEL_READY))
1568 (void)printf(
"the tunnel state hook failed\n");
1574static BOOL clearing_the_dvc_hooks_waits_for_a_running_one(
void)
1576 freerdp_peer* peer = test_peer_new();
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);
1585 TEST(freerdp_multitransport_set_dvc_callbacks(peer->context, &hooks, &slow));
1586 HANDLE thread = CreateThread(
nullptr, 0, notify_state_thread, &slow, 0,
nullptr);
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);
1594 (void)CloseHandle(slow.entered);
1595 test_peer_free(peer);
1599int TestUdpListener(
int argc,
char* argv[])
1604 WSADATA wsaData = WINPR_C_ARRAY_INIT;
1605 if (WSAStartup(0x0202, &wsaData) != 0)
1609 if (!sorts_by_cookie_hash_then_address())
1611 if (!a_bound_address_rejects_another_cookie_hash())
1613 if (!remove_flow_on_another_listener_is_a_no_op())
1615 if (!a_short_syn_is_ignored())
1617 if (!a_full_flow_drops_new_datagrams())
1619 if (!a_flow_sends_through_each_path())
1621 if (!a_listener_runs_on_its_own_thread())
1623 if (!the_shared_listener_opens_and_closes_with_its_flows())
1625 if (!a_socket_no_session_uses_closes_without_a_restart())
1627 if (!a_relay_forwards_both_directions())
1629 if (!many_clients_reach_their_own_flows())
1631 if (!removing_a_relay_ends_it())
1634 if (!a_datagram_relay_ends_when_its_peer_closes())
1637 if (!relays_share_one_thread())
1639 if (!peer_udp_settings_without_a_tunnel())
1641#if defined(WITH_WINPR_TOOLS)
1642 if (!a_manual_tunnel_runs_on_the_application_thread())
1645 if (!a_listener_and_its_flows_free_on_different_threads())
1647 if (!setting_a_callback_waits_for_a_running_one())
1649 if (!clearing_the_dvc_hooks_waits_for_a_running_one())
1651#if defined(__linux__)
1652 if (!a_reply_uses_the_request_destination_address())
1656 if (!a_forked_process_serves_a_client_through_a_relay())
1658 if (!a_forked_child_closes_its_copy_of_the_listener())
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...
WINPR_ATTR_NODISCARD BOOL(* OfferTunnel)(void *custom, rdpUdpFlow *flow, const BYTE cookieHash[32])
Comprehensive UDP send state information, including additional metrics.
UINT64 rateBytesPerSecond
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)
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....