jingle/glue/fake_ssl_client_socket.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 // This StreamSocket implementation is to be used with servers that
   6 // accept connections on port 443 but don't really use SSL.  For
   7 // example, the Google Talk servers do this to bypass proxies.  (The
   8 // connection is upgraded to TLS as part of the XMPP negotiation, so
   9 // security is preserved.)  A "fake" SSL handshake is done immediately
  10 // after connection to fool proxies into thinking that this is a real
  11 // SSL connection.
  12 //
  13 // NOTE: This StreamSocket implementation does *not* do a real SSL
  14 // handshake nor does it do any encryption!
  15
  16 #ifndef JINGLE_GLUE_FAKE_SSL_CLIENT_SOCKET_H_
  17 #define JINGLE_GLUE_FAKE_SSL_CLIENT_SOCKET_H_
  18
  19 #include <cstddef>
  20
  21 #include "base/basictypes.h"
  22 #include "base/compiler_specific.h"
  23 #include "base/memory/ref_counted.h"
  24 #include "base/memory/scoped_ptr.h"
  25 #include "base/string_piece.h"
  26 #include "net/base/completion_callback.h"
  27 #include "net/base/net_errors.h"
  28 #include "net/socket/stream_socket.h"
  29
  30 namespace net {
  31 class DrainableIOBuffer;
  32 class SSLInfo;
  33 }  // namespace net
  34
  35 namespace jingle_glue {
  36
  37 class FakeSSLClientSocket : public net::StreamSocket {
  38  public:
  39   // Takes ownership of |transport_socket|.
  40   explicit FakeSSLClientSocket(net::StreamSocket* transport_socket);
  41
  42   virtual ~FakeSSLClientSocket();
  43
  44   // Exposed for testing.
  45   static base::StringPiece GetSslClientHello();
  46   static base::StringPiece GetSslServerHello();
  47
  48   // net::StreamSocket implementation.
  49   virtual int Read(net::IOBuffer* buf, int buf_len,
  50                    const net::CompletionCallback& callback) OVERRIDE;
  51   virtual int Write(net::IOBuffer* buf, int buf_len,
  52                     const net::CompletionCallback& callback) OVERRIDE;
  53   virtual bool SetReceiveBufferSize(int32 size) OVERRIDE;
  54   virtual bool SetSendBufferSize(int32 size) OVERRIDE;
  55   virtual int Connect(const net::CompletionCallback& callback) OVERRIDE;
  56   virtual void Disconnect() OVERRIDE;
  57   virtual bool IsConnected() const OVERRIDE;
  58   virtual bool IsConnectedAndIdle() const OVERRIDE;
  59   virtual int GetPeerAddress(net::IPEndPoint* address) const OVERRIDE;
  60   virtual int GetLocalAddress(net::IPEndPoint* address) const OVERRIDE;
  61   virtual const net::BoundNetLog& NetLog() const OVERRIDE;
  62   virtual void SetSubresourceSpeculation() OVERRIDE;
  63   virtual void SetOmniboxSpeculation() OVERRIDE;
  64   virtual bool WasEverUsed() const OVERRIDE;
  65   virtual bool UsingTCPFastOpen() const OVERRIDE;
  66   virtual bool WasNpnNegotiated() const OVERRIDE;
  67   virtual net::NextProto GetNegotiatedProtocol() const OVERRIDE;
  68   virtual bool GetSSLInfo(net::SSLInfo* ssl_info) OVERRIDE;
  69
  70  private:
  71   enum HandshakeState {
  72     STATE_NONE,
  73     STATE_CONNECT,
  74     STATE_SEND_CLIENT_HELLO,
  75     STATE_VERIFY_SERVER_HELLO,
  76   };
  77
  78   int DoHandshakeLoop();
  79   void RunUserConnectCallback(int status);
  80   void DoHandshakeLoopWithUserConnectCallback();
  81
  82   int DoConnect();
  83   void OnConnectDone(int status);
  84   void ProcessConnectDone();
  85
  86   int DoSendClientHello();
  87   void OnSendClientHelloDone(int status);
  88   void ProcessSendClientHelloDone(size_t written);
  89
  90   int DoVerifyServerHello();
  91   void OnVerifyServerHelloDone(int status);
  92   net::Error ProcessVerifyServerHelloDone(size_t read);
  93
  94   scoped_ptr<net::StreamSocket> transport_socket_;
  95
  96   // During the handshake process, holds a value from HandshakeState.
  97   // STATE_NONE otherwise.
  98   HandshakeState next_handshake_state_;
  99
 100   // True iff we're connected and we've finished the handshake.
 101   bool handshake_completed_;
 102
 103   // The callback passed to Connect().
 104   net::CompletionCallback user_connect_callback_;
 105
 106   scoped_refptr<net::DrainableIOBuffer> write_buf_;
 107   scoped_refptr<net::DrainableIOBuffer> read_buf_;
 108 };
 109
 110 }  // namespace jingle_glue
 111
 112 #endif  // JINGLE_GLUE_FAKE_SSL_CLIENT_SOCKET_H_