1 // Copyright 2013 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/quic/test_tools/quic_test_packet_maker.h" 6 7 #include "net/quic/quic_framer.h" 8 #include "net/quic/quic_http_utils.h" 9 #include "net/quic/quic_utils.h" 10 #include "net/quic/test_tools/quic_test_utils.h" 11 12 namespace net { 13 namespace test { 14 15 QuicTestPacketMaker::QuicTestPacketMaker(QuicVersion version, 16 QuicConnectionId connection_id) 17 : version_(version), 18 connection_id_(connection_id), 19 spdy_request_framer_(SPDY3), 20 spdy_response_framer_(SPDY3) { 21 } 22 23 QuicTestPacketMaker::~QuicTestPacketMaker() { 24 } 25 26 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeRstPacket( 27 QuicPacketSequenceNumber num, 28 bool include_version, 29 QuicStreamId stream_id, 30 QuicRstStreamErrorCode error_code) { 31 QuicPacketHeader header; 32 header.public_header.connection_id = connection_id_; 33 header.public_header.reset_flag = false; 34 header.public_header.version_flag = include_version; 35 header.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER; 36 header.packet_sequence_number = num; 37 header.entropy_flag = false; 38 header.fec_flag = false; 39 header.fec_group = 0; 40 41 QuicRstStreamFrame rst(stream_id, error_code, 0); 42 return scoped_ptr<QuicEncryptedPacket>(MakePacket(header, QuicFrame(&rst))); 43 } 44 45 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeAckAndRstPacket( 46 QuicPacketSequenceNumber num, 47 bool include_version, 48 QuicStreamId stream_id, 49 QuicRstStreamErrorCode error_code, 50 QuicPacketSequenceNumber largest_received, 51 QuicPacketSequenceNumber least_unacked, 52 bool send_feedback) { 53 54 QuicPacketHeader header; 55 header.public_header.connection_id = connection_id_; 56 header.public_header.reset_flag = false; 57 header.public_header.version_flag = include_version; 58 header.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER; 59 header.packet_sequence_number = num; 60 header.entropy_flag = false; 61 header.fec_flag = false; 62 header.fec_group = 0; 63 64 QuicAckFrame ack(MakeAckFrame(largest_received, least_unacked)); 65 ack.received_info.delta_time_largest_observed = QuicTime::Delta::Zero(); 66 QuicFrames frames; 67 frames.push_back(QuicFrame(&ack)); 68 QuicCongestionFeedbackFrame feedback; 69 if (send_feedback) { 70 feedback.type = kTCP; 71 feedback.tcp.receive_window = 256000; 72 73 frames.push_back(QuicFrame(&feedback)); 74 } 75 76 QuicStopWaitingFrame stop_waiting; 77 if (version_ > QUIC_VERSION_15) { 78 stop_waiting.least_unacked = least_unacked; 79 frames.push_back(QuicFrame(&stop_waiting)); 80 } 81 82 QuicRstStreamFrame rst(stream_id, error_code, 0); 83 frames.push_back(QuicFrame(&rst)); 84 85 QuicFramer framer(SupportedVersions(version_), QuicTime::Zero(), false); 86 scoped_ptr<QuicPacket> packet( 87 BuildUnsizedDataPacket(&framer, header, frames).packet); 88 return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket( 89 ENCRYPTION_NONE, header.packet_sequence_number, *packet)); 90 } 91 92 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeConnectionClosePacket( 93 QuicPacketSequenceNumber num) { 94 QuicPacketHeader header; 95 header.public_header.connection_id = connection_id_; 96 header.public_header.reset_flag = false; 97 header.public_header.version_flag = false; 98 header.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER; 99 header.packet_sequence_number = num; 100 header.entropy_flag = false; 101 header.fec_flag = false; 102 header.fec_group = 0; 103 104 QuicConnectionCloseFrame close; 105 close.error_code = QUIC_CRYPTO_VERSION_NOT_SUPPORTED; 106 close.error_details = "Time to panic!"; 107 return scoped_ptr<QuicEncryptedPacket>(MakePacket(header, QuicFrame(&close))); 108 } 109 110 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeAckPacket( 111 QuicPacketSequenceNumber sequence_number, 112 QuicPacketSequenceNumber largest_received, 113 QuicPacketSequenceNumber least_unacked, 114 bool send_feedback) { 115 QuicPacketHeader header; 116 header.public_header.connection_id = connection_id_; 117 header.public_header.reset_flag = false; 118 header.public_header.version_flag = false; 119 header.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER; 120 header.packet_sequence_number = sequence_number; 121 header.entropy_flag = false; 122 header.fec_flag = false; 123 header.fec_group = 0; 124 125 QuicAckFrame ack(MakeAckFrame(largest_received, least_unacked)); 126 ack.received_info.delta_time_largest_observed = QuicTime::Delta::Zero(); 127 128 QuicCongestionFeedbackFrame feedback; 129 feedback.type = kTCP; 130 feedback.tcp.receive_window = 256000; 131 132 QuicFramer framer(SupportedVersions(version_), QuicTime::Zero(), false); 133 QuicFrames frames; 134 frames.push_back(QuicFrame(&ack)); 135 if (send_feedback) { 136 frames.push_back(QuicFrame(&feedback)); 137 } 138 139 QuicStopWaitingFrame stop_waiting; 140 if (version_ > QUIC_VERSION_15) { 141 stop_waiting.least_unacked = least_unacked; 142 frames.push_back(QuicFrame(&stop_waiting)); 143 } 144 145 scoped_ptr<QuicPacket> packet( 146 BuildUnsizedDataPacket(&framer, header, frames).packet); 147 return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket( 148 ENCRYPTION_NONE, header.packet_sequence_number, *packet)); 149 } 150 151 // Returns a newly created packet to send kData on stream 1. 152 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeDataPacket( 153 QuicPacketSequenceNumber sequence_number, 154 QuicStreamId stream_id, 155 bool should_include_version, 156 bool fin, 157 QuicStreamOffset offset, 158 base::StringPiece data) { 159 InitializeHeader(sequence_number, should_include_version); 160 QuicStreamFrame frame(stream_id, fin, offset, MakeIOVector(data)); 161 return MakePacket(header_, QuicFrame(&frame)); 162 } 163 164 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeRequestHeadersPacket( 165 QuicPacketSequenceNumber sequence_number, 166 QuicStreamId stream_id, 167 bool should_include_version, 168 bool fin, 169 const SpdyHeaderBlock& headers) { 170 InitializeHeader(sequence_number, should_include_version); 171 SpdySynStreamIR syn_stream(stream_id); 172 syn_stream.set_name_value_block(headers); 173 syn_stream.set_fin(fin); 174 syn_stream.set_priority(0); 175 scoped_ptr<SpdySerializedFrame> spdy_frame( 176 spdy_request_framer_.SerializeSynStream(syn_stream)); 177 QuicStreamFrame frame(kHeadersStreamId, false, 0, 178 MakeIOVector(base::StringPiece(spdy_frame->data(), 179 spdy_frame->size()))); 180 return MakePacket(header_, QuicFrame(&frame)); 181 } 182 183 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeResponseHeadersPacket( 184 QuicPacketSequenceNumber sequence_number, 185 QuicStreamId stream_id, 186 bool should_include_version, 187 bool fin, 188 const SpdyHeaderBlock& headers) { 189 InitializeHeader(sequence_number, should_include_version); 190 SpdySynReplyIR syn_reply(stream_id); 191 syn_reply.set_name_value_block(headers); 192 syn_reply.set_fin(fin); 193 scoped_ptr<SpdySerializedFrame> spdy_frame( 194 spdy_response_framer_.SerializeSynReply(syn_reply)); 195 QuicStreamFrame frame(kHeadersStreamId, false, 0, 196 MakeIOVector(base::StringPiece(spdy_frame->data(), 197 spdy_frame->size()))); 198 return MakePacket(header_, QuicFrame(&frame)); 199 } 200 201 SpdyHeaderBlock QuicTestPacketMaker::GetRequestHeaders( 202 const std::string& method, 203 const std::string& scheme, 204 const std::string& path) { 205 SpdyHeaderBlock headers; 206 headers[":method"] = method; 207 headers[":host"] = "www.google.com"; 208 headers[":path"] = path; 209 headers[":scheme"] = scheme; 210 headers[":version"] = "HTTP/1.1"; 211 return headers; 212 } 213 214 SpdyHeaderBlock QuicTestPacketMaker::GetResponseHeaders( 215 const std::string& status) { 216 SpdyHeaderBlock headers; 217 headers[":status"] = status; 218 headers[":version"] = "HTTP/1.1"; 219 headers["content-type"] = "text/plain"; 220 return headers; 221 } 222 223 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakePacket( 224 const QuicPacketHeader& header, 225 const QuicFrame& frame) { 226 QuicFramer framer(SupportedVersions(version_), QuicTime::Zero(), false); 227 QuicFrames frames; 228 frames.push_back(frame); 229 scoped_ptr<QuicPacket> packet( 230 BuildUnsizedDataPacket(&framer, header, frames).packet); 231 return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket( 232 ENCRYPTION_NONE, header.packet_sequence_number, *packet)); 233 } 234 235 void QuicTestPacketMaker::InitializeHeader( 236 QuicPacketSequenceNumber sequence_number, 237 bool should_include_version) { 238 header_.public_header.connection_id = connection_id_; 239 header_.public_header.reset_flag = false; 240 header_.public_header.version_flag = should_include_version; 241 header_.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER; 242 header_.packet_sequence_number = sequence_number; 243 header_.fec_group = 0; 244 header_.entropy_flag = false; 245 header_.fec_flag = false; 246 } 247 248 } // namespace test 249 } // namespace net 250
