src/net/quic/test_tools/quic_test_packet_maker.cc

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