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 12using base::StringPiece; 13using std::string; 14using std::vector; 15 16namespace net { 17namespace test { 18 19class 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 190SimpleQuicFramer::SimpleQuicFramer() 191 : framer_(QuicSupportedVersions(), QuicTime::Zero(), true) { 192} 193 194SimpleQuicFramer::SimpleQuicFramer(const QuicVersionVector& supported_versions) 195 : framer_(supported_versions, QuicTime::Zero(), true) { 196} 197 198SimpleQuicFramer::~SimpleQuicFramer() { 199} 200 201bool SimpleQuicFramer::ProcessPacket(const QuicPacket& packet) { 202 scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPacket( 203 ENCRYPTION_NONE, 0, packet)); 204 return ProcessPacket(*encrypted); 205} 206 207bool SimpleQuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) { 208 visitor_.reset(new SimpleFramerVisitor); 209 framer_.set_visitor(visitor_.get()); 210 return framer_.ProcessPacket(packet); 211} 212 213void SimpleQuicFramer::Reset() { 214 visitor_.reset(new SimpleFramerVisitor); 215} 216 217 218const QuicPacketHeader& SimpleQuicFramer::header() const { 219 return visitor_->header(); 220} 221 222const QuicFecData& SimpleQuicFramer::fec_data() const { 223 return visitor_->fec_data(); 224} 225 226const QuicVersionNegotiationPacket* 227SimpleQuicFramer::version_negotiation_packet() const { 228 return visitor_->version_negotiation_packet(); 229} 230 231const QuicPublicResetPacket* SimpleQuicFramer::public_reset_packet() const { 232 return visitor_->public_reset_packet(); 233} 234 235QuicFramer* SimpleQuicFramer::framer() { 236 return &framer_; 237} 238 239size_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 250const vector<QuicAckFrame>& SimpleQuicFramer::ack_frames() const { 251 return visitor_->ack_frames(); 252} 253 254const vector<QuicStopWaitingFrame>& 255SimpleQuicFramer::stop_waiting_frames() const { 256 return visitor_->stop_waiting_frames(); 257} 258 259const vector<QuicPingFrame>& SimpleQuicFramer::ping_frames() const { 260 return visitor_->ping_frames(); 261} 262 263const vector<QuicStreamFrame>& SimpleQuicFramer::stream_frames() const { 264 return visitor_->stream_frames(); 265} 266 267const vector<QuicRstStreamFrame>& SimpleQuicFramer::rst_stream_frames() const { 268 return visitor_->rst_stream_frames(); 269} 270 271const vector<QuicCongestionFeedbackFrame>& 272SimpleQuicFramer::feedback_frames() const { 273 return visitor_->feedback_frames(); 274} 275 276const vector<QuicGoAwayFrame>& 277SimpleQuicFramer::goaway_frames() const { 278 return visitor_->goaway_frames(); 279} 280 281const vector<QuicConnectionCloseFrame>& 282SimpleQuicFramer::connection_close_frames() const { 283 return visitor_->connection_close_frames(); 284} 285 286} // namespace test 287} // namespace net 288