net/quic/quic_crypto_server_stream.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 #ifndef NET_QUIC_QUIC_CRYPTO_SERVER_STREAM_H_
   6 #define NET_QUIC_QUIC_CRYPTO_SERVER_STREAM_H_
   7
   8 #include <string>
   9
  10 #include "net/quic/crypto/crypto_handshake.h"
  11 #include "net/quic/crypto/quic_crypto_server_config.h"
  12 #include "net/quic/quic_config.h"
  13 #include "net/quic/quic_crypto_stream.h"
  14
  15 namespace net {
  16
  17 class CachedNetworkParameters;
  18 class CryptoHandshakeMessage;
  19 class QuicCryptoServerConfig;
  20 class QuicCryptoServerStream;
  21 class QuicSession;
  22 class SourceAddressTokens;
  23
  24 namespace test {
  25 class CryptoTestUtils;
  26 }  // namespace test
  27
  28 // Receives a notification when the server hello (SHLO) has been ACKed by the
  29 // peer. At this point we disable HANDSHAKE_MODE in the sent packet manager.
  30 class NET_EXPORT_PRIVATE ServerHelloNotifier : public
  31     QuicAckNotifier::DelegateInterface {
  32  public:
  33   explicit ServerHelloNotifier(QuicCryptoServerStream* stream)
  34       : server_stream_(stream) {}
  35
  36   // QuicAckNotifier::DelegateInterface implementation
  37   void OnAckNotification(int num_retransmitted_packets,
  38                          int num_retransmitted_bytes,
  39                          QuicTime::Delta delta_largest_observed) override;
  40
  41  private:
  42   ~ServerHelloNotifier() override {}
  43
  44   QuicCryptoServerStream* server_stream_;
  45
  46   DISALLOW_COPY_AND_ASSIGN(ServerHelloNotifier);
  47 };
  48
  49 class NET_EXPORT_PRIVATE QuicCryptoServerStream : public QuicCryptoStream {
  50  public:
  51   // |crypto_config| must outlive the stream.
  52   QuicCryptoServerStream(const QuicCryptoServerConfig* crypto_config,
  53                          QuicSession* session);
  54   ~QuicCryptoServerStream() override;
  55
  56   // Cancel any outstanding callbacks, such as asynchronous validation of client
  57   // hello.
  58   void CancelOutstandingCallbacks();
  59
  60   // CryptoFramerVisitorInterface implementation
  61   void OnHandshakeMessage(const CryptoHandshakeMessage& message) override;
  62
  63   // GetBase64SHA256ClientChannelID sets |*output| to the base64 encoded,
  64   // SHA-256 hash of the client's ChannelID key and returns true, if the client
  65   // presented a ChannelID. Otherwise it returns false.
  66   bool GetBase64SHA256ClientChannelID(std::string* output) const;
  67
  68   uint8 num_handshake_messages() const { return num_handshake_messages_; }
  69
  70   int num_server_config_update_messages_sent() const {
  71     return num_server_config_update_messages_sent_;
  72   }
  73
  74   // Sends the latest server config and source-address token to the client.
  75   virtual void SendServerConfigUpdate(
  76       const CachedNetworkParameters* cached_network_params);
  77
  78   // Called by the ServerHello AckNotifier once the SHLO has been ACKed by the
  79   // client.
  80   void OnServerHelloAcked();
  81
  82   void set_previous_cached_network_params(
  83       CachedNetworkParameters cached_network_params);
  84
  85   const CachedNetworkParameters* previous_cached_network_params() const;
  86
  87  protected:
  88   virtual QuicErrorCode ProcessClientHello(
  89       const CryptoHandshakeMessage& message,
  90       const ValidateClientHelloResultCallback::Result& result,
  91       CryptoHandshakeMessage* reply,
  92       std::string* error_details);
  93
  94   // Hook that allows the server to set QuicConfig defaults just
  95   // before going through the parameter negotiation step.
  96   virtual void OverrideQuicConfigDefaults(QuicConfig* config);
  97
  98  private:
  99   friend class test::CryptoTestUtils;
 100
 101   class ValidateCallback : public ValidateClientHelloResultCallback {
 102    public:
 103     explicit ValidateCallback(QuicCryptoServerStream* parent);
 104     // To allow the parent to detach itself from the callback before deletion.
 105     void Cancel();
 106
 107     // From ValidateClientHelloResultCallback
 108     void RunImpl(const CryptoHandshakeMessage& client_hello,
 109                  const Result& result) override;
 110
 111    private:
 112     QuicCryptoServerStream* parent_;
 113
 114     DISALLOW_COPY_AND_ASSIGN(ValidateCallback);
 115   };
 116
 117   // Invoked by ValidateCallback::RunImpl once initial validation of
 118   // the client hello is complete.  Finishes processing of the client
 119   // hello message and handles handshake success/failure.
 120   void FinishProcessingHandshakeMessage(
 121       const CryptoHandshakeMessage& message,
 122       const ValidateClientHelloResultCallback::Result& result);
 123
 124   // crypto_config_ contains crypto parameters for the handshake.
 125   const QuicCryptoServerConfig* crypto_config_;
 126
 127   // Pointer to the active callback that will receive the result of
 128   // the client hello validation request and forward it to
 129   // FinishProcessingHandshakeMessage for processing.  nullptr if no
 130   // handshake message is being validated.
 131   ValidateCallback* validate_client_hello_cb_;
 132
 133   // Number of handshake messages received by this stream.
 134   uint8 num_handshake_messages_;
 135
 136   // Number of server config update (SCUP) messages sent by this stream.
 137   int num_server_config_update_messages_sent_;
 138
 139   // If the client provides CachedNetworkParameters in the STK in the CHLO, then
 140   // store here, and send back in future STKs if we have no better bandwidth
 141   // estimate to send.
 142   scoped_ptr<CachedNetworkParameters> previous_cached_network_params_;
 143
 144   // Contains any source address tokens which were present in the CHLO.
 145   SourceAddressTokens previous_source_address_tokens_;
 146
 147   DISALLOW_COPY_AND_ASSIGN(QuicCryptoServerStream);
 148 };
 149
 150 }  // namespace net
 151
 152 #endif  // NET_QUIC_QUIC_CRYPTO_SERVER_STREAM_H_