27#include <winpr/wtypes.h>
29#include <winpr/stream.h>
30#include <winpr/synch.h>
31#include <winpr/sysinfo.h>
32#include <winpr/winsock.h>
33#include <winpr/wlog.h>
36#include <sys/socket.h>
37#include <netinet/in.h>
43#define TAG "com.freerdp.core.test.rdpudp"
46#define FLAG_SYN 0x0001
47#define FLAG_ACK 0x0004
48#define FLAG_SYNEX 0x1000
53#define V3_ACKVEC 0x008
55#define V3_OVERHEADSIZE 0x040
56#define V3_DELAYACKINFO 0x100
58#define V3_TYPE_STANDARD 0
59#define V3_TYPE_DUMMY 8
61#define SYN_LENGTH 1232
62#define FIRST_SEQUENCE 100
69 (void)fprintf(stderr, "%s:%d: check failed: %s\n", __FILE__, __LINE__, #cond); \
97 struct sockaddr_in serverAddr;
102 V3Packet seen[MAX_SEEN];
110static BOOL on_receive(
void* custom,
const BYTE* data,
size_t length)
112 TestCtx* ctx = custom;
113 if (!Stream_EnsureRemainingCapacity(ctx->delivered, length))
115 Stream_Write(ctx->delivered, data, length);
119static BOOL server_open(TestCtx* ctx)
121 ctx->server = _socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
122 if (ctx->server == INVALID_SOCKET)
125 struct sockaddr_in addr = WINPR_C_ARRAY_INIT;
126 addr.sin_family = AF_INET;
127 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
129 if (_bind(ctx->server, (
const struct sockaddr*)&addr,
sizeof(addr)) != 0)
132 socklen_t length =
sizeof(ctx->serverAddr);
133 if (_getsockname(ctx->server, (
struct sockaddr*)&ctx->serverAddr, &length) != 0)
137 return _ioctlsocket(ctx->server, FIONBIO, &arg) == 0;
141static size_t server_recv(TestCtx* ctx, BYTE* buffer,
size_t size, UINT32 timeoutMs)
143 const UINT64 deadline = GetTickCount64() + timeoutMs;
146 const int rc = _recv(ctx->server, (
char*)buffer, (
int)size, 0);
149 if (GetTickCount64() >= deadline)
155static BOOL server_send_raw(TestCtx* ctx,
const BYTE* data,
size_t length)
157 return _send(ctx->server, (
const char*)data, (
int)length, 0) == (int)length;
161static BOOL pump(TestCtx* ctx)
164 return rdpudp_check(ctx->udp);
171static void write_uint24(
wStream* s, UINT32 value)
173 Stream_Write_UINT8(s, (BYTE)(value & 0xFF));
174 Stream_Write_UINT8(s, (BYTE)((value >> 8) & 0xFF));
175 Stream_Write_UINT8(s, (BYTE)((value >> 16) & 0xFF));
186 UINT16 delayedAckTimeout;
193 size_t payloadLength;
198static BOOL server_send_v3(TestCtx* ctx,
const V3Out* out)
200 BYTE wire[1500] = WINPR_C_ARRAY_INIT;
201 wStream sbuffer = WINPR_C_ARRAY_INIT;
202 wStream* s = Stream_StaticInit(&sbuffer, wire,
sizeof(wire));
207 if (out->hasDelayAck)
208 flags |= V3_DELAYACKINFO;
215 Stream_Write_UINT16(s, (UINT16)(flags | (15u << 12)));
218 Stream_Write_UINT16(s, out->ack);
220 Stream_Write_UINT8(s, 0);
221 Stream_Write_UINT8(s, 0);
223 if (out->hasDelayAck)
225 Stream_Write_UINT8(s, out->maxDelayedAcks);
226 Stream_Write_UINT16(s, out->delayedAckTimeout);
229 Stream_Write_UINT16(s, out->aoa);
232 Stream_Write_UINT16(s, out->dataSeq);
233 Stream_Write_UINT16(s, out->channelSeq);
234 Stream_Write(s, out->payload, out->payloadLength);
237 const size_t layout = Stream_GetPosition(s) - 1;
238 BYTE shortLength = 7;
241 shortLength = (BYTE)layout;
242 Stream_Zero(s, 7 - layout);
244 const size_t length = Stream_GetPosition(s);
245 const BYTE type = out->dummy ? V3_TYPE_DUMMY : V3_TYPE_STANDARD;
246 wire[0] = (BYTE)((shortLength << 5) | (type << 1));
247 const BYTE eighth = wire[7];
250 return server_send_raw(ctx, wire, length);
253static BOOL send_data(TestCtx* ctx, UINT16 dataSeq, UINT16 channelSeq,
const char* text)
255 const V3Out out = { .hasData = TRUE,
257 .channelSeq = channelSeq,
258 .payload = (
const BYTE*)text,
259 .payloadLength = strlen(text) };
260 return server_send_v3(ctx, &out);
263static BOOL send_aoa(TestCtx* ctx, UINT16 aoa)
265 const V3Out out = { .hasAoA = TRUE, .aoa = aoa };
266 return server_send_v3(ctx, &out);
269static BOOL send_ack(TestCtx* ctx, UINT16 ack)
271 const V3Out out = { .hasAck = TRUE, .ack = ack };
272 return server_send_v3(ctx, &out);
275static BOOL parse_v3(
const BYTE* wire,
size_t length, V3Packet* packet)
277 BYTE buffer[1500] = WINPR_C_ARRAY_INIT;
278 if ((length < 8) || (length >
sizeof(buffer)))
280 memcpy(buffer, wire, length);
281 const BYTE eighth = buffer[7];
282 buffer[7] = buffer[0];
285 memset(packet, 0,
sizeof(*packet));
286 const BYTE prefix = buffer[0];
287 const BYTE shortLength = prefix >> 5;
289 length = 1ull + shortLength;
291 wStream sbuffer = WINPR_C_ARRAY_INIT;
292 wStream* s = Stream_StaticConstInit(&sbuffer, buffer + 1, length - 1);
293 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
295 const UINT16 header = Stream_Get_UINT16(s);
296 packet->flags = header & 0x0FFF;
297 packet->logWindow = (BYTE)(header >> 12);
299 if (packet->flags & V3_ACK)
301 if (!Stream_CheckAndLogRequiredLength(TAG, s, 7))
303 packet->ack = Stream_Get_UINT16(s);
305 const size_t delayed = Stream_Get_UINT8(s) & 0x0F;
306 if (!Stream_SafeSeek(s, delayed))
309 if ((packet->flags & V3_OVERHEADSIZE) && !Stream_SafeSeek(s, 1))
311 if ((packet->flags & V3_DELAYACKINFO) && !Stream_SafeSeek(s, 3))
313 if (packet->flags & V3_AOA)
315 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
317 packet->hasAoA = TRUE;
318 packet->aoa = Stream_Get_UINT16(s);
320 if (packet->flags & V3_DATA)
322 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
324 packet->dataSeq = Stream_Get_UINT16(s);
326 if (packet->flags & V3_ACKVEC)
328 if (!Stream_CheckAndLogRequiredLength(TAG, s, 3))
330 packet->vecBase = Stream_Get_UINT16(s);
331 const BYTE control = Stream_Get_UINT8(s);
332 if ((control & 0x80) && !Stream_SafeSeek(s, 4))
334 packet->vecLength = control & 0x7F;
335 if (!Stream_CheckAndLogRequiredLength(TAG, s, packet->vecLength))
337 Stream_Read(s, packet->vec, packet->vecLength);
339 if (packet->flags & V3_DATA)
341 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
343 packet->hasData = TRUE;
344 packet->channelSeq = Stream_Get_UINT16(s);
345 packet->payloadLength = Stream_GetRemainingLength(s);
346 if (packet->payloadLength >
sizeof(packet->payload))
347 packet->payloadLength =
sizeof(packet->payload);
348 Stream_Read(s, packet->payload, packet->payloadLength);
354static BOOL drain(TestCtx* ctx, UINT32 waitMs)
356 BYTE buffer[1500] = WINPR_C_ARRAY_INIT;
359 while ((length = server_recv(ctx, buffer,
sizeof(buffer), waitMs)) > 0)
361 V3Packet packet = WINPR_C_ARRAY_INIT;
362 if (!parse_v3(buffer, length, &packet))
364 if (ctx->seenCount == MAX_SEEN)
366 memmove(&ctx->seen[0], &ctx->seen[1],
sizeof(ctx->seen[0]) * (MAX_SEEN - 1));
369 ctx->seen[ctx->seenCount++] = packet;
375static BOOL collect_data(TestCtx* ctx,
size_t want, UINT32 timeoutMs)
377 BYTE buffer[1500] = WINPR_C_ARRAY_INIT;
382 const size_t length = server_recv(ctx, buffer,
sizeof(buffer), timeoutMs);
385 if (ctx->seenCount == MAX_SEEN)
387 V3Packet* packet = &ctx->seen[ctx->seenCount++];
388 if (!parse_v3(buffer, length, packet))
397static const V3Packet* last_ack(
const TestCtx* ctx)
399 for (
size_t x = ctx->seenCount; x > 0; x--)
401 const V3Packet* packet = &ctx->seen[x - 1];
402 if (packet->flags & (V3_ACK | V3_ACKVEC))
408static size_t count_data(
const TestCtx* ctx)
411 for (
size_t x = 0; x < ctx->seenCount; x++)
413 if (ctx->seen[x].hasData)
419static const V3Packet* first_data(
const TestCtx* ctx)
421 for (
size_t x = 0; x < ctx->seenCount; x++)
423 if (ctx->seen[x].hasData)
424 return &ctx->seen[x];
429static BOOL delivered_is(
const TestCtx* ctx,
const char* expected)
431 const size_t length = strlen(expected);
432 return (Stream_GetPosition(ctx->delivered) == length) &&
433 (memcmp(Stream_Buffer(ctx->delivered), expected, length) == 0);
437static BOOL delivered_tail_is(
const TestCtx* ctx,
size_t offset,
const char* expected)
439 const size_t length = strlen(expected);
440 return (Stream_GetPosition(ctx->delivered) == offset + length) &&
441 (memcmp(Stream_Buffer(ctx->delivered) + offset, expected, length) == 0);
448static const BYTE cookieHash[32] = { 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
449 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
450 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
451 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA };
457 UINT32 initialSequence;
460 BYTE raw[SYN_LENGTH];
463static void ctx_free(TestCtx* ctx)
465 rdpudp_free(ctx->udp);
466 if (ctx->server != INVALID_SOCKET)
467 closesocket(ctx->server);
468 Stream_Free(ctx->delivered, TRUE);
469 memset(ctx, 0,
sizeof(*ctx));
470 ctx->server = INVALID_SOCKET;
474static BOOL ctx_start(TestCtx* ctx, BOOL offerV3, SynInfo* syn)
476 memset(ctx, 0,
sizeof(*ctx));
477 ctx->server = INVALID_SOCKET;
478 ctx->delivered = Stream_New(
nullptr, 1024);
479 if (!ctx->delivered || !server_open(ctx))
482 ctx->udp = rdpudp_new(WLog_Get(TAG), offerV3 ? cookieHash :
nullptr, on_receive, ctx);
485 if (!rdpudp_connect(ctx->udp, (
const struct sockaddr*)&ctx->serverAddr,
486 sizeof(ctx->serverAddr)))
489 BYTE buffer[1500] = WINPR_C_ARRAY_INIT;
490 struct sockaddr_in from = WINPR_C_ARRAY_INIT;
491 int fromLength =
sizeof(from);
492 const UINT64 deadline = GetTickCount64() + 1000;
494 while ((rc = _recvfrom(ctx->server, (
char*)buffer,
sizeof(buffer), 0, (
struct sockaddr*)&from,
497 if (GetTickCount64() >= deadline)
501 if (_connect(ctx->server, (
const struct sockaddr*)&from, fromLength) != 0)
504 wStream sbuffer = WINPR_C_ARRAY_INIT;
505 wStream* s = Stream_StaticConstInit(&sbuffer, buffer, (
size_t)rc);
506 if (!Stream_CheckAndLogRequiredLength(TAG, s, 20))
508 syn->length = (size_t)rc;
509 if (syn->length <=
sizeof(syn->raw))
510 memcpy(syn->raw, buffer, syn->length);
512 syn->flags = Stream_Get_UINT16_BE(s);
513 syn->initialSequence = Stream_Get_UINT32_BE(s);
515 syn->version = Stream_Get_UINT16_BE(s);
516 if (Stream_GetRemainingLength(s) >=
sizeof(syn->cookie))
517 Stream_Read(s, syn->cookie,
sizeof(syn->cookie));
521static BOOL send_syn_ack(TestCtx* ctx, UINT32 acknowledged, UINT16 version)
523 BYTE wire[20] = WINPR_C_ARRAY_INIT;
524 wStream sbuffer = WINPR_C_ARRAY_INIT;
525 wStream* s = Stream_StaticInit(&sbuffer, wire,
sizeof(wire));
526 Stream_Write_UINT32_BE(s, acknowledged);
527 Stream_Write_UINT16_BE(s, 64);
528 Stream_Write_UINT16_BE(s, FLAG_SYN | FLAG_ACK | FLAG_SYNEX);
529 Stream_Write_UINT32_BE(s, 0x1000);
530 Stream_Write_UINT16_BE(s, SYN_LENGTH);
531 Stream_Write_UINT16_BE(s, SYN_LENGTH);
532 Stream_Write_UINT16_BE(s, 0x0001);
533 Stream_Write_UINT16_BE(s, version);
534 return server_send_raw(ctx, wire,
sizeof(wire));
538static BOOL ctx_connect(TestCtx* ctx)
540 SynInfo syn = WINPR_C_ARRAY_INIT;
541 if (!ctx_start(ctx, TRUE, &syn))
543 if (!send_syn_ack(ctx, syn.initialSequence, RDPUDP_PROTOCOL_VERSION_3))
545 for (
size_t x = 0; x < 100; x++)
549 if (rdpudp_get_state(ctx->udp) == RDPUDP_STATE_ESTABLISHED)
550 return rdpudp_get_version(ctx->udp) == RDPUDP_PROTOCOL_VERSION_3;
558static BOOL stream_ahead(TestCtx* ctx, UINT16* dataSeq, UINT16* channel,
size_t count)
562 const size_t batch = (count > 64) ? 64 : count;
563 for (
size_t x = 0; x < batch; x++)
565 if (!send_data(ctx, *dataSeq, *channel,
"."))
570 if (!pump(ctx) || !drain(ctx, 0))
581static BOOL syn_offers_version_3_with_the_cookie_hash(
void)
584 TestCtx ctx = WINPR_C_ARRAY_INIT;
585 SynInfo syn = WINPR_C_ARRAY_INIT;
586 CHECK(ctx_start(&ctx, TRUE, &syn));
588 CHECK(syn.length == SYN_LENGTH);
589 CHECK((syn.flags & (FLAG_SYN | FLAG_SYNEX)) == (FLAG_SYN | FLAG_SYNEX));
590 CHECK(syn.version == RDPUDP_PROTOCOL_VERSION_3);
591 CHECK(memcmp(syn.cookie, cookieHash,
sizeof(cookieHash)) == 0);
598static BOOL syn_offers_version_2_without_a_cookie_hash(
void)
601 TestCtx ctx = WINPR_C_ARRAY_INIT;
602 SynInfo syn = WINPR_C_ARRAY_INIT;
603 CHECK(ctx_start(&ctx, FALSE, &syn));
604 CHECK(syn.length == SYN_LENGTH);
605 CHECK(syn.version == RDPUDP_PROTOCOL_VERSION_2);
616static BOOL dummy_packets_are_acknowledged_but_not_delivered(
void)
619 TestCtx ctx = WINPR_C_ARRAY_INIT;
620 CHECK(ctx_connect(&ctx));
622 const V3Out dummy = { .dummy = TRUE,
624 .dataSeq = FIRST_SEQUENCE,
626 .payload = (
const BYTE*)
"junk",
627 .payloadLength = 4 };
628 CHECK(server_send_v3(&ctx, &dummy));
630 CHECK(delivered_is(&ctx,
""));
633 CHECK(send_data(&ctx, FIRST_SEQUENCE + 1, 1,
"payload"));
635 CHECK(delivered_is(&ctx,
"payload"));
637 CHECK(drain(&ctx, 20));
638 const V3Packet* ack = last_ack(&ctx);
639 CHECK(ack && (ack->flags & V3_ACK));
640 CHECK(ack->ack == FIRST_SEQUENCE + 1);
650static BOOL retransmission_is_reordered_back_into_the_stream(
void)
653 TestCtx ctx = WINPR_C_ARRAY_INIT;
654 CHECK(ctx_connect(&ctx));
655 CHECK(send_data(&ctx, 100, 1,
"a"));
656 CHECK(send_data(&ctx, 101, 3,
"c"));
657 CHECK(send_data(&ctx, 102, 4,
"d"));
659 CHECK(delivered_is(&ctx,
"a"));
661 CHECK(send_data(&ctx, 103, 2,
"b"));
663 CHECK(delivered_is(&ctx,
"abcd"));
672static BOOL ack_of_acks_advances_the_window_without_touching_the_stream(
void)
675 TestCtx ctx = WINPR_C_ARRAY_INIT;
676 CHECK(ctx_connect(&ctx));
677 CHECK(send_data(&ctx, 100, 1,
"a"));
679 CHECK(send_data(&ctx, 102, 2,
"b"));
681 CHECK(delivered_is(&ctx,
"ab"));
682 CHECK(drain(&ctx, 20));
683 const V3Packet* ack = last_ack(&ctx);
684 CHECK(ack && (ack->flags & V3_ACKVEC) && (ack->vecBase == 101));
686 CHECK(send_aoa(&ctx, 102));
688 CHECK(drain(&ctx, 20));
689 ack = last_ack(&ctx);
690 CHECK(ack && (ack->flags & V3_ACK));
691 CHECK(ack->ack == 102);
692 CHECK(delivered_is(&ctx,
"ab"));
702static BOOL ack_of_acks_on_its_own_is_answered(
void)
705 TestCtx ctx = WINPR_C_ARRAY_INIT;
706 CHECK(ctx_connect(&ctx));
707 CHECK(send_data(&ctx, 100, 1,
"a"));
709 CHECK(drain(&ctx, 30));
710 const V3Packet* ack = last_ack(&ctx);
711 CHECK(ack && (ack->flags & V3_ACK) && (ack->ack == 100));
713 for (
size_t x = 0; x < 2; x++)
716 CHECK(send_aoa(&ctx, 101));
718 CHECK(drain(&ctx, 30));
719 ack = last_ack(&ctx);
720 CHECK(ack && (ack->flags & V3_ACK) && (ack->ack == 100));
722 CHECK(delivered_is(&ctx,
"a"));
729static BOOL send_data_aoa(TestCtx* ctx, UINT16 dataSeq, UINT16 channelSeq,
const char* text,
732 const V3Out out = { .hasAoA = TRUE,
736 .channelSeq = channelSeq,
737 .payload = (
const BYTE*)text,
738 .payloadLength = strlen(text) };
739 return server_send_v3(ctx, &out);
745static BOOL ack_of_acks_past_its_own_packet_keeps_the_chunk(
void)
748 TestCtx ctx = WINPR_C_ARRAY_INIT;
749 CHECK(ctx_connect(&ctx));
750 CHECK(send_data(&ctx, 100, 1,
"a"));
751 CHECK(send_data_aoa(&ctx, 101, 2,
"b", 102));
752 CHECK(send_data_aoa(&ctx, 102, 3,
"c", 102));
754 CHECK(delivered_is(&ctx,
"abc"));
755 CHECK(drain(&ctx, 20));
756 const V3Packet* ack = last_ack(&ctx);
757 CHECK(ack && (ack->flags & V3_ACK) && (ack->ack == 102));
767static BOOL ack_of_acks_past_its_own_packet_gets_no_ack_vector(
void)
770 TestCtx ctx = WINPR_C_ARRAY_INIT;
771 CHECK(ctx_connect(&ctx));
772 CHECK(send_data(&ctx, 100, 1,
"a"));
774 CHECK(drain(&ctx, 20));
776 CHECK(send_data_aoa(&ctx, 101, 2,
"b", 102));
777 CHECK(send_data_aoa(&ctx, 102, 3,
"c", 102));
779 CHECK(delivered_is(&ctx,
"abc"));
780 CHECK(drain(&ctx, 20));
781 for (
size_t x = 0; x < ctx.seenCount; x++)
782 CHECK(!(ctx.seen[x].flags & V3_ACKVEC));
783 const V3Packet* ack = last_ack(&ctx);
784 CHECK(ack && (ack->flags & V3_ACK) && (ack->ack == 102));
793static BOOL ack_of_acks_far_past_its_own_packet_keeps_the_chunk(
void)
796 TestCtx ctx = WINPR_C_ARRAY_INIT;
797 CHECK(ctx_connect(&ctx));
798 CHECK(send_data(&ctx, 100, 1,
"a"));
799 CHECK(send_data_aoa(&ctx, 101, 2,
"b", 104));
800 CHECK(send_data(&ctx, 104, 3,
"c"));
802 CHECK(delivered_is(&ctx,
"abc"));
803 CHECK(drain(&ctx, 20));
804 const V3Packet* ack = last_ack(&ctx);
805 CHECK(ack && (ack->flags & V3_ACK) && (ack->ack == 104));
814static BOOL late_packet_behind_the_window_fills_the_hole(
void)
817 TestCtx ctx = WINPR_C_ARRAY_INIT;
818 CHECK(ctx_connect(&ctx));
819 CHECK(send_data(&ctx, 100, 1,
"a"));
821 CHECK(send_data(&ctx, 102, 3,
"c"));
822 CHECK(send_aoa(&ctx, 102));
824 CHECK(delivered_is(&ctx,
"a"));
826 CHECK(send_data(&ctx, 101, 2,
"b"));
828 CHECK(delivered_is(&ctx,
"abc"));
831 CHECK(send_data(&ctx, 103, 2,
"b"));
832 CHECK(send_data(&ctx, 104, 4,
"d"));
834 CHECK(delivered_is(&ctx,
"abcd"));
843static BOOL retransmitted_packets_are_acknowledged_again(
void)
846 TestCtx ctx = WINPR_C_ARRAY_INIT;
847 CHECK(ctx_connect(&ctx));
848 CHECK(send_data(&ctx, 100, 1,
"first"));
850 CHECK(drain(&ctx, 20));
851 CHECK(last_ack(&ctx));
853 CHECK(send_data(&ctx, 100, 1,
"first"));
855 CHECK(delivered_is(&ctx,
"first"));
856 CHECK(drain(&ctx, 20));
858 const V3Packet* ack = last_ack(&ctx);
859 CHECK(ack && (ack->flags & V3_ACKVEC) && (ack->vecBase == 100) && (ack->vecLength == 1) &&
860 (ack->vec[0] == (0x80 | 0x40 | 1)));
874 UINT16 watchedChannel;
887static UINT64 g_serverTime = 1000000000000ULL;
889static UINT64 server_clock(WINPR_ATTR_UNUSED
void* custom)
894static BOOL server_on_receive(
void* custom, WINPR_ATTR_UNUSED
const BYTE* data,
895 WINPR_ATTR_UNUSED
size_t length)
897 ServerSent* sent = custom;
902static BOOL server_on_send(
void* custom,
const BYTE* data,
size_t length)
904 ServerSent* sent = custom;
906 V3Packet packet = WINPR_C_ARRAY_INIT;
907 if (!parse_v3(data, length, &packet))
909 if (packet.flags & V3_ACK)
912 sent->ack = packet.ack;
914 if (packet.flags & V3_ACKVEC)
916 sent->hasVector = TRUE;
917 sent->vectorBase = packet.vecBase;
919 if (packet.hasAoA && !packet.hasData && !(packet.flags & (V3_ACK | V3_ACKVEC)))
922 sent->base = packet.aoa;
926 sent->hasDataSeq = TRUE;
927 sent->lastDataSeq = packet.dataSeq;
928 sent->lastChannel = packet.channelSeq;
929 if (packet.channelSeq == sent->watchedChannel)
930 sent->watchedSends++;
938static BOOL server_receive_data(rdpUdp* udp, UINT16 dataSeq, UINT16 channelSeq)
940 BYTE wire[32] = WINPR_C_ARRAY_INIT;
941 wStream sbuffer = WINPR_C_ARRAY_INIT;
942 wStream* s = Stream_StaticInit(&sbuffer, wire,
sizeof(wire));
944 Stream_Write_UINT16(s, (UINT16)(V3_DATA | (15u << 12)));
945 Stream_Write_UINT16(s, dataSeq);
946 Stream_Write_UINT16(s, channelSeq);
947 Stream_Write(s,
"abcd", 4);
948 const size_t length = Stream_GetPosition(s);
949 wire[0] = (BYTE)((7 << 5) | (V3_TYPE_STANDARD << 1));
950 const BYTE eighth = wire[7];
953 return rdpudp_receive(udp, wire, length);
957static BOOL server_receive_data_with_aoa(rdpUdp* udp, UINT16 dataSeq, UINT16 channelSeq, UINT16 aoa)
959 BYTE wire[32] = WINPR_C_ARRAY_INIT;
960 wStream sbuffer = WINPR_C_ARRAY_INIT;
961 wStream* s = Stream_StaticInit(&sbuffer, wire,
sizeof(wire));
963 Stream_Write_UINT16(s, (UINT16)(V3_DATA | V3_AOA | (15u << 12)));
964 Stream_Write_UINT16(s, aoa);
965 Stream_Write_UINT16(s, dataSeq);
966 Stream_Write_UINT16(s, channelSeq);
967 Stream_Write(s,
"abcd", 4);
968 const size_t length = Stream_GetPosition(s);
969 wire[0] = (BYTE)((7 << 5) | (V3_TYPE_STANDARD << 1));
970 const BYTE eighth = wire[7];
973 return rdpudp_receive(udp, wire, length);
978static BOOL server_receive_data_aoa(rdpUdp* udp, UINT16 dataSeq, UINT16 channelSeq)
980 return server_receive_data_with_aoa(udp, dataSeq, channelSeq, dataSeq);
984static BOOL server_run_timers(rdpUdp* udp, UINT32 waitMs)
986 for (UINT32 x = 0; x < waitMs; x += 5)
988 g_serverTime += 5ULL * 1000000ULL;
989 if (!rdpudp_check(udp))
996static void server_make_syn(BYTE syn[SYN_LENGTH])
998 memset(syn, 0, SYN_LENGTH);
999 wStream sbuffer = WINPR_C_ARRAY_INIT;
1000 wStream* s = Stream_StaticInit(&sbuffer, syn, SYN_LENGTH);
1001 Stream_Write_UINT32_BE(s, 0xFFFFFFFF);
1002 Stream_Write_UINT16_BE(s, 64);
1003 Stream_Write_UINT16_BE(s, 0x0001 | 0x1000);
1004 Stream_Write_UINT32_BE(s, 1000);
1005 Stream_Write_UINT16_BE(s, SYN_LENGTH);
1006 Stream_Write_UINT16_BE(s, SYN_LENGTH);
1007 Stream_Write_UINT16_BE(s, 0x0001);
1008 Stream_Write_UINT16_BE(s, RDPUDP_PROTOCOL_VERSION_3);
1012static rdpUdp* server_accept(ServerSent* sent)
1014 rdpUdp* udp = rdpudp_new(WLog_Get(TAG),
nullptr, server_on_receive, sent);
1017 rdpudp_set_clock(udp, server_clock,
nullptr);
1020 server_make_syn(syn);
1021 if (!rdpudp_accept(udp, server_on_send, sent, syn,
sizeof(syn)))
1030static BOOL server_does_not_report_a_packet_behind_its_window(
void)
1033 ServerSent sent = WINPR_C_ARRAY_INIT;
1034 rdpUdp* udp = server_accept(&sent);
1039 if (!server_receive_data_aoa(udp, 100, 1))
1041 for (UINT16 x = 1; x < 3; x++)
1043 if (!server_receive_data(udp, (UINT16)(100 + x), (UINT16)(1 + x)))
1046 if (!server_run_timers(udp, 100) || !sent.hasAck || (sent.ack != 102) || sent.hasVector)
1050 if (!server_receive_data(udp, 100, 1) || !server_run_timers(udp, 100) || sent.hasVector)
1054 if (!server_receive_data(udp, 104, 5) || !server_run_timers(udp, 100) || !sent.hasVector ||
1055 (sent.vectorBase != 103))
1067static BOOL server_takes_its_base_from_an_ackofacks(
void)
1070 ServerSent sent = WINPR_C_ARRAY_INIT;
1071 rdpUdp* udp = server_accept(&sent);
1076 if (!server_receive_data(udp, 101, 2) || !server_run_timers(udp, 100) || sent.hasAck ||
1080 if (!server_receive_data_aoa(udp, 102, 1) || !server_run_timers(udp, 100))
1083 if (!sent.hasAck || (sent.ack != 102) || (sent.delivered != 1))
1092static BOOL server_receive_chunks(rdpUdp* udp, UINT16* dataSeq, UINT16 first, UINT16 last)
1094 for (UINT16 channel = first; channel <= last; channel++)
1096 if (!server_receive_data(udp, (*dataSeq)++, channel))
1104static BOOL server_limits_buffered_chunks_until_verified(
void)
1107 ServerSent unverified = WINPR_C_ARRAY_INIT;
1108 ServerSent verified = WINPR_C_ARRAY_INIT;
1109 rdpUdp* a = server_accept(&unverified);
1110 rdpUdp* b = server_accept(&verified);
1113 rdpudp_set_peer_verified(b);
1119 if (!server_receive_data_aoa(a, 100, 129) || !server_receive_chunks(a, &seqA, 1, 128) ||
1120 !server_receive_data_aoa(b, 100, 129) || !server_receive_chunks(b, &seqB, 1, 128))
1124 rc = (unverified.delivered == 128) && (verified.delivered == 129);
1133static BOOL server_refuses_a_short_syn(
void)
1135 ServerSent sent = WINPR_C_ARRAY_INIT;
1136 rdpUdp* udp = rdpudp_new(WLog_Get(TAG),
nullptr, server_on_receive, &sent);
1141 server_make_syn(syn);
1142 const BOOL refused = !rdpudp_accept(udp, server_on_send, &sent, syn, 64) &&
1143 !rdpudp_accept(udp, server_on_send, &sent, syn,
sizeof(syn) - 1);
1144 BYTE hash[32] = WINPR_C_ARRAY_INIT;
1145 const BOOL noHash = !rdpudp_get_syn_cookie_hash(syn, 64, hash) &&
1146 rdpudp_get_syn_cookie_hash(syn,
sizeof(syn), hash);
1148 return refused && noHash && (sent.sends == 0);
1152static BOOL server_receive_ack(rdpUdp* udp, UINT16 ack)
1154 BYTE wire[32] = WINPR_C_ARRAY_INIT;
1155 wStream sbuffer = WINPR_C_ARRAY_INIT;
1156 wStream* s = Stream_StaticInit(&sbuffer, wire,
sizeof(wire));
1158 Stream_Write_UINT16(s, (UINT16)(V3_ACK | (15u << 12)));
1159 Stream_Write_UINT16(s, ack);
1161 Stream_Write_UINT8(s, 0);
1162 Stream_Write_UINT8(s, 0);
1163 const size_t length = Stream_GetPosition(s);
1164 wire[0] = (BYTE)((7 << 5) | (V3_TYPE_STANDARD << 1));
1165 const BYTE eighth = wire[7];
1168 return rdpudp_receive(udp, wire, length);
1175static BOOL server_repeats_ack_of_acks_until_the_first_ack(
void)
1178 ServerSent sent = WINPR_C_ARRAY_INIT;
1179 rdpUdp* udp = server_accept(&sent);
1183 for (
size_t x = 0; x < 3; x++)
1185 if (!rdpudp_send(udp, (
const BYTE*)
"abcd", 4))
1188 if (!server_run_timers(udp, 5) || (sent.dataSends != 3) || (sent.aoaSends != 3))
1190 (void)fprintf(stderr,
"before the ACK: %" PRIuz
" data, %" PRIuz
" with AckOfAcks\n",
1191 sent.dataSends, sent.aoaSends);
1196 if (!server_receive_ack(udp, 102))
1200 for (
size_t x = 0; x < 2; x++)
1202 if (!rdpudp_send(udp, (
const BYTE*)
"efgh", 4))
1205 if (!server_run_timers(udp, 5))
1207 rc = (sent.dataSends == 2) && (sent.aoaSends == 1);
1209 (void)fprintf(stderr,
"after the ACK: %" PRIuz
" data, %" PRIuz
" with AckOfAcks\n",
1210 sent.dataSends, sent.aoaSends);
1219static BOOL server_ignores_an_ack_past_what_it_sent(
void)
1222 ServerSent sent = WINPR_C_ARRAY_INIT;
1223 rdpUdp* udp = server_accept(&sent);
1227 for (
size_t x = 0; x < 3; x++)
1229 if (!rdpudp_send(udp, (
const BYTE*)
"abcd", 4))
1232 if (!server_run_timers(udp, 5) || (sent.dataSends != 3))
1236 if (!server_receive_ack(udp, 0x2000))
1239 if (!server_run_timers(udp, 1500))
1241 rc = (sent.dataSends >= 1);
1243 (void)fprintf(stderr,
"a forged ACK stopped the resends\n");
1252static BOOL server_keeps_what_lies_below_a_behind_report(
void)
1255 ServerSent sent = WINPR_C_ARRAY_INIT;
1256 rdpUdp* udp = server_accept(&sent);
1260 for (
size_t x = 0; x < 3; x++)
1262 if (!rdpudp_send(udp, (
const BYTE*)
"abcd", 4))
1265 if (!server_run_timers(udp, 5) || (sent.dataSends != 3))
1269 BYTE wire[32] = WINPR_C_ARRAY_INIT;
1270 wStream sbuffer = WINPR_C_ARRAY_INIT;
1271 wStream* s = Stream_StaticInit(&sbuffer, wire,
sizeof(wire));
1273 Stream_Write_UINT16(s, (UINT16)(V3_ACKVEC | (15u << 12)));
1274 Stream_Write_UINT16(s, 101);
1275 Stream_Write_UINT8(s, 1);
1276 Stream_Write_UINT8(s, 0x80 | 0x40 | 1);
1278 const size_t layout = Stream_GetPosition(s) - 1;
1279 const size_t length = 8;
1280 wire[0] = (BYTE)((layout << 5) | (V3_TYPE_STANDARD << 1));
1281 const BYTE eighth = wire[7];
1284 if (!rdpudp_receive(udp, wire, length))
1288 sent.watchedChannel = 1;
1289 sent.watchedSends = 0;
1290 if (!server_run_timers(udp, 1500))
1292 rc = (sent.watchedSends >= 1);
1294 (void)fprintf(stderr,
"the behind report acknowledged datagram 100\n");
1301static rdpUdp* server_accept_with_rtt(ServerSent* sent, UINT32 rttMs)
1303 rdpUdp* udp = server_accept(sent);
1306 g_serverTime += 1000000ULL * rttMs;
1307 if (!server_receive_data(udp, 100, 1) || (rdpudp_get_rtt(udp) != rttMs))
1309 (void)fprintf(stderr,
"round trip %" PRIu32
" ms after the handshake\n",
1310 rdpudp_get_rtt(udp));
1319static BOOL server_drops_an_oversized_chunk(
void)
1322 ServerSent sent = WINPR_C_ARRAY_INIT;
1323 rdpUdp* udp = server_accept(&sent);
1327 BYTE wire[2100] = WINPR_C_ARRAY_INIT;
1328 wStream sbuffer = WINPR_C_ARRAY_INIT;
1329 wStream* s = Stream_StaticInit(&sbuffer, wire,
sizeof(wire));
1331 Stream_Write_UINT16(s, (UINT16)(V3_DATA | V3_AOA | (15u << 12)));
1332 Stream_Write_UINT16(s, 100);
1333 Stream_Write_UINT16(s, 100);
1334 Stream_Write_UINT16(s, 1);
1335 Stream_Seek(s, 2049);
1336 const size_t length = Stream_GetPosition(s);
1337 wire[0] = (BYTE)((7 << 5) | (V3_TYPE_STANDARD << 1));
1338 const BYTE eighth = wire[7];
1342 const BOOL dropped = rdpudp_receive(udp, wire, length) && server_run_timers(udp, 100) &&
1343 (!sent.hasAck || (sent.ack != 100)) && (sent.delivered == 0);
1344 const BOOL resent = server_receive_data_aoa(udp, 100, 1) && server_run_timers(udp, 100) &&
1345 (sent.delivered == 1);
1346 rc = dropped && resent && sent.hasAck && (sent.ack == 100);
1348 (void)fprintf(stderr,
1349 "dropped %d, resent %d, ack %d of 0x%04" PRIx16
", %" PRIuz
" delivered\n",
1350 dropped, resent, sent.hasAck, sent.ack, sent.delivered);
1356static BOOL server_samples_the_rtt_from_the_handshake(
void)
1358 ServerSent sent = WINPR_C_ARRAY_INIT;
1359 rdpUdp* udp = server_accept_with_rtt(&sent, 120);
1368static BOOL server_follows_large_ack_of_acks_jumps(
void)
1371 ServerSent sent = WINPR_C_ARRAY_INIT;
1372 rdpUdp* udp = server_accept(&sent);
1377 const UINT16 seqs[] = { 100, 101, 30100, 30101, 50100, 50101 };
1378 for (
size_t x = 0; x < ARRAYSIZE(seqs); x++)
1380 const UINT16 channel = (UINT16)(1 + x);
1381 const BOOL ok = (x % 2 == 0) ? server_receive_data_aoa(udp, seqs[x], channel)
1382 : server_receive_data(udp, seqs[x], channel);
1386 if (!server_run_timers(udp, 100))
1388 rc = (sent.delivered == ARRAYSIZE(seqs)) && sent.hasAck && (sent.ack == 50101) &&
1398static BOOL server_does_not_find_a_skipped_slot_a_wrap_later(
void)
1401 ServerSent sent = WINPR_C_ARRAY_INIT;
1402 rdpUdp* udp = server_accept(&sent);
1407 if (!server_receive_data_aoa(udp, 100, 1) || !server_receive_data(udp, 105, 2) ||
1408 !server_receive_data_aoa(udp, 110, 3))
1411 if (!server_receive_data_aoa(udp, 30110, 4) || !server_receive_data_aoa(udp, 60110, 5) ||
1412 !server_receive_data_aoa(udp, 104, 6) || !server_run_timers(udp, 100))
1414 sent.hasAck = FALSE;
1415 sent.hasVector = FALSE;
1418 if (!server_receive_data(udp, 106, 7) || !server_run_timers(udp, 100))
1420 rc = sent.hasVector && (sent.vectorBase == 105) && !(sent.hasAck && (sent.ack == 106));
1431static BOOL server_keeps_its_window_when_acks_were_lost_in_a_silence(
void)
1434 ServerSent sent = WINPR_C_ARRAY_INIT;
1435 rdpUdp* udp = server_accept(&sent);
1439 if (!server_receive_data_aoa(udp, 100, 1) || !server_receive_data(udp, 101, 2) ||
1440 !server_receive_data(udp, 102, 3) || !server_run_timers(udp, 100) || !sent.hasAck ||
1445 if (!server_run_timers(udp, 9000))
1447 sent.hasAck = FALSE;
1448 sent.hasVector = FALSE;
1452 if (!server_receive_data_with_aoa(udp, 103, 4, 100) || !server_run_timers(udp, 100))
1454 rc = sent.hasAck && (sent.ack == 103) && !sent.hasVector && (sent.delivered == 4);
1456 (void)fprintf(stderr,
1457 "after the silence: ACK %d of 0x%04" PRIx16
", vector %d, %" PRIuz
1459 sent.hasAck, sent.ack, sent.hasVector, sent.delivered);
1469typedef UINT32 (*ServerRttFn)(UINT32 inFlight);
1471static BOOL server_run_paced(rdpUdp* udp, ServerSent* sent, ServerRttFn rttMs, UINT32 ms,
1472 UINT64 due[65536], UINT16* nextSeq, UINT16* acked,
size_t* window)
1475 for (UINT32 t = 0; t < ms; t += 5)
1477 while (rdpudp_get_send_backlog(udp) < 256)
1479 if (!rdpudp_send(udp, (
const BYTE*)
"abcd", 4))
1482 g_serverTime += 5ULL * 1000000ULL;
1483 if (!rdpudp_check(udp))
1486 while (sent->hasDataSeq && (UINT16)(sent->lastDataSeq + 1 - *nextSeq) != 0 &&
1487 (UINT16)(sent->lastDataSeq - *nextSeq) < 0x8000)
1489 const UINT32 inFlight = (UINT16)(*nextSeq - *acked);
1490 due[*nextSeq] = g_serverTime + 1000000ULL * rttMs(inFlight);
1494 UINT16 ack = *acked;
1495 while ((ack != *nextSeq) && (due[ack] <= g_serverTime))
1500 if (!server_receive_ack(udp, (UINT16)(ack - 1)))
1503 if ((ms - t <= 1000) && (rdpudp_get_send_window(udp) > *window))
1504 *window = rdpudp_get_send_window(udp);
1509static UINT32 rtt_2ms(WINPR_ATTR_UNUSED UINT32 inFlight)
1514static UINT32 rtt_100ms(WINPR_ATTR_UNUSED UINT32 inFlight)
1520static UINT32 rtt_queue(UINT32 inFlight)
1522 return 2 + inFlight / 10;
1526static UINT32 rtt_queue_100ms(UINT32 inFlight)
1528 return 100 + inFlight / 10;
1535static BOOL server_takes_a_lasting_delay_step_as_the_new_base(
void)
1538 ServerSent sent = WINPR_C_ARRAY_INIT;
1539 static UINT64 due[65536];
1540 UINT16 nextSeq = 100;
1544 rdpUdp* udp = server_accept(&sent);
1547 if (!server_receive_data_aoa(udp, 100, 1) ||
1548 !server_run_paced(udp, &sent, rtt_2ms, 3000, due, &nextSeq, &acked, &before) ||
1549 !server_run_paced(udp, &sent, rtt_100ms, 3000, due, &nextSeq, &acked, &after))
1551 rc = (before >= 1000) && (after * 2 >= before);
1553 (void)fprintf(stderr,
"send window %" PRIuz
" before the delay step, %" PRIuz
" after\n",
1564static BOOL server_keeps_cutting_for_its_own_queue(
void)
1567 ServerSent sent = WINPR_C_ARRAY_INIT;
1568 static UINT64 due[65536];
1569 UINT16 nextSeq = 100;
1572 rdpUdp* udp = server_accept(&sent);
1575 if (!server_receive_data_aoa(udp, 100, 1) ||
1576 !server_run_paced(udp, &sent, rtt_queue, 45000, due, &nextSeq, &acked, &window))
1579 rc = (window < 1000);
1581 (void)fprintf(stderr,
"send window %" PRIuz
" with a queue of its own\n", window);
1590static BOOL server_follows_the_base_delay_down(
void)
1593 ServerSent sent = WINPR_C_ARRAY_INIT;
1594 static UINT64 due[65536];
1595 UINT16 nextSeq = 100;
1598 rdpUdp* udp = server_accept(&sent);
1602 g_serverTime += 100ULL * 1000000ULL;
1603 if (!server_receive_data_aoa(udp, 100, 1) ||
1604 !server_run_paced(udp, &sent, rtt_queue_100ms, 5000, due, &nextSeq, &acked, &window) ||
1605 !server_run_paced(udp, &sent, rtt_queue, 30000, due, &nextSeq, &acked, &window))
1609 rc = (rdpudp_get_rtt(udp) < 48);
1611 (void)fprintf(stderr,
"round trip %" PRIu32
" ms after the delay fell to 2 ms\n",
1612 rdpudp_get_rtt(udp));
1621static BOOL server_waits_for_the_fourth_keepalive(
void)
1624 ServerSent sent = WINPR_C_ARRAY_INIT;
1625 rdpUdp* udp = server_accept(&sent);
1629 if (!server_receive_data_aoa(udp, 100, 1) || !server_run_timers(udp, 16060))
1631 sent.hasAck = FALSE;
1632 if (!server_receive_data_aoa(udp, 101, 2) || !server_run_timers(udp, 100))
1634 rc = (rdpudp_get_state(udp) == RDPUDP_STATE_ESTABLISHED) && sent.hasAck && (sent.ack == 101) &&
1635 (sent.delivered == 2);
1642static BOOL server_ends_a_silent_connection(
void)
1645 ServerSent sent = WINPR_C_ARRAY_INIT;
1646 rdpUdp* udp = server_accept(&sent);
1650 if (!server_run_timers(udp, 5000))
1652 for (
size_t x = 0; x < 60; x++)
1654 g_serverTime += 1000ULL * 1000000ULL;
1655 if (!rdpudp_check(udp))
1657 rc = rdpudp_get_state(udp) == RDPUDP_STATE_FAILED;
1668static BOOL server_takes_no_data_while_held(
void)
1671 ServerSent sent = WINPR_C_ARRAY_INIT;
1672 rdpUdp* udp = server_accept(&sent);
1676 if (!server_receive_data_aoa(udp, 100, 1) || !server_run_timers(udp, 100) || !sent.hasAck ||
1677 (sent.ack != 100) || (sent.delivered != 1))
1680 rdpudp_set_receive_hold(udp, TRUE);
1681 sent.hasAck = FALSE;
1682 if (!server_receive_data(udp, 101, 2) || !server_receive_data(udp, 102, 3) ||
1683 !server_receive_data(udp, 103, 4) || !server_run_timers(udp, 100))
1685 if (sent.hasAck || sent.hasVector || (sent.delivered != 1))
1687 (void)fprintf(stderr,
"held: ACK %d, vector %d, %" PRIuz
" delivered\n", sent.hasAck,
1688 sent.hasVector, sent.delivered);
1692 rdpudp_set_receive_hold(udp, FALSE);
1693 if (!server_receive_data(udp, 101, 2) || !server_receive_data(udp, 102, 3) ||
1694 !server_receive_data(udp, 103, 4) || !server_run_timers(udp, 100))
1696 rc = sent.hasAck && (sent.ack == 103) && !sent.hasVector && (sent.delivered == 4);
1698 (void)fprintf(stderr,
"released: ACK %d of 0x%04" PRIx16
", %" PRIuz
" delivered\n",
1699 sent.hasAck, sent.ack, sent.delivered);
1707static BOOL server_keepalive_after_a_silence_is_an_ack_of_acks(
void)
1710 ServerSent sent = WINPR_C_ARRAY_INIT;
1711 rdpUdp* udp = server_accept(&sent);
1715 if (!server_receive_data_aoa(udp, 100, 1) || !server_run_timers(udp, 100) || !sent.hasAck)
1718 sent.hasAck = FALSE;
1719 if (!server_run_timers(udp, 4500) || !sent.hasAck || (sent.baseSends != 0))
1723 if (!server_run_timers(udp, 4000))
1725 sent.hasAck = FALSE;
1726 sent.hasVector = FALSE;
1727 const size_t before = sent.sends;
1728 const size_t baseBefore = sent.baseSends;
1729 if (!server_run_timers(udp, 4500))
1731 const size_t bases = sent.baseSends - baseBefore;
1732 rc = (bases >= 1) && (sent.sends == before + bases) && !sent.hasAck && !sent.hasVector;
1734 (void)fprintf(stderr,
"after the silence: %" PRIuz
" AckOfAcks, %" PRIuz
" sent, ACK %d\n",
1735 bases, sent.sends - before, sent.hasAck);
1748 size_t loseToClient;
1749 size_t loseToServer;
1753static BOOL pair_on_send(
void* custom,
const BYTE* data,
size_t length)
1755 Pair* pair = custom;
1757 const size_t bases = pair->sent.baseSends;
1758 if (!server_on_send(&pair->sent, data, length))
1760 if ((pair->sent.baseSends != bases) && (pair->loseBases > 0))
1765 if (pair->loseToClient > 0)
1767 pair->loseToClient--;
1770 return server_send_raw(&pair->client, data, length);
1774static BOOL pair_run(Pair* pair, UINT32 ms)
1776 BYTE buffer[1500] = WINPR_C_ARRAY_INIT;
1777 for (UINT32 x = 0; x < ms; x += 10)
1779 g_serverTime += 10ULL * 1000000ULL;
1780 if (!rdpudp_check(pair->client.udp))
1783 while ((length = server_recv(&pair->client, buffer,
sizeof(buffer), 0)) > 0)
1785 if (pair->loseToServer > 0)
1787 pair->loseToServer--;
1790 if (!rdpudp_receive(pair->server, buffer, length))
1793 if (!rdpudp_check(pair->server))
1799static void pair_free(Pair* pair)
1801 rdpudp_free(pair->server);
1802 pair->server =
nullptr;
1803 ctx_free(&pair->client);
1807static BOOL pair_connect(Pair* pair)
1809 SynInfo syn = WINPR_C_ARRAY_INIT;
1810 if (!ctx_start(&pair->client, TRUE, &syn) || (syn.length >
sizeof(syn.raw)))
1813 g_serverTime = GetTickCount64() * 1000000ULL;
1814 rdpudp_set_clock(pair->client.udp, server_clock,
nullptr);
1816 pair->server = rdpudp_new(WLog_Get(TAG),
nullptr, server_on_receive, &pair->sent);
1819 rdpudp_set_clock(pair->server, server_clock,
nullptr);
1820 if (!rdpudp_accept(pair->server, pair_on_send, pair, syn.raw, syn.length))
1823 (x < 100) && (rdpudp_get_state(pair->client.udp) != RDPUDP_STATE_ESTABLISHED); x++)
1825 if (!pump(&pair->client))
1828 if (rdpudp_get_state(pair->client.udp) != RDPUDP_STATE_ESTABLISHED)
1831 if (!rdpudp_send(pair->client.udp, (
const BYTE*)
"c", 1) ||
1832 !rdpudp_send(pair->server, (
const BYTE*)
"s", 1))
1834 for (
size_t x = 0; (x < 100) && ((pair->sent.delivered < 1) ||
1835 (Stream_GetPosition(pair->client.delivered) < 1));
1839 if (!pair_run(pair, 10))
1842 return (pair->sent.delivered == 1) && delivered_is(&pair->client,
"s");
1849static BOOL idle_pair_survives(BOOL fromServer)
1852 Pair pair = WINPR_C_ARRAY_INIT;
1853 pair.client.server = INVALID_SOCKET;
1854 CHECK(pair_connect(&pair));
1855 CHECK(pair_run(&pair, 1000));
1858 pair.loseToClient = 1;
1860 pair.loseToServer = 1;
1862 CHECK(pair_run(&pair, 40000));
1863 CHECK((pair.loseToClient == 0) && (pair.loseToServer == 0));
1866 CHECK(rdpudp_send(pair.client.udp, (
const BYTE*)
"d", 1));
1867 CHECK(rdpudp_send(pair.server, (
const BYTE*)
"t", 1));
1868 for (
size_t x = 0; (x < 100) && ((pair.sent.delivered < 2) ||
1869 (Stream_GetPosition(pair.client.delivered) < 2));
1873 CHECK(pair_run(&pair, 10));
1875 CHECK(pair.sent.delivered == 2);
1876 CHECK(delivered_is(&pair.client,
"st"));
1887static BOOL idle_tunnel_survives_lost_wake_ups(
void)
1890 Pair pair = WINPR_C_ARRAY_INIT;
1891 pair.client.server = INVALID_SOCKET;
1892 CHECK(pair_connect(&pair));
1893 CHECK(pair_run(&pair, 1000));
1897 pair.loseToClient = 1;
1899 CHECK(pair_run(&pair, 40000));
1900 CHECK((pair.loseToClient == 0) && (pair.loseBases == 0));
1907static BOOL idle_tunnel_survives_a_lost_server_keepalive(
void)
1909 return idle_pair_survives(TRUE);
1912static BOOL idle_tunnel_survives_a_lost_client_keepalive(
void)
1914 return idle_pair_survives(FALSE);
1919static BOOL server_backs_off_once_for_many_timeouts(
void)
1922 ServerSent sent = WINPR_C_ARRAY_INIT;
1923 rdpUdp* udp = server_accept(&sent);
1928 for (
size_t x = 0; x < 8; x++)
1930 if (!rdpudp_send(udp, (
const BYTE*)
"abcd", 4))
1933 if (!server_run_timers(udp, 250))
1938 sent.watchedChannel = (UINT16)(sent.lastChannel + 1);
1939 sent.watchedSends = 0;
1940 if (!rdpudp_send(udp, (
const BYTE*)
"efgh", 4) || !server_run_timers(udp, 700))
1942 rc = sent.watchedSends >= 2;
1951static BOOL client_resends_at_least_every_two_seconds(
void)
1954 TestCtx ctx = WINPR_C_ARRAY_INIT;
1955 SynInfo syn = WINPR_C_ARRAY_INIT;
1956 CHECK(ctx_start(&ctx, TRUE, &syn));
1958 g_serverTime = GetTickCount64() * 1000000ULL;
1959 rdpudp_set_clock(ctx.udp, server_clock,
nullptr);
1960 CHECK(send_syn_ack(&ctx, syn.initialSequence, RDPUDP_PROTOCOL_VERSION_3));
1961 for (
size_t x = 0; (x < 100) && (rdpudp_get_state(ctx.udp) != RDPUDP_STATE_ESTABLISHED); x++)
1963 CHECK(rdpudp_get_state(ctx.udp) == RDPUDP_STATE_ESTABLISHED);
1965 CHECK(rdpudp_send(ctx.udp, (
const BYTE*)
"x", 1));
1966 CHECK(drain(&ctx, 20));
1967 CHECK(count_data(&ctx) == 1);
1970 UINT64 lastSend = g_serverTime;
1971 UINT64 longestGap = 0;
1973 for (
size_t step = 0; step < 1200; step++)
1975 g_serverTime += 10ULL * 1000000ULL;
1976 CHECK(rdpudp_check(ctx.udp));
1977 CHECK(drain(&ctx, 0));
1978 if (count_data(&ctx) == 0)
1980 const UINT64 gap = g_serverTime - lastSend;
1981 if (gap > longestGap)
1983 lastSend = g_serverTime;
1986 CHECK(resends >= 6);
1987 CHECK(longestGap <= 2000ULL * 1000000ULL);
1988 CHECK(g_serverTime - lastSend <= 2000ULL * 1000000ULL);
1998static BOOL ack_vector_is_not_lost_to_outgoing_data(
void)
2001 TestCtx ctx = WINPR_C_ARRAY_INIT;
2002 CHECK(ctx_connect(&ctx));
2004 const V3Out first = { .hasDelayAck = TRUE,
2005 .maxDelayedAcks = 8,
2006 .delayedAckTimeout = 200,
2010 .payload = (
const BYTE*)
"first",
2011 .payloadLength = 5 };
2012 CHECK(server_send_v3(&ctx, &first));
2016 CHECK(drain(&ctx, 20));
2017 CHECK(last_ack(&ctx));
2020 CHECK(send_data(&ctx, 100, 1,
"first"));
2022 CHECK(rdpudp_send(ctx.udp, (
const BYTE*)
"x", 1));
2023 CHECK(drain(&ctx, 20));
2024 const V3Packet* sent = first_data(&ctx);
2025 CHECK(sent && !(sent->flags & V3_ACK));
2030 CHECK(drain(&ctx, 20));
2031 BOOL vector = FALSE;
2032 for (
size_t x = 0; x < ctx.seenCount; x++)
2034 const V3Packet* p = &ctx.seen[x];
2035 if ((p->flags & V3_ACKVEC) && (p->vecBase == 100) && (p->vecLength == 1) &&
2036 (p->vec[0] == (0x80 | 0x40 | 1)))
2040 CHECK(delivered_is(&ctx,
"first"));
2049static BOOL retransmitted_channel_data_is_not_delivered_twice(
void)
2052 TestCtx ctx = WINPR_C_ARRAY_INIT;
2053 CHECK(ctx_connect(&ctx));
2054 CHECK(send_data(&ctx, 100, 1,
"a"));
2055 CHECK(send_data(&ctx, 101, 2,
"b"));
2056 CHECK(send_data(&ctx, 102, 2,
"b"));
2057 CHECK(send_data(&ctx, 103, 3,
"c"));
2059 CHECK(delivered_is(&ctx,
"abc"));
2066static BOOL gap_produces_an_ack_vector_rather_than_a_cumulative_ack(
void)
2069 TestCtx ctx = WINPR_C_ARRAY_INIT;
2070 CHECK(ctx_connect(&ctx));
2071 CHECK(send_data(&ctx, 100, 1,
"a"));
2072 CHECK(send_data(&ctx, 102, 3,
"c"));
2074 CHECK(drain(&ctx, 20));
2075 const V3Packet* ack = last_ack(&ctx);
2077 CHECK((ack->flags & V3_ACKVEC) && !(ack->flags & V3_ACK));
2078 CHECK(ack->vecBase == 101);
2080 CHECK((ack->vecLength == 1) && (ack->vec[0] == 0x02));
2087static BOOL ack_advertises_the_largest_window(
void)
2090 TestCtx ctx = WINPR_C_ARRAY_INIT;
2091 CHECK(ctx_connect(&ctx));
2092 CHECK(send_data(&ctx, 100, 1,
"a"));
2094 CHECK(drain(&ctx, 20));
2095 const V3Packet* ack = last_ack(&ctx);
2096 CHECK(ack && (ack->flags & V3_ACK) && (ack->ack == 100));
2098 CHECK(ack->logWindow == 15);
2107static BOOL channel_sequence_wraps_past_zero(
void)
2110 TestCtx ctx = WINPR_C_ARRAY_INIT;
2111 CHECK(ctx_connect(&ctx));
2112 UINT16 dataSeq = FIRST_SEQUENCE;
2114 CHECK(stream_ahead(&ctx, &dataSeq, &channel, 65534));
2115 CHECK(channel == 65535);
2116 const size_t before = Stream_GetPosition(ctx.delivered);
2117 CHECK(before == 65534);
2119 CHECK(send_data(&ctx, dataSeq, 65535,
"f"));
2120 CHECK(send_data(&ctx, (UINT16)(dataSeq + 1), 1,
"a"));
2122 CHECK(delivered_tail_is(&ctx, before,
"fa"));
2124 CHECK(send_data(&ctx, (UINT16)(dataSeq + 2), 2,
"b"));
2126 CHECK(delivered_tail_is(&ctx, before,
"fab"));
2135static BOOL real_server_ack_with_delayed_acks_and_data(
void)
2137 static const BYTE raw[] = { 0x00, 0x45, 0xf0, 0x66, 0x00, 0x03, 0x22, 0xe0,
2138 0x00, 0x01, 0x54, 0x08, 0xe0, 0x00, 0x02, 0x00,
2139 0x17, 0x03, 0x03, 0x00, 0x62, 0x56, 0x2c, 0x9f };
2141 TestCtx ctx = WINPR_C_ARRAY_INIT;
2142 CHECK(ctx_connect(&ctx));
2144 CHECK(send_data(&ctx, 223, 1,
"a"));
2145 CHECK(server_send_raw(&ctx, raw,
sizeof(raw)));
2147 CHECK(Stream_GetPosition(ctx.delivered) > 6);
2148 CHECK(memcmp(Stream_Buffer(ctx.delivered),
"a\x17\x03\x03\x00\x62", 6) == 0);
2164static BOOL ack_of_acks_reports_the_oldest_unacknowledged_packet(
void)
2167 TestCtx ctx = WINPR_C_ARRAY_INIT;
2168 CHECK(ctx_connect(&ctx));
2169 CHECK(rdpudp_send(ctx.udp, (
const BYTE*)
"1", 1));
2170 CHECK(drain(&ctx, 20));
2171 const V3Packet* sent = first_data(&ctx);
2172 CHECK(sent && sent->hasAoA && (sent->aoa == FIRST_SEQUENCE));
2175 CHECK(rdpudp_send(ctx.udp, (
const BYTE*)
"2", 1));
2176 CHECK(drain(&ctx, 20));
2177 sent = first_data(&ctx);
2178 CHECK(sent && sent->hasAoA && (sent->aoa == FIRST_SEQUENCE));
2180 CHECK(send_ack(&ctx, FIRST_SEQUENCE));
2182 CHECK(rdpudp_send(ctx.udp, (
const BYTE*)
"3", 1));
2183 CHECK(drain(&ctx, 20));
2184 sent = first_data(&ctx);
2185 CHECK(sent && sent->hasAoA && (sent->aoa == FIRST_SEQUENCE + 1));
2188 CHECK(rdpudp_send(ctx.udp, (
const BYTE*)
"4", 1));
2189 CHECK(drain(&ctx, 20));
2190 sent = first_data(&ctx);
2191 CHECK(sent && !sent->hasAoA);
2200static BOOL acknowledgements_survive_sequence_wraparound(
void)
2203 TestCtx ctx = WINPR_C_ARRAY_INIT;
2204 CHECK(ctx_connect(&ctx));
2207 UINT16 next = FIRST_SEQUENCE;
2208 while (next != 0xFFFE)
2210 const size_t batch = ((size_t)(0xFFFE - next) > 64) ? 64 : (size_t)(0xFFFE - next);
2211 for (
size_t x = 0; x < batch; x++)
2212 CHECK(rdpudp_send(ctx.udp, (
const BYTE*)
".", 1));
2213 CHECK(collect_data(&ctx, batch, 1000));
2214 next = (UINT16)(next + batch);
2215 CHECK(send_ack(&ctx, (UINT16)(next - 1)));
2220 for (
size_t x = 0; x < 4; x++)
2221 CHECK(rdpudp_send(ctx.udp, (
const BYTE*)
"w", 1));
2222 CHECK(collect_data(&ctx, 4, 1000));
2223 CHECK(send_ack(&ctx, 0x0000));
2229 CHECK(drain(&ctx, 20));
2230 CHECK(count_data(&ctx) == 1);
2231 const V3Packet* resent = first_data(&ctx);
2232 CHECK(resent && (resent->channelSeq == 0xFFFE - FIRST_SEQUENCE + 4));
2242static BOOL ack_of_acks_resyncs_after_a_silence(
void)
2245 TestCtx ctx = WINPR_C_ARRAY_INIT;
2246 CHECK(ctx_connect(&ctx));
2247 CHECK(send_data(&ctx, FIRST_SEQUENCE, 1,
"a"));
2249 CHECK(drain(&ctx, 20));
2250 const V3Packet* ack = last_ack(&ctx);
2251 CHECK(ack && (ack->flags & V3_ACK) && (ack->ack == FIRST_SEQUENCE));
2256 CHECK(drain(&ctx, 20));
2257 CHECK(last_ack(&ctx) ==
nullptr);
2261 const V3Out unannounced = { .dummy = TRUE,
2263 .dataSeq = FIRST_SEQUENCE + 1,
2264 .payload = (
const BYTE*)
"x",
2265 .payloadLength = 1 };
2266 CHECK(server_send_v3(&ctx, &unannounced));
2269 CHECK(rdpudp_get_timeout(ctx.udp) > 0);
2270 CHECK(drain(&ctx, 20));
2271 CHECK(last_ack(&ctx) ==
nullptr);
2273 const UINT16 ahead = (UINT16)(FIRST_SEQUENCE + 45000);
2274 const V3Out out = { .hasAoA = TRUE,
2279 .payload = (
const BYTE*)
"b",
2280 .payloadLength = 1 };
2281 CHECK(server_send_v3(&ctx, &out));
2283 CHECK(delivered_is(&ctx,
"ab"));
2284 CHECK(drain(&ctx, 20));
2285 ack = last_ack(&ctx);
2286 CHECK(ack && (ack->flags & V3_ACK) && (ack->ack == ahead));
2297static BOOL packets_past_a_wrap_are_acknowledged_on_their_own(
void)
2300 TestCtx ctx = WINPR_C_ARRAY_INIT;
2301 CHECK(ctx_connect(&ctx));
2302 CHECK(send_data(&ctx, FIRST_SEQUENCE, 1,
"a"));
2304 CHECK(drain(&ctx, 20));
2308 const UINT16 wrapped = (UINT16)(FIRST_SEQUENCE + 1 + 42530);
2309 const size_t total = 100;
2310 char expected[80] =
"a";
2311 for (
size_t x = 0; x < total; x++)
2313 const UINT16 seq = (UINT16)(wrapped + x);
2316 const char text[2] = { (char)(
'A' + (x % 26)),
'\0' };
2317 expected[x + 1] = text[0];
2318 CHECK(send_data_aoa(&ctx, seq, (UINT16)(2 + x), text, (UINT16)(wrapped - 6976)));
2322 const V3Out dummy = { .dummy = TRUE,
2326 .payload = (
const BYTE*)
"x",
2327 .payloadLength = 1 };
2328 CHECK(server_send_v3(&ctx, &dummy));
2334 CHECK(delivered_is(&ctx, expected));
2337 CHECK(drain(&ctx, 50));
2338 BOOL reported[100] = WINPR_C_ARRAY_INIT;
2340 for (
size_t x = 0; x < ctx.seenCount; x++)
2342 const V3Packet* p = &ctx.seen[x];
2343 CHECK(!(p->flags & V3_ACK) || (p->ack != FIRST_SEQUENCE));
2344 if (!(p->flags & V3_ACKVEC))
2347 size_t pos = (UINT16)(p->vecBase - wrapped);
2348 for (
size_t y = 0; y < p->vecLength; y++)
2351 CHECK((p->vec[y] & 0xC0) == 0xC0);
2352 for (
size_t z = 0; z < (p->vec[y] & 0x3F); z++)
2355 reported[pos++] = TRUE;
2359 for (
size_t x = 0; x < total; x++)
2362 CHECK(vectors < total / 4);
2371static BOOL piggybacked_ack_is_not_repeated_after_a_jump(
void)
2374 TestCtx ctx = WINPR_C_ARRAY_INIT;
2375 CHECK(ctx_connect(&ctx));
2377 const V3Out first = { .hasDelayAck = TRUE,
2378 .maxDelayedAcks = 8,
2379 .delayedAckTimeout = 200,
2381 .dataSeq = FIRST_SEQUENCE,
2383 .payload = (
const BYTE*)
"a",
2384 .payloadLength = 1 };
2385 CHECK(server_send_v3(&ctx, &first));
2387 CHECK(rdpudp_send(ctx.udp, (
const BYTE*)
"x", 1));
2388 CHECK(drain(&ctx, 20));
2389 const V3Packet* sent = first_data(&ctx);
2390 CHECK(sent && (sent->flags & V3_ACK) && (sent->ack == FIRST_SEQUENCE));
2391 CHECK(send_ack(&ctx, sent->dataSeq));
2394 const UINT16 wrapped = (UINT16)(FIRST_SEQUENCE + 1 + 42530);
2395 for (
size_t x = 0; x < 10; x++)
2396 CHECK(send_data_aoa(&ctx, (UINT16)(wrapped + x), (UINT16)(2 + x),
"b",
2397 (UINT16)(wrapped - 6976)));
2401 CHECK(drain(&ctx, 20));
2403 BOOL vector = FALSE;
2404 for (
size_t x = 0; x < ctx.seenCount; x++)
2406 const V3Packet* p = &ctx.seen[x];
2407 CHECK(!(p->flags & V3_ACK) || (p->ack != FIRST_SEQUENCE));
2408 if (p->flags & V3_ACKVEC)
2426static const TestCase cases[] = {
2427 {
"syn_offers_version_3_with_the_cookie_hash", syn_offers_version_3_with_the_cookie_hash },
2428 {
"syn_offers_version_2_without_a_cookie_hash", syn_offers_version_2_without_a_cookie_hash },
2429 {
"dummy_packets_are_acknowledged_but_not_delivered",
2430 dummy_packets_are_acknowledged_but_not_delivered },
2431 {
"retransmission_is_reordered_back_into_the_stream",
2432 retransmission_is_reordered_back_into_the_stream },
2433 {
"ack_of_acks_advances_the_window_without_touching_the_stream",
2434 ack_of_acks_advances_the_window_without_touching_the_stream },
2435 {
"ack_of_acks_on_its_own_is_answered", ack_of_acks_on_its_own_is_answered },
2436 {
"ack_of_acks_past_its_own_packet_keeps_the_chunk",
2437 ack_of_acks_past_its_own_packet_keeps_the_chunk },
2438 {
"ack_of_acks_past_its_own_packet_gets_no_ack_vector",
2439 ack_of_acks_past_its_own_packet_gets_no_ack_vector },
2440 {
"ack_of_acks_far_past_its_own_packet_keeps_the_chunk",
2441 ack_of_acks_far_past_its_own_packet_keeps_the_chunk },
2442 {
"server_backs_off_once_for_many_timeouts", server_backs_off_once_for_many_timeouts },
2443 {
"client_resends_at_least_every_two_seconds", client_resends_at_least_every_two_seconds },
2444 {
"server_limits_buffered_chunks_until_verified",
2445 server_limits_buffered_chunks_until_verified },
2446 {
"server_ends_a_silent_connection", server_ends_a_silent_connection },
2447 {
"server_waits_for_the_fourth_keepalive", server_waits_for_the_fourth_keepalive },
2448 {
"server_takes_no_data_while_held", server_takes_no_data_while_held },
2449 {
"server_takes_a_lasting_delay_step_as_the_new_base",
2450 server_takes_a_lasting_delay_step_as_the_new_base },
2451 {
"server_keeps_cutting_for_its_own_queue", server_keeps_cutting_for_its_own_queue },
2452 {
"server_follows_the_base_delay_down", server_follows_the_base_delay_down },
2453 {
"server_keepalive_after_a_silence_is_an_ack_of_acks",
2454 server_keepalive_after_a_silence_is_an_ack_of_acks },
2455 {
"idle_tunnel_survives_lost_wake_ups", idle_tunnel_survives_lost_wake_ups },
2456 {
"idle_tunnel_survives_a_lost_server_keepalive",
2457 idle_tunnel_survives_a_lost_server_keepalive },
2458 {
"idle_tunnel_survives_a_lost_client_keepalive",
2459 idle_tunnel_survives_a_lost_client_keepalive },
2460 {
"server_keeps_its_window_when_acks_were_lost_in_a_silence",
2461 server_keeps_its_window_when_acks_were_lost_in_a_silence },
2462 {
"server_refuses_a_short_syn", server_refuses_a_short_syn },
2463 {
"server_follows_large_ack_of_acks_jumps", server_follows_large_ack_of_acks_jumps },
2464 {
"server_does_not_find_a_skipped_slot_a_wrap_later",
2465 server_does_not_find_a_skipped_slot_a_wrap_later },
2466 {
"server_repeats_ack_of_acks_until_the_first_ack",
2467 server_repeats_ack_of_acks_until_the_first_ack },
2468 {
"server_ignores_an_ack_past_what_it_sent", server_ignores_an_ack_past_what_it_sent },
2469 {
"server_samples_the_rtt_from_the_handshake", server_samples_the_rtt_from_the_handshake },
2470 {
"server_drops_an_oversized_chunk", server_drops_an_oversized_chunk },
2471 {
"server_takes_its_base_from_an_ackofacks", server_takes_its_base_from_an_ackofacks },
2472 {
"server_keeps_what_lies_below_a_behind_report",
2473 server_keeps_what_lies_below_a_behind_report },
2474 {
"server_does_not_report_a_packet_behind_its_window",
2475 server_does_not_report_a_packet_behind_its_window },
2476 {
"late_packet_behind_the_window_fills_the_hole",
2477 late_packet_behind_the_window_fills_the_hole },
2478 {
"retransmitted_packets_are_acknowledged_again",
2479 retransmitted_packets_are_acknowledged_again },
2480 {
"ack_vector_is_not_lost_to_outgoing_data", ack_vector_is_not_lost_to_outgoing_data },
2481 {
"retransmitted_channel_data_is_not_delivered_twice",
2482 retransmitted_channel_data_is_not_delivered_twice },
2483 {
"gap_produces_an_ack_vector_rather_than_a_cumulative_ack",
2484 gap_produces_an_ack_vector_rather_than_a_cumulative_ack },
2485 {
"ack_advertises_the_largest_window", ack_advertises_the_largest_window },
2486 {
"channel_sequence_wraps_past_zero", channel_sequence_wraps_past_zero },
2487 {
"real_server_ack_with_delayed_acks_and_data", real_server_ack_with_delayed_acks_and_data },
2488 {
"ack_of_acks_reports_the_oldest_unacknowledged_packet",
2489 ack_of_acks_reports_the_oldest_unacknowledged_packet },
2490 {
"acknowledgements_survive_sequence_wraparound",
2491 acknowledgements_survive_sequence_wraparound },
2492 {
"ack_of_acks_resyncs_after_a_silence", ack_of_acks_resyncs_after_a_silence },
2493 {
"packets_past_a_wrap_are_acknowledged_on_their_own",
2494 packets_past_a_wrap_are_acknowledged_on_their_own },
2495 {
"piggybacked_ack_is_not_repeated_after_a_jump",
2496 piggybacked_ack_is_not_repeated_after_a_jump },
2499int TestRdpUdp(
int argc,
char* argv[])
2504 WSADATA wsaData = WINPR_C_ARRAY_INIT;
2505 if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
2509 for (
size_t x = 0; x < ARRAYSIZE(cases); x++)
2511 const BOOL ok = cases[x].fn();
2512 (void)printf(
"%s %s\n", ok ?
"ok " :
"FAILED", cases[x].name);
Layout layout(float leftWidth, float leftHeight, float rightWidth, float rightHeight, float width, float margin)