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 "net/quic/crypto/crypto_framer.h" 8 #include "net/quic/crypto/quic_decrypter.h" 9 #include "net/quic/crypto/quic_encrypter.h" 10 11 using base::StringPiece; 12 using std::string; 13 using std::vector; 14 15 namespace net { 16 namespace test { 17 18 class SimpleFramerVisitor : public QuicFramerVisitorInterface { 19 public: 20 SimpleFramerVisitor() 21 : error_(QUIC_NO_ERROR) { 22 } 23 24 virtual void OnError(QuicFramer* framer) OVERRIDE { 25 error_ = framer->error(); 26 } 27 28 virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE { 29 return false; 30 } 31 32 virtual void OnPacket() OVERRIDE {} 33 virtual void OnPublicResetPacket( 34 const QuicPublicResetPacket& packet) OVERRIDE {} 35 virtual void OnVersionNegotiationPacket( 36 const QuicVersionNegotiationPacket& packet) OVERRIDE {} 37 virtual void OnRevivedPacket() OVERRIDE {} 38 39 virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE { 40 has_header_ = true; 41 header_ = header; 42 return true; 43 } 44 45 virtual void OnFecProtectedPayload(StringPiece payload) OVERRIDE {} 46 47 virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE { 48 // Save a copy of the data so it is valid after the packet is processed. 49 stream_data_.push_back(frame.data.as_string()); 50 QuicStreamFrame stream_frame(frame); 51 // Make sure that the stream frame points to this data. 52 stream_frame.data = stream_data_.back(); 53 stream_frames_.push_back(stream_frame); 54 return true; 55 } 56 57 virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE { 58 ack_frames_.push_back(frame); 59 return true; 60 } 61 62 virtual bool OnCongestionFeedbackFrame( 63 const QuicCongestionFeedbackFrame& frame) OVERRIDE { 64 feedback_frames_.push_back(frame); 65 return true; 66 } 67 68 virtual void OnFecData(const QuicFecData& fec) OVERRIDE { 69 fec_data_ = fec; 70 fec_redundancy_ = fec_data_.redundancy.as_string(); 71 fec_data_.redundancy = fec_redundancy_; 72 } 73 74 virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE { 75 rst_stream_frames_.push_back(frame); 76 return true; 77 } 78 79 virtual bool OnConnectionCloseFrame( 80 const QuicConnectionCloseFrame& frame) OVERRIDE { 81 connection_close_frames_.push_back(frame); 82 return true; 83 } 84 85 virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE { 86 goaway_frames_.push_back(frame); 87 return true; 88 } 89 90 virtual void OnPacketComplete() OVERRIDE {} 91 92 const QuicPacketHeader& header() const { return header_; } 93 const vector<QuicAckFrame>& ack_frames() const { return ack_frames_; } 94 const vector<QuicConnectionCloseFrame>& connection_close_frames() const { 95 return connection_close_frames_; 96 } 97 const vector<QuicCongestionFeedbackFrame>& feedback_frames() const { 98 return feedback_frames_; 99 } 100 const vector<QuicGoAwayFrame>& goaway_frames() const { 101 return goaway_frames_; 102 } 103 const vector<QuicRstStreamFrame>& rst_stream_frames() const { 104 return rst_stream_frames_; 105 } 106 const vector<QuicStreamFrame>& stream_frames() const { 107 return stream_frames_; 108 } 109 const QuicFecData& fec_data() const { 110 return fec_data_; 111 } 112 113 private: 114 QuicErrorCode error_; 115 bool has_header_; 116 QuicPacketHeader header_; 117 QuicFecData fec_data_; 118 string fec_redundancy_; 119 vector<QuicAckFrame> ack_frames_; 120 vector<QuicCongestionFeedbackFrame> feedback_frames_; 121 vector<QuicStreamFrame> stream_frames_; 122 vector<QuicRstStreamFrame> rst_stream_frames_; 123 vector<QuicGoAwayFrame> goaway_frames_; 124 vector<QuicConnectionCloseFrame> connection_close_frames_; 125 vector<string> stream_data_; 126 127 DISALLOW_COPY_AND_ASSIGN(SimpleFramerVisitor); 128 }; 129 130 SimpleQuicFramer::SimpleQuicFramer() 131 : framer_(QuicVersionMax(), QuicTime::Zero(), true) { 132 } 133 134 SimpleQuicFramer::~SimpleQuicFramer() { 135 } 136 137 bool SimpleQuicFramer::ProcessPacket(const QuicPacket& packet) { 138 scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPacket( 139 ENCRYPTION_NONE, 0, packet)); 140 return ProcessPacket(*encrypted); 141 } 142 143 bool SimpleQuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) { 144 visitor_.reset(new SimpleFramerVisitor); 145 framer_.set_visitor(visitor_.get()); 146 return framer_.ProcessPacket(packet); 147 } 148 149 const QuicPacketHeader& SimpleQuicFramer::header() const { 150 return visitor_->header(); 151 } 152 153 const QuicFecData& SimpleQuicFramer::fec_data() const { 154 return visitor_->fec_data(); 155 } 156 157 QuicFramer* SimpleQuicFramer::framer() { 158 return &framer_; 159 } 160 161 size_t SimpleQuicFramer::num_frames() const { 162 return ack_frames().size() + 163 stream_frames().size() + 164 feedback_frames().size() + 165 rst_stream_frames().size() + 166 goaway_frames().size() + 167 connection_close_frames().size(); 168 } 169 170 const vector<QuicAckFrame>& SimpleQuicFramer::ack_frames() const { 171 return visitor_->ack_frames(); 172 } 173 174 const vector<QuicStreamFrame>& SimpleQuicFramer::stream_frames() const { 175 return visitor_->stream_frames(); 176 } 177 178 const vector<QuicRstStreamFrame>& SimpleQuicFramer::rst_stream_frames() const { 179 return visitor_->rst_stream_frames(); 180 } 181 182 const vector<QuicCongestionFeedbackFrame>& 183 SimpleQuicFramer::feedback_frames() const { 184 return visitor_->feedback_frames(); 185 } 186 187 const vector<QuicGoAwayFrame>& 188 SimpleQuicFramer::goaway_frames() const { 189 return visitor_->goaway_frames(); 190 } 191 192 const vector<QuicConnectionCloseFrame>& 193 SimpleQuicFramer::connection_close_frames() const { 194 return visitor_->connection_close_frames(); 195 } 196 197 } // namespace test 198 } // namespace net 199
