net/socket/ssl_server_socket_openssl.h

   1 // Copyright 2014 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_SOCKET_SSL_SERVER_SOCKET_OPENSSL_H_
   6 #define NET_SOCKET_SSL_SERVER_SOCKET_OPENSSL_H_
   7
   8 #include "base/memory/scoped_ptr.h"
   9 #include "net/base/completion_callback.h"
  10 #include "net/base/io_buffer.h"
  11 #include "net/log/net_log.h"
  12 #include "net/socket/ssl_server_socket.h"
  13 #include "net/ssl/ssl_config_service.h"
  14
  15 // Avoid including misc OpenSSL headers, i.e.:
  16 // <openssl/bio.h>
  17 typedef struct bio_st BIO;
  18 // <openssl/ssl.h>
  19 typedef struct ssl_st SSL;
  20
  21 namespace net {
  22
  23 class SSLInfo;
  24
  25 class SSLServerSocketOpenSSL : public SSLServerSocket {
  26  public:
  27   // See comments on CreateSSLServerSocket for details of how these
  28   // parameters are used.
  29   SSLServerSocketOpenSSL(scoped_ptr<StreamSocket> socket,
  30                          scoped_refptr<X509Certificate> certificate,
  31                          crypto::RSAPrivateKey* key,
  32                          const SSLConfig& ssl_config);
  33   ~SSLServerSocketOpenSSL() override;
  34
  35   // SSLServerSocket interface.
  36   int Handshake(const CompletionCallback& callback) override;
  37
  38   // SSLSocket interface.
  39   int ExportKeyingMaterial(const base::StringPiece& label,
  40                            bool has_context,
  41                            const base::StringPiece& context,
  42                            unsigned char* out,
  43                            unsigned int outlen) override;
  44   int GetTLSUniqueChannelBinding(std::string* out) override;
  45
  46   // Socket interface (via StreamSocket).
  47   int Read(IOBuffer* buf,
  48            int buf_len,
  49            const CompletionCallback& callback) override;
  50   int Write(IOBuffer* buf,
  51             int buf_len,
  52             const CompletionCallback& callback) override;
  53   int SetReceiveBufferSize(int32 size) override;
  54   int SetSendBufferSize(int32 size) override;
  55
  56   // StreamSocket implementation.
  57   int Connect(const CompletionCallback& callback) override;
  58   void Disconnect() override;
  59   bool IsConnected() const override;
  60   bool IsConnectedAndIdle() const override;
  61   int GetPeerAddress(IPEndPoint* address) const override;
  62   int GetLocalAddress(IPEndPoint* address) const override;
  63   const BoundNetLog& NetLog() const override;
  64   void SetSubresourceSpeculation() override;
  65   void SetOmniboxSpeculation() override;
  66   bool WasEverUsed() const override;
  67   bool UsingTCPFastOpen() const override;
  68   bool WasNpnNegotiated() const override;
  69   NextProto GetNegotiatedProtocol() const override;
  70   bool GetSSLInfo(SSLInfo* ssl_info) override;
  71   void GetConnectionAttempts(ConnectionAttempts* out) const override;
  72   void ClearConnectionAttempts() override {}
  73   void AddConnectionAttempts(const ConnectionAttempts& attempts) override {}
  74
  75  private:
  76   enum State {
  77     STATE_NONE,
  78     STATE_HANDSHAKE,
  79   };
  80
  81   void OnSendComplete(int result);
  82   void OnRecvComplete(int result);
  83   void OnHandshakeIOComplete(int result);
  84
  85   int BufferSend();
  86   void BufferSendComplete(int result);
  87   void TransportWriteComplete(int result);
  88   int BufferRecv();
  89   void BufferRecvComplete(int result);
  90   int TransportReadComplete(int result);
  91   bool DoTransportIO();
  92   int DoPayloadRead();
  93   int DoPayloadWrite();
  94
  95   int DoHandshakeLoop(int last_io_result);
  96   int DoReadLoop(int result);
  97   int DoWriteLoop(int result);
  98   int DoHandshake();
  99   void DoHandshakeCallback(int result);
 100   void DoReadCallback(int result);
 101   void DoWriteCallback(int result);
 102
 103   int Init();
 104
 105   // Members used to send and receive buffer.
 106   bool transport_send_busy_;
 107   bool transport_recv_busy_;
 108   bool transport_recv_eof_;
 109
 110   scoped_refptr<DrainableIOBuffer> send_buffer_;
 111   scoped_refptr<IOBuffer> recv_buffer_;
 112
 113   BoundNetLog net_log_;
 114
 115   CompletionCallback user_handshake_callback_;
 116   CompletionCallback user_read_callback_;
 117   CompletionCallback user_write_callback_;
 118
 119   // Used by Read function.
 120   scoped_refptr<IOBuffer> user_read_buf_;
 121   int user_read_buf_len_;
 122
 123   // Used by Write function.
 124   scoped_refptr<IOBuffer> user_write_buf_;
 125   int user_write_buf_len_;
 126
 127   // Used by TransportWriteComplete() and TransportReadComplete() to signify an
 128   // error writing to the transport socket. A value of OK indicates no error.
 129   int transport_write_error_;
 130
 131   // OpenSSL stuff
 132   SSL* ssl_;
 133   BIO* transport_bio_;
 134
 135   // StreamSocket for sending and receiving data.
 136   scoped_ptr<StreamSocket> transport_socket_;
 137
 138   // Options for the SSL socket.
 139   SSLConfig ssl_config_;
 140
 141   // Certificate for the server.
 142   scoped_refptr<X509Certificate> cert_;
 143
 144   // Private key used by the server.
 145   scoped_ptr<crypto::RSAPrivateKey> key_;
 146
 147   State next_handshake_state_;
 148   bool completed_handshake_;
 149
 150   DISALLOW_COPY_AND_ASSIGN(SSLServerSocketOpenSSL);
 151 };
 152
 153 }  // namespace net
 154
 155 #endif  // NET_SOCKET_SSL_SERVER_SOCKET_OPENSSL_H_