net/quic/test_tools/simple_quic_framer.cc

   1 // Copyright (c) 2012 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/simple_quic_framer.h"
   6
   7 #include "base/stl_util.h"
   8 #include "net/quic/crypto/crypto_framer.h"
   9 #include "net/quic/crypto/quic_decrypter.h"
  10 #include "net/quic/crypto/quic_encrypter.h"
  11
  12 using base::StringPiece;
  13 using std::string;
  14 using std::vector;
  15
  16 namespace net {
  17 namespace test {
  18
  19 class SimpleFramerVisitor : public QuicFramerVisitorInterface {
  20  public:
  21   SimpleFramerVisitor()
  22       : error_(QUIC_NO_ERROR) {
  23   }
  24
  25   virtual ~SimpleFramerVisitor() OVERRIDE {
  26     STLDeleteElements(&stream_data_);
  27   }
  28
  29   virtual void OnError(QuicFramer* framer) OVERRIDE {
  30     error_ = framer->error();
  31   }
  32
  33   virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE {
  34     return false;
  35   }
  36
  37   virtual void OnPacket() OVERRIDE {}
  38   virtual void OnPublicResetPacket(
  39       const QuicPublicResetPacket& packet) OVERRIDE {
  40     public_reset_packet_.reset(new QuicPublicResetPacket(packet));
  41   }
  42   virtual void OnVersionNegotiationPacket(
  43       const QuicVersionNegotiationPacket& packet) OVERRIDE {
  44     version_negotiation_packet_.reset(
  45         new QuicVersionNegotiationPacket(packet));
  46   }
  47   virtual void OnRevivedPacket() OVERRIDE {}
  48
  49   virtual bool OnUnauthenticatedPublicHeader(
  50       const QuicPacketPublicHeader& header) OVERRIDE {
  51     return true;
  52   }
  53   virtual bool OnUnauthenticatedHeader(
  54       const QuicPacketHeader& header) OVERRIDE {
  55     return true;
  56   }
  57   virtual void OnDecryptedPacket(EncryptionLevel level) OVERRIDE {}
  58   virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE {
  59     has_header_ = true;
  60     header_ = header;
  61     return true;
  62   }
  63
  64   virtual void OnFecProtectedPayload(StringPiece payload) OVERRIDE {}
  65
  66   virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE {
  67     // Save a copy of the data so it is valid after the packet is processed.
  68     stream_data_.push_back(frame.GetDataAsString());
  69     QuicStreamFrame stream_frame(frame);
  70     // Make sure that the stream frame points to this data.
  71     stream_frame.data.Clear();
  72     stream_frame.data.Append(const_cast<char*>(stream_data_.back()->data()),
  73                              stream_data_.back()->size());
  74     stream_frames_.push_back(stream_frame);
  75     return true;
  76   }
  77
  78   virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE {
  79     ack_frames_.push_back(frame);
  80     return true;
  81   }
  82
  83   virtual bool OnCongestionFeedbackFrame(
  84       const QuicCongestionFeedbackFrame& frame) OVERRIDE {
  85     feedback_frames_.push_back(frame);
  86     return true;
  87   }
  88
  89   virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) OVERRIDE {
  90     stop_waiting_frames_.push_back(frame);
  91     return true;
  92   }
  93
  94   virtual bool OnPingFrame(const QuicPingFrame& frame) OVERRIDE {
  95     ping_frames_.push_back(frame);
  96     return true;
  97   }
  98
  99   virtual void OnFecData(const QuicFecData& fec) OVERRIDE {
 100     fec_data_ = fec;
 101     fec_redundancy_ = fec_data_.redundancy.as_string();
 102     fec_data_.redundancy = fec_redundancy_;
 103   }
 104
 105   virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE {
 106     rst_stream_frames_.push_back(frame);
 107     return true;
 108   }
 109
 110   virtual bool OnConnectionCloseFrame(
 111       const QuicConnectionCloseFrame& frame) OVERRIDE {
 112     connection_close_frames_.push_back(frame);
 113     return true;
 114   }
 115
 116   virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE {
 117     goaway_frames_.push_back(frame);
 118     return true;
 119   }
 120
 121   virtual bool OnWindowUpdateFrame(
 122       const QuicWindowUpdateFrame& frame) OVERRIDE {
 123     window_update_frames_.push_back(frame);
 124     return true;
 125   }
 126
 127   virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE {
 128     blocked_frames_.push_back(frame);
 129     return true;
 130   }
 131
 132   virtual void OnPacketComplete() OVERRIDE {}
 133
 134   const QuicPacketHeader& header() const { return header_; }
 135   const vector<QuicAckFrame>& ack_frames() const { return ack_frames_; }
 136   const vector<QuicConnectionCloseFrame>& connection_close_frames() const {
 137     return connection_close_frames_;
 138   }
 139   const vector<QuicCongestionFeedbackFrame>& feedback_frames() const {
 140     return feedback_frames_;
 141   }
 142   const vector<QuicGoAwayFrame>& goaway_frames() const {
 143     return goaway_frames_;
 144   }
 145   const vector<QuicRstStreamFrame>& rst_stream_frames() const {
 146     return rst_stream_frames_;
 147   }
 148   const vector<QuicStreamFrame>& stream_frames() const {
 149     return stream_frames_;
 150   }
 151   const vector<QuicStopWaitingFrame>& stop_waiting_frames() const {
 152     return stop_waiting_frames_;
 153   }
 154   const vector<QuicPingFrame>& ping_frames() const {
 155     return ping_frames_;
 156   }
 157   const QuicFecData& fec_data() const {
 158     return fec_data_;
 159   }
 160   const QuicVersionNegotiationPacket* version_negotiation_packet() const {
 161     return version_negotiation_packet_.get();
 162   }
 163   const QuicPublicResetPacket* public_reset_packet() const {
 164     return public_reset_packet_.get();
 165   }
 166
 167  private:
 168   QuicErrorCode error_;
 169   bool has_header_;
 170   QuicPacketHeader header_;
 171   QuicFecData fec_data_;
 172   scoped_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
 173   scoped_ptr<QuicPublicResetPacket> public_reset_packet_;
 174   string fec_redundancy_;
 175   vector<QuicAckFrame> ack_frames_;
 176   vector<QuicCongestionFeedbackFrame> feedback_frames_;
 177   vector<QuicStopWaitingFrame> stop_waiting_frames_;
 178   vector<QuicPingFrame> ping_frames_;
 179   vector<QuicStreamFrame> stream_frames_;
 180   vector<QuicRstStreamFrame> rst_stream_frames_;
 181   vector<QuicGoAwayFrame> goaway_frames_;
 182   vector<QuicConnectionCloseFrame> connection_close_frames_;
 183   vector<QuicWindowUpdateFrame> window_update_frames_;
 184   vector<QuicBlockedFrame> blocked_frames_;
 185   vector<string*> stream_data_;
 186
 187   DISALLOW_COPY_AND_ASSIGN(SimpleFramerVisitor);
 188 };
 189
 190 SimpleQuicFramer::SimpleQuicFramer()
 191     : framer_(QuicSupportedVersions(), QuicTime::Zero(), true) {
 192 }
 193
 194 SimpleQuicFramer::SimpleQuicFramer(const QuicVersionVector& supported_versions)
 195     : framer_(supported_versions, QuicTime::Zero(), true) {
 196 }
 197
 198 SimpleQuicFramer::~SimpleQuicFramer() {
 199 }
 200
 201 bool SimpleQuicFramer::ProcessPacket(const QuicPacket& packet) {
 202   scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPacket(
 203       ENCRYPTION_NONE, 0, packet));
 204   return ProcessPacket(*encrypted);
 205 }
 206
 207 bool SimpleQuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) {
 208   visitor_.reset(new SimpleFramerVisitor);
 209   framer_.set_visitor(visitor_.get());
 210   return framer_.ProcessPacket(packet);
 211 }
 212
 213 void SimpleQuicFramer::Reset() {
 214   visitor_.reset(new SimpleFramerVisitor);
 215 }
 216
 217
 218 const QuicPacketHeader& SimpleQuicFramer::header() const {
 219   return visitor_->header();
 220 }
 221
 222 const QuicFecData& SimpleQuicFramer::fec_data() const {
 223   return visitor_->fec_data();
 224 }
 225
 226 const QuicVersionNegotiationPacket*
 227 SimpleQuicFramer::version_negotiation_packet() const {
 228   return visitor_->version_negotiation_packet();
 229 }
 230
 231 const QuicPublicResetPacket* SimpleQuicFramer::public_reset_packet() const {
 232   return visitor_->public_reset_packet();
 233 }
 234
 235 QuicFramer* SimpleQuicFramer::framer() {
 236   return &framer_;
 237 }
 238
 239 size_t SimpleQuicFramer::num_frames() const {
 240   return ack_frames().size() +
 241       feedback_frames().size() +
 242       goaway_frames().size() +
 243       rst_stream_frames().size() +
 244       stop_waiting_frames().size() +
 245       stream_frames().size() +
 246       ping_frames().size() +
 247       connection_close_frames().size();
 248 }
 249
 250 const vector<QuicAckFrame>& SimpleQuicFramer::ack_frames() const {
 251   return visitor_->ack_frames();
 252 }
 253
 254 const vector<QuicStopWaitingFrame>&
 255 SimpleQuicFramer::stop_waiting_frames() const {
 256   return visitor_->stop_waiting_frames();
 257 }
 258
 259 const vector<QuicPingFrame>& SimpleQuicFramer::ping_frames() const {
 260   return visitor_->ping_frames();
 261 }
 262
 263 const vector<QuicStreamFrame>& SimpleQuicFramer::stream_frames() const {
 264   return visitor_->stream_frames();
 265 }
 266
 267 const vector<QuicRstStreamFrame>& SimpleQuicFramer::rst_stream_frames() const {
 268   return visitor_->rst_stream_frames();
 269 }
 270
 271 const vector<QuicCongestionFeedbackFrame>&
 272 SimpleQuicFramer::feedback_frames() const {
 273   return visitor_->feedback_frames();
 274 }
 275
 276 const vector<QuicGoAwayFrame>&
 277 SimpleQuicFramer::goaway_frames() const {
 278   return visitor_->goaway_frames();
 279 }
 280
 281 const vector<QuicConnectionCloseFrame>&
 282 SimpleQuicFramer::connection_close_frames() const {
 283   return visitor_->connection_close_frames();
 284 }
 285
 286 }  // namespace test
 287 }  // namespace net