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