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