18#include <freerdp/config.h>
22#include <winpr/assert.h>
23#include <winpr/cast.h>
25#include <winpr/crypto.h>
26#include <winpr/sysinfo.h>
27#include <winpr/collections.h>
28#include <winpr/stream.h>
29#include <winpr/winsock.h>
32#include <sys/socket.h>
33#include <netinet/in.h>
39typedef enum WINPR_C23_ENUM_TYPE(uint16_t)
41 RDPUDP_FLAG_SYN = 0x0001,
42 RDPUDP_FLAG_ACK = 0x0004,
43 RDPUDP_FLAG_DATA = 0x0008,
44 RDPUDP_FLAG_FEC = 0x0010,
45 RDPUDP_FLAG_CN = 0x0020,
46 RDPUDP_FLAG_CWR = 0x0040,
47 RDPUDP_FLAG_ACK_OF_ACKS = 0x0100,
48 RDPUDP_FLAG_CORRELATION_ID = 0x0800,
49 RDPUDP_FLAG_SYNEX = 0x1000
53typedef enum WINPR_C23_ENUM_TYPE(uint16_t)
55 RDPUDP_VERSION_INFO_VALID = 0x0001
59typedef enum WINPR_C23_ENUM_TYPE(uint8_t)
61 DATAGRAM_RECEIVED = 0,
62 DATAGRAM_NOT_YET_RECEIVED = 3
63} RDPUDP_VECTOR_ELEMENT_STATE;
66typedef enum WINPR_C23_ENUM_TYPE(uint16_t)
70 RDPUDP2_ACKVEC = 0x008,
72 RDPUDP2_OVERHEADSIZE = 0x040,
73 RDPUDP2_DELAYACKINFO = 0x100,
78typedef enum WINPR_C23_ENUM_TYPE(uint8_t)
80 RDPUDP2_PACKET_STANDARD = 0,
81 RDPUDP2_PACKET_DUMMY = 8
85#define RDPUDP_MAX_ACK_VECTOR 2048
87#define RDPUDP_MTU 1232
88#define RDPUDP_MIN_MTU 1132
91#define RDPUDP_RECEIVE_WINDOW 64
97#define RDPUDP_RECEIVE_SLOTS 32768
98#define RDPUDP_RECEIVE_REACH 32767
102#define RDPUDP_INPUT_BUDGET 256
107#define RDPUDP_MAX_CHUNK 2048
114#define RDPUDP_UNVERIFIED_REACH 128
118#define RDPUDP_MAX_IN_FLIGHT 4096
119#define RDPUDP_CLIENT_MAX_IN_FLIGHT 64
124#define RDPUDP_PENDING_INDEX 65536
151#define RDPUDP2_INITIAL_CWND 32
152#define RDPUDP2_MIN_CWND 8
153#define RDPUDP2_REORDER_THRESHOLD 3
154#define RDPUDP2_MAX_REORDER_THRESHOLD 128
155#define RDPUDP2_REORDER_DECAY_ROUNDS 8
157#define RDPUDP2_RESENT_HISTORY 256
161#define RDPUDP2_RESENT_MAX_AGE_MS 2000
166#define RDPUDP2_MAX_RTO_BACKOFF 6
167#define RDPUDP2_GROWTH_ACKS 8
168#define RDPUDP2_CONGESTED_LOSS_PERCENT 10
169#define RDPUDP2_LOSS_RISE_PERCENT 5
171#define RDPUDP2_LOSS_AVG_SHIFT 3
172#define RDPUDP2_ROUND_MIN_SAMPLES 16
173#define RDPUDP2_QUEUE_DELAY_MS 30
176#define RDPUDP2_DELAY_REBASE_CUTS 2u
179#define RDPUDP2_DELAY_REBASE_PERCENT 90
183#define RDPUDP2_RTT_PROBE_MS 10000
189#define RDPUDP2_MAX_SPAN RDPUDP_MAX_IN_FLIGHT
193#define RDPUDP2_LOG_WINDOW_SIZE 15
196#define RDPUDP2_INITIAL_SEQUENCE 100
200#define RDPUDP2_DEFAULT_DELAYED_ACKS 8
201#define RDPUDP2_MAX_DELAYED_ACKS 15
205#define RDPUDP2_DATA_OVERHEAD 19
208#define RDPUDP2_DATA_ACK_ROOM 5
212#define RDPUDP_RECEIVE_BUFFER (2 * 1024 * 1024)
215#define RDPUDP2_MAX_ACKVEC 127
218#define RDPUDP_ACK_ROOM 64
224#define RDPUDP_SYN_TIMEOUT_MS 1000
225#define RDPUDP_SYN_ATTEMPTS 3
231#define RDPUDP_MAX_RTO_MS 120000
237#define RDPUDP2_MAX_RTO_MS 2000
239#define RDPUDP2_HANDSHAKE_RTT_MAX_MS 500
243#define RDPUDP_MAX_RETRANSMITS 5
244#define RDPUDP_KEEPALIVE_MS 5000
245#define RDPUDP_PEER_TIMEOUT_MS 65000
250#define RDPUDP2_MAX_RETRANSMITS 10
257#define RDPUDP2_REPORT_MIN_ROUND_MS 1
258#define RDPUDP2_REPORT_MIN_BUDGET 16
260#define RDPUDP2_KEEPALIVE_MS 4000
264#define RDPUDP2_PEER_TIMEOUT_MS 16500
269#define RDPUDP2_RESYNC_MS (2ull * RDPUDP2_KEEPALIVE_MS)
273#define RDPUDP2_RESYNC_KEEPALIVE_MS 1000
280#define RDPUDP2_STALE_AOA_REACH 16384
285#define RDPUDP2_MAX_RESEND_SPAN (RDPUDP_RECEIVE_REACH - 1)
292#define RDPUDP_STALL_TIMEOUT_MS RDPUDP2_PEER_TIMEOUT_MS
342 rdpUdpReceiveFn receive;
358 rdpudp_pending pending[RDPUDP_MAX_IN_FLIGHT];
361 UINT16 pendingIndex[RDPUDP_PENDING_INDEX];
371 UINT32 ccRoundRttMin;
373 UINT32 ccDelayLastRtt;
379 UINT32 reorderThreshold;
381 UINT32 reorderCalmRounds;
389 } resent[RDPUDP2_RESENT_HISTORY];
395 UINT64 reportRoundStart;
396 UINT32 reportRoundUsed;
399 UINT32 initialSequence;
406 UINT16 nextChannelSeq;
411 rdpudp_slot slots[RDPUDP_RECEIVE_SLOTS];
414 UINT64 bufferingSince;
417 UINT32 peerInitialSequence;
420 UINT32 ackVectorStart;
426 UINT64 v3ExpectedFull;
431 UINT64 v3Received[RDPUDP_RECEIVE_SLOTS];
432 UINT64 v3Arrival[RDPUDP_RECEIVE_SLOTS];
433 UINT64 v3InOrderArrival;
434 BOOL v3InOrderReceived;
435 UINT64 v3LatestArrival;
436 size_t v3MaxDelayedAcks;
437 UINT32 v3DelayedAckTimeout;
439 size_t v3UnackedPackets;
442 BOOL v3WindowPending;
446 size_t v3BehindCount;
447 UINT64 v3BehindArrival;
448 UINT16 v3NextChannel;
454 BYTE synAck[RDPUDP_MTU];
458 BYTE recvBuffer[0x10000];
465static inline UINT16 seq16_add(UINT16 a,
size_t n)
467 return WINPR_ASSERTING_INT_CAST(UINT16, (a + n) & 0xFFFFu);
472static inline UINT16 seq16_diff(UINT16 a, UINT16 b)
474 return WINPR_ASSERTING_INT_CAST(UINT16, ((UINT32)a - (UINT32)b) & 0xFFFFu);
478static inline UINT32 seq32_add(UINT32 a, UINT32 n)
480 return WINPR_ASSERTING_INT_CAST(UINT32, ((UINT64)a + n) & 0xFFFFFFFFull);
485static inline UINT32 seq32_diff(UINT32 a, UINT32 b)
487 return WINPR_ASSERTING_INT_CAST(UINT32, ((UINT64)a - (UINT64)b) & 0xFFFFFFFFull);
491static BOOL seq16_after(UINT16 a, UINT16 b)
493 return (a != b) && (seq16_diff(a, b) < 0x8000);
497static BOOL seq32_after(UINT32 a, UINT32 b)
499 return (a != b) && (seq32_diff(a, b) < 0x80000000u);
505static UINT16 channel_seq_next(UINT16 seq)
507 return (seq == UINT16_MAX) ? 1 : seq16_add(seq, 1);
518static UINT64 v3_full(
const rdpUdp* udp, UINT16 seq)
521 const UINT16 ahead = seq16_diff(seq, udp->v3Expected);
523 return udp->v3ExpectedFull + ahead;
524 return udp->v3ExpectedFull - (0x10000u - ahead);
528static BOOL v3_received(
const rdpUdp* udp, UINT16 seq)
531 return udp->v3Received[seq % RDPUDP_RECEIVE_SLOTS] == v3_full(udp, seq);
536static UINT64 v3_arrival(
const rdpUdp* udp, UINT16 seq)
539 return v3_received(udp, seq) ? udp->v3Arrival[seq % RDPUDP_RECEIVE_SLOTS] : 0;
542static void v3_mark_received(rdpUdp* udp, UINT16 seq, UINT64 arrival)
545 udp->v3Received[seq % RDPUDP_RECEIVE_SLOTS] = v3_full(udp, seq);
546 udp->v3Arrival[seq % RDPUDP_RECEIVE_SLOTS] = arrival;
550static void v3_set_expected(rdpUdp* udp, UINT16 seq)
553 udp->v3ExpectedFull = v3_full(udp, seq);
554 udp->v3Expected = seq;
558static void stream_write_uint24(
wStream* s, UINT32 value)
561 const UINT16 low = WINPR_ASSERTING_INT_CAST(UINT16, value & 0xFFFF);
562 const BYTE high = WINPR_ASSERTING_INT_CAST(BYTE, (value >> 16) & 0xFF);
563 Stream_Write_UINT16(s, low);
564 Stream_Write_UINT8(s, high);
568static UINT64 now_ns(
const rdpUdp* udp)
572 return udp->clock(udp->clockCustom);
573 return winpr_GetTickCount64NS();
577static UINT64 now_ms(
const rdpUdp* udp)
581 return udp->clock(udp->clockCustom) / 1000000ULL;
582 return GetTickCount64();
591static UINT32 rto_floor(
const rdpUdp* udp)
595 return udp->rttSampled ? 100 : 300;
596 return (udp->version == RDPUDP_PROTOCOL_VERSION_1) ? 500 : 300;
603#define RDPUDP2_RTO_MIN_VARIATION_MS 80
606static UINT64 rto_base(
const rdpUdp* udp)
610 if (udp->server && udp->rttSampled)
612 const UINT64 variation = 4ull * udp->rttvar;
613 const UINT64 margin =
614 (variation > RDPUDP2_RTO_MIN_VARIATION_MS) ? variation : RDPUDP2_RTO_MIN_VARIATION_MS;
615 rto = udp->srtt + margin;
619 const UINT32 floor = rto_floor(udp);
620 const UINT64 rtt2 = (UINT64)udp->srtt * 2ull;
621 rto = (rtt2 > floor) ? rtt2 : floor;
629static UINT64 rto_v3_cap(
const rdpUdp* udp)
632 const UINT64 base = rto_base(udp);
633 return (base > RDPUDP2_MAX_RTO_MS) ? base : RDPUDP2_MAX_RTO_MS;
637static UINT32 rto_initial(
const rdpUdp* udp)
640 UINT64 rto = rto_base(udp);
644 WINPR_ASSERT(udp->rtoBackoff <= RDPUDP2_MAX_RTO_BACKOFF);
645 rto <<= udp->rtoBackoff;
646 const UINT64 cap = rto_v3_cap(udp);
650 return (rto > RDPUDP_MAX_RTO_MS) ? RDPUDP_MAX_RTO_MS : WINPR_ASSERTING_INT_CAST(UINT32, rto);
653static void chunk_free(
void* obj)
655 rdpudp_chunk* chunk = obj;
662static void slot_clear(rdpudp_slot* slot)
666 slot->data =
nullptr;
668 slot->present = FALSE;
671static void pending_clear(rdpudp_pending* p)
675 memset(p, 0,
sizeof(*p));
678static void rdpudp_fail(rdpUdp* udp,
const char* why)
682 if (udp->state != RDPUDP_STATE_FAILED)
683 WLog_Print(udp->log, WLOG_WARN,
"RDP-UDP connection failed: %s", why);
684 udp->state = RDPUDP_STATE_FAILED;
694BOOL rdpudp_socket_error_is_transient(
int error)
705 case WSAECONNREFUSED:
710 case WSAEHOSTUNREACH:
718static BOOL rdpudp_send_raw(rdpUdp* udp,
const BYTE* data,
size_t length)
724 if (!udp->sendFn(udp->sendCustom, data, length))
726 rdpudp_fail(udp,
"sending failed");
729 udp->lastSent = now_ms(udp);
733 const int rc = _send(udp->sockfd, (
const char*)data, WINPR_ASSERTING_INT_CAST(
int, length), 0);
736 const int error = WSAGetLastError();
737 if (!rdpudp_socket_error_is_transient(error))
739 WLog_Print(udp->log, WLOG_ERROR,
"send failed with %d", error);
740 rdpudp_fail(udp,
"sending on the socket failed");
743 WLog_Print(udp->log, WLOG_DEBUG,
"send failed with %d, the datagram counts as lost", error);
746 udp->lastSent = now_ms(udp);
755static UINT32 v3_timestamp(UINT64 ns)
758 return WINPR_ASSERTING_INT_CAST(UINT32, (ns / 4000ULL) & 0x00FFFFFFULL);
763static BYTE v3_ack_gap(UINT64 arrival, UINT64 now)
765 if ((arrival == 0) || (now < arrival))
767 const UINT64 gap = (now - arrival) / 1000000ULL;
768 return (gap > 254) ? 254 : WINPR_ASSERTING_INT_CAST(BYTE, gap);
772static BOOL v3_has_gap(
const rdpUdp* udp)
775 return udp->v3BaseKnown && seq16_after(udp->v3Highest, seq16_diff(udp->v3Expected, 1));
785static void v3_write_ack(rdpUdp* udp,
wStream* s,
size_t room)
789 const UINT64 now = now_ns(udp);
792 const UINT64 arrival = udp->v3InOrderReceived ? udp->v3InOrderArrival : now;
793 const UINT16 seq = seq16_diff(udp->v3Expected, 1);
795 UINT64 gaps[RDPUDP2_MAX_DELAYED_ACKS] = WINPR_C_ARRAY_INIT;
797 if (udp->v3InOrderReceived)
799 size_t limit = seq16_diff(seq, udp->v3AckedSeq);
800 limit = (limit > 0) ? limit - 1 : 0;
801 if (limit > udp->v3MaxDelayedAcks)
802 limit = udp->v3MaxDelayedAcks;
805 if (limit > RDPUDP2_MAX_DELAYED_ACKS)
806 limit = RDPUDP2_MAX_DELAYED_ACKS;
808 UINT16 current = seq;
809 UINT64 currentArrival = arrival;
810 while (count < limit)
812 const UINT16 previous = seq16_diff(current, 1);
813 const UINT64 previousArrival = v3_arrival(udp, previous);
814 if (previousArrival == 0)
817 gaps[count++] = (currentArrival > previousArrival)
818 ? (currentArrival - previousArrival) / 1000ULL
821 currentArrival = previousArrival;
827 for (
size_t x = 0; x < count; x++)
829 while ((scale < 15) && ((gaps[x] >> scale) > 255))
833 Stream_Write_UINT16(s, seq);
834 stream_write_uint24(s, v3_timestamp(arrival));
836 const BYTE gap = v3_ack_gap(arrival, now);
837 Stream_Write_UINT8(s, gap);
838 const BYTE delayed = WINPR_ASSERTING_INT_CAST(BYTE, count | ((
size_t)scale << 4));
839 Stream_Write_UINT8(s, delayed);
840 for (
size_t x = 0; x < count; x++)
842 const UINT64 scaled = gaps[x] >> scale;
843 const BYTE addition = (scaled > 255) ? 255 : WINPR_ASSERTING_INT_CAST(BYTE, scaled);
844 Stream_Write_UINT8(s, addition);
846 udp->v3AckedSeq = seq;
851static wStream* v3_packet_init(
wStream* buffer, BYTE* data,
size_t size, UINT16 flags)
853 WINPR_ASSERT(buffer);
855 wStream* s = Stream_StaticInit(buffer, data, size);
859 const UINT16 header = WINPR_ASSERTING_INT_CAST(UINT16, flags | (RDPUDP2_LOG_WINDOW_SIZE << 12));
860 Stream_Write_UINT16(s, header);
867static BOOL v3_send_packet(rdpUdp* udp,
wStream* s, BYTE packetType)
871 if (Stream_GetPosition(s) < 1)
873 const size_t layout = Stream_GetPosition(s) - 1;
874 BYTE shortLength = 7;
877 shortLength = WINPR_ASSERTING_INT_CAST(BYTE, layout);
878 Stream_Zero(s, 7 - layout);
880 const size_t length = Stream_GetPosition(s);
882 if (!Stream_SetPosition(s, 0))
885 WINPR_ASSERTING_INT_CAST(BYTE, (shortLength << 5) | ((packetType & 0x0F) << 1));
886 Stream_Write_UINT8(s, prefix);
889 BYTE* wire = Stream_Buffer(s);
890 const BYTE eighth = wire[7];
893 return rdpudp_send_raw(udp, wire, length);
899static BOOL v3_send_ack_vector(rdpUdp* udp, UINT16 base,
const BYTE* vec,
size_t count,
902 BYTE buffer[64 + RDPUDP2_MAX_ACKVEC] = WINPR_C_ARRAY_INIT;
903 wStream sbuffer = WINPR_C_ARRAY_INIT;
907 WINPR_ASSERT((count > 0) && (count <= RDPUDP2_MAX_ACKVEC));
909 v3_packet_init(&sbuffer, buffer,
sizeof(buffer), RDPUDP2_OVERHEADSIZE | RDPUDP2_ACKVEC);
912 const UINT64 now = now_ns(udp);
913 const BYTE control = WINPR_ASSERTING_INT_CAST(BYTE, 0x80 | count);
915 const BYTE ackGap = v3_ack_gap(udp->v3LatestArrival, now);
916 const UINT32 timestamp = v3_timestamp((arrival != 0) ? arrival : now);
917 Stream_Write_UINT8(s, 10);
918 Stream_Write_UINT16(s, base);
919 Stream_Write_UINT8(s, control);
920 stream_write_uint24(s, timestamp);
921 Stream_Write_UINT8(s, ackGap);
922 Stream_Write(s, vec, count);
923 return v3_send_packet(udp, s, RDPUDP2_PACKET_STANDARD);
927static BOOL v3_send_ack(rdpUdp* udp)
929 BYTE buffer[64] = WINPR_C_ARRAY_INIT;
930 wStream sbuffer = WINPR_C_ARRAY_INIT;
933 if (!udp->v3BaseKnown)
941 if (udp->v3BehindCount > 0)
943 BYTE vec[RDPUDP2_MAX_ACKVEC] = WINPR_C_ARRAY_INIT;
945 for (
size_t left = udp->v3BehindCount; left > 0;)
947 const size_t run = (left > 63) ? 63 : left;
948 vec[count++] = WINPR_ASSERTING_INT_CAST(BYTE, 0x80 | 0x40 | run);
951 udp->v3BehindCount = 0;
952 if (!v3_send_ack_vector(udp, udp->v3BehindBase, vec, count, udp->v3BehindArrival))
954 if (!udp->v3WindowPending)
956 udp->ackPending = FALSE;
957 udp->v3UnackedPackets = 0;
967 udp->ackPending = FALSE;
968 udp->v3UnackedPackets = 0;
973 udp->ackPending = FALSE;
974 udp->v3WindowPending = FALSE;
975 udp->v3UnackedPackets = 0;
980 const BOOL gap = v3_has_gap(udp);
981 udp->v3AckedGap = gap;
985 v3_packet_init(&sbuffer, buffer,
sizeof(buffer), RDPUDP2_OVERHEADSIZE | RDPUDP2_ACK);
988 v3_write_ack(udp, s, RDPUDP2_MAX_DELAYED_ACKS);
989 Stream_Write_UINT8(s, 10);
990 return v3_send_packet(udp, s, RDPUDP2_PACKET_STANDARD);
993 const UINT16 base = udp->v3Expected;
994 size_t span = (size_t)seq16_diff(udp->v3Highest, base) + 1;
995 if (span > RDPUDP_RECEIVE_REACH)
996 span = RDPUDP_RECEIVE_REACH;
1002 BYTE vec[RDPUDP2_MAX_ACKVEC] = WINPR_C_ARRAY_INIT;
1005 while ((pos < span) && (count < RDPUDP2_MAX_ACKVEC))
1007 const BOOL state = v3_received(udp, seq16_add(base, pos));
1009 while ((pos + run < span) && (run < 63) &&
1010 (v3_received(udp, seq16_add(base, pos + run)) == state))
1014 vec[count++] = WINPR_ASSERTING_INT_CAST(BYTE, 0x80 | (state ? 0x40 : 0x00) | run);
1019 for (
size_t bit = 0; (bit < 7) && (pos + bit < span); bit++)
1021 if (v3_received(udp, seq16_add(base, pos + bit)))
1022 bits |= WINPR_ASSERTING_INT_CAST(BYTE, 1 << bit);
1024 vec[count++] = bits;
1029 const UINT64 highest = v3_arrival(udp, udp->v3Highest);
1030 return v3_send_ack_vector(udp, base, vec, count, highest);
1036static UINT32 sender_base(
const rdpUdp* udp)
1039 if (udp->inFlight > 0)
1040 return udp->sendBase;
1041 return (udp->version == RDPUDP_PROTOCOL_VERSION_3) ? udp->nextCoded : udp->nextSource;
1052static BOOL v3_send_base_keepalive(rdpUdp* udp)
1054 BYTE buffer[16] = WINPR_C_ARRAY_INIT;
1055 wStream sbuffer = WINPR_C_ARRAY_INIT;
1058 wStream* s = v3_packet_init(&sbuffer, buffer,
sizeof(buffer), RDPUDP2_AOA);
1061 const UINT16 base = WINPR_ASSERTING_INT_CAST(UINT16, sender_base(udp));
1062 Stream_Write_UINT16(s, base);
1063 return v3_send_packet(udp, s, RDPUDP2_PACKET_STANDARD);
1068static UINT32 next_send_seq(
const rdpUdp* udp)
1071 return (udp->version == RDPUDP_PROTOCOL_VERSION_3) ? udp->nextCoded : udp->nextSource;
1075static UINT32 send_seq_add(
const rdpUdp* udp, UINT32 seq,
size_t n)
1078 if (udp->version == RDPUDP_PROTOCOL_VERSION_3)
1079 return seq16_add(WINPR_ASSERTING_INT_CAST(UINT16, seq), n);
1080 return seq32_add(seq, WINPR_ASSERTING_INT_CAST(UINT32, n));
1084static rdpudp_pending* pending_find(rdpUdp* udp, UINT32 seq)
1087 const UINT16 pos = udp->pendingIndex[seq & 0xFFFF];
1090 WINPR_ASSERT(pos <= udp->inFlight);
1091 rdpudp_pending* p = &udp->pending[pos - 1];
1092 return (p->seq == seq) ? p :
nullptr;
1097static void send_base_advance(rdpUdp* udp)
1100 if (udp->inFlight == 0)
1102 udp->sendBase = next_send_seq(udp);
1105 while (!pending_find(udp, udp->sendBase))
1107 WINPR_ASSERT(udp->sendBase != next_send_seq(udp));
1108 udp->sendBase = send_seq_add(udp, udp->sendBase, 1);
1113static void pending_remove(rdpUdp* udp, rdpudp_pending* p)
1117 WINPR_ASSERT(udp->inFlight > 0);
1118 const size_t pos = WINPR_ASSERTING_INT_CAST(
size_t, p - udp->pending);
1119 const size_t last = udp->inFlight - 1;
1120 WINPR_ASSERT(pos <= last);
1121 udp->pendingIndex[p->seq & 0xFFFF] = 0;
1125 *p = udp->pending[last];
1126 memset(&udp->pending[last], 0,
sizeof(udp->pending[last]));
1127 udp->pendingIndex[p->seq & 0xFFFF] = WINPR_ASSERTING_INT_CAST(UINT16, pos + 1);
1129 udp->inFlight = last;
1130 send_base_advance(udp);
1134static void pending_due_at(rdpUdp* udp, UINT64 at)
1137 if (at < udp->pendingDue)
1138 udp->pendingDue = at;
1142static UINT64 report_resend_interval(
const rdpUdp* udp);
1146static UINT64 pending_next_due(
const rdpUdp* udp,
const rdpudp_pending* p, UINT64 due)
1156 const UINT64 at = p->lastSent + report_resend_interval(udp);
1164static BOOL v3_send_data(rdpUdp* udp,
const rdpudp_pending* p)
1166 BYTE buffer[RDPUDP_MTU + 32] = WINPR_C_ARRAY_INIT;
1167 wStream sbuffer = WINPR_C_ARRAY_INIT;
1175 const BOOL withAck = udp->ackPending && udp->v3BaseKnown && !v3_has_gap(udp) &&
1176 (udp->v3BehindCount == 0) && !udp->v3Resync;
1177 const UINT16 base = WINPR_ASSERTING_INT_CAST(UINT16, sender_base(udp));
1182 const BOOL withAoA = !udp->aoaAnnounced || (udp->announcedAoA != base) ||
1183 (p->retransmits > 0) || !udp->peerAcked;
1186 UINT16 flags = RDPUDP2_DATA | RDPUDP2_DELAYACKINFO;
1187 flags |= withAck ? RDPUDP2_ACK : RDPUDP2_NOACK;
1189 flags |= RDPUDP2_AOA;
1191 wStream* s = v3_packet_init(&sbuffer, buffer,
sizeof(buffer), flags);
1197 const size_t used = RDPUDP2_DATA_OVERHEAD + p->length;
1198 v3_write_ack(udp, s, (udp->mtu > used) ? udp->mtu - used : 0);
1201 udp->ackPending = FALSE;
1202 udp->v3WindowPending = FALSE;
1203 udp->v3UnackedPackets = 0;
1205 udp->v3AckedGap = FALSE;
1208 Stream_Write_UINT8(s, 1);
1209 Stream_Write_UINT16(s, 20);
1214 Stream_Write_UINT16(s, base);
1215 udp->announcedAoA = base;
1216 udp->aoaAnnounced = TRUE;
1219 const UINT16 dataSeq = WINPR_ASSERTING_INT_CAST(UINT16, p->seq);
1220 Stream_Write_UINT16(s, dataSeq);
1221 Stream_Write_UINT16(s, p->channelSeq);
1222 if (!Stream_CheckAndLogRequiredCapacityWLog(udp->log, s, p->length))
1224 Stream_Write(s, p->payload, p->length);
1226 return v3_send_packet(udp, s, RDPUDP2_PACKET_STANDARD);
1236static void v1_write_ack_vector(
const rdpUdp* udp,
wStream* s,
size_t room)
1240 if (!udp->receivedData)
1242 Stream_Write_UINT16_BE(s, 0);
1247 const UINT32 highest = udp->recvHighest;
1248 UINT32 low = udp->ackVectorStart;
1249 if (seq32_after(low, highest))
1251 if (seq32_diff(highest, low) >= RDPUDP_RECEIVE_REACH)
1252 low = seq32_diff(highest, RDPUDP_RECEIVE_REACH - 1);
1254 BYTE elements[RDPUDP_MAX_ACK_VECTOR] = WINPR_C_ARRAY_INIT;
1262 BYTE current = DATAGRAM_RECEIVED;
1263 if (!seq32_after(udp->recvNext, seq))
1265 const rdpudp_slot* slot = &udp->slots[seq % RDPUDP_RECEIVE_SLOTS];
1266 if (!slot->present || (slot->seq != seq))
1267 current = DATAGRAM_NOT_YET_RECEIVED;
1270 if ((current != state) || (run == 0x40))
1274 if (count >= ARRAYSIZE(elements))
1276 elements[count++] = WINPR_ASSERTING_INT_CAST(BYTE, (state << 6) | (run - 1));
1287 if ((run > 0) && (count < ARRAYSIZE(elements)))
1288 elements[count++] = WINPR_ASSERTING_INT_CAST(BYTE, (state << 6) | (run - 1));
1292 while ((2 + (count - skip) + 3) > room && (skip < count))
1296 const UINT16 vectorSize = WINPR_ASSERTING_INT_CAST(UINT16, count);
1297 Stream_Write_UINT16_BE(s, vectorSize);
1298 Stream_Write(s, &elements[skip], count);
1299 Stream_Zero(s, (4 - ((2 + count) % 4)) % 4);
1303static UINT32 v1_cumulative_ack(
const rdpUdp* udp)
1306 return seq32_diff(sender_base(udp), 1);
1310static BOOL v1_send_packet(rdpUdp* udp,
const rdpudp_pending* p)
1312 BYTE buffer[RDPUDP_MTU + 2048] = WINPR_C_ARRAY_INIT;
1313 wStream sbuffer = WINPR_C_ARRAY_INIT;
1316 WINPR_ASSERT(udp->mtu >= RDPUDP_MIN_MTU);
1318 const UINT32 cumulative = v1_cumulative_ack(udp);
1319 const BOOL withAoA = !udp->aoaAnnounced || (udp->announcedAoA != cumulative);
1321 UINT16 flags = RDPUDP_FLAG_ACK;
1323 flags |= RDPUDP_FLAG_ACK_OF_ACKS;
1326 flags |= RDPUDP_FLAG_DATA;
1327 if (udp->cwrPending)
1329 flags |= RDPUDP_FLAG_CWR;
1330 udp->cwrPending = FALSE;
1334 wStream* s = Stream_StaticInit(&sbuffer, buffer,
sizeof(buffer));
1339 Stream_Write_UINT32_BE(s, udp->receivedData ? udp->recvHighest
1340 : udp->peerInitialSequence);
1341 Stream_Write_UINT16_BE(s, RDPUDP_RECEIVE_WINDOW);
1342 Stream_Write_UINT16_BE(s, flags);
1345 v1_write_ack_vector(udp, s, p ? RDPUDP_ACK_ROOM - 4 : udp->mtu - 12u);
1346 udp->ackPending = FALSE;
1350 Stream_Write_UINT32_BE(s, cumulative);
1351 udp->announcedAoA = cumulative;
1352 udp->aoaAnnounced = TRUE;
1358 const UINT32 snCoded = udp->nextCoded++;
1359 Stream_Write_UINT32_BE(s, snCoded);
1360 Stream_Write_UINT32_BE(s, p->seq);
1361 if (!Stream_CheckAndLogRequiredCapacityWLog(udp->log, s, p->length))
1363 Stream_Write(s, p->payload, p->length);
1366 return rdpudp_send_raw(udp, Stream_Buffer(s), Stream_GetPosition(s));
1370static BOOL rdpudp_send_ack(rdpUdp* udp)
1373 if (udp->state != RDPUDP_STATE_ESTABLISHED)
1375 if (udp->version == RDPUDP_PROTOCOL_VERSION_3)
1376 return v3_send_ack(udp);
1377 return v1_send_packet(udp,
nullptr);
1385static BOOL v3_ack_if_due(rdpUdp* udp)
1388 if ((udp->version != RDPUDP_PROTOCOL_VERSION_3) || (udp->state != RDPUDP_STATE_ESTABLISHED) ||
1391 if ((v3_has_gap(udp) == udp->v3AckedGap) && (udp->v3UnackedPackets <= udp->v3MaxDelayedAcks))
1393 return v3_send_ack(udp);
1398static UINT32 v3_ack_delay(
const rdpUdp* udp)
1401 return (udp->v3DelayedAckTimeout != UINT32_MAX) ? udp->v3DelayedAckTimeout : udp->srtt / 2;
1409static BOOL ack_when_due(rdpUdp* udp)
1412 if (!udp->ackPending)
1414 if (udp->version == RDPUDP_PROTOCOL_VERSION_3)
1416 if ((udp->state != RDPUDP_STATE_ESTABLISHED) || !udp->v3BaseKnown)
1418 const UINT64 now = now_ms(udp);
1419 if (udp->v3AckDue == 0)
1420 udp->v3AckDue = now + v3_ack_delay(udp);
1421 if (now < udp->v3AckDue)
1424 return rdpudp_send_ack(udp);
1428static BOOL rdpudp_transmit(rdpUdp* udp,
const rdpudp_pending* p)
1432 if (udp->version == RDPUDP_PROTOCOL_VERSION_3)
1433 return v3_send_data(udp, p);
1434 return v1_send_packet(udp, p);
1442static size_t window_limit(
const rdpUdp* udp)
1446 return (udp->cwnd < RDPUDP_MAX_IN_FLIGHT) ? udp->cwnd : RDPUDP_MAX_IN_FLIGHT;
1447 size_t limit = RDPUDP_CLIENT_MAX_IN_FLIGHT;
1448 if ((udp->version != RDPUDP_PROTOCOL_VERSION_3) && (udp->peerWindow > 0) &&
1449 (udp->peerWindow < limit))
1450 limit = udp->peerWindow;
1456static BOOL send_chunk_now(rdpUdp* udp, BYTE* data,
size_t length)
1460 if ((udp->inFlight >= RDPUDP_MAX_IN_FLIGHT) ||
1461 (udp->pendingIndex[next_send_seq(udp) & 0xFFFF] != 0))
1466 rdpudp_pending* p = &udp->pending[udp->inFlight];
1471 if (udp->version == RDPUDP_PROTOCOL_VERSION_3)
1473 const UINT16 coded = WINPR_ASSERTING_INT_CAST(UINT16, udp->nextCoded);
1475 udp->nextCoded = seq16_add(coded, 1);
1476 p->channelSeq = udp->nextChannelSeq;
1477 udp->nextChannelSeq = channel_seq_next(udp->nextChannelSeq);
1481 p->seq = udp->nextSource++;
1484 const UINT64 now = now_ms(udp);
1488 p->rto = rto_initial(udp);
1489 p->due = now + p->rto;
1492 if (udp->inFlight == 0)
1493 udp->sendBase = p->seq;
1495 udp->pendingIndex[p->seq & 0xFFFF] = WINPR_ASSERTING_INT_CAST(UINT16, udp->inFlight);
1496 pending_due_at(udp, p->due);
1498 return rdpudp_transmit(udp, p);
1504static BOOL span_has_room(
const rdpUdp* udp)
1507 if (udp->inFlight == 0)
1509 if (udp->pendingIndex[next_send_seq(udp) & 0xFFFF] != 0)
1513 const UINT16 base = WINPR_ASSERTING_INT_CAST(UINT16, sender_base(udp));
1514 return seq16_diff(WINPR_ASSERTING_INT_CAST(UINT16, udp->nextCoded), base) < RDPUDP2_MAX_SPAN;
1518static BOOL flush_send_queue(rdpUdp* udp)
1521 while ((udp->state == RDPUDP_STATE_ESTABLISHED) && (udp->inFlight < window_limit(udp)) &&
1522 (Queue_Count(udp->sendQueue) > 0) && span_has_room(udp))
1524 rdpudp_chunk* chunk = Queue_Dequeue(udp->sendQueue);
1527 BYTE* data = chunk->data;
1528 const size_t length = chunk->length;
1530 if (!send_chunk_now(udp, data, length))
1536BOOL rdpudp_send(rdpUdp* udp,
const BYTE* data,
size_t length)
1541 if ((length == 0) || (length > rdpudp_get_max_payload(udp)))
1543 if ((udp->state != RDPUDP_STATE_ESTABLISHED) && (udp->state != RDPUDP_STATE_SYN_SENT))
1545 rdpudp_chunk* chunk = calloc(1,
sizeof(rdpudp_chunk));
1548 chunk->data = malloc(length);
1554 memcpy(chunk->data, data, length);
1555 chunk->length = length;
1557 if (!Queue_Enqueue(udp->sendQueue, chunk))
1563 return flush_send_queue(udp);
1566static void sample_rtt(rdpUdp* udp,
const rdpudp_pending* p)
1574 const BOOL lastIsKnown = udp->server && (udp->version == RDPUDP_PROTOCOL_VERSION_3);
1575 if ((p->retransmits > 0) && !lastIsKnown)
1577 const UINT64 sentAt = (p->retransmits > 0) ? p->lastSent : p->sent;
1578 const UINT64 sample64 = now_ms(udp) - sentAt;
1579 const UINT32 sample =
1580 (sample64 > UINT32_MAX) ? UINT32_MAX : WINPR_ASSERTING_INT_CAST(UINT32, sample64);
1583 udp->srtt = (udp->srtt == 0)
1585 : WINPR_ASSERTING_INT_CAST(UINT32, ((UINT64)udp->srtt * 7 + sample) / 8);
1588 udp->rtoBackoff = 0;
1589 if (sample < udp->ccRoundRttMin)
1590 udp->ccRoundRttMin = sample;
1591 if (sample < udp->rttMin)
1594 if (udp->rttMin == UINT32_MAX)
1595 udp->rttMinSeen = now_ms(udp);
1596 udp->rttMin = sample;
1600 if ((sample <= udp->rttMin) && (Queue_Count(udp->sendQueue) == 0))
1601 udp->rttMinSeen = now_ms(udp);
1602 if (!udp->rttSampled)
1606 udp->rttvar = sample / 2;
1607 udp->rttSampled = TRUE;
1611 const UINT32 delta = (udp->srtt > sample) ? udp->srtt - sample : sample - udp->srtt;
1612 udp->rttvar = WINPR_ASSERTING_INT_CAST(UINT32, ((UINT64)udp->rttvar * 3 + delta) / 4);
1613 udp->srtt = WINPR_ASSERTING_INT_CAST(UINT32, ((UINT64)udp->srtt * 7 + sample) / 8);
1618static BOOL cc_queue_is_building(
const rdpUdp* udp)
1621 if (!udp->rttSampled || (udp->rttMin == UINT32_MAX))
1626 (udp->rttMin / 2 > RDPUDP2_QUEUE_DELAY_MS) ? udp->rttMin / 2 : RDPUDP2_QUEUE_DELAY_MS;
1627 if (4ull * udp->rttvar > allowance)
1628 allowance = 4ull * udp->rttvar;
1629 return udp->srtt > udp->rttMin + allowance;
1640static BOOL cc_delay_is_ours(rdpUdp* udp)
1643 if (udp->ccRoundRttMin == UINT32_MAX)
1645 const UINT64 now = udp->ccRoundRttMin;
1646 const UINT64 last = udp->ccDelayLastRtt;
1647 udp->ccDelayLastRtt = udp->ccRoundRttMin;
1648 const BOOL flat = (last > 0) && (100ull * now >= RDPUDP2_DELAY_REBASE_PERCENT * last) &&
1649 (100ull * now <= (200ull - RDPUDP2_DELAY_REBASE_PERCENT) * last);
1652 udp->ccDelayCuts = 0;
1655 if (++udp->ccDelayCuts < RDPUDP2_DELAY_REBASE_CUTS)
1657 WLog_Print(udp->log, WLOG_DEBUG,
1658 "round trip stayed at %" PRIu32
" ms after %" PRIu32
" cuts (lowest was %" PRIu32
1659 " ms): new base delay, slow start from a window of %" PRIu32,
1660 udp->ccRoundRttMin, RDPUDP2_DELAY_REBASE_CUTS, udp->rttMin, udp->cwnd);
1661 udp->rttMin = udp->ccRoundRttMin;
1662 udp->rttMinSeen = now_ms(udp);
1663 udp->ssthresh = RDPUDP_MAX_IN_FLIGHT;
1664 udp->ccDelayCuts = 0;
1665 udp->ccDelayLastRtt = 0;
1675static BOOL cc_probe(rdpUdp* udp, UINT64 now)
1678 switch (udp->ccProbe)
1684 if (udp->ccRoundRttMin != UINT32_MAX)
1686 WLog_Print(udp->log, WLOG_DEBUG,
1687 "drain probe: lowest round trip %" PRIu32
" ms (was %" PRIu32
1688 " ms), congestion window back to %" PRIu32,
1689 udp->ccRoundRttMin, udp->rttMin, udp->ccProbeCwnd);
1690 udp->rttMin = udp->ccRoundRttMin;
1694 udp->log, WLOG_DEBUG,
1695 "drain probe: no round trip measured, congestion window back to %" PRIu32,
1697 udp->rttMinSeen = now;
1698 udp->cwnd = udp->ccProbeCwnd;
1702 if ((udp->rttMin == UINT32_MAX) || (now - udp->rttMinSeen < RDPUDP2_RTT_PROBE_MS))
1704 udp->ccProbeCwnd = udp->cwnd;
1705 udp->cwnd = RDPUDP2_MIN_CWND;
1708 udp->ccDelayCuts = 0;
1709 udp->ccDelayLastRtt = 0;
1710 udp->ccDelayHold = FALSE;
1716static void cc_round_reset(rdpUdp* udp, UINT64 now)
1719 udp->ccRoundStart = now;
1720 udp->ccRoundAcked = 0;
1721 udp->ccRoundLost = 0;
1722 udp->ccRoundRttMin = UINT32_MAX;
1727static void cc_round(rdpUdp* udp)
1730 const UINT64 now = now_ms(udp);
1731 const UINT32 rtt = (udp->srtt > 0) ? udp->srtt : rto_floor(udp);
1732 if (udp->ccRoundStart == 0)
1733 udp->ccRoundStart = now;
1734 if (now - udp->ccRoundStart < rtt)
1736 if (cc_probe(udp, now))
1738 cc_round_reset(udp, now);
1743 const UINT64 total = (UINT64)udp->ccRoundAcked + udp->ccRoundLost;
1745 if (total >= RDPUDP2_ROUND_MIN_SAMPLES)
1749 const UINT32 loss = WINPR_ASSERTING_INT_CAST(UINT32, udp->ccRoundLost * 1000ull / total);
1750 lossy = (loss >= RDPUDP2_CONGESTED_LOSS_PERCENT * 10u) &&
1751 (loss >= udp->ccLossAvg + RDPUDP2_LOSS_RISE_PERCENT * 10u);
1752 const INT64 delta = (INT64)loss - (INT64)udp->ccLossAvg;
1753 udp->ccLossAvg = WINPR_ASSERTING_INT_CAST(
1754 UINT32, (INT64)udp->ccLossAvg + delta / (1 << RDPUDP2_LOSS_AVG_SHIFT));
1756 BOOL queued = cc_queue_is_building(udp);
1757 if (queued && !lossy)
1761 if (udp->ccDelayHold)
1764 queued = cc_delay_is_ours(udp);
1768 udp->ccDelayCuts = 0;
1769 udp->ccDelayLastRtt = 0;
1771 udp->ccDelayHold = FALSE;
1772 if (lossy || queued)
1774 const UINT32 reduced = WINPR_ASSERTING_INT_CAST(UINT32, udp->cwnd * 7ull / 10);
1775 udp->ssthresh = (reduced > RDPUDP2_MIN_CWND) ? reduced : RDPUDP2_MIN_CWND;
1776 udp->cwnd = udp->ssthresh;
1778 udp->ccDelayHold = TRUE;
1779 WLog_Print(udp->log, WLOG_DEBUG,
1780 "congestion (%" PRIu32
" of %" PRIu64
" lost, round trip %" PRIu32
1781 " ms, lowest %" PRIu32
" ms), congestion window %" PRIu32,
1782 udp->ccRoundLost, total, udp->srtt, udp->rttMin, udp->cwnd);
1784 if ((udp->reorderThreshold > RDPUDP2_REORDER_THRESHOLD) &&
1785 (++udp->reorderCalmRounds >= RDPUDP2_REORDER_DECAY_ROUNDS))
1787 udp->reorderThreshold--;
1788 udp->reorderCalmRounds = 0;
1790 cc_round_reset(udp, now);
1793static void cc_on_ack(rdpUdp* udp)
1796 udp->ccRoundAcked++;
1797 if (udp->ccProbe != 0)
1801 else if (udp->cwnd < udp->ssthresh)
1803 else if (!cc_queue_is_building(udp) && (++udp->ccAcked >= RDPUDP2_GROWTH_ACKS))
1808 if (udp->cwnd > RDPUDP_MAX_IN_FLIGHT)
1809 udp->cwnd = RDPUDP_MAX_IN_FLIGHT;
1814static void cc_on_loss(rdpUdp* udp)
1824static UINT64 report_resend_interval(
const rdpUdp* udp)
1827 return (udp->srtt > RDPUDP2_REPORT_MIN_ROUND_MS) ? udp->srtt : RDPUDP2_REPORT_MIN_ROUND_MS;
1834static void handle_reported_loss(rdpUdp* udp, rdpudp_pending* p)
1838 const UINT64 now = now_ms(udp);
1839 if (now - udp->reportRoundStart >= report_resend_interval(udp))
1841 udp->reportRoundStart = now;
1842 udp->reportRoundUsed = 0;
1844 const UINT32 share = udp->cwnd / 4;
1845 const UINT32 budget = (share > RDPUDP2_REPORT_MIN_BUDGET) ? share : RDPUDP2_REPORT_MIN_BUDGET;
1846 p->reportHeld = FALSE;
1847 if (udp->reportRoundUsed >= budget)
1849 udp->reportRoundUsed++;
1851 pending_due_at(udp, 0);
1855static void acknowledge(rdpUdp* udp, rdpudp_pending* p)
1860 pending_remove(udp, p);
1861 udp->peerAcked = TRUE;
1866static void acknowledge_seq(rdpUdp* udp, UINT32 seq)
1869 rdpudp_pending* p = pending_find(udp, seq);
1871 acknowledge(udp, p);
1879static BOOL deliver(rdpUdp* udp,
const BYTE* data,
size_t length)
1882 udp->lastDelivery = now_ms(udp);
1886 WINPR_ASSERT(udp->receive);
1887 if (!udp->receive(udp->custom, data, length))
1889 rdpudp_fail(udp,
"receiver rejected data");
1896static BOOL store_slot(rdpUdp* udp, UINT32 seq,
const BYTE* data,
size_t length)
1899 WINPR_ASSERT(data || (length == 0));
1900 rdpudp_slot* slot = &udp->slots[seq % RDPUDP_RECEIVE_SLOTS];
1903 if (slot->seq == seq)
1909 slot->data =
nullptr;
1912 slot->data = malloc(length);
1915 memcpy(slot->data, data, length);
1917 slot->length = length;
1919 slot->present = TRUE;
1920 if (udp->buffered++ == 0)
1921 udp->bufferingSince = now_ms(udp);
1926static BOOL v1_receive_source(rdpUdp* udp, UINT32 seq,
const BYTE* data,
size_t length)
1929 WINPR_ASSERT(data || (length == 0));
1930 if (!udp->receivedData)
1934 if (seq == udp->peerInitialSequence)
1936 udp->recvNext = seq;
1937 udp->ackVectorStart = seq;
1939 udp->recvHighest = seq32_diff(udp->recvNext, 1);
1942 udp->ackPending = TRUE;
1944 if (seq32_after(udp->recvNext, seq))
1947 const UINT32 ahead = seq32_diff(seq, udp->recvNext);
1948 if (ahead >= RDPUDP_RECEIVE_REACH)
1951 udp->receivedData = TRUE;
1952 if (seq32_after(seq, udp->recvHighest))
1953 udp->recvHighest = seq;
1955 if (!store_slot(udp, seq, data, length))
1960 rdpudp_slot* slot = &udp->slots[udp->recvNext % RDPUDP_RECEIVE_SLOTS];
1961 if (!slot->present || (slot->seq != udp->recvNext))
1963 BYTE* chunk = slot->data;
1964 const size_t chunkLength = slot->length;
1965 slot->data =
nullptr;
1966 slot->present = FALSE;
1969 const BOOL rc = deliver(udp, chunk, chunkLength);
1978static void v1_process_ack_vector(rdpUdp* udp, UINT32 snSourceAck,
wStream* s,
size_t count)
1983 WINPR_ASSERT(count <= RDPUDP_MAX_ACK_VECTOR);
1984 const size_t start = Stream_GetPosition(s);
1986 for (
size_t x = 0; x < count; x++)
1987 total += (Stream_Get_UINT8(s) & 0x3Fu) + 1u;
1988 if ((total == 0) || !Stream_SetPosition(s, start))
1991 UINT32 seq = seq32_add(seq32_diff(snSourceAck, total), 1);
1992 for (
size_t x = 0; x < count; x++)
1994 const BYTE element = Stream_Get_UINT8(s);
1995 const BYTE state = WINPR_ASSERTING_INT_CAST(BYTE, element >> 6);
1996 const BYTE run = WINPR_ASSERTING_INT_CAST(BYTE, (element & 0x3F) + 1);
1997 for (BYTE y = 0; y < run; y++)
1999 if (state == DATAGRAM_RECEIVED)
2000 acknowledge_seq(udp, seq);
2007static BOOL v1_process_datagram(rdpUdp* udp,
const BYTE* data,
size_t length)
2009 wStream sbuffer = WINPR_C_ARRAY_INIT;
2012 wStream* s = Stream_StaticConstInit(&sbuffer, data, length);
2015 if (!Stream_CheckAndLogRequiredLengthWLog(udp->log, s, 8))
2017 const UINT32 snSourceAck = Stream_Get_UINT32_BE(s);
2018 const UINT16 window = Stream_Get_UINT16_BE(s);
2019 const UINT16 flags = Stream_Get_UINT16_BE(s);
2021 if (flags & RDPUDP_FLAG_SYN)
2024 udp->ackPending = TRUE;
2028 udp->peerWindow = window;
2029 if (flags & RDPUDP_FLAG_CN)
2030 udp->cwrPending = TRUE;
2032 if (flags & RDPUDP_FLAG_ACK)
2035 if (!Stream_CheckAndLogRequiredLengthWLog(udp->log, s, 2))
2037 const size_t size = Stream_Get_UINT16_BE(s);
2038 if (size > RDPUDP_MAX_ACK_VECTOR)
2040 const size_t padding = (4 - ((2 + size) % 4)) % 4;
2041 if (!Stream_CheckAndLogRequiredLengthWLog(udp->log, s, size + padding))
2043 v1_process_ack_vector(udp, snSourceAck, s, size);
2044 Stream_Seek(s, padding);
2047 if (flags & RDPUDP_FLAG_ACK_OF_ACKS)
2050 if (!Stream_CheckAndLogRequiredLengthWLog(udp->log, s, 4))
2052 const UINT32 reset = Stream_Get_UINT32_BE(s);
2054 const UINT32 start = seq32_add(reset, 1);
2055 if (seq32_after(start, udp->ackVectorStart) && !seq32_after(start, udp->recvNext))
2056 udp->ackVectorStart = start;
2059 if ((flags & RDPUDP_FLAG_CORRELATION_ID) && !Stream_SafeSeek(s, 32))
2062 if (!(flags & RDPUDP_FLAG_DATA))
2065 if (flags & RDPUDP_FLAG_FEC)
2069 if (!Stream_CheckAndLogRequiredLengthWLog(udp->log, s, 8))
2071 Stream_Seek_UINT32(s);
2072 const UINT32 snSourceStart = Stream_Get_UINT32_BE(s);
2073 return v1_receive_source(udp, snSourceStart, Stream_ConstPointer(s),
2074 Stream_GetRemainingLength(s));
2077static void v3_advance_window(rdpUdp* udp)
2080 while (v3_received(udp, udp->v3Expected))
2082 udp->v3InOrderArrival = v3_arrival(udp, udp->v3Expected);
2083 udp->v3InOrderReceived = TRUE;
2084 v3_set_expected(udp, seq16_add(udp->v3Expected, 1));
2093static void v3_resync_base(rdpUdp* udp, UINT16 base)
2096 udp->v3Resync = FALSE;
2105 if (udp->server && seq16_after(udp->v3Expected, base) &&
2106 (seq16_diff(udp->v3Expected, base) <= RDPUDP2_STALE_AOA_REACH))
2108 udp->ackPending = TRUE;
2109 udp->v3WindowPending = TRUE;
2112 if (base == udp->v3Expected)
2115 WLog_Print(udp->log, WLOG_DEBUG,
2116 "heard from the peer again, its AckOfAcks 0x%04" PRIx16
" replaces 0x%04" PRIx16,
2117 base, udp->v3Expected);
2119 memset(udp->v3Received, 0,
sizeof(udp->v3Received));
2120 memset(udp->v3Arrival, 0,
sizeof(udp->v3Arrival));
2121 udp->v3ExpectedFull += 0x10000;
2122 udp->v3Expected = base;
2123 udp->v3Highest = seq16_diff(base, 1);
2124 udp->v3InOrderReceived = FALSE;
2125 udp->ackPending = TRUE;
2126 udp->v3WindowPending = TRUE;
2130static void v3_note_silence(rdpUdp* udp, UINT64 now)
2133 if ((udp->version == RDPUDP_PROTOCOL_VERSION_3) && udp->v3BaseKnown &&
2134 (now - udp->lastReceived >= RDPUDP2_RESYNC_MS))
2135 udp->v3Resync = TRUE;
2138static void v3_advance_base(rdpUdp* udp, UINT16 base)
2145 if (!udp->v3BaseKnown)
2149 v3_resync_base(udp, base);
2152 if (!seq16_after(base, udp->v3Expected))
2160 v3_set_expected(udp, base);
2161 udp->v3InOrderReceived = FALSE;
2162 const UINT16 last = seq16_diff(base, 1);
2163 if (seq16_after(last, udp->v3Highest))
2164 udp->v3Highest = last;
2165 v3_advance_window(udp);
2166 udp->ackPending = TRUE;
2167 udp->v3WindowPending = TRUE;
2173static UINT16 v3_last_sent(
const rdpUdp* udp)
2176 return seq16_diff(WINPR_ASSERTING_INT_CAST(UINT16, udp->nextCoded), 1);
2181static BOOL v3_not_sent(
const rdpUdp* udp, UINT16 seq)
2183 return seq16_after(seq, v3_last_sent(udp));
2190static BOOL v3_from_send_base(
const rdpUdp* udp, UINT16 seq)
2193 const UINT16 base = WINPR_ASSERTING_INT_CAST(UINT16, udp->sendBase);
2194 return seq16_diff(seq, base) <=
2195 seq16_diff(WINPR_ASSERTING_INT_CAST(UINT16, udp->nextCoded), base);
2198static void v3_process_ack_vector(rdpUdp* udp, UINT16 base,
wStream* s,
size_t count)
2204 WINPR_ASSERT(count <= RDPUDP2_MAX_ACKVEC);
2205 WINPR_ASSERT(Stream_GetRemainingLength(s) >= count);
2208 BYTE received[RDPUDP2_MAX_ACKVEC * 63] = WINPR_C_ARRAY_INIT;
2211 for (
size_t x = 0; x < count; x++)
2213 const BYTE entry = Stream_Get_UINT8(s);
2217 const BOOL got = (entry & 0x40) != 0;
2218 const BYTE run = entry & 0x3F;
2219 for (BYTE y = 0; (y < run) && (covered < ARRAYSIZE(received)); y++)
2221 received[covered++] = got ? 1 : 0;
2229 for (BYTE bit = 0; (bit < 7) && (covered < ARRAYSIZE(received)); bit++)
2231 const BOOL got = (entry & (1 << bit)) != 0;
2232 received[covered++] = got ? 1 : 0;
2243 const UINT16 last = v3_last_sent(udp);
2244 const size_t sentFromBase = seq16_after(base, last) ? 0 : seq16_diff(last, base) + 1u;
2245 if (v3_not_sent(udp, seq16_diff(base, 1)) || (highest > sentFromBase))
2247 WLog_Print(udp->log, WLOG_DEBUG,
2248 "ignoring an ACK vector at base 0x%04" PRIx16
2249 " that reports datagrams never sent (last sent 0x%04" PRIx16
")",
2262 const BOOL baseIsMissing = (covered == 0) || !received[0];
2263 const BOOL baseInRange =
2264 baseIsMissing && (!udp->server || (udp->inFlight == 0) || v3_from_send_base(udp, base));
2265 while (baseInRange && (udp->inFlight > 0) &&
2266 seq16_after(base, WINPR_ASSERTING_INT_CAST(UINT16, udp->sendBase)))
2267 acknowledge(udp, pending_find(udp, udp->sendBase));
2269 const size_t sent = seq16_diff(WINPR_ASSERTING_INT_CAST(UINT16, udp->nextCoded), base);
2270 for (
size_t offset = 0; (offset < covered) && (offset < sent) && (udp->inFlight > 0); offset++)
2272 rdpudp_pending* p = pending_find(udp, seq16_add(base, offset));
2275 if (received[offset])
2276 acknowledge(udp, p);
2277 else if (udp->server && (highest > offset + udp->reorderThreshold) && !p->lost)
2281 if (now_ms(udp) - p->lastSent >= report_resend_interval(udp))
2282 handle_reported_loss(udp, p);
2285 p->reportHeld = TRUE;
2286 pending_due_at(udp, p->lastSent + report_resend_interval(udp));
2295 const UINT64 vectorTime = now_ms(udp);
2296 for (
size_t x = 0; x < RDPUDP2_RESENT_HISTORY; x++)
2298 if (!udp->resent[x].valid)
2300 const UINT16 seq = udp->resent[x].seq;
2301 if (seq16_after(base, seq) || (vectorTime - udp->resent[x].at > RDPUDP2_RESENT_MAX_AGE_MS))
2303 udp->resent[x].valid = FALSE;
2306 const size_t offset = seq16_diff(seq, base);
2307 if ((offset >= covered) || !received[offset])
2309 udp->resent[x].valid = FALSE;
2310 if (udp->ccRoundLost > 0)
2312 if (!udp->resent[x].reported)
2314 if (udp->reorderThreshold < RDPUDP2_MAX_REORDER_THRESHOLD)
2316 udp->reorderThreshold *= 2;
2317 if (udp->reorderThreshold > RDPUDP2_MAX_REORDER_THRESHOLD)
2318 udp->reorderThreshold = RDPUDP2_MAX_REORDER_THRESHOLD;
2319 WLog_Print(udp->log, WLOG_DEBUG,
2320 "datagram 0x%04" PRIx16
2321 " arrived after its resend, reordering threshold: %" PRIu32,
2322 seq, udp->reorderThreshold);
2324 udp->reorderCalmRounds = 0;
2328static void v3_process_ack(rdpUdp* udp, UINT16 ack)
2332 if (udp->server && v3_not_sent(udp, ack))
2334 WLog_Print(udp->log, WLOG_DEBUG,
2335 "ignoring an ACK of 0x%04" PRIx16
", past the last datagram sent 0x%04" PRIx16,
2336 ack, v3_last_sent(udp));
2342 if (udp->server && (udp->inFlight > 0) && !v3_from_send_base(udp, ack))
2345 while ((udp->inFlight > 0) &&
2346 !seq16_after(WINPR_ASSERTING_INT_CAST(UINT16, udp->sendBase), ack))
2347 acknowledge(udp, pending_find(udp, udp->sendBase));
2352static BOOL v3_deliver_ready(rdpUdp* udp)
2357 rdpudp_slot* slot = &udp->slots[udp->v3NextChannel % RDPUDP_RECEIVE_SLOTS];
2358 if (!slot->present || (slot->seq != udp->v3NextChannel))
2360 BYTE* chunk = slot->data;
2361 const size_t chunkLength = slot->length;
2362 slot->data =
nullptr;
2363 slot->present = FALSE;
2365 udp->v3NextChannel = channel_seq_next(udp->v3NextChannel);
2366 const BOOL rc = deliver(udp, chunk, chunkLength);
2375static BOOL v3_receive_channel_data(rdpUdp* udp, UINT16 channelSeq,
const BYTE* data,
size_t length)
2378 WINPR_ASSERT(data || (length == 0));
2379 WINPR_ASSERT(!udp->server || (length <= RDPUDP_MAX_CHUNK));
2384 const UINT16 ahead = seq16_diff(channelSeq, udp->v3NextChannel);
2385 if (ahead >= RDPUDP_RECEIVE_REACH)
2389 if ((ahead == 0) && !udp->slots[channelSeq % RDPUDP_RECEIVE_SLOTS].present)
2391 udp->v3NextChannel = channel_seq_next(udp->v3NextChannel);
2392 if (!deliver(udp, data, length))
2394 return v3_deliver_ready(udp);
2397 if (!store_slot(udp, channelSeq, data, length))
2399 return v3_deliver_ready(udp);
2403static BOOL v3_process_datagram(rdpUdp* udp, BYTE* data,
size_t length)
2412 const BYTE eighth = data[7];
2416 wStream sbuffer = WINPR_C_ARRAY_INIT;
2417 wStream* s = Stream_StaticConstInit(&sbuffer, data, length);
2419 const BYTE prefix = Stream_Get_UINT8(s);
2422 const BYTE shortLength = WINPR_ASSERTING_INT_CAST(BYTE, prefix >> 5);
2423 const BYTE packetType = WINPR_ASSERTING_INT_CAST(BYTE, (prefix >> 1) & 0x0F);
2424 if ((packetType != RDPUDP2_PACKET_STANDARD) && (packetType != RDPUDP2_PACKET_DUMMY))
2427 if ((shortLength > 0) && (shortLength < 7) && !Stream_SetLength(s, 1ull + shortLength))
2430 if (!Stream_CheckAndLogRequiredLengthWLog(udp->log, s, 2))
2432 const UINT16 flags = Stream_Get_UINT16(s) & 0x0FFF;
2434 if ((flags & RDPUDP2_ACK) && (flags & RDPUDP2_ACKVEC))
2437 if (flags & RDPUDP2_ACK)
2439 if (!Stream_CheckAndLogRequiredLengthWLog(udp->log, s, 7))
2441 const UINT16 ack = Stream_Get_UINT16(s);
2443 const size_t delayed = Stream_Get_UINT8(s) & 0x0F;
2444 if (!Stream_SafeSeek(s, delayed))
2446 v3_process_ack(udp, ack);
2449 if ((flags & RDPUDP2_OVERHEADSIZE) && !Stream_SafeSeek(s, 1))
2452 if (flags & RDPUDP2_DELAYACKINFO)
2456 if (!Stream_CheckAndLogRequiredLengthWLog(udp->log, s, 3))
2458 const size_t maxDelayed = Stream_Get_UINT8(s);
2459 udp->v3DelayedAckTimeout = Stream_Get_UINT16(s);
2460 if (maxDelayed == 0)
2461 udp->v3MaxDelayedAcks = 1;
2462 else if (maxDelayed > RDPUDP2_MAX_DELAYED_ACKS)
2463 udp->v3MaxDelayedAcks = RDPUDP2_MAX_DELAYED_ACKS;
2465 udp->v3MaxDelayedAcks = maxDelayed;
2468 BOOL haveAoA = FALSE;
2470 if (flags & RDPUDP2_AOA)
2472 if (!Stream_CheckAndLogRequiredLengthWLog(udp->log, s, 2))
2474 aoa = Stream_Get_UINT16(s);
2478 BOOL haveData = FALSE;
2480 if (flags & RDPUDP2_DATA)
2482 if (!Stream_CheckAndLogRequiredLengthWLog(udp->log, s, 2))
2484 dataSeq = Stream_Get_UINT16(s);
2488 if (flags & RDPUDP2_ACKVEC)
2490 if (!Stream_CheckAndLogRequiredLengthWLog(udp->log, s, 3))
2492 const UINT16 base = Stream_Get_UINT16(s);
2493 const BYTE control = Stream_Get_UINT8(s);
2494 const size_t size = control & 0x7F;
2496 if ((control & 0x80) && !Stream_SafeSeek(s, 4))
2498 if (!Stream_CheckAndLogRequiredLengthWLog(udp->log, s, size))
2500 v3_process_ack_vector(udp, base, s, size);
2506 v3_advance_base(udp, aoa);
2512 if (haveAoA && !haveData && !(flags & (RDPUDP2_ACK | RDPUDP2_ACKVEC)) && udp->v3BaseKnown &&
2515 udp->ackPending = TRUE;
2516 udp->v3WindowPending = TRUE;
2523 if (udp->receiveHold)
2531 if (udp->server && !udp->v3BaseKnown && !haveAoA)
2534 udp->v3LatestArrival = now_ns(udp);
2535 udp->v3UnackedPackets++;
2536 udp->receivedData = TRUE;
2537 if (!udp->v3BaseKnown)
2542 UINT16 base = dataSeq;
2543 if (haveAoA && !seq16_after(aoa, dataSeq) &&
2544 (seq16_diff(dataSeq, aoa) < RDPUDP_RECEIVE_REACH))
2546 udp->v3BaseKnown = TRUE;
2547 udp->v3Expected = base;
2548 udp->v3Highest = seq16_diff(base, 1);
2549 udp->v3AckedSeq = seq16_diff(base, 1);
2552 const UINT16 ahead = seq16_diff(dataSeq, udp->v3Expected);
2557 const BOOL behind = (ahead >= 0x8000);
2562 BOOL acknowledged = haveAoA && seq16_after(aoa, dataSeq);
2571 if (udp->server && behind)
2573 WLog_Print(udp->log, WLOG_DEBUG,
2574 "data packet 0x%04" PRIx16
" is behind the window at 0x%04" PRIx16
2575 ", skipping ACK vector",
2576 dataSeq, udp->v3Expected);
2577 acknowledged = TRUE;
2580 if (udp->server && (packetType != RDPUDP2_PACKET_DUMMY) && (Stream_GetRemainingLength(s) >= 2))
2587 UINT16 nextChannel = 0;
2588 Stream_Peek_UINT16(s, nextChannel);
2589 const UINT16 chunkAhead = seq16_diff(nextChannel, udp->v3NextChannel);
2590 if ((chunkAhead >= udp->chunkReach) && (chunkAhead < 0x8000))
2592 if (Stream_GetRemainingLength(s) > 2ull + RDPUDP_MAX_CHUNK)
2594 WLog_Print(udp->log, WLOG_DEBUG,
"discarding a chunk of %" PRIuz
" bytes",
2595 Stream_GetRemainingLength(s) - 2);
2600 if (behind && !acknowledged)
2603 const BOOL extends = (udp->v3BehindCount > 0) &&
2604 (dataSeq == seq16_add(udp->v3BehindBase, udp->v3BehindCount)) &&
2605 (udp->v3BehindCount < 63ull * RDPUDP2_MAX_ACKVEC);
2606 if ((udp->v3BehindCount > 0) && !extends && !v3_send_ack(udp))
2610 udp->v3BehindBase = dataSeq;
2611 udp->v3BehindCount = 0;
2613 udp->v3BehindCount++;
2614 udp->v3BehindArrival = udp->v3LatestArrival;
2615 udp->ackPending = TRUE;
2619 udp->ackPending = TRUE;
2620 udp->v3WindowPending = TRUE;
2621 if (ahead >= RDPUDP_RECEIVE_REACH)
2626 const BOOL withChunk =
2627 (packetType != RDPUDP2_PACKET_DUMMY) && (Stream_GetRemainingLength(s) >= 2);
2628 UINT16 channelSeq = 0;
2633 channelSeq = Stream_Get_UINT16(s);
2634 const UINT16 chunkAhead = seq16_diff(channelSeq, udp->v3NextChannel);
2635 if ((chunkAhead >= udp->chunkReach) && (chunkAhead < 0x8000))
2641 if (seq16_after(dataSeq, udp->v3Highest))
2642 udp->v3Highest = dataSeq;
2643 v3_mark_received(udp, dataSeq, udp->v3LatestArrival);
2644 v3_advance_window(udp);
2649 return v3_receive_channel_data(udp, channelSeq, Stream_ConstPointer(s),
2650 Stream_GetRemainingLength(s));
2658static BOOL send_syn(rdpUdp* udp)
2662 BYTE syn[RDPUDP_MTU] = WINPR_C_ARRAY_INIT;
2663 wStream sbuffer = WINPR_C_ARRAY_INIT;
2664 wStream* s = Stream_StaticInit(&sbuffer, syn,
sizeof(syn));
2667 const UINT16 version = udp->offerV3 ? RDPUDP_PROTOCOL_VERSION_3 : RDPUDP_PROTOCOL_VERSION_2;
2670 Stream_Write_UINT32_BE(s, UINT32_MAX);
2671 Stream_Write_UINT16_BE(s, RDPUDP_RECEIVE_WINDOW);
2672 Stream_Write_UINT16_BE(s, RDPUDP_FLAG_SYN | RDPUDP_FLAG_SYNEX);
2675 Stream_Write_UINT32_BE(s, udp->initialSequence);
2676 Stream_Write_UINT16_BE(s, RDPUDP_MTU);
2677 Stream_Write_UINT16_BE(s, RDPUDP_MTU);
2680 Stream_Write_UINT16_BE(s, RDPUDP_VERSION_INFO_VALID);
2681 Stream_Write_UINT16_BE(s, version);
2682 if (version == RDPUDP_PROTOCOL_VERSION_3)
2683 Stream_Write(s, udp->cookieHash,
sizeof(udp->cookieHash));
2685 udp->synSent = now_ms(udp);
2687 WLog_Print(udp->log, WLOG_DEBUG,
"sending SYN #%" PRIu32
" offering version 0x%04" PRIx16,
2688 udp->synAttempts, version);
2689 return rdpudp_send_raw(udp, syn,
sizeof(syn));
2693static BOOL process_syn_ack(rdpUdp* udp,
const BYTE* data,
size_t length)
2695 wStream sbuffer = WINPR_C_ARRAY_INIT;
2698 wStream* s = Stream_StaticConstInit(&sbuffer, data, length);
2701 if (!Stream_CheckAndLogRequiredLengthWLog(udp->log, s, 16))
2703 const UINT32 snSourceAck = Stream_Get_UINT32_BE(s);
2704 const UINT16 window = Stream_Get_UINT16_BE(s);
2705 const UINT16 flags = Stream_Get_UINT16_BE(s);
2706 if ((flags & (RDPUDP_FLAG_SYN | RDPUDP_FLAG_ACK)) != (RDPUDP_FLAG_SYN | RDPUDP_FLAG_ACK))
2711 if (snSourceAck != udp->initialSequence)
2713 WLog_Print(udp->log, WLOG_WARN,
2714 "dropping a SYN+ACK that acknowledges 0x%08" PRIx32
2715 ", the SYN carried 0x%08" PRIx32,
2716 snSourceAck, udp->initialSequence);
2720 const UINT32 peerInitial = Stream_Get_UINT32_BE(s);
2721 UINT16 upMtu = Stream_Get_UINT16_BE(s);
2722 Stream_Seek_UINT16(s);
2724 if ((flags & RDPUDP_FLAG_CORRELATION_ID) && !Stream_SafeSeek(s, 32))
2728 UINT16 version = RDPUDP_PROTOCOL_VERSION_1;
2729 if ((flags & RDPUDP_FLAG_SYNEX) && (Stream_GetRemainingLength(s) >= 4))
2731 const UINT16 synExFlags = Stream_Get_UINT16_BE(s);
2732 const UINT16 udpVersion = Stream_Get_UINT16_BE(s);
2733 if (synExFlags & RDPUDP_VERSION_INFO_VALID)
2734 version = udpVersion;
2739 case RDPUDP_PROTOCOL_VERSION_1:
2740 case RDPUDP_PROTOCOL_VERSION_2:
2742 case RDPUDP_PROTOCOL_VERSION_3:
2745 version = RDPUDP_PROTOCOL_VERSION_2;
2748 version = RDPUDP_PROTOCOL_VERSION_1;
2752 if ((upMtu < RDPUDP_MIN_MTU) || (upMtu > RDPUDP_MTU))
2753 upMtu = RDPUDP_MIN_MTU;
2756 udp->version = version;
2757 udp->peerWindow = window;
2758 udp->peerInitialSequence = peerInitial;
2759 udp->recvNext = seq32_add(peerInitial, 1);
2760 udp->recvHighest = peerInitial;
2761 udp->ackVectorStart = seq32_add(peerInitial, 1);
2762 udp->lastDelivery = now_ms(udp);
2763 udp->state = RDPUDP_STATE_ESTABLISHED;
2765 if (version == RDPUDP_PROTOCOL_VERSION_3)
2769 udp->nextCoded = RDPUDP2_INITIAL_SEQUENCE;
2770 udp->nextChannelSeq = 1;
2773 udp->v3NextChannel = 1;
2774 udp->v3MaxDelayedAcks = RDPUDP2_DEFAULT_DELAYED_ACKS;
2775 udp->v3DelayedAckTimeout = UINT32_MAX;
2779 udp->nextSource = seq32_add(udp->initialSequence, 1);
2780 udp->nextCoded = seq32_add(udp->initialSequence, 1);
2782 udp->ackPending = TRUE;
2785 WLog_Print(udp->log, WLOG_INFO,
2786 "RDP-UDP connected, protocol version 0x%04" PRIx16
", MTU %" PRIu16, version, upMtu);
2787 return flush_send_queue(udp);
2793static BOOL is_syn(
const BYTE* data,
size_t length)
2795 WINPR_ASSERT(data || (length == 0));
2798 const UINT16 flags = WINPR_ASSERTING_INT_CAST(UINT16, (data[6] << 8) | data[7]);
2799 return (data[0] == 0xFF) && (data[1] == 0xFF) && (data[2] == 0xFF) && (data[3] == 0xFF) &&
2800 ((flags & (RDPUDP_FLAG_SYN | RDPUDP_FLAG_ACK)) == RDPUDP_FLAG_SYN);
2804static BOOL process_datagram(rdpUdp* udp, BYTE* data,
size_t length)
2812 if (udp->server && is_syn(data, length))
2814 if (length < udp->synAckLength)
2816 WLog_Print(udp->log, WLOG_DEBUG,
"discarding a duplicate SYN shorter than the MTU");
2819 WLog_Print(udp->log, WLOG_DEBUG,
"received duplicate SYN, re-sending SYN+ACK");
2820 udp->synAckResent = TRUE;
2821 return rdpudp_send_raw(udp, udp->synAck, udp->synAckLength);
2824 const UINT64 now = now_ms(udp);
2825 if (udp->server && (udp->synAckSent != 0))
2833 if (!udp->synAckResent && !udp->rttSampled && (now >= udp->synAckSent))
2835 UINT64 sample = now - udp->synAckSent;
2838 if (sample > RDPUDP2_HANDSHAKE_RTT_MAX_MS)
2839 sample = RDPUDP2_HANDSHAKE_RTT_MAX_MS;
2840 udp->srtt = WINPR_ASSERTING_INT_CAST(UINT32, sample);
2841 udp->rttvar = udp->srtt / 2;
2842 udp->rttSampled = TRUE;
2844 udp->synAckSent = 0;
2846 v3_note_silence(udp, now);
2847 udp->lastReceived = now;
2851 case RDPUDP_STATE_SYN_SENT:
2852 return process_syn_ack(udp, data, length);
2853 case RDPUDP_STATE_ESTABLISHED:
2854 if (udp->version == RDPUDP_PROTOCOL_VERSION_3)
2855 return v3_process_datagram(udp, data, length);
2856 return v1_process_datagram(udp, data, length);
2867static BOOL run_timers(rdpUdp* udp)
2870 const UINT64 now = now_ms(udp);
2872 if (udp->state == RDPUDP_STATE_SYN_SENT)
2874 if (now - udp->synSent < RDPUDP_SYN_TIMEOUT_MS)
2876 if (udp->synAttempts >= RDPUDP_SYN_ATTEMPTS)
2878 rdpudp_fail(udp,
"no SYN+ACK from the server");
2881 return send_syn(udp);
2884 if (udp->state != RDPUDP_STATE_ESTABLISHED)
2887 const BOOL v3 = udp->version == RDPUDP_PROTOCOL_VERSION_3;
2888 if (now - udp->lastReceived > (v3 ? RDPUDP2_PEER_TIMEOUT_MS : RDPUDP_PEER_TIMEOUT_MS))
2890 rdpudp_fail(udp, v3 ?
"nothing heard from the peer for 16 seconds"
2891 :
"nothing heard from the peer for 65 seconds");
2894 v3_note_silence(udp, now);
2897 const UINT64 progress =
2898 (udp->bufferingSince > udp->lastDelivery) ? udp->bufferingSince : udp->lastDelivery;
2899 if ((udp->buffered > 0) && (now - progress > RDPUDP_STALL_TIMEOUT_MS))
2901 rdpudp_fail(udp,
"the stream is stuck behind a chunk the peer no longer resends");
2907 BOOL backedOff = FALSE;
2909 const BOOL scan = (now >= udp->pendingDue);
2910 UINT64 nextDue = UINT64_MAX;
2911 for (
size_t x = 0; scan && (x < udp->inFlight); x++)
2913 rdpudp_pending* p = &udp->pending[x];
2914 if (p->reportHeld && (now - p->lastSent >= report_resend_interval(udp)))
2915 handle_reported_loss(udp, p);
2916 if ((now < p->due) && !p->lost)
2918 nextDue = pending_next_due(udp, p, nextDue);
2924 if (udp->server && v3 && (p->seq != udp->sendBase) &&
2925 (seq16_diff(WINPR_ASSERTING_INT_CAST(UINT16, udp->nextCoded),
2926 WINPR_ASSERTING_INT_CAST(UINT16, udp->sendBase)) >=
2927 RDPUDP2_MAX_RESEND_SPAN))
2929 rdpudp_pending* oldest = pending_find(udp, udp->sendBase);
2930 WINPR_ASSERT(oldest);
2931 oldest->lost = TRUE;
2935 const BOOL reported = p->lost;
2945 if (p->timeouts >= (v3 ? RDPUDP2_MAX_RETRANSMITS : RDPUDP_MAX_RETRANSMITS))
2947 rdpudp_fail(udp,
"a datagram went unacknowledged too many times");
2951 UINT64 maxRto = v3 ? rto_v3_cap(udp) : RDPUDP_MAX_RTO_MS;
2952 if (maxRto > RDPUDP_MAX_RTO_MS)
2953 maxRto = RDPUDP_MAX_RTO_MS;
2955 (p->rto * 2ull > maxRto) ? WINPR_ASSERTING_INT_CAST(UINT32, maxRto) : p->rto * 2;
2958 if (!backedOff && (udp->rtoBackoff < RDPUDP2_MAX_RTO_BACKOFF))
2965 p->due = now + p->rto;
2969 p->reportHeld = FALSE;
2971 if (udp->version == RDPUDP_PROTOCOL_VERSION_3)
2976 const UINT16 coded = WINPR_ASSERTING_INT_CAST(UINT16, udp->nextCoded);
2977 if (udp->pendingIndex[coded] != 0)
2979 rdpudp_fail(udp,
"a datagram is still in flight 65536 sequence numbers back");
2984 udp->resent[udp->resentNext].valid = TRUE;
2985 udp->resent[udp->resentNext].reported = reported;
2986 udp->resent[udp->resentNext].seq = WINPR_ASSERTING_INT_CAST(UINT16, p->seq);
2987 udp->resent[udp->resentNext].at = now;
2988 udp->resentNext = (udp->resentNext + 1) % RDPUDP2_RESENT_HISTORY;
2990 udp->pendingIndex[p->seq & 0xFFFF] = 0;
2991 udp->pendingIndex[coded] = WINPR_ASSERTING_INT_CAST(UINT16, x + 1);
2993 udp->nextCoded = seq16_add(coded, 1);
2994 send_base_advance(udp);
2998 udp->cwrPending = TRUE;
3000 WLog_Print(udp->log, WLOG_TRACE,
"retransmitting 0x%08" PRIx32
" (#%" PRIu32
")", p->seq,
3002 if (!rdpudp_transmit(udp, p))
3004 nextDue = pending_next_due(udp, p, nextDue);
3007 udp->pendingDue = nextDue;
3010 const BOOL baseKeepalive = v3 && udp->server && udp->v3Resync;
3011 const UINT64 keepalive = baseKeepalive ? RDPUDP2_RESYNC_KEEPALIVE_MS
3012 : (v3 ? RDPUDP2_KEEPALIVE_MS : RDPUDP_KEEPALIVE_MS);
3013 if ((now >= udp->lastSent) && (now - udp->lastSent >= keepalive))
3017 if (!v3_send_base_keepalive(udp))
3020 else if (!rdpudp_send_ack(udp))
3022 udp->lastSent = now;
3032rdpUdp* rdpudp_new(wLog* log,
const BYTE* cookieHash, rdpUdpReceiveFn receive,
void* custom)
3035 WINPR_ASSERT(receive);
3037 rdpUdp* udp = calloc(1,
sizeof(rdpUdp));
3042 udp->sockfd = INVALID_SOCKET;
3043 udp->ownsSocket = TRUE;
3044 udp->state = RDPUDP_STATE_CLOSED;
3045 udp->receive = receive;
3046 udp->custom = custom;
3047 udp->mtu = RDPUDP_MTU;
3048 udp->cwnd = RDPUDP2_INITIAL_CWND;
3049 udp->ssthresh = RDPUDP_MAX_IN_FLIGHT;
3052 udp->v3ExpectedFull = 0x10000;
3053 udp->rttMin = UINT32_MAX;
3054 udp->ccRoundRttMin = UINT32_MAX;
3055 udp->reorderThreshold = RDPUDP2_REORDER_THRESHOLD;
3056 udp->chunkReach = RDPUDP_RECEIVE_REACH;
3057 udp->offerV3 = (cookieHash !=
nullptr);
3058 udp->version = udp->offerV3 ? RDPUDP_PROTOCOL_VERSION_3 : RDPUDP_PROTOCOL_VERSION_2;
3060 memcpy(udp->cookieHash, cookieHash,
sizeof(udp->cookieHash));
3062 udp->sendQueue = Queue_New(FALSE, -1, -1);
3063 if (!udp->sendQueue)
3065 wObject* obj = Queue_Object(udp->sendQueue);
3068 obj->fnObjectFree = chunk_free;
3070 if (winpr_RAND(&udp->initialSequence,
sizeof(udp->initialSequence)) < 0)
3075 WINPR_PRAGMA_DIAG_PUSH
3076 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
3078 WINPR_PRAGMA_DIAG_POP
3082void rdpudp_free(rdpUdp* udp)
3087 if (udp->ownsSocket && (udp->sockfd != INVALID_SOCKET))
3088 closesocket(udp->sockfd);
3090 for (
size_t x = 0; x < udp->inFlight; x++)
3091 pending_clear(&udp->pending[x]);
3092 for (
size_t x = 0; x < RDPUDP_RECEIVE_SLOTS; x++)
3093 slot_clear(&udp->slots[x]);
3098 rdpudp_chunk* chunk =
nullptr;
3099 while ((chunk = Queue_Dequeue(udp->sendQueue)))
3101 Queue_Free(udp->sendQueue);
3107static BOOL set_non_blocking(SOCKET sockfd)
3110 return _ioctlsocket(sockfd, FIONBIO, &arg) == 0;
3113BOOL rdpudp_connect(rdpUdp* udp,
const struct sockaddr* addr,
size_t addrlen)
3118 if (udp->state != RDPUDP_STATE_CLOSED)
3121 udp->sockfd = _socket(addr->sa_family, SOCK_DGRAM, IPPROTO_UDP);
3122 if (udp->sockfd == INVALID_SOCKET)
3124 WLog_Print(udp->log, WLOG_ERROR,
"failed to create the UDP socket");
3130 const UINT32 optval = RDPUDP_RECEIVE_BUFFER;
3131 if (_setsockopt(udp->sockfd, SOL_SOCKET, SO_RCVBUF, (
const char*)&optval,
3132 WINPR_ASSERTING_INT_CAST(
int,
sizeof(optval))) != 0)
3133 WLog_Print(udp->log, WLOG_WARN,
"setsockopt() SOL_SOCKET, SO_RCVBUF failed");
3135 if (_connect(udp->sockfd, addr, WINPR_ASSERTING_INT_CAST(
int, addrlen)) != 0)
3137 WLog_Print(udp->log, WLOG_ERROR,
"failed to connect the UDP socket");
3141 if (!set_non_blocking(udp->sockfd))
3144 udp->state = RDPUDP_STATE_SYN_SENT;
3145 udp->lastReceived = now_ms(udp);
3146 return send_syn(udp);
3153static BOOL build_syn_ack(rdpUdp* udp, UINT32 clientInitial)
3158 if ((udp->mtu < RDPUDP_MIN_MTU) || (udp->mtu >
sizeof(udp->synAck)))
3160 memset(udp->synAck, 0,
sizeof(udp->synAck));
3161 wStream sbuffer = WINPR_C_ARRAY_INIT;
3162 wStream* s = Stream_StaticInit(&sbuffer, udp->synAck,
sizeof(udp->synAck));
3167 Stream_Write_UINT32_BE(
3169 Stream_Write_UINT16_BE(s, RDPUDP_RECEIVE_WINDOW);
3170 Stream_Write_UINT16_BE(s, RDPUDP_FLAG_SYN | RDPUDP_FLAG_ACK | RDPUDP_FLAG_SYNEX);
3173 Stream_Write_UINT32_BE(s, udp->initialSequence);
3174 Stream_Write_UINT16_BE(s, udp->mtu);
3175 Stream_Write_UINT16_BE(s, udp->mtu);
3178 Stream_Write_UINT16_BE(s, RDPUDP_VERSION_INFO_VALID);
3179 Stream_Write_UINT16_BE(s, udp->version);
3181 udp->synAckLength = udp->mtu;
3185BOOL rdpudp_accept(rdpUdp* udp, rdpUdpSendFn send,
void* sendCustom,
const BYTE* syn,
size_t length)
3191 if ((udp->state != RDPUDP_STATE_CLOSED) || !is_syn(syn, length))
3194 wStream sbuffer = WINPR_C_ARRAY_INIT;
3195 wStream* s = Stream_StaticConstInit(&sbuffer, syn, length);
3196 if (!s || !Stream_CheckAndLogRequiredLengthWLog(udp->log, s, 16))
3200 Stream_Seek_UINT32(s);
3201 const UINT16 window = Stream_Get_UINT16_BE(s);
3202 const UINT16 flags = Stream_Get_UINT16_BE(s);
3205 const UINT32 clientInitial = Stream_Get_UINT32_BE(s);
3206 const UINT16 upMtu = Stream_Get_UINT16_BE(s);
3207 const UINT16 downMtu = Stream_Get_UINT16_BE(s);
3209 if ((flags & RDPUDP_FLAG_CORRELATION_ID) && !Stream_SafeSeek(s, 32))
3214 UINT16 version = RDPUDP_PROTOCOL_VERSION_1;
3215 if ((flags & RDPUDP_FLAG_SYNEX) && (Stream_GetRemainingLength(s) >= 4))
3217 const UINT16 synExFlags = Stream_Get_UINT16_BE(s);
3218 const UINT16 udpVersion = Stream_Get_UINT16_BE(s);
3219 if (synExFlags & RDPUDP_VERSION_INFO_VALID)
3220 version = udpVersion;
3222 if (version != RDPUDP_PROTOCOL_VERSION_3)
3224 WLog_Print(udp->log, WLOG_WARN,
3225 "client offered RDP-UDP version 0x%04" PRIx16
", only 0x%04" PRIx16
3226 " is implemented for a server",
3227 version, RDPUDP_PROTOCOL_VERSION_3);
3232 UINT16 mtu = (upMtu < downMtu) ? upMtu : downMtu;
3233 if (mtu > RDPUDP_MTU)
3235 if (mtu < RDPUDP_MIN_MTU)
3236 mtu = RDPUDP_MIN_MTU;
3243 WLog_Print(udp->log, WLOG_WARN,
3244 "rejecting a SYN of %" PRIuz
" bytes, which is shorter than the MTU of %" PRIu16,
3250 udp->ownsSocket = FALSE;
3252 udp->sendCustom = sendCustom;
3253 udp->chunkReach = RDPUDP_UNVERIFIED_REACH;
3256 udp->version = version;
3257 udp->peerWindow = window;
3258 udp->lastReceived = now_ms(udp);
3259 udp->lastDelivery = udp->lastReceived;
3260 udp->state = RDPUDP_STATE_ESTABLISHED;
3263 udp->nextCoded = RDPUDP2_INITIAL_SEQUENCE;
3264 udp->nextChannelSeq = 1;
3265 udp->v3NextChannel = 1;
3266 udp->v3MaxDelayedAcks = RDPUDP2_DEFAULT_DELAYED_ACKS;
3267 udp->v3DelayedAckTimeout = UINT32_MAX;
3269 if (!build_syn_ack(udp, clientInitial))
3271 WLog_Print(udp->log, WLOG_INFO,
3272 "accepted RDP-UDP client, protocol version 0x%04" PRIx16
", MTU %" PRIu16, version,
3274 udp->synAckSent = now_ms(udp);
3275 if (udp->synAckSent == 0)
3276 udp->synAckSent = 1;
3277 return rdpudp_send_raw(udp, udp->synAck, udp->synAckLength);
3280BOOL rdpudp_get_syn_cookie_hash(
const BYTE* data,
size_t length, BYTE hash[32])
3284 if ((length < RDPUDP_MIN_MTU) || !is_syn(data, length))
3287 wStream sbuffer = WINPR_C_ARRAY_INIT;
3288 wStream* s = Stream_StaticConstInit(&sbuffer, data, length);
3289 if (!s || !Stream_SafeSeek(s, 6))
3291 const UINT16 flags = Stream_Get_UINT16_BE(s);
3292 if (!(flags & RDPUDP_FLAG_SYNEX) || !Stream_SafeSeek(s, 8))
3294 if ((flags & RDPUDP_FLAG_CORRELATION_ID) && !Stream_SafeSeek(s, 32))
3296 if (Stream_GetRemainingLength(s) < 4 + 32)
3298 const UINT16 synExFlags = Stream_Get_UINT16_BE(s);
3299 const UINT16 version = Stream_Get_UINT16_BE(s);
3300 if (!(synExFlags & RDPUDP_VERSION_INFO_VALID) || (version != RDPUDP_PROTOCOL_VERSION_3))
3302 Stream_Read(s, hash, 32);
3306BOOL rdpudp_receive(rdpUdp* udp, BYTE* data,
size_t length)
3311 if (udp->state != RDPUDP_STATE_ESTABLISHED)
3313 if (!process_datagram(udp, data, length))
3315 rdpudp_fail(udp,
"failed to process a datagram");
3318 if (udp->state == RDPUDP_STATE_FAILED)
3320 if (!v3_ack_if_due(udp))
3322 if (!ack_when_due(udp))
3324 if (!run_timers(udp))
3326 return flush_send_queue(udp);
3329SOCKET rdpudp_get_socket(
const rdpUdp* udp)
3335RDPUDP_STATE rdpudp_get_state(
const rdpUdp* udp)
3341UINT16 rdpudp_get_version(
const rdpUdp* udp)
3344 return udp->version;
3347size_t rdpudp_get_max_payload(
const rdpUdp* udp)
3351 WINPR_ASSERT(udp->mtu >= RDPUDP_MIN_MTU);
3354 const size_t overhead = (udp->version == RDPUDP_PROTOCOL_VERSION_3)
3355 ? (RDPUDP2_DATA_OVERHEAD + RDPUDP2_DATA_ACK_ROOM)
3356 : (8u + RDPUDP_ACK_ROOM + 8u);
3357 if (udp->mtu <= overhead)
3359 return udp->mtu - overhead;
3362size_t rdpudp_get_send_backlog(
const rdpUdp* udp)
3365 return Queue_Count(udp->sendQueue);
3368size_t rdpudp_get_send_window(
const rdpUdp* udp)
3370 return window_limit(udp);
3373UINT32 rdpudp_get_rtt(
const rdpUdp* udp)
3376 if (!udp->rttSampled)
3379 return (udp->srtt > 0) ? udp->srtt : 1;
3382UINT32 rdpudp_get_timeout(
const rdpUdp* udp)
3385 const UINT64 now = now_ms(udp);
3386 UINT64 timeout = 50;
3388 if (udp->state == RDPUDP_STATE_SYN_SENT)
3390 const UINT64 due = udp->synSent + RDPUDP_SYN_TIMEOUT_MS;
3393 if (due - now < timeout)
3394 timeout = due - now;
3395 return WINPR_ASSERTING_INT_CAST(UINT32, timeout);
3398 if (udp->inFlight > 0)
3400 if (udp->pendingDue <= now)
3402 if (udp->pendingDue - now < timeout)
3403 timeout = udp->pendingDue - now;
3407 if (udp->ackPending && (udp->v3AckDue != 0))
3409 if (udp->v3AckDue <= now)
3411 if (udp->v3AckDue - now < timeout)
3412 timeout = udp->v3AckDue - now;
3414 return WINPR_ASSERTING_INT_CAST(UINT32, timeout);
3417BOOL rdpudp_check(rdpUdp* udp)
3421 if ((udp->state == RDPUDP_STATE_FAILED) || (udp->state == RDPUDP_STATE_CLOSED))
3424 BYTE* buffer = udp->recvBuffer;
3428 for (
size_t count = 0; udp->ownsSocket && (count < RDPUDP_INPUT_BUDGET); count++)
3430 const int rc = _recv(udp->sockfd, (
char*)buffer,
3431 WINPR_ASSERTING_INT_CAST(
int,
sizeof(udp->recvBuffer)), 0);
3434 const int error = WSAGetLastError();
3435 if (!rdpudp_socket_error_is_transient(error))
3437 WLog_Print(udp->log, WLOG_ERROR,
"recv failed with %d", error);
3438 rdpudp_fail(udp,
"receiving from the socket failed");
3443 if (error != WSAEWOULDBLOCK)
3444 WLog_Print(udp->log, WLOG_DEBUG,
"recv failed with %d", error);
3448 if (!process_datagram(udp, buffer, WINPR_ASSERTING_INT_CAST(
size_t, rc)))
3450 rdpudp_fail(udp,
"failed to process a datagram");
3453 if (udp->state == RDPUDP_STATE_FAILED)
3455 if (!v3_ack_if_due(udp))
3459 if (!ack_when_due(udp))
3462 if (!flush_send_queue(udp))
3465 if (!run_timers(udp))
3469 return flush_send_queue(udp);
3473void rdpudp_set_peer_verified(rdpUdp* udp)
3476 udp->chunkReach = RDPUDP_RECEIVE_REACH;
3479void rdpudp_set_receive_hold(rdpUdp* udp, BOOL hold)
3482 udp->receiveHold = hold;
3485void rdpudp_set_clock(rdpUdp* udp, rdpUdpClockFn clock,
void* custom)
3489 udp->clockCustom = custom;
3492UINT64 rdpudp_get_time(
const rdpUdp* udp)
Layout layout(float leftWidth, float leftHeight, float rightWidth, float rightHeight, float width, float margin)
This struct contains function pointer to initialize/free objects.