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_packets.h"
6
7 #include <memory>
8
9 #include "absl/memory/memory.h"
10 #include "quiche/quic/core/quic_time.h"
11 #include "quiche/quic/core/quic_types.h"
12 #include "quiche/quic/platform/api/quic_flags.h"
13 #include "quiche/quic/platform/api/quic_test.h"
14 #include "quiche/quic/test_tools/quic_test_utils.h"
15 #include "quiche/common/test_tools/quiche_test_utils.h"
16
17 namespace quic {
18 namespace test {
19 namespace {
20
CreateFakePacketHeader()21 QuicPacketHeader CreateFakePacketHeader() {
22 QuicPacketHeader header;
23 header.destination_connection_id = TestConnectionId(1);
24 header.destination_connection_id_included = CONNECTION_ID_PRESENT;
25 header.source_connection_id = TestConnectionId(2);
26 header.source_connection_id_included = CONNECTION_ID_ABSENT;
27 return header;
28 }
29
30 class QuicPacketsTest : public QuicTest {};
31
TEST_F(QuicPacketsTest,GetServerConnectionIdAsRecipient)32 TEST_F(QuicPacketsTest, GetServerConnectionIdAsRecipient) {
33 QuicPacketHeader header = CreateFakePacketHeader();
34 EXPECT_EQ(TestConnectionId(1),
35 GetServerConnectionIdAsRecipient(header, Perspective::IS_SERVER));
36 EXPECT_EQ(TestConnectionId(2),
37 GetServerConnectionIdAsRecipient(header, Perspective::IS_CLIENT));
38 }
39
TEST_F(QuicPacketsTest,GetServerConnectionIdAsSender)40 TEST_F(QuicPacketsTest, GetServerConnectionIdAsSender) {
41 QuicPacketHeader header = CreateFakePacketHeader();
42 EXPECT_EQ(TestConnectionId(2),
43 GetServerConnectionIdAsSender(header, Perspective::IS_SERVER));
44 EXPECT_EQ(TestConnectionId(1),
45 GetServerConnectionIdAsSender(header, Perspective::IS_CLIENT));
46 }
47
TEST_F(QuicPacketsTest,GetServerConnectionIdIncludedAsSender)48 TEST_F(QuicPacketsTest, GetServerConnectionIdIncludedAsSender) {
49 QuicPacketHeader header = CreateFakePacketHeader();
50 EXPECT_EQ(CONNECTION_ID_ABSENT, GetServerConnectionIdIncludedAsSender(
51 header, Perspective::IS_SERVER));
52 EXPECT_EQ(CONNECTION_ID_PRESENT, GetServerConnectionIdIncludedAsSender(
53 header, Perspective::IS_CLIENT));
54 }
55
TEST_F(QuicPacketsTest,GetClientConnectionIdIncludedAsSender)56 TEST_F(QuicPacketsTest, GetClientConnectionIdIncludedAsSender) {
57 QuicPacketHeader header = CreateFakePacketHeader();
58 EXPECT_EQ(CONNECTION_ID_PRESENT, GetClientConnectionIdIncludedAsSender(
59 header, Perspective::IS_SERVER));
60 EXPECT_EQ(CONNECTION_ID_ABSENT, GetClientConnectionIdIncludedAsSender(
61 header, Perspective::IS_CLIENT));
62 }
63
TEST_F(QuicPacketsTest,GetClientConnectionIdAsRecipient)64 TEST_F(QuicPacketsTest, GetClientConnectionIdAsRecipient) {
65 QuicPacketHeader header = CreateFakePacketHeader();
66 EXPECT_EQ(TestConnectionId(2),
67 GetClientConnectionIdAsRecipient(header, Perspective::IS_SERVER));
68 EXPECT_EQ(TestConnectionId(1),
69 GetClientConnectionIdAsRecipient(header, Perspective::IS_CLIENT));
70 }
71
TEST_F(QuicPacketsTest,GetClientConnectionIdAsSender)72 TEST_F(QuicPacketsTest, GetClientConnectionIdAsSender) {
73 QuicPacketHeader header = CreateFakePacketHeader();
74 EXPECT_EQ(TestConnectionId(1),
75 GetClientConnectionIdAsSender(header, Perspective::IS_SERVER));
76 EXPECT_EQ(TestConnectionId(2),
77 GetClientConnectionIdAsSender(header, Perspective::IS_CLIENT));
78 }
79
TEST_F(QuicPacketsTest,CopyQuicPacketHeader)80 TEST_F(QuicPacketsTest, CopyQuicPacketHeader) {
81 QuicPacketHeader header;
82 QuicPacketHeader header2 = CreateFakePacketHeader();
83 EXPECT_NE(header, header2);
84 QuicPacketHeader header3(header2);
85 EXPECT_EQ(header2, header3);
86 }
87
TEST_F(QuicPacketsTest,CopySerializedPacket)88 TEST_F(QuicPacketsTest, CopySerializedPacket) {
89 std::string buffer(1000, 'a');
90 quiche::SimpleBufferAllocator allocator;
91 SerializedPacket packet(QuicPacketNumber(1), PACKET_1BYTE_PACKET_NUMBER,
92 buffer.data(), buffer.length(), /*has_ack=*/false,
93 /*has_stop_waiting=*/false);
94 packet.retransmittable_frames.push_back(QuicFrame(QuicWindowUpdateFrame()));
95 packet.retransmittable_frames.push_back(QuicFrame(QuicStreamFrame()));
96
97 QuicAckFrame ack_frame(InitAckFrame(1));
98 packet.nonretransmittable_frames.push_back(QuicFrame(&ack_frame));
99 packet.nonretransmittable_frames.push_back(QuicFrame(QuicPaddingFrame(-1)));
100
101 std::unique_ptr<SerializedPacket> copy = absl::WrapUnique<SerializedPacket>(
102 CopySerializedPacket(packet, &allocator, /*copy_buffer=*/true));
103 EXPECT_EQ(quic::QuicPacketNumber(1), copy->packet_number);
104 EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, copy->packet_number_length);
105 ASSERT_EQ(2u, copy->retransmittable_frames.size());
106 EXPECT_EQ(WINDOW_UPDATE_FRAME, copy->retransmittable_frames[0].type);
107 EXPECT_EQ(STREAM_FRAME, copy->retransmittable_frames[1].type);
108
109 ASSERT_EQ(2u, copy->nonretransmittable_frames.size());
110 EXPECT_EQ(ACK_FRAME, copy->nonretransmittable_frames[0].type);
111 EXPECT_EQ(PADDING_FRAME, copy->nonretransmittable_frames[1].type);
112 EXPECT_EQ(1000u, copy->encrypted_length);
113 quiche::test::CompareCharArraysWithHexError(
114 "encrypted_buffer", copy->encrypted_buffer, copy->encrypted_length,
115 packet.encrypted_buffer, packet.encrypted_length);
116
117 std::unique_ptr<SerializedPacket> copy2 = absl::WrapUnique<SerializedPacket>(
118 CopySerializedPacket(packet, &allocator, /*copy_buffer=*/false));
119 EXPECT_EQ(packet.encrypted_buffer, copy2->encrypted_buffer);
120 EXPECT_EQ(1000u, copy2->encrypted_length);
121 }
122
TEST_F(QuicPacketsTest,CloneReceivedPacket)123 TEST_F(QuicPacketsTest, CloneReceivedPacket) {
124 char header[4] = "bar";
125 QuicReceivedPacket packet("foo", 3, QuicTime::Zero(), false, 0, true, header,
126 sizeof(header) - 1, false,
127 QuicEcnCodepoint::ECN_ECT1);
128 std::unique_ptr<QuicReceivedPacket> copy = packet.Clone();
129 EXPECT_EQ(packet.ecn_codepoint(), copy->ecn_codepoint());
130 }
131
132 } // namespace
133 } // namespace test
134 } // namespace quic
135