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