net/quic/quic_crypto_client_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_CLIENT_STREAM_H_
   6 #define NET_QUIC_QUIC_CRYPTO_CLIENT_STREAM_H_
   7
   8 #include <string>
   9
  10 #include "net/quic/crypto/proof_verifier.h"
  11 #include "net/quic/crypto/quic_crypto_client_config.h"
  12 #include "net/quic/quic_config.h"
  13 #include "net/quic/quic_crypto_stream.h"
  14 #include "net/quic/quic_session_key.h"
  15
  16 namespace net {
  17
  18 class QuicClientSessionBase;
  19
  20 namespace test {
  21 class CryptoTestUtils;
  22 }  // namespace test
  23
  24 class NET_EXPORT_PRIVATE QuicCryptoClientStream : public QuicCryptoStream {
  25  public:
  26   QuicCryptoClientStream(const QuicSessionKey& server_key,
  27                          QuicClientSessionBase* session,
  28                          ProofVerifyContext* verify_context,
  29                          QuicCryptoClientConfig* crypto_config);
  30   virtual ~QuicCryptoClientStream();
  31
  32   // CryptoFramerVisitorInterface implementation
  33   virtual void OnHandshakeMessage(
  34       const CryptoHandshakeMessage& message) OVERRIDE;
  35
  36   // Performs a crypto handshake with the server. Returns true if the crypto
  37   // handshake is started successfully.
  38   // TODO(agl): this should probably return void.
  39   virtual bool CryptoConnect();
  40
  41   // num_sent_client_hellos returns the number of client hello messages that
  42   // have been sent. If the handshake has completed then this is one greater
  43   // than the number of round-trips needed for the handshake.
  44   int num_sent_client_hellos() const;
  45
  46  private:
  47   // ProofVerifierCallbackImpl is passed as the callback method to VerifyProof.
  48   // The ProofVerifier calls this class with the result of proof verification
  49   // when verification is performed asynchronously.
  50   class ProofVerifierCallbackImpl : public ProofVerifierCallback {
  51    public:
  52     explicit ProofVerifierCallbackImpl(QuicCryptoClientStream* stream);
  53     virtual ~ProofVerifierCallbackImpl();
  54
  55     // ProofVerifierCallback interface.
  56     virtual void Run(bool ok,
  57                      const string& error_details,
  58                      scoped_ptr<ProofVerifyDetails>* details) OVERRIDE;
  59
  60     // Cancel causes any future callbacks to be ignored. It must be called on
  61     // the same thread as the callback will be made on.
  62     void Cancel();
  63
  64    private:
  65     QuicCryptoClientStream* stream_;
  66   };
  67
  68   friend class test::CryptoTestUtils;
  69   friend class ProofVerifierCallbackImpl;
  70
  71   enum State {
  72     STATE_IDLE,
  73     STATE_INITIALIZE,
  74     STATE_SEND_CHLO,
  75     STATE_RECV_REJ,
  76     STATE_VERIFY_PROOF,
  77     STATE_VERIFY_PROOF_COMPLETE,
  78     STATE_RECV_SHLO,
  79   };
  80
  81   // DoHandshakeLoop performs a step of the handshake state machine. Note that
  82   // |in| may be NULL if the call did not result from a received message.
  83   void DoHandshakeLoop(const CryptoHandshakeMessage* in);
  84
  85   // Called to set the proof of |cached| valid.  Also invokes the session's
  86   // OnProofValid() method.
  87   void SetCachedProofValid(QuicCryptoClientConfig::CachedState* cached);
  88
  89   QuicClientSessionBase* client_session();
  90
  91   State next_state_;
  92   // num_client_hellos_ contains the number of client hello messages that this
  93   // connection has sent.
  94   int num_client_hellos_;
  95
  96   QuicCryptoClientConfig* const crypto_config_;
  97
  98   // Client's connection nonce (4-byte timestamp + 28 random bytes)
  99   std::string nonce_;
 100   // Server's (hostname, port, is_https) tuple.
 101   const QuicSessionKey server_key_;
 102
 103   // Generation counter from QuicCryptoClientConfig's CachedState.
 104   uint64 generation_counter_;
 105
 106   // proof_verify_callback_ contains the callback object that we passed to an
 107   // asynchronous proof verification. The ProofVerifier owns this object.
 108   ProofVerifierCallbackImpl* proof_verify_callback_;
 109
 110   // These members are used to store the result of an asynchronous proof
 111   // verification. These members must not be used after
 112   // STATE_VERIFY_PROOF_COMPLETE.
 113   bool verify_ok_;
 114   string verify_error_details_;
 115   scoped_ptr<ProofVerifyDetails> verify_details_;
 116   scoped_ptr<ProofVerifyContext> verify_context_;
 117
 118   DISALLOW_COPY_AND_ASSIGN(QuicCryptoClientStream);
 119 };
 120
 121 }  // namespace net
 122
 123 #endif  // NET_QUIC_QUIC_CRYPTO_CLIENT_STREAM_H_