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