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 "net/third_party/quiche/src/quic/core/quic_coalesced_packet.h"
6
7 #include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
8 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
9 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
10 #include "net/third_party/quiche/src/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 SimpleBufferAllocator allocator;
21 EXPECT_EQ(0u, coalesced.length());
22 char buffer[1000];
23 QuicSocketAddress self_address(QuicIpAddress::Loopback4(), 1);
24 QuicSocketAddress peer_address(QuicIpAddress::Loopback4(), 2);
25 SerializedPacket packet1(QuicPacketNumber(1), PACKET_4BYTE_PACKET_NUMBER,
26 buffer, 500, false, false);
27 packet1.transmission_type = PTO_RETRANSMISSION;
28 QuicAckFrame ack_frame(InitAckFrame(1));
29 packet1.nonretransmittable_frames.push_back(QuicFrame(&ack_frame));
30 packet1.retransmittable_frames.push_back(
31 QuicFrame(QuicStreamFrame(1, true, 0, 100)));
32 ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet1, self_address, peer_address,
33 &allocator, 1500));
34 EXPECT_EQ(PTO_RETRANSMISSION,
35 coalesced.TransmissionTypeOfPacket(ENCRYPTION_INITIAL));
36 EXPECT_EQ(1500u, coalesced.max_packet_length());
37 EXPECT_EQ(500u, coalesced.length());
38 EXPECT_EQ(
39 "total_length: 1500 padding_size: 1000 packets: {ENCRYPTION_INITIAL}",
40 coalesced.ToString(1500));
41
42 // Cannot coalesce packet of the same encryption level.
43 SerializedPacket packet2(QuicPacketNumber(2), PACKET_4BYTE_PACKET_NUMBER,
44 buffer, 500, false, false);
45 EXPECT_FALSE(coalesced.MaybeCoalescePacket(packet2, self_address,
46 peer_address, &allocator, 1500));
47
48 SerializedPacket packet3(QuicPacketNumber(3), PACKET_4BYTE_PACKET_NUMBER,
49 buffer, 500, false, false);
50 packet3.nonretransmittable_frames.push_back(QuicFrame(QuicPaddingFrame(100)));
51 packet3.encryption_level = ENCRYPTION_ZERO_RTT;
52 packet3.transmission_type = LOSS_RETRANSMISSION;
53 ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet3, self_address, peer_address,
54 &allocator, 1500));
55 EXPECT_EQ(1500u, coalesced.max_packet_length());
56 EXPECT_EQ(1000u, coalesced.length());
57 EXPECT_EQ(LOSS_RETRANSMISSION,
58 coalesced.TransmissionTypeOfPacket(ENCRYPTION_ZERO_RTT));
59 EXPECT_EQ(
60 "total_length: 1500 padding_size: 500 packets: {ENCRYPTION_INITIAL, "
61 "ENCRYPTION_ZERO_RTT}",
62 coalesced.ToString(1500));
63
64 SerializedPacket packet4(QuicPacketNumber(4), PACKET_4BYTE_PACKET_NUMBER,
65 buffer, 500, false, false);
66 packet4.encryption_level = ENCRYPTION_FORWARD_SECURE;
67 // Cannot coalesce packet of changed self/peer address.
68 EXPECT_FALSE(coalesced.MaybeCoalescePacket(
69 packet4, QuicSocketAddress(QuicIpAddress::Loopback4(), 3), peer_address,
70 &allocator, 1500));
71
72 // Packet does not fit.
73 SerializedPacket packet5(QuicPacketNumber(5), PACKET_4BYTE_PACKET_NUMBER,
74 buffer, 501, false, false);
75 packet5.encryption_level = ENCRYPTION_FORWARD_SECURE;
76 EXPECT_FALSE(coalesced.MaybeCoalescePacket(packet5, self_address,
77 peer_address, &allocator, 1500));
78 EXPECT_EQ(1500u, coalesced.max_packet_length());
79 EXPECT_EQ(1000u, coalesced.length());
80
81 // Max packet number length changed.
82 SerializedPacket packet6(QuicPacketNumber(6), PACKET_4BYTE_PACKET_NUMBER,
83 buffer, 100, false, false);
84 packet6.encryption_level = ENCRYPTION_FORWARD_SECURE;
85 EXPECT_QUIC_BUG(coalesced.MaybeCoalescePacket(packet6, self_address,
86 peer_address, &allocator, 1000),
87 "Max packet length changes in the middle of the write path");
88 EXPECT_EQ(1500u, coalesced.max_packet_length());
89 EXPECT_EQ(1000u, coalesced.length());
90 }
91
TEST(QuicCoalescedPacketTest,CopyEncryptedBuffers)92 TEST(QuicCoalescedPacketTest, CopyEncryptedBuffers) {
93 QuicCoalescedPacket coalesced;
94 SimpleBufferAllocator allocator;
95 QuicSocketAddress self_address(QuicIpAddress::Loopback4(), 1);
96 QuicSocketAddress peer_address(QuicIpAddress::Loopback4(), 2);
97 std::string buffer(500, 'a');
98 std::string buffer2(500, 'b');
99 SerializedPacket packet1(QuicPacketNumber(1), PACKET_4BYTE_PACKET_NUMBER,
100 buffer.data(), 500,
101 /*has_ack=*/false, /*has_stop_waiting=*/false);
102 packet1.encryption_level = ENCRYPTION_ZERO_RTT;
103 SerializedPacket packet2(QuicPacketNumber(2), PACKET_4BYTE_PACKET_NUMBER,
104 buffer2.data(), 500,
105 /*has_ack=*/false, /*has_stop_waiting=*/false);
106 packet2.encryption_level = ENCRYPTION_FORWARD_SECURE;
107
108 ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet1, self_address, peer_address,
109 &allocator, 1500));
110 ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet2, self_address, peer_address,
111 &allocator, 1500));
112 EXPECT_EQ(1000u, coalesced.length());
113
114 char copy_buffer[1000];
115 size_t length_copied = 0;
116 EXPECT_FALSE(
117 coalesced.CopyEncryptedBuffers(copy_buffer, 900, &length_copied));
118 ASSERT_TRUE(
119 coalesced.CopyEncryptedBuffers(copy_buffer, 1000, &length_copied));
120 EXPECT_EQ(1000u, length_copied);
121 char expected[1000];
122 memset(expected, 'a', 500);
123 memset(expected + 500, 'b', 500);
124 quiche::test::CompareCharArraysWithHexError("copied buffers", copy_buffer,
125 length_copied, expected, 1000);
126 }
127
TEST(QuicCoalescedPacketTest,NeuterInitialPacket)128 TEST(QuicCoalescedPacketTest, NeuterInitialPacket) {
129 QuicCoalescedPacket coalesced;
130 EXPECT_EQ("total_length: 0 padding_size: 0 packets: {}",
131 coalesced.ToString(0));
132 // Noop when neutering initial packet on a empty coalescer.
133 coalesced.NeuterInitialPacket();
134 EXPECT_EQ("total_length: 0 padding_size: 0 packets: {}",
135 coalesced.ToString(0));
136
137 SimpleBufferAllocator allocator;
138 EXPECT_EQ(0u, coalesced.length());
139 char buffer[1000];
140 QuicSocketAddress self_address(QuicIpAddress::Loopback4(), 1);
141 QuicSocketAddress peer_address(QuicIpAddress::Loopback4(), 2);
142 SerializedPacket packet1(QuicPacketNumber(1), PACKET_4BYTE_PACKET_NUMBER,
143 buffer, 500, false, false);
144 packet1.transmission_type = PTO_RETRANSMISSION;
145 QuicAckFrame ack_frame(InitAckFrame(1));
146 packet1.nonretransmittable_frames.push_back(QuicFrame(&ack_frame));
147 packet1.retransmittable_frames.push_back(
148 QuicFrame(QuicStreamFrame(1, true, 0, 100)));
149 ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet1, self_address, peer_address,
150 &allocator, 1500));
151 EXPECT_EQ(PTO_RETRANSMISSION,
152 coalesced.TransmissionTypeOfPacket(ENCRYPTION_INITIAL));
153 EXPECT_EQ(1500u, coalesced.max_packet_length());
154 EXPECT_EQ(500u, coalesced.length());
155 EXPECT_EQ(
156 "total_length: 1500 padding_size: 1000 packets: {ENCRYPTION_INITIAL}",
157 coalesced.ToString(1500));
158 // Neuter initial packet.
159 coalesced.NeuterInitialPacket();
160 EXPECT_EQ(0u, coalesced.max_packet_length());
161 EXPECT_EQ(0u, coalesced.length());
162 EXPECT_EQ("total_length: 0 padding_size: 0 packets: {}",
163 coalesced.ToString(0));
164
165 // Coalesce initial packet again.
166 ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet1, self_address, peer_address,
167 &allocator, 1500));
168
169 SerializedPacket packet2(QuicPacketNumber(3), PACKET_4BYTE_PACKET_NUMBER,
170 buffer, 500, false, false);
171 packet2.nonretransmittable_frames.push_back(QuicFrame(QuicPaddingFrame(100)));
172 packet2.encryption_level = ENCRYPTION_ZERO_RTT;
173 packet2.transmission_type = LOSS_RETRANSMISSION;
174 ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet2, self_address, peer_address,
175 &allocator, 1500));
176 EXPECT_EQ(1500u, coalesced.max_packet_length());
177 EXPECT_EQ(1000u, coalesced.length());
178 EXPECT_EQ(LOSS_RETRANSMISSION,
179 coalesced.TransmissionTypeOfPacket(ENCRYPTION_ZERO_RTT));
180 EXPECT_EQ(
181 "total_length: 1500 padding_size: 500 packets: {ENCRYPTION_INITIAL, "
182 "ENCRYPTION_ZERO_RTT}",
183 coalesced.ToString(1500));
184
185 // Neuter initial packet.
186 coalesced.NeuterInitialPacket();
187 EXPECT_EQ(1500u, coalesced.max_packet_length());
188 EXPECT_EQ(500u, coalesced.length());
189 EXPECT_EQ(
190 "total_length: 1500 padding_size: 1000 packets: {ENCRYPTION_ZERO_RTT}",
191 coalesced.ToString(1500));
192
193 SerializedPacket packet3(QuicPacketNumber(5), PACKET_4BYTE_PACKET_NUMBER,
194 buffer, 501, false, false);
195 packet3.encryption_level = ENCRYPTION_FORWARD_SECURE;
196 EXPECT_TRUE(coalesced.MaybeCoalescePacket(packet3, self_address, peer_address,
197 &allocator, 1500));
198 EXPECT_EQ(1500u, coalesced.max_packet_length());
199 EXPECT_EQ(1001u, coalesced.length());
200 // Neuter initial packet.
201 coalesced.NeuterInitialPacket();
202 EXPECT_EQ(1500u, coalesced.max_packet_length());
203 EXPECT_EQ(1001u, coalesced.length());
204 }
205
206 } // namespace
207 } // namespace test
208 } // namespace quic
209