reliable_quic_stream.h revision 58537e28ecd584eab876aee8be7156509866d23a 
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;
29class SSLInfo;
30
31// All this does right now is send data to subclasses via the sequencer.
32class 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  void set_visitor(Visitor* visitor) { visitor_ = visitor; }
112
113  QuicSpdyCompressor* compressor();
114
115  // Gets the SSL connection information.
116  bool GetSSLInfo(SSLInfo* ssl_info);
117
118  bool headers_decompressed() const { return headers_decompressed_; }
119  QuicPriority priority() const { return priority_; }
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 HasBufferedData();
139
140  bool fin_buffered() { return fin_buffered_; }
141
142  QuicSession* session() { return session_; }
143
144  // Sends as much of 'data' to the connection as the connection will consume,
145  // and then buffers any remaining data in queued_data_.
146  // Returns (data.size(), true) as it always consumed all data: it returns for
147  // convenience to have the same return type as WriteDataInternal.
148  QuicConsumedData WriteOrBuffer(base::StringPiece data, bool fin);
149
150  // Sends as much of 'data' to the connection as the connection will consume.
151  // Returns the number of bytes consumed by the connection.
152  QuicConsumedData WriteDataInternal(base::StringPiece data, bool fin);
153
154 private:
155  friend class test::ReliableQuicStreamPeer;
156  friend class QuicStreamUtils;
157
158  uint32 StripPriorityAndHeaderId(const char* data, uint32 data_len);
159
160  std::list<string> queued_data_;
161
162  QuicStreamSequencer sequencer_;
163  QuicStreamId id_;
164  QuicSession* session_;
165  // Optional visitor of this stream to be notified when the stream is closed.
166  Visitor* visitor_;
167  // Bytes read and written refer to payload bytes only: they do not include
168  // framing, encryption overhead etc.
169  uint64 stream_bytes_read_;
170  uint64 stream_bytes_written_;
171  // True if the headers have been completely decompresssed.
172  bool headers_decompressed_;
173  // The priority of the stream, once parsed.
174  QuicPriority priority_;
175  // ID of the header block sent by the peer, once parsed.
176  QuicHeaderId headers_id_;
177  // Buffer into which we write bytes from priority_ and headers_id_
178  // until each is fully parsed.
179  string headers_id_and_priority_buffer_;
180  // Contains a copy of the decompressed headers_ until they are consumed
181  // via ProcessData or Readv.
182  string decompressed_headers_;
183  // True if an error was encountered during decompression.
184  bool decompression_failed_;
185
186  // Stream error code received from a RstStreamFrame or error code sent by the
187  // visitor or sequencer in the RstStreamFrame.
188  QuicRstStreamErrorCode stream_error_;
189  // Connection error code due to which the stream was closed. |stream_error_|
190  // is set to |QUIC_STREAM_CONNECTION_ERROR| when this happens and consumers
191  // should check |connection_error_|.
192  QuicErrorCode connection_error_;
193
194  // True if the read side is closed and further frames should be rejected.
195  bool read_side_closed_;
196  // True if the write side is closed, and further writes should fail.
197  bool write_side_closed_;
198
199  // True if the priority has been read, false otherwise.
200  bool priority_parsed_;
201  bool fin_buffered_;
202  bool fin_sent_;
203};
204
205}  // namespace net
206
207#endif  // NET_QUIC_RELIABLE_QUIC_STREAM_H_
208