src/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/ref_counted.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "base/threading/non_thread_safe.h"
  15 #include "net/base/address_family.h"
  16 #include "net/base/completion_callback.h"
  17 #include "net/base/net_export.h"
  18 #include "net/base/net_log.h"
  19 #include "net/socket/socket_descriptor.h"
  20
  21 namespace net {
  22
  23 class AddressList;
  24 class IOBuffer;
  25 class IPEndPoint;
  26
  27 class NET_EXPORT TCPSocketLibevent : public base::NonThreadSafe {
  28  public:
  29   TCPSocketLibevent(NetLog* net_log, const NetLog::Source& source);
  30   virtual ~TCPSocketLibevent();
  31
  32   int Open(AddressFamily family);
  33   // Takes ownership of |socket|.
  34   int AdoptConnectedSocket(int socket, const IPEndPoint& peer_address);
  35
  36   int Bind(const IPEndPoint& address);
  37
  38   int Listen(int backlog);
  39   int Accept(scoped_ptr<TCPSocketLibevent>* socket,
  40              IPEndPoint* address,
  41              const CompletionCallback& callback);
  42
  43   int Connect(const IPEndPoint& address, const CompletionCallback& callback);
  44   bool IsConnected() const;
  45   bool IsConnectedAndIdle() const;
  46
  47   // Multiple outstanding requests are not supported.
  48   // Full duplex mode (reading and writing at the same time) is supported.
  49   int Read(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
  50   int Write(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
  51
  52   int GetLocalAddress(IPEndPoint* address) const;
  53   int GetPeerAddress(IPEndPoint* address) const;
  54
  55   // Sets various socket options.
  56   // The commonly used options for server listening sockets:
  57   // - SetAddressReuse(true).
  58   int SetDefaultOptionsForServer();
  59   // The commonly used options for client sockets and accepted sockets:
  60   // - SetNoDelay(true);
  61   // - SetKeepAlive(true, 45).
  62   void SetDefaultOptionsForClient();
  63   int SetAddressReuse(bool allow);
  64   int SetReceiveBufferSize(int32 size);
  65   int SetSendBufferSize(int32 size);
  66   bool SetKeepAlive(bool enable, int delay);
  67   bool SetNoDelay(bool no_delay);
  68
  69   void Close();
  70
  71   bool UsingTCPFastOpen() const;
  72   bool IsValid() const { return socket_ != kInvalidSocket; }
  73
  74   // Marks the start/end of a series of connect attempts for logging purpose.
  75   //
  76   // TCPClientSocket may attempt to connect to multiple addresses until it
  77   // succeeds in establishing a connection. The corresponding log will have
  78   // multiple NetLog::TYPE_TCP_CONNECT_ATTEMPT entries nested within a
  79   // NetLog::TYPE_TCP_CONNECT. These methods set the start/end of
  80   // NetLog::TYPE_TCP_CONNECT.
  81   //
  82   // TODO(yzshen): Change logging format and let TCPClientSocket log the
  83   // start/end of a series of connect attempts itself.
  84   void StartLoggingMultipleConnectAttempts(const AddressList& addresses);
  85   void EndLoggingMultipleConnectAttempts(int net_error);
  86
  87   const BoundNetLog& net_log() const { return net_log_; }
  88
  89  private:
  90   // States that a fast open socket attempt can result in.
  91   enum FastOpenStatus {
  92     FAST_OPEN_STATUS_UNKNOWN,
  93
  94     // The initial fast open connect attempted returned synchronously,
  95     // indicating that we had and sent a cookie along with the initial data.
  96     FAST_OPEN_FAST_CONNECT_RETURN,
  97
  98     // The initial fast open connect attempted returned asynchronously,
  99     // indicating that we did not have a cookie for the server.
 100     FAST_OPEN_SLOW_CONNECT_RETURN,
 101
 102     // Some other error occurred on connection, so we couldn't tell if
 103     // fast open would have worked.
 104     FAST_OPEN_ERROR,
 105
 106     // An attempt to do a fast open succeeded immediately
 107     // (FAST_OPEN_FAST_CONNECT_RETURN) and we later confirmed that the server
 108     // had acked the data we sent.
 109     FAST_OPEN_SYN_DATA_ACK,
 110
 111     // An attempt to do a fast open succeeded immediately
 112     // (FAST_OPEN_FAST_CONNECT_RETURN) and we later confirmed that the server
 113     // had nacked the data we sent.
 114     FAST_OPEN_SYN_DATA_NACK,
 115
 116     // An attempt to do a fast open succeeded immediately
 117     // (FAST_OPEN_FAST_CONNECT_RETURN) and our probe to determine if the
 118     // socket was using fast open failed.
 119     FAST_OPEN_SYN_DATA_FAILED,
 120
 121     // An attempt to do a fast open failed (FAST_OPEN_SLOW_CONNECT_RETURN)
 122     // and we later confirmed that the server had acked initial data.  This
 123     // should never happen (we didn't send data, so it shouldn't have
 124     // been acked).
 125     FAST_OPEN_NO_SYN_DATA_ACK,
 126
 127     // An attempt to do a fast open failed (FAST_OPEN_SLOW_CONNECT_RETURN)
 128     // and we later discovered that the server had nacked initial data.  This
 129     // is the expected case results for FAST_OPEN_SLOW_CONNECT_RETURN.
 130     FAST_OPEN_NO_SYN_DATA_NACK,
 131
 132     // An attempt to do a fast open failed (FAST_OPEN_SLOW_CONNECT_RETURN)
 133     // and our later probe for ack/nack state failed.
 134     FAST_OPEN_NO_SYN_DATA_FAILED,
 135
 136     FAST_OPEN_MAX_VALUE
 137   };
 138
 139   // Watcher simply forwards notifications to Closure objects set via the
 140   // constructor.
 141   class Watcher: public base::MessageLoopForIO::Watcher {
 142    public:
 143     Watcher(const base::Closure& read_ready_callback,
 144             const base::Closure& write_ready_callback);
 145     virtual ~Watcher();
 146
 147     // base::MessageLoopForIO::Watcher methods.
 148     virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
 149     virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
 150
 151    private:
 152     base::Closure read_ready_callback_;
 153     base::Closure write_ready_callback_;
 154
 155     DISALLOW_COPY_AND_ASSIGN(Watcher);
 156   };
 157
 158   int AcceptInternal(scoped_ptr<TCPSocketLibevent>* socket,
 159                      IPEndPoint* address);
 160
 161   int DoConnect();
 162   void DoConnectComplete(int result);
 163
 164   void LogConnectBegin(const AddressList& addresses);
 165   void LogConnectEnd(int net_error);
 166
 167   void DidCompleteRead();
 168   void DidCompleteWrite();
 169   void DidCompleteConnect();
 170   void DidCompleteConnectOrWrite();
 171   void DidCompleteAccept();
 172
 173   // Internal function to write to a socket. Returns an OS error.
 174   int InternalWrite(IOBuffer* buf, int buf_len);
 175
 176   // Called when the socket is known to be in a connected state.
 177   void RecordFastOpenStatus();
 178
 179   int socket_;
 180
 181   base::MessageLoopForIO::FileDescriptorWatcher accept_socket_watcher_;
 182   Watcher accept_watcher_;
 183
 184   scoped_ptr<TCPSocketLibevent>* accept_socket_;
 185   IPEndPoint* accept_address_;
 186   CompletionCallback accept_callback_;
 187
 188   // The socket's libevent wrappers for reads and writes.
 189   base::MessageLoopForIO::FileDescriptorWatcher read_socket_watcher_;
 190   base::MessageLoopForIO::FileDescriptorWatcher write_socket_watcher_;
 191
 192   // The corresponding watchers for reads and writes.
 193   Watcher read_watcher_;
 194   Watcher write_watcher_;
 195
 196   // The buffer used for reads.
 197   scoped_refptr<IOBuffer> read_buf_;
 198   int read_buf_len_;
 199
 200   // The buffer used for writes.
 201   scoped_refptr<IOBuffer> write_buf_;
 202   int write_buf_len_;
 203
 204   // External callback; called when read is complete.
 205   CompletionCallback read_callback_;
 206
 207   // External callback; called when write or connect is complete.
 208   CompletionCallback write_callback_;
 209
 210   // Enables experimental TCP FastOpen option.
 211   const bool use_tcp_fastopen_;
 212
 213   // True when TCP FastOpen is in use and we have done the connect.
 214   bool tcp_fastopen_connected_;
 215
 216   FastOpenStatus fast_open_status_;
 217
 218   // A connect operation is pending. In this case, |write_callback_| needs to be
 219   // called when connect is complete.
 220   bool waiting_connect_;
 221
 222   scoped_ptr<IPEndPoint> peer_address_;
 223   // The OS error that a connect attempt last completed with.
 224   int connect_os_error_;
 225
 226   bool logging_multiple_connect_attempts_;
 227
 228   BoundNetLog net_log_;
 229
 230   DISALLOW_COPY_AND_ASSIGN(TCPSocketLibevent);
 231 };
 232
 233 }  // namespace net
 234
 235 #endif  // NET_SOCKET_TCP_SOCKET_LIBEVENT_H_