Home | History | Annotate | Download | only in test_tools 
      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
    288