1 // Copyright (c) 2019 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "quiche/quic/core/quic_coalesced_packet.h"
6
7 #include "quiche/quic/platform/api/quic_expect_bug.h"
8 #include "quiche/quic/platform/api/quic_test.h"
9 #include "quiche/quic/test_tools/quic_test_utils.h"
10 #include "quiche/common/test_tools/quiche_test_utils.h"
11
12 namespace quic {
13 namespace test {
14 namespace {
15
TEST(QuicCoalescedPacketTest,MaybeCoalescePacket)16 TEST(QuicCoalescedPacketTest, MaybeCoalescePacket) {
17 QuicCoalescedPacket coalesced;
18 EXPECT_EQ("total_length: 0 padding_size: 0 packets: {}",
19 coalesced.ToString(0));
20 quiche::SimpleBufferAllocator allocator;
21 EXPECT_EQ(0u, coalesced.length());
22 EXPECT_EQ(0u, coalesced.NumberOfPackets());
23 char buffer[1000];
24 QuicSocketAddress self_address(QuicIpAddress::Loopback4(), 1);
25 QuicSocketAddress peer_address(QuicIpAddress::Loopback4(), 2);
26 SerializedPacket packet1(QuicPacketNumber(1), PACKET_4BYTE_PACKET_NUMBER,
27 buffer, 500, false, false);
28 packet1.transmission_type = PTO_RETRANSMISSION;
29 QuicAckFrame ack_frame(InitAckFrame(1));
30 packet1.nonretransmittable_frames.push_back(QuicFrame(&ack_frame));
31 packet1.retransmittable_frames.push_back(
32 QuicFrame(QuicStreamFrame(1, true, 0, 100)));
33 ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet1, self_address, peer_address,
34 &allocator, 1500, ECN_NOT_ECT));
35 EXPECT_EQ(PTO_RETRANSMISSION,
36 coalesced.TransmissionTypeOfPacket(ENCRYPTION_INITIAL));
37 EXPECT_EQ(1500u, coalesced.max_packet_length());
38 EXPECT_EQ(500u, coalesced.length());
39 EXPECT_EQ(1u, coalesced.NumberOfPackets());
40 EXPECT_EQ(
41 "total_length: 1500 padding_size: 1000 packets: {ENCRYPTION_INITIAL}",
42 coalesced.ToString(1500));
43 EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
44
45 // Cannot coalesce packet of the same encryption level.
46 SerializedPacket packet2(QuicPacketNumber(2), PACKET_4BYTE_PACKET_NUMBER,
47 buffer, 500, false, false);
48 EXPECT_FALSE(coalesced.MaybeCoalescePacket(
49 packet2, self_address, peer_address, &allocator, 1500, ECN_NOT_ECT));
50 EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
51
52 SerializedPacket packet3(QuicPacketNumber(3), PACKET_4BYTE_PACKET_NUMBER,
53 buffer, 500, false, false);
54 packet3.nonretransmittable_frames.push_back(QuicFrame(QuicPaddingFrame(100)));
55 packet3.encryption_level = ENCRYPTION_ZERO_RTT;
56 packet3.transmission_type = LOSS_RETRANSMISSION;
57 ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet3, self_address, peer_address,
58 &allocator, 1500, ECN_NOT_ECT));
59 EXPECT_EQ(1500u, coalesced.max_packet_length());
60 EXPECT_EQ(1000u, coalesced.length());
61 EXPECT_EQ(2u, coalesced.NumberOfPackets());
62 EXPECT_EQ(LOSS_RETRANSMISSION,
63 coalesced.TransmissionTypeOfPacket(ENCRYPTION_ZERO_RTT));
64 EXPECT_EQ(
65 "total_length: 1500 padding_size: 500 packets: {ENCRYPTION_INITIAL, "
66 "ENCRYPTION_ZERO_RTT}",
67 coalesced.ToString(1500));
68 EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
69
70 SerializedPacket packet4(QuicPacketNumber(4), PACKET_4BYTE_PACKET_NUMBER,
71 buffer, 500, false, false);
72 packet4.encryption_level = ENCRYPTION_FORWARD_SECURE;
73 // Cannot coalesce packet of changed self/peer address.
74 EXPECT_FALSE(coalesced.MaybeCoalescePacket(
75 packet4, QuicSocketAddress(QuicIpAddress::Loopback4(), 3), peer_address,
76 &allocator, 1500, ECN_NOT_ECT));
77
78 // Packet does not fit.
79 SerializedPacket packet5(QuicPacketNumber(5), PACKET_4BYTE_PACKET_NUMBER,
80 buffer, 501, false, false);
81 packet5.encryption_level = ENCRYPTION_FORWARD_SECURE;
82 EXPECT_FALSE(coalesced.MaybeCoalescePacket(
83 packet5, self_address, peer_address, &allocator, 1500, ECN_NOT_ECT));
84 EXPECT_EQ(1500u, coalesced.max_packet_length());
85 EXPECT_EQ(1000u, coalesced.length());
86 EXPECT_EQ(2u, coalesced.NumberOfPackets());
87 EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
88
89 // Max packet number length changed.
90 SerializedPacket packet6(QuicPacketNumber(6), PACKET_4BYTE_PACKET_NUMBER,
91 buffer, 100, false, false);
92 packet6.encryption_level = ENCRYPTION_FORWARD_SECURE;
93 EXPECT_QUIC_BUG(
94 coalesced.MaybeCoalescePacket(packet6, self_address, peer_address,
95 &allocator, 1000, ECN_NOT_ECT),
96 "Max packet length changes in the middle of the write path");
97 EXPECT_EQ(1500u, coalesced.max_packet_length());
98 EXPECT_EQ(1000u, coalesced.length());
99 EXPECT_EQ(2u, coalesced.NumberOfPackets());
100 EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
101 }
102
TEST(QuicCoalescedPacketTest,CopyEncryptedBuffers)103 TEST(QuicCoalescedPacketTest, CopyEncryptedBuffers) {
104 QuicCoalescedPacket coalesced;
105 quiche::SimpleBufferAllocator allocator;
106 QuicSocketAddress self_address(QuicIpAddress::Loopback4(), 1);
107 QuicSocketAddress peer_address(QuicIpAddress::Loopback4(), 2);
108 std::string buffer(500, 'a');
109 std::string buffer2(500, 'b');
110 SerializedPacket packet1(QuicPacketNumber(1), PACKET_4BYTE_PACKET_NUMBER,
111 buffer.data(), 500,
112 /*has_ack=*/false, /*has_stop_waiting=*/false);
113 packet1.encryption_level = ENCRYPTION_ZERO_RTT;
114 SerializedPacket packet2(QuicPacketNumber(2), PACKET_4BYTE_PACKET_NUMBER,
115 buffer2.data(), 500,
116 /*has_ack=*/false, /*has_stop_waiting=*/false);
117 packet2.encryption_level = ENCRYPTION_FORWARD_SECURE;
118
119 ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet1, self_address, peer_address,
120 &allocator, 1500, ECN_NOT_ECT));
121 ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet2, self_address, peer_address,
122 &allocator, 1500, ECN_NOT_ECT));
123 EXPECT_EQ(1000u, coalesced.length());
124 EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
125
126 char copy_buffer[1000];
127 size_t length_copied = 0;
128 EXPECT_FALSE(
129 coalesced.CopyEncryptedBuffers(copy_buffer, 900, &length_copied));
130 ASSERT_TRUE(
131 coalesced.CopyEncryptedBuffers(copy_buffer, 1000, &length_copied));
132 EXPECT_EQ(1000u, length_copied);
133 char expected[1000];
134 memset(expected, 'a', 500);
135 memset(expected + 500, 'b', 500);
136 quiche::test::CompareCharArraysWithHexError("copied buffers", copy_buffer,
137 length_copied, expected, 1000);
138 }
139
TEST(QuicCoalescedPacketTest,NeuterInitialPacket)140 TEST(QuicCoalescedPacketTest, NeuterInitialPacket) {
141 QuicCoalescedPacket coalesced;
142 EXPECT_EQ("total_length: 0 padding_size: 0 packets: {}",
143 coalesced.ToString(0));
144 // Noop when neutering initial packet on a empty coalescer.
145 coalesced.NeuterInitialPacket();
146 EXPECT_EQ("total_length: 0 padding_size: 0 packets: {}",
147 coalesced.ToString(0));
148
149 quiche::SimpleBufferAllocator allocator;
150 EXPECT_EQ(0u, coalesced.length());
151 char buffer[1000];
152 QuicSocketAddress self_address(QuicIpAddress::Loopback4(), 1);
153 QuicSocketAddress peer_address(QuicIpAddress::Loopback4(), 2);
154 SerializedPacket packet1(QuicPacketNumber(1), PACKET_4BYTE_PACKET_NUMBER,
155 buffer, 500, false, false);
156 packet1.transmission_type = PTO_RETRANSMISSION;
157 QuicAckFrame ack_frame(InitAckFrame(1));
158 packet1.nonretransmittable_frames.push_back(QuicFrame(&ack_frame));
159 packet1.retransmittable_frames.push_back(
160 QuicFrame(QuicStreamFrame(1, true, 0, 100)));
161 ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet1, self_address, peer_address,
162 &allocator, 1500, ECN_NOT_ECT));
163 EXPECT_EQ(PTO_RETRANSMISSION,
164 coalesced.TransmissionTypeOfPacket(ENCRYPTION_INITIAL));
165 EXPECT_EQ(1500u, coalesced.max_packet_length());
166 EXPECT_EQ(500u, coalesced.length());
167 EXPECT_EQ(
168 "total_length: 1500 padding_size: 1000 packets: {ENCRYPTION_INITIAL}",
169 coalesced.ToString(1500));
170 EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
171 coalesced.NeuterInitialPacket();
172 EXPECT_EQ(0u, coalesced.max_packet_length());
173 EXPECT_EQ(0u, coalesced.length());
174 EXPECT_EQ("total_length: 0 padding_size: 0 packets: {}",
175 coalesced.ToString(0));
176 EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
177
178 // Coalesce initial packet again.
179 ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet1, self_address, peer_address,
180 &allocator, 1500, ECN_NOT_ECT));
181
182 SerializedPacket packet2(QuicPacketNumber(3), PACKET_4BYTE_PACKET_NUMBER,
183 buffer, 500, false, false);
184 packet2.nonretransmittable_frames.push_back(QuicFrame(QuicPaddingFrame(100)));
185 packet2.encryption_level = ENCRYPTION_ZERO_RTT;
186 packet2.transmission_type = LOSS_RETRANSMISSION;
187 ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet2, self_address, peer_address,
188 &allocator, 1500, ECN_NOT_ECT));
189 EXPECT_EQ(1500u, coalesced.max_packet_length());
190 EXPECT_EQ(1000u, coalesced.length());
191 EXPECT_EQ(LOSS_RETRANSMISSION,
192 coalesced.TransmissionTypeOfPacket(ENCRYPTION_ZERO_RTT));
193 EXPECT_EQ(
194 "total_length: 1500 padding_size: 500 packets: {ENCRYPTION_INITIAL, "
195 "ENCRYPTION_ZERO_RTT}",
196 coalesced.ToString(1500));
197 EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
198
199 // Neuter initial packet.
200 coalesced.NeuterInitialPacket();
201 EXPECT_EQ(1500u, coalesced.max_packet_length());
202 EXPECT_EQ(500u, coalesced.length());
203 EXPECT_EQ(
204 "total_length: 1500 padding_size: 1000 packets: {ENCRYPTION_ZERO_RTT}",
205 coalesced.ToString(1500));
206 EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
207
208 SerializedPacket packet3(QuicPacketNumber(5), PACKET_4BYTE_PACKET_NUMBER,
209 buffer, 501, false, false);
210 packet3.encryption_level = ENCRYPTION_FORWARD_SECURE;
211 EXPECT_TRUE(coalesced.MaybeCoalescePacket(packet3, self_address, peer_address,
212 &allocator, 1500, ECN_NOT_ECT));
213 EXPECT_EQ(1500u, coalesced.max_packet_length());
214 EXPECT_EQ(1001u, coalesced.length());
215 EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
216 // Neuter initial packet.
217 coalesced.NeuterInitialPacket();
218 EXPECT_EQ(1500u, coalesced.max_packet_length());
219 EXPECT_EQ(1001u, coalesced.length());
220 EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
221 }
222
TEST(QuicCoalescedPacketTest,DoNotCoalesceDifferentEcn)223 TEST(QuicCoalescedPacketTest, DoNotCoalesceDifferentEcn) {
224 QuicCoalescedPacket coalesced;
225 EXPECT_EQ("total_length: 0 padding_size: 0 packets: {}",
226 coalesced.ToString(0));
227 quiche::SimpleBufferAllocator allocator;
228 EXPECT_EQ(0u, coalesced.length());
229 EXPECT_EQ(0u, coalesced.NumberOfPackets());
230 char buffer[1000];
231 QuicSocketAddress self_address(QuicIpAddress::Loopback4(), 1);
232 QuicSocketAddress peer_address(QuicIpAddress::Loopback4(), 2);
233 SerializedPacket packet1(QuicPacketNumber(1), PACKET_4BYTE_PACKET_NUMBER,
234 buffer, 500, false, false);
235 packet1.transmission_type = PTO_RETRANSMISSION;
236 QuicAckFrame ack_frame(InitAckFrame(1));
237 packet1.nonretransmittable_frames.push_back(QuicFrame(&ack_frame));
238 packet1.retransmittable_frames.push_back(
239 QuicFrame(QuicStreamFrame(1, true, 0, 100)));
240 ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet1, self_address, peer_address,
241 &allocator, 1500, ECN_ECT1));
242 EXPECT_EQ(coalesced.ecn_codepoint(), ECN_ECT1);
243
244 SerializedPacket packet2(QuicPacketNumber(2), PACKET_4BYTE_PACKET_NUMBER,
245 buffer, 500, false, false);
246 packet2.nonretransmittable_frames.push_back(QuicFrame(QuicPaddingFrame(100)));
247 packet2.encryption_level = ENCRYPTION_ZERO_RTT;
248 packet2.transmission_type = LOSS_RETRANSMISSION;
249 EXPECT_FALSE(coalesced.MaybeCoalescePacket(
250 packet2, self_address, peer_address, &allocator, 1500, ECN_NOT_ECT));
251 EXPECT_EQ(coalesced.ecn_codepoint(), ECN_ECT1);
252 }
253
254 } // namespace
255 } // namespace test
256 } // namespace quic
257