reliable_quic_stream.h revision 90dce4d38c5ff5333bea97d859d4e484e27edf0c
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_spdy_compressor.h" 18#include "net/quic/quic_spdy_decompressor.h" 19#include "net/quic/quic_stream_sequencer.h" 20 21namespace net { 22 23namespace test { 24class ReliableQuicStreamPeer; 25} // namespace test 26 27class IPEndPoint; 28class QuicSession; 29 30// All this does right now is send data to subclasses via the sequencer. 31class NET_EXPORT_PRIVATE ReliableQuicStream : public 32 QuicSpdyDecompressor::Visitor { 33 public: 34 // Visitor receives callbacks from the stream. 35 class Visitor { 36 public: 37 Visitor() {} 38 39 // Called when the stream is closed. 40 virtual void OnClose(ReliableQuicStream* stream) = 0; 41 42 protected: 43 virtual ~Visitor() {} 44 45 private: 46 DISALLOW_COPY_AND_ASSIGN(Visitor); 47 }; 48 49 ReliableQuicStream(QuicStreamId id, 50 QuicSession* session); 51 52 virtual ~ReliableQuicStream(); 53 54 bool WillAcceptStreamFrame(const QuicStreamFrame& frame) const; 55 virtual bool OnStreamFrame(const QuicStreamFrame& frame); 56 57 virtual void OnCanWrite(); 58 59 // Called by the session just before the stream is deleted. 60 virtual void OnClose(); 61 62 // Called when we get a stream reset from the client. 63 virtual void OnStreamReset(QuicRstStreamErrorCode error); 64 65 // Called when we get or send a connection close, and should immediately 66 // close the stream. This is not passed through the sequencer, 67 // but is handled immediately. 68 virtual void ConnectionClose(QuicErrorCode error, bool from_peer); 69 70 // Called by the sequencer, when we should process a stream termination or 71 // stream close from the peer. 72 virtual void TerminateFromPeer(bool half_close); 73 74 virtual uint32 ProcessRawData(const char* data, uint32 data_len); 75 virtual uint32 ProcessHeaderData(); 76 77 virtual uint32 ProcessData(const char* data, uint32 data_len) = 0; 78 79 virtual bool OnDecompressedData(base::StringPiece data) OVERRIDE; 80 virtual void OnDecompressionError() OVERRIDE; 81 82 // Called to close the stream from this end. 83 virtual void Close(QuicRstStreamErrorCode error); 84 85 // This block of functions wraps the sequencer's functions of the same 86 // name. These methods return uncompressed data until that has 87 // been fully processed. Then they simply delegate to the sequencer. 88 virtual int Readv(const struct iovec* iov, int iov_len); 89 virtual int GetReadableRegions(iovec* iov, int iov_len); 90 virtual bool IsHalfClosed() const; 91 virtual bool IsClosed() const; 92 virtual bool HasBytesToRead() const; 93 94 // Called by the session when a decompression blocked stream 95 // becomes unblocked. 96 virtual void OnDecompressorAvailable(); 97 98 QuicStreamId id() const { return id_; } 99 100 QuicRstStreamErrorCode stream_error() const { return stream_error_; } 101 QuicErrorCode connection_error() const { return connection_error_; } 102 103 bool read_side_closed() const { return read_side_closed_; } 104 bool write_side_closed() const { return write_side_closed_; } 105 106 uint64 stream_bytes_read() { return stream_bytes_read_; } 107 uint64 stream_bytes_written() { return stream_bytes_written_; } 108 109 const IPEndPoint& GetPeerAddress() const; 110 111 Visitor* visitor() { return visitor_; } 112 void set_visitor(Visitor* visitor) { visitor_ = visitor; } 113 114 QuicSpdyCompressor* compressor(); 115 116 protected: 117 // Returns a pair with the number of bytes consumed from data, and a boolean 118 // indicating if the fin bit was consumed. This does not indicate the data 119 // has been sent on the wire: it may have been turned into a packet and queued 120 // if the socket was unexpectedly blocked. 121 // 122 // The default implementation always consumed all bytes and any fin, but 123 // this behavior is not guaranteed for subclasses so callers should check the 124 // return value. 125 virtual QuicConsumedData WriteData(base::StringPiece data, bool fin); 126 127 // Close the read side of the socket. Further frames will not be accepted. 128 virtual void CloseReadSide(); 129 130 // Close the write side of the socket. Further writes will fail. 131 void CloseWriteSide(); 132 133 bool fin_buffered() { return fin_buffered_; } 134 135 QuicSession* session() { return session_; } 136 137 // Sends as much of 'data' to the connection as the connection will consume, 138 // and then buffers any remaining data in queued_data_. 139 // Returns (data.size(), true) as it always consumed all data: it returns for 140 // convenience to have the same return type as WriteDataInternal. 141 QuicConsumedData WriteOrBuffer(base::StringPiece data, bool fin); 142 143 // Sends as much of 'data' to the connection as the connection will consume. 144 // Returns the number of bytes consumed by the connection. 145 QuicConsumedData WriteDataInternal(base::StringPiece data, bool fin); 146 147 private: 148 friend class test::ReliableQuicStreamPeer; 149 friend class QuicStreamUtils; 150 151 std::list<string> queued_data_; 152 153 QuicStreamSequencer sequencer_; 154 QuicStreamId id_; 155 QuicSession* session_; 156 // Optional visitor of this stream to be notified when the stream is closed. 157 Visitor* visitor_; 158 // Bytes read and written refer to payload bytes only: they do not include 159 // framing, encryption overhead etc. 160 uint64 stream_bytes_read_; 161 uint64 stream_bytes_written_; 162 // True if the headers have been completely decompresssed. 163 bool headers_decompressed_; 164 // ID of the header block sent by the peer, once parsed. 165 QuicHeaderId headers_id_; 166 // Buffer into which we write bytes from the headers_id_ 167 // until it is fully parsed. 168 string headers_id_buffer_; 169 // Contains a copy of the decompressed headers_ until they are consumed 170 // via ProcessData or Readv. 171 string decompressed_headers_; 172 173 // Stream error code received from a RstStreamFrame or error code sent by the 174 // visitor or sequencer in the RstStreamFrame. 175 QuicRstStreamErrorCode stream_error_; 176 // Connection error code due to which the stream was closed. |stream_error_| 177 // is set to |QUIC_STREAM_CONNECTION_ERROR| when this happens and consumers 178 // should check |connection_error_|. 179 QuicErrorCode connection_error_; 180 181 // True if the read side is closed and further frames should be rejected. 182 bool read_side_closed_; 183 // True if the write side is closed, and further writes should fail. 184 bool write_side_closed_; 185 186 bool fin_buffered_; 187 bool fin_sent_; 188}; 189 190} // namespace net 191 192#endif // NET_QUIC_RELIABLE_QUIC_STREAM_H_ 193