net/socket/tcp_socket_libevent.h

   1 // Copyright 2013 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_TCP_SOCKET_LIBEVENT_H_
   6 #define NET_SOCKET_TCP_SOCKET_LIBEVENT_H_
   7
   8 #include "base/basictypes.h"
   9 #include "base/callback.h"
  10 #include "base/compiler_specific.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/time/time.h"
  13 #include "net/base/address_family.h"
  14 #include "net/base/completion_callback.h"
  15 #include "net/base/net_export.h"
  16 #include "net/log/net_log.h"
  17
  18 namespace net {
  19
  20 class AddressList;
  21 class IOBuffer;
  22 class IPEndPoint;
  23 class SocketLibevent;
  24
  25 class NET_EXPORT TCPSocketLibevent {
  26  public:
  27   TCPSocketLibevent(NetLog* net_log, const NetLog::Source& source);
  28   virtual ~TCPSocketLibevent();
  29
  30   int Open(AddressFamily family);
  31   // Takes ownership of |socket_fd|.
  32   int AdoptConnectedSocket(int socket_fd, const IPEndPoint& peer_address);
  33
  34   int Bind(const IPEndPoint& address);
  35
  36   int Listen(int backlog);
  37   int Accept(scoped_ptr<TCPSocketLibevent>* socket,
  38              IPEndPoint* address,
  39              const CompletionCallback& callback);
  40
  41   int Connect(const IPEndPoint& address, const CompletionCallback& callback);
  42   bool IsConnected() const;
  43   bool IsConnectedAndIdle() const;
  44
  45   // Multiple outstanding requests are not supported.
  46   // Full duplex mode (reading and writing at the same time) is supported.
  47   int Read(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
  48   int Write(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
  49
  50   int GetLocalAddress(IPEndPoint* address) const;
  51   int GetPeerAddress(IPEndPoint* address) const;
  52
  53   // Sets various socket options.
  54   // The commonly used options for server listening sockets:
  55   // - SetAddressReuse(true).
  56   int SetDefaultOptionsForServer();
  57   // The commonly used options for client sockets and accepted sockets:
  58   // - SetNoDelay(true);
  59   // - SetKeepAlive(true, 45).
  60   void SetDefaultOptionsForClient();
  61   int SetAddressReuse(bool allow);
  62   int SetReceiveBufferSize(int32 size);
  63   int SetSendBufferSize(int32 size);
  64   bool SetKeepAlive(bool enable, int delay);
  65   bool SetNoDelay(bool no_delay);
  66
  67   // Gets the estimated RTT. Returns false if the RTT is
  68   // unavailable. May also return false when estimated RTT is 0.
  69   bool GetEstimatedRoundTripTime(base::TimeDelta* out_rtt) const
  70       WARN_UNUSED_RESULT;
  71
  72   void Close();
  73
  74   // Setter/Getter methods for TCP FastOpen socket option.
  75   bool UsingTCPFastOpen() const;
  76   void EnableTCPFastOpenIfSupported();
  77
  78   bool IsValid() const;
  79
  80   // Marks the start/end of a series of connect attempts for logging purpose.
  81   //
  82   // TCPClientSocket may attempt to connect to multiple addresses until it
  83   // succeeds in establishing a connection. The corresponding log will have
  84   // multiple NetLog::TYPE_TCP_CONNECT_ATTEMPT entries nested within a
  85   // NetLog::TYPE_TCP_CONNECT. These methods set the start/end of
  86   // NetLog::TYPE_TCP_CONNECT.
  87   //
  88   // TODO(yzshen): Change logging format and let TCPClientSocket log the
  89   // start/end of a series of connect attempts itself.
  90   void StartLoggingMultipleConnectAttempts(const AddressList& addresses);
  91   void EndLoggingMultipleConnectAttempts(int net_error);
  92
  93   const BoundNetLog& net_log() const { return net_log_; }
  94
  95  private:
  96   // States that using a socket with TCP FastOpen can lead to.
  97   enum TCPFastOpenStatus {
  98     TCP_FASTOPEN_STATUS_UNKNOWN,
  99
 100     // The initial FastOpen connect attempted returned synchronously,
 101     // indicating that we had and sent a cookie along with the initial data.
 102     TCP_FASTOPEN_FAST_CONNECT_RETURN,
 103
 104     // The initial FastOpen connect attempted returned asynchronously,
 105     // indicating that we did not have a cookie for the server.
 106     TCP_FASTOPEN_SLOW_CONNECT_RETURN,
 107
 108     // Some other error occurred on connection, so we couldn't tell if
 109     // FastOpen would have worked.
 110     TCP_FASTOPEN_ERROR,
 111
 112     // An attempt to do a FastOpen succeeded immediately
 113     // (TCP_FASTOPEN_FAST_CONNECT_RETURN) and we later confirmed that the server
 114     // had acked the data we sent.
 115     TCP_FASTOPEN_SYN_DATA_ACK,
 116
 117     // An attempt to do a FastOpen succeeded immediately
 118     // (TCP_FASTOPEN_FAST_CONNECT_RETURN) and we later confirmed that the server
 119     // had nacked the data we sent.
 120     TCP_FASTOPEN_SYN_DATA_NACK,
 121
 122     // An attempt to do a FastOpen succeeded immediately
 123     // (TCP_FASTOPEN_FAST_CONNECT_RETURN) and our probe to determine if the
 124     // socket was using FastOpen failed.
 125     TCP_FASTOPEN_SYN_DATA_GETSOCKOPT_FAILED,
 126
 127     // An attempt to do a FastOpen failed (TCP_FASTOPEN_SLOW_CONNECT_RETURN)
 128     // and we later confirmed that the server had acked initial data.  This
 129     // should never happen (we didn't send data, so it shouldn't have
 130     // been acked).
 131     TCP_FASTOPEN_NO_SYN_DATA_ACK,
 132
 133     // An attempt to do a FastOpen failed (TCP_FASTOPEN_SLOW_CONNECT_RETURN)
 134     // and we later discovered that the server had nacked initial data.  This
 135     // is the expected case results for TCP_FASTOPEN_SLOW_CONNECT_RETURN.
 136     TCP_FASTOPEN_NO_SYN_DATA_NACK,
 137
 138     // An attempt to do a FastOpen failed (TCP_FASTOPEN_SLOW_CONNECT_RETURN)
 139     // and our later probe for ack/nack state failed.
 140     TCP_FASTOPEN_NO_SYN_DATA_GETSOCKOPT_FAILED,
 141
 142     // The initial FastOpen connect+write succeeded immediately
 143     // (TCP_FASTOPEN_FAST_CONNECT_RETURN) and a subsequent attempt to read from
 144     // the connection failed.
 145     TCP_FASTOPEN_FAST_CONNECT_READ_FAILED,
 146
 147     // The initial FastOpen connect+write failed
 148     // (TCP_FASTOPEN_SLOW_CONNECT_RETURN)
 149     // and a subsequent attempt to read from the connection failed.
 150     TCP_FASTOPEN_SLOW_CONNECT_READ_FAILED,
 151
 152     // We didn't try FastOpen because it had failed in the past
 153     // (g_tcp_fastopen_has_failed was true.)
 154     // NOTE: This status is currently registered before a connect/write call
 155     // is attempted, and may capture some cases where the status is registered
 156     // but no connect is subsequently attempted.
 157     // TODO(jri): The expectation is that such cases are not the common case
 158     // with TCP FastOpen for SSL sockets however. Change code to be more
 159     // accurate when TCP FastOpen is used for more than just SSL sockets.
 160     TCP_FASTOPEN_PREVIOUSLY_FAILED,
 161
 162     TCP_FASTOPEN_MAX_VALUE
 163   };
 164
 165   void AcceptCompleted(scoped_ptr<TCPSocketLibevent>* tcp_socket,
 166                        IPEndPoint* address,
 167                        const CompletionCallback& callback,
 168                        int rv);
 169   int HandleAcceptCompleted(scoped_ptr<TCPSocketLibevent>* tcp_socket,
 170                             IPEndPoint* address,
 171                             int rv);
 172   int BuildTcpSocketLibevent(scoped_ptr<TCPSocketLibevent>* tcp_socket,
 173                              IPEndPoint* address);
 174
 175   void ConnectCompleted(const CompletionCallback& callback, int rv) const;
 176   int HandleConnectCompleted(int rv) const;
 177   void LogConnectBegin(const AddressList& addresses) const;
 178   void LogConnectEnd(int net_error) const;
 179
 180   void ReadCompleted(const scoped_refptr<IOBuffer>& buf,
 181                      const CompletionCallback& callback,
 182                      int rv);
 183   int HandleReadCompleted(IOBuffer* buf, int rv);
 184
 185   void WriteCompleted(const scoped_refptr<IOBuffer>& buf,
 186                       const CompletionCallback& callback,
 187                       int rv);
 188   int HandleWriteCompleted(IOBuffer* buf, int rv);
 189   int TcpFastOpenWrite(IOBuffer* buf,
 190                        int buf_len,
 191                        const CompletionCallback& callback);
 192
 193   // Called after the first read completes on a TCP FastOpen socket.
 194   void UpdateTCPFastOpenStatusAfterRead();
 195
 196   scoped_ptr<SocketLibevent> socket_;
 197   scoped_ptr<SocketLibevent> accept_socket_;
 198
 199   // Enables experimental TCP FastOpen option.
 200   bool use_tcp_fastopen_;
 201
 202   // True when TCP FastOpen is in use and we have attempted the
 203   // connect with write.
 204   bool tcp_fastopen_write_attempted_;
 205
 206   // True when TCP FastOpen is in use and we have done the connect.
 207   bool tcp_fastopen_connected_;
 208
 209   TCPFastOpenStatus tcp_fastopen_status_;
 210
 211   bool logging_multiple_connect_attempts_;
 212
 213   BoundNetLog net_log_;
 214
 215   DISALLOW_COPY_AND_ASSIGN(TCPSocketLibevent);
 216 };
 217
 218 }  // namespace net
 219
 220 #endif  // NET_SOCKET_TCP_SOCKET_LIBEVENT_H_