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