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