src/net/quic/quic_session.h

   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 // A QuicSession, which demuxes a single connection to individual streams.
   6
   7 #ifndef NET_QUIC_QUIC_SESSION_H_
   8 #define NET_QUIC_QUIC_SESSION_H_
   9
  10 #include <vector>
  11
  12 #include "base/compiler_specific.h"
  13 #include "base/containers/hash_tables.h"
  14 #include "net/base/ip_endpoint.h"
  15 #include "net/quic/quic_connection.h"
  16 #include "net/quic/quic_crypto_stream.h"
  17 #include "net/quic/quic_data_stream.h"
  18 #include "net/quic/quic_headers_stream.h"
  19 #include "net/quic/quic_packet_creator.h"
  20 #include "net/quic/quic_protocol.h"
  21 #include "net/quic/quic_write_blocked_list.h"
  22 #include "net/quic/reliable_quic_stream.h"
  23
  24 namespace net {
  25
  26 class QuicCryptoStream;
  27 class QuicFlowController;
  28 class ReliableQuicStream;
  29 class SSLInfo;
  30 class VisitorShim;
  31
  32 namespace test {
  33 class QuicSessionPeer;
  34 }  // namespace test
  35
  36 class NET_EXPORT_PRIVATE QuicSession : public QuicConnectionVisitorInterface {
  37  public:
  38   // CryptoHandshakeEvent enumerates the events generated by a QuicCryptoStream.
  39   enum CryptoHandshakeEvent {
  40     // ENCRYPTION_FIRST_ESTABLISHED indicates that a full client hello has been
  41     // sent by a client and that subsequent packets will be encrypted. (Client
  42     // only.)
  43     ENCRYPTION_FIRST_ESTABLISHED,
  44     // ENCRYPTION_REESTABLISHED indicates that a client hello was rejected by
  45     // the server and thus the encryption key has been updated. Therefore the
  46     // connection should resend any packets that were sent under
  47     // ENCRYPTION_INITIAL. (Client only.)
  48     ENCRYPTION_REESTABLISHED,
  49     // HANDSHAKE_CONFIRMED, in a client, indicates the the server has accepted
  50     // our handshake. In a server it indicates that a full, valid client hello
  51     // has been received. (Client and server.)
  52     HANDSHAKE_CONFIRMED,
  53   };
  54
  55   QuicSession(QuicConnection* connection,
  56               const QuicConfig& config,
  57               bool is_secure);
  58   void InitializeSession();
  59
  60   ~QuicSession() override;
  61
  62   // QuicConnectionVisitorInterface methods:
  63   void OnStreamFrames(const std::vector<QuicStreamFrame>& frames) override;
  64   void OnRstStream(const QuicRstStreamFrame& frame) override;
  65   void OnGoAway(const QuicGoAwayFrame& frame) override;
  66   void OnWindowUpdateFrames(
  67       const std::vector<QuicWindowUpdateFrame>& frames) override;
  68   void OnBlockedFrames(const std::vector<QuicBlockedFrame>& frames) override;
  69   void OnConnectionClosed(QuicErrorCode error, bool from_peer) override;
  70   void OnWriteBlocked() override {}
  71   void OnSuccessfulVersionNegotiation(const QuicVersion& version) override;
  72   void OnCanWrite() override;
  73   void OnCongestionWindowChange(QuicTime now) override {}
  74   bool WillingAndAbleToWrite() const override;
  75   bool HasPendingHandshake() const override;
  76   bool HasOpenDataStreams() const override;
  77
  78   // Called by the headers stream when headers have been received for a stream.
  79   virtual void OnStreamHeaders(QuicStreamId stream_id,
  80                                base::StringPiece headers_data);
  81   // Called by the headers stream when headers with a priority have been
  82   // received for this stream.  This method will only be called for server
  83   // streams.
  84   virtual void OnStreamHeadersPriority(QuicStreamId stream_id,
  85                                        QuicPriority priority);
  86   // Called by the headers stream when headers have been completely received
  87   // for a stream.  |fin| will be true if the fin flag was set in the headers
  88   // frame.
  89   virtual void OnStreamHeadersComplete(QuicStreamId stream_id,
  90                                        bool fin,
  91                                        size_t frame_len);
  92
  93   // Called by streams when they want to write data to the peer.
  94   // Returns a pair with the number of bytes consumed from data, and a boolean
  95   // indicating if the fin bit was consumed.  This does not indicate the data
  96   // has been sent on the wire: it may have been turned into a packet and queued
  97   // if the socket was unexpectedly blocked.  |fec_protection| indicates if
  98   // data is to be FEC protected. Note that data that is sent immediately
  99   // following MUST_FEC_PROTECT data may get protected by falling within the
 100   // same FEC group.
 101   // If provided, |ack_notifier_delegate| will be registered to be notified when
 102   // we have seen ACKs for all packets resulting from this call.
 103   virtual QuicConsumedData WritevData(
 104       QuicStreamId id,
 105       const IOVector& data,
 106       QuicStreamOffset offset,
 107       bool fin,
 108       FecProtection fec_protection,
 109       QuicAckNotifier::DelegateInterface* ack_notifier_delegate);
 110
 111   // Writes |headers| for the stream |id| to the dedicated headers stream.
 112   // If |fin| is true, then no more data will be sent for the stream |id|.
 113   // If provided, |ack_notifier_delegate| will be registered to be notified when
 114   // we have seen ACKs for all packets resulting from this call.
 115   size_t WriteHeaders(
 116       QuicStreamId id,
 117       const SpdyHeaderBlock& headers,
 118       bool fin,
 119       QuicAckNotifier::DelegateInterface* ack_notifier_delegate);
 120
 121   // Called by streams when they want to close the stream in both directions.
 122   virtual void SendRstStream(QuicStreamId id,
 123                              QuicRstStreamErrorCode error,
 124                              QuicStreamOffset bytes_written);
 125
 126   // Called when the session wants to go away and not accept any new streams.
 127   void SendGoAway(QuicErrorCode error_code, const std::string& reason);
 128
 129   // Removes the stream associated with 'stream_id' from the active stream map.
 130   virtual void CloseStream(QuicStreamId stream_id);
 131
 132   // Returns true if outgoing packets will be encrypted, even if the server
 133   // hasn't confirmed the handshake yet.
 134   virtual bool IsEncryptionEstablished();
 135
 136   // For a client, returns true if the server has confirmed our handshake. For
 137   // a server, returns true if a full, valid client hello has been received.
 138   virtual bool IsCryptoHandshakeConfirmed();
 139
 140   // Called by the QuicCryptoStream when a new QuicConfig has been negotiated.
 141   virtual void OnConfigNegotiated();
 142
 143   // Called by the QuicCryptoStream when the handshake enters a new state.
 144   //
 145   // Clients will call this function in the order:
 146   //   ENCRYPTION_FIRST_ESTABLISHED
 147   //   zero or more ENCRYPTION_REESTABLISHED
 148   //   HANDSHAKE_CONFIRMED
 149   //
 150   // Servers will simply call it once with HANDSHAKE_CONFIRMED.
 151   virtual void OnCryptoHandshakeEvent(CryptoHandshakeEvent event);
 152
 153   // Called by the QuicCryptoStream when a handshake message is sent.
 154   virtual void OnCryptoHandshakeMessageSent(
 155       const CryptoHandshakeMessage& message);
 156
 157   // Called by the QuicCryptoStream when a handshake message is received.
 158   virtual void OnCryptoHandshakeMessageReceived(
 159       const CryptoHandshakeMessage& message);
 160
 161   // Returns mutable config for this session. Returned config is owned
 162   // by QuicSession.
 163   QuicConfig* config();
 164
 165   // Returns true if the stream existed previously and has been closed.
 166   // Returns false if the stream is still active or if the stream has
 167   // not yet been created.
 168   bool IsClosedStream(QuicStreamId id);
 169
 170   QuicConnection* connection() { return connection_.get(); }
 171   const QuicConnection* connection() const { return connection_.get(); }
 172   size_t num_active_requests() const { return stream_map_.size(); }
 173   const IPEndPoint& peer_address() const {
 174     return connection_->peer_address();
 175   }
 176   QuicConnectionId connection_id() const {
 177     return connection_->connection_id();
 178   }
 179
 180   // Returns the number of currently open streams, including those which have
 181   // been implicitly created, but excluding the reserved headers and crypto
 182   // streams.
 183   virtual size_t GetNumOpenStreams() const;
 184
 185   void MarkWriteBlocked(QuicStreamId id, QuicPriority priority);
 186
 187   // Returns true if the session has data to be sent, either queued in the
 188   // connection, or in a write-blocked stream.
 189   bool HasDataToWrite() const;
 190
 191   bool goaway_received() const {
 192     return goaway_received_;
 193   }
 194
 195   bool goaway_sent() const {
 196     return goaway_sent_;
 197   }
 198
 199   // Gets the SSL connection information.
 200   virtual bool GetSSLInfo(SSLInfo* ssl_info) const;
 201
 202   QuicErrorCode error() const { return error_; }
 203
 204   bool is_server() const { return connection_->is_server(); }
 205
 206   QuicFlowController* flow_controller() { return flow_controller_.get(); }
 207
 208   // Returns true if connection is flow controller blocked.
 209   bool IsConnectionFlowControlBlocked() const;
 210
 211   // Returns true if any stream is flow controller blocked.
 212   bool IsStreamFlowControlBlocked();
 213
 214   // Returns true if this is a secure QUIC session.
 215   bool is_secure() const {
 216     return is_secure_;
 217   }
 218
 219   size_t get_max_open_streams() const { return max_open_streams_; }
 220
 221  protected:
 222   typedef base::hash_map<QuicStreamId, QuicDataStream*> DataStreamMap;
 223
 224   // Creates a new stream, owned by the caller, to handle a peer-initiated
 225   // stream.  Returns nullptr and does error handling if the stream can not be
 226   // created.
 227   virtual QuicDataStream* CreateIncomingDataStream(QuicStreamId id) = 0;
 228
 229   // Create a new stream, owned by the caller, to handle a locally-initiated
 230   // stream.  Returns nullptr if max streams have already been opened.
 231   virtual QuicDataStream* CreateOutgoingDataStream() = 0;
 232
 233   // Return the reserved crypto stream.
 234   virtual QuicCryptoStream* GetCryptoStream() = 0;
 235
 236   // Adds 'stream' to the active stream map.
 237   virtual void ActivateStream(QuicDataStream* stream);
 238
 239   // Returns the stream id for a new stream.
 240   QuicStreamId GetNextStreamId();
 241
 242   QuicDataStream* GetIncomingDataStream(QuicStreamId stream_id);
 243
 244   QuicDataStream* GetDataStream(const QuicStreamId stream_id);
 245
 246   ReliableQuicStream* GetStream(const QuicStreamId stream_id);
 247
 248   // This is called after every call other than OnConnectionClose from the
 249   // QuicConnectionVisitor to allow post-processing once the work has been done.
 250   // In this case, it deletes streams given that it's safe to do so (no other
 251   // operations are being done on the streams at this time)
 252   virtual void PostProcessAfterData();
 253
 254   base::hash_map<QuicStreamId, QuicDataStream*>* streams() {
 255     return &stream_map_;
 256   }
 257
 258   const base::hash_map<QuicStreamId, QuicDataStream*>* streams() const {
 259     return &stream_map_;
 260   }
 261
 262   std::vector<QuicDataStream*>* closed_streams() { return &closed_streams_; }
 263
 264   void set_max_open_streams(size_t max_open_streams);
 265
 266   scoped_ptr<QuicHeadersStream> headers_stream_;
 267
 268  private:
 269   friend class test::QuicSessionPeer;
 270   friend class VisitorShim;
 271
 272   // Performs the work required to close |stream_id|.  If |locally_reset|
 273   // then the stream has been reset by this endpoint, not by the peer.
 274   void CloseStreamInner(QuicStreamId stream_id, bool locally_reset);
 275
 276   // When a stream is closed locally, it may not yet know how many bytes the
 277   // peer sent on that stream.
 278   // When this data arrives (via stream frame w. FIN, or RST) this method
 279   // is called, and correctly updates the connection level flow controller.
 280   void UpdateFlowControlOnFinalReceivedByteOffset(
 281       QuicStreamId id, QuicStreamOffset final_byte_offset);
 282
 283   // Called in OnConfigNegotiated when we receive a new stream level flow
 284   // control window in a negotiated config. Closes the connection if invalid.
 285   void OnNewStreamFlowControlWindow(uint32 new_window);
 286
 287   // Called in OnConfigNegotiated when we receive a new session level flow
 288   // control window in a negotiated config. Closes the connection if invalid.
 289   void OnNewSessionFlowControlWindow(uint32 new_window);
 290
 291   // Keep track of highest received byte offset of locally closed streams, while
 292   // waiting for a definitive final highest offset from the peer.
 293   std::map<QuicStreamId, QuicStreamOffset>
 294       locally_closed_streams_highest_offset_;
 295
 296   scoped_ptr<QuicConnection> connection_;
 297
 298   // A shim to stand between the connection and the session, to handle stream
 299   // deletions.
 300   scoped_ptr<VisitorShim> visitor_shim_;
 301
 302   std::vector<QuicDataStream*> closed_streams_;
 303
 304   QuicConfig config_;
 305
 306   // Returns the maximum number of streams this connection can open.
 307   size_t max_open_streams_;
 308
 309   // Map from StreamId to pointers to streams that are owned by the caller.
 310   DataStreamMap stream_map_;
 311   QuicStreamId next_stream_id_;
 312
 313   // Set of stream ids that have been "implicitly created" by receipt
 314   // of a stream id larger than the next expected stream id.
 315   base::hash_set<QuicStreamId> implicitly_created_streams_;
 316
 317   // A list of streams which need to write more data.
 318   QuicWriteBlockedList write_blocked_streams_;
 319
 320   QuicStreamId largest_peer_created_stream_id_;
 321
 322   // The latched error with which the connection was closed.
 323   QuicErrorCode error_;
 324
 325   // Whether a GoAway has been received.
 326   bool goaway_received_;
 327   // Whether a GoAway has been sent.
 328   bool goaway_sent_;
 329
 330   // Indicate if there is pending data for the crypto stream.
 331   bool has_pending_handshake_;
 332
 333   // Used for session level flow control.
 334   scoped_ptr<QuicFlowController> flow_controller_;
 335
 336   // True if this is a secure (HTTPS) QUIC session.
 337   bool is_secure_;
 338
 339   DISALLOW_COPY_AND_ASSIGN(QuicSession);
 340 };
 341
 342 }  // namespace net
 343
 344 #endif  // NET_QUIC_QUIC_SESSION_H_