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