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