Landing Recent QUIC changes until Sun Sep 4 03:41:00

net/quic/core/quic_crypto_server_stream.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_QUIC_QUIC_CRYPTO_SERVER_STREAM_H_
 #define NET_QUIC_QUIC_CRYPTO_SERVER_STREAM_H_
 
 #include <cstdint>
 #include <memory>
 #include <string>
@@ skipping 16 matching lines @@
 
 namespace test {
 class CryptoTestUtils;
 class QuicCryptoServerStreamPeer;
 }  // namespace test
 
 // TODO(alyssar) see what can be moved out of QuicCryptoServerStream with
 // various code and test refactoring.
 class NET_EXPORT_PRIVATE QuicCryptoServerStreamBase : public QuicCryptoStream {
  public:
-  explicit QuicCryptoServerStreamBase(QuicServerSessionBase* session);
+  explicit QuicCryptoServerStreamBase(QuicSession* session);
+
   ~QuicCryptoServerStreamBase() override {}
 
   // Cancel any outstanding callbacks, such as asynchronous validation of client
   // hello.
   virtual void CancelOutstandingCallbacks() = 0;
 
   // GetBase64SHA256ClientChannelID sets |*output| to the base64 encoded,
   // SHA-256 hash of the client's ChannelID key and returns true, if the client
   // presented a ChannelID. Otherwise it returns false.
   virtual bool GetBase64SHA256ClientChannelID(std::string* output) const = 0;
@@ skipping 21 matching lines @@
 
   // Checks the options on the handshake-message to see whether the
   // peer supports stateless-rejects.
   static bool DoesPeerSupportStatelessRejects(
       const CryptoHandshakeMessage& message);
 };
 
 class NET_EXPORT_PRIVATE QuicCryptoServerStream
     : public QuicCryptoServerStreamBase {
  public:
+  class Helper {
+   public:
+    virtual ~Helper() {}
+
+    // Given the current connection_id, generates a new ConnectionId to
+    // be returned with a stateless reject.
+    virtual QuicConnectionId GenerateConnectionIdForReject(
+        QuicConnectionId connection_id) const = 0;
+
+    // Returns true if |message|, which was received on |self_address| is
+    // acceptable according to the visitor's policy. Otherwise, returns false
+    // and populates |error_details|.
+    virtual bool CanAcceptClientHello(const CryptoHandshakeMessage& message,
+                                      const IPEndPoint& self_address,
+                                      std::string* error_details) const = 0;
+  };
+
   // |crypto_config| must outlive the stream.
+  // |session| must outlive the stream.
+  // |helper| must outlive the stream.
   QuicCryptoServerStream(const QuicCryptoServerConfig* crypto_config,
                          QuicCompressedCertsCache* compressed_certs_cache,
                          bool use_stateless_rejects_if_peer_supported,
-                         QuicServerSessionBase* session);
+                         QuicSession* session,
+                         Helper* helper);
+
   ~QuicCryptoServerStream() override;
 
   // From QuicCryptoServerStreamBase
   void CancelOutstandingCallbacks() override;
   void OnHandshakeMessage(const CryptoHandshakeMessage& message) override;
   bool GetBase64SHA256ClientChannelID(std::string* output) const override;
   void SendServerConfigUpdate(
       const CachedNetworkParameters* cached_network_params) override;
   void OnServerHelloAcked() override;
   uint8_t NumHandshakeMessages() const override;
@@ skipping 92 matching lines @@
   // Hash of the last received CHLO message which can be used for generating
   // server config update messages.
   std::string chlo_hash_;
 
   // Pointer to the active callback that will receive the result of
   // the client hello validation request and forward it to
   // FinishProcessingHandshakeMessage for processing.  nullptr if no
   // handshake message is being validated.
   ValidateCallback* validate_client_hello_cb_;
 
+  // Pointer to the helper for this crypto stream. Must outlive this stream.
+  Helper* helper_;
+
   // Number of handshake messages received by this stream.
   uint8_t num_handshake_messages_;
 
   // Number of handshake messages received by this stream that contain
   // server nonces (indicating that this is a non-zero-RTT handshake
   // attempt).
   uint8_t num_handshake_messages_with_server_nonces_;
 
   // Pointer to the active callback that will receive the result of
   // BuildServerConfigUpdateMessage and forward it to
@@ skipping 25 matching lines @@
 
   // Size of the packet containing the most recently received CHLO.
   QuicByteCount chlo_packet_size_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicCryptoServerStream);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CRYPTO_SERVER_STREAM_H_