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/base/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   virtual ~SSLServerSocketOpenSSL();
  34
  35   // SSLServerSocket interface.
  36   virtual int Handshake(const CompletionCallback& callback) OVERRIDE;
  37
  38   // SSLSocket interface.
  39   virtual 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   virtual int GetTLSUniqueChannelBinding(std::string* out) OVERRIDE;
  45
  46   // Socket interface (via StreamSocket).
  47   virtual int Read(IOBuffer* buf, int buf_len,
  48                    const CompletionCallback& callback) OVERRIDE;
  49   virtual int Write(IOBuffer* buf, int buf_len,
  50                     const CompletionCallback& callback) OVERRIDE;
  51   virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
  52   virtual int SetSendBufferSize(int32 size) OVERRIDE;
  53
  54   // StreamSocket implementation.
  55   virtual int Connect(const CompletionCallback& callback) OVERRIDE;
  56   virtual void Disconnect() OVERRIDE;
  57   virtual bool IsConnected() const OVERRIDE;
  58   virtual bool IsConnectedAndIdle() const OVERRIDE;
  59   virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
  60   virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
  61   virtual const 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 NextProto GetNegotiatedProtocol() const OVERRIDE;
  68   virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
  69
  70  private:
  71   enum State {
  72     STATE_NONE,
  73     STATE_HANDSHAKE,
  74   };
  75
  76   void OnSendComplete(int result);
  77   void OnRecvComplete(int result);
  78   void OnHandshakeIOComplete(int result);
  79
  80   int BufferSend();
  81   void BufferSendComplete(int result);
  82   void TransportWriteComplete(int result);
  83   int BufferRecv();
  84   void BufferRecvComplete(int result);
  85   int TransportReadComplete(int result);
  86   bool DoTransportIO();
  87   int DoPayloadRead();
  88   int DoPayloadWrite();
  89
  90   int DoHandshakeLoop(int last_io_result);
  91   int DoReadLoop(int result);
  92   int DoWriteLoop(int result);
  93   int DoHandshake();
  94   void DoHandshakeCallback(int result);
  95   void DoReadCallback(int result);
  96   void DoWriteCallback(int result);
  97
  98   int Init();
  99
 100   // Members used to send and receive buffer.
 101   bool transport_send_busy_;
 102   bool transport_recv_busy_;
 103   bool transport_recv_eof_;
 104
 105   scoped_refptr<DrainableIOBuffer> send_buffer_;
 106   scoped_refptr<IOBuffer> recv_buffer_;
 107
 108   BoundNetLog net_log_;
 109
 110   CompletionCallback user_handshake_callback_;
 111   CompletionCallback user_read_callback_;
 112   CompletionCallback user_write_callback_;
 113
 114   // Used by Read function.
 115   scoped_refptr<IOBuffer> user_read_buf_;
 116   int user_read_buf_len_;
 117
 118   // Used by Write function.
 119   scoped_refptr<IOBuffer> user_write_buf_;
 120   int user_write_buf_len_;
 121
 122   // Used by TransportWriteComplete() and TransportReadComplete() to signify an
 123   // error writing to the transport socket. A value of OK indicates no error.
 124   int transport_write_error_;
 125
 126   // OpenSSL stuff
 127   SSL* ssl_;
 128   BIO* transport_bio_;
 129
 130   // StreamSocket for sending and receiving data.
 131   scoped_ptr<StreamSocket> transport_socket_;
 132
 133   // Options for the SSL socket.
 134   SSLConfig ssl_config_;
 135
 136   // Certificate for the server.
 137   scoped_refptr<X509Certificate> cert_;
 138
 139   // Private key used by the server.
 140   scoped_ptr<crypto::RSAPrivateKey> key_;
 141
 142   State next_handshake_state_;
 143   bool completed_handshake_;
 144
 145   DISALLOW_COPY_AND_ASSIGN(SSLServerSocketOpenSSL);
 146 };
 147
 148 }  // namespace net
 149
 150 #endif  // NET_SOCKET_SSL_SERVER_SOCKET_OPENSSL_H_