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/strings/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   explicit FakeSSLClientSocket(scoped_ptr<net::StreamSocket> transport_socket);
  40
  41   virtual ~FakeSSLClientSocket();
  42
  43   // Exposed for testing.
  44   static base::StringPiece GetSslClientHello();
  45   static base::StringPiece GetSslServerHello();
  46
  47   // net::StreamSocket implementation.
  48   virtual int Read(net::IOBuffer* buf, int buf_len,
  49                    const net::CompletionCallback& callback) OVERRIDE;
  50   virtual int Write(net::IOBuffer* buf, int buf_len,
  51                     const net::CompletionCallback& callback) OVERRIDE;
  52   virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
  53   virtual int SetSendBufferSize(int32 size) OVERRIDE;
  54   virtual int Connect(const net::CompletionCallback& callback) OVERRIDE;
  55   virtual void Disconnect() OVERRIDE;
  56   virtual bool IsConnected() const OVERRIDE;
  57   virtual bool IsConnectedAndIdle() const OVERRIDE;
  58   virtual int GetPeerAddress(net::IPEndPoint* address) const OVERRIDE;
  59   virtual int GetLocalAddress(net::IPEndPoint* address) const OVERRIDE;
  60   virtual const net::BoundNetLog& NetLog() const OVERRIDE;
  61   virtual void SetSubresourceSpeculation() OVERRIDE;
  62   virtual void SetOmniboxSpeculation() OVERRIDE;
  63   virtual bool WasEverUsed() const OVERRIDE;
  64   virtual bool UsingTCPFastOpen() const OVERRIDE;
  65   virtual bool WasNpnNegotiated() const OVERRIDE;
  66   virtual net::NextProto GetNegotiatedProtocol() const OVERRIDE;
  67   virtual bool GetSSLInfo(net::SSLInfo* ssl_info) OVERRIDE;
  68
  69  private:
  70   enum HandshakeState {
  71     STATE_NONE,
  72     STATE_CONNECT,
  73     STATE_SEND_CLIENT_HELLO,
  74     STATE_VERIFY_SERVER_HELLO,
  75   };
  76
  77   int DoHandshakeLoop();
  78   void RunUserConnectCallback(int status);
  79   void DoHandshakeLoopWithUserConnectCallback();
  80
  81   int DoConnect();
  82   void OnConnectDone(int status);
  83   void ProcessConnectDone();
  84
  85   int DoSendClientHello();
  86   void OnSendClientHelloDone(int status);
  87   void ProcessSendClientHelloDone(size_t written);
  88
  89   int DoVerifyServerHello();
  90   void OnVerifyServerHelloDone(int status);
  91   net::Error ProcessVerifyServerHelloDone(size_t read);
  92
  93   scoped_ptr<net::StreamSocket> transport_socket_;
  94
  95   // During the handshake process, holds a value from HandshakeState.
  96   // STATE_NONE otherwise.
  97   HandshakeState next_handshake_state_;
  98
  99   // True iff we're connected and we've finished the handshake.
 100   bool handshake_completed_;
 101
 102   // The callback passed to Connect().
 103   net::CompletionCallback user_connect_callback_;
 104
 105   scoped_refptr<net::DrainableIOBuffer> write_buf_;
 106   scoped_refptr<net::DrainableIOBuffer> read_buf_;
 107 };
 108
 109 }  // namespace jingle_glue
 110
 111 #endif  // JINGLE_GLUE_FAKE_SSL_CLIENT_SOCKET_H_