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 // The base class for client/server reliable streams. 6 7 #ifndef NET_QUIC_RELIABLE_QUIC_STREAM_H_ 8 #define NET_QUIC_RELIABLE_QUIC_STREAM_H_ 9 10 #include <sys/types.h> 11 12 #include <list> 13 14 #include "base/strings/string_piece.h" 15 #include "net/base/iovec.h" 16 #include "net/base/net_export.h" 17 #include "net/quic/quic_ack_notifier.h" 18 #include "net/quic/quic_protocol.h" 19 #include "net/quic/quic_spdy_compressor.h" 20 #include "net/quic/quic_stream_sequencer.h" 21 22 namespace net { 23 24 namespace test { 25 class ReliableQuicStreamPeer; 26 } // namespace test 27 28 class IPEndPoint; 29 class QuicSession; 30 class SSLInfo; 31 32 class NET_EXPORT_PRIVATE ReliableQuicStream { 33 public: 34 ReliableQuicStream(QuicStreamId id, 35 QuicSession* session); 36 37 virtual ~ReliableQuicStream(); 38 39 bool WillAcceptStreamFrame(const QuicStreamFrame& frame) const; 40 41 // Called when a (potentially duplicate) stream frame has been received 42 // for this stream. Returns false if this frame can not be accepted 43 // because there is too much data already buffered. 44 virtual bool OnStreamFrame(const QuicStreamFrame& frame); 45 46 // Called when the connection becomes writeable to allow the stream 47 // to write any pending data. 48 virtual void OnCanWrite(); 49 50 // Called by the session just before the stream is deleted. 51 virtual void OnClose(); 52 53 // Called when we get a stream reset from the peer. 54 virtual void OnStreamReset(QuicRstStreamErrorCode error); 55 56 // Called when we get or send a connection close, and should immediately 57 // close the stream. This is not passed through the sequencer, 58 // but is handled immediately. 59 virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer); 60 61 // Called when the final data has been read. 62 virtual void OnFinRead(); 63 64 virtual uint32 ProcessRawData(const char* data, uint32 data_len) = 0; 65 66 // Called to reset the stream from this end. 67 virtual void Reset(QuicRstStreamErrorCode error); 68 69 // Called to close the entire connection from this end. 70 virtual void CloseConnection(QuicErrorCode error); 71 virtual void CloseConnectionWithDetails(QuicErrorCode error, 72 const string& details); 73 74 // Returns the effective priority for the stream. This value may change 75 // during the life of the stream. 76 virtual QuicPriority EffectivePriority() const = 0; 77 78 QuicStreamId id() const { return id_; } 79 80 QuicRstStreamErrorCode stream_error() const { return stream_error_; } 81 QuicErrorCode connection_error() const { return connection_error_; } 82 83 bool read_side_closed() const { return read_side_closed_; } 84 bool write_side_closed() const { return write_side_closed_; } 85 86 uint64 stream_bytes_read() { return stream_bytes_read_; } 87 uint64 stream_bytes_written() { return stream_bytes_written_; } 88 89 QuicVersion version(); 90 91 protected: 92 // Sends as much of 'data' to the connection as the connection will consume, 93 // and then buffers any remaining data in queued_data_. 94 void WriteOrBufferData(base::StringPiece data, bool fin); 95 96 // Sends as many bytes in the first |count| buffers of |iov| to the connection 97 // as the connection will consume. 98 // If |ack_notifier_delegate| is provided, then it will be notified once all 99 // the ACKs for this write have been received. 100 // Returns the number of bytes consumed by the connection. 101 QuicConsumedData WritevData( 102 const struct iovec* iov, 103 int iov_count, 104 bool fin, 105 QuicAckNotifier::DelegateInterface* ack_notifier_delegate); 106 107 // Close the read side of the socket. Further frames will not be accepted. 108 virtual void CloseReadSide(); 109 110 // Close the write side of the socket. Further writes will fail. 111 void CloseWriteSide(); 112 113 bool HasBufferedData(); 114 115 bool fin_buffered() { return fin_buffered_; } 116 117 QuicSession* session() { return session_; } 118 119 const QuicStreamSequencer* sequencer() const { return &sequencer_; } 120 QuicStreamSequencer* sequencer() { return &sequencer_; } 121 122 private: 123 friend class test::ReliableQuicStreamPeer; 124 friend class QuicStreamUtils; 125 126 std::list<string> queued_data_; 127 128 QuicStreamSequencer sequencer_; 129 QuicStreamId id_; 130 QuicSession* session_; 131 // Bytes read and written refer to payload bytes only: they do not include 132 // framing, encryption overhead etc. 133 uint64 stream_bytes_read_; 134 uint64 stream_bytes_written_; 135 136 // Stream error code received from a RstStreamFrame or error code sent by the 137 // visitor or sequencer in the RstStreamFrame. 138 QuicRstStreamErrorCode stream_error_; 139 // Connection error code due to which the stream was closed. |stream_error_| 140 // is set to |QUIC_STREAM_CONNECTION_ERROR| when this happens and consumers 141 // should check |connection_error_|. 142 QuicErrorCode connection_error_; 143 144 // True if the read side is closed and further frames should be rejected. 145 bool read_side_closed_; 146 // True if the write side is closed, and further writes should fail. 147 bool write_side_closed_; 148 149 bool fin_buffered_; 150 bool fin_sent_; 151 152 // True if the session this stream is running under is a server session. 153 bool is_server_; 154 155 DISALLOW_COPY_AND_ASSIGN(ReliableQuicStream); 156 }; 157 158 } // namespace net 159 160 #endif // NET_QUIC_RELIABLE_QUIC_STREAM_H_ 161
