Home | History | Annotate | Download | only in socket 
      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_
    151