Plumbing for TCP FastOpen for SSL sockets.

net/socket/tcp_socket_libevent.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/socket/tcp_socket.h"
 
 #include <errno.h>
 #include <netinet/tcp.h>
 #include <sys/socket.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/posix/eintr_wrapper.h"
+#include "base/task_runner_util.h"
+#include "base/threading/worker_pool.h"
 #include "net/base/address_list.h"
 #include "net/base/connection_type_histograms.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/network_change_notifier.h"
 #include "net/socket/socket_libevent.h"
 #include "net/socket/socket_net_log_params.h"
 
 // If we don't have a definition for TCPI_OPT_SYN_DATA, create one.
 #ifndef TCPI_OPT_SYN_DATA
 #define TCPI_OPT_SYN_DATA 32
 #endif
 
+// True if OS supports TCP FastOpen.
+bool g_tcp_fastopen_supported = false;
+// True if TCP FastOpen is user-enabled for all connections.
+// TODO(jri): Change global variable to param in HttpNetworkSession::Params.
+bool g_tcp_fastopen_user_enabled = false;
+
 namespace net {
 
 namespace {
 
 // SetTCPNoDelay turns on/off buffering in the kernel. By default, TCP sockets
 // will wait up to 200ms for more data to complete a packet before transmitting.
 // After calling this function, the kernel will not wait. See TCP_NODELAY in
 // `man 7 tcp`.
 bool SetTCPNoDelay(int fd, bool no_delay) {
   int on = no_delay ? 1 : 0;
@@ skipping 21 matching lines @@
   }
   // Set seconds between TCP keep alives.
   if (setsockopt(fd, SOL_TCP, TCP_KEEPINTVL, &delay, sizeof(delay))) {
     PLOG(ERROR) << "Failed to set TCP_KEEPINTVL on fd: " << fd;
     return false;
   }
 #endif
   return true;
 }
 
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+// Checks if the kernel supports TCP FastOpen.
+bool SystemSupportsTCPFastOpen() {
+  static const base::FilePath::CharType kTCPFastOpenProcFilePath[] =

[mmenke, 2014/09/05 19:36:42]

I seem to recall reading on Chromium dev that static in this case may result in
worse code on some platforms.

[Jana, 2014/09/05 20:38:57]

Hmm. I don't know why this is static in the first place -- the variable is
scoped within the function. Removing static.

+      "/proc/sys/net/ipv4/tcp_fastopen";
+  std::string system_supports_tcp_fastopen;
+  if (!base::ReadFileToString(base::FilePath(kTCPFastOpenProcFilePath),
+                              &system_supports_tcp_fastopen)) {
+    return false;
+  }
+  // The read from /proc should return '1' if TCP FastOpen is enabled in the OS.
+  if (system_supports_tcp_fastopen.empty() ||
+      (system_supports_tcp_fastopen[0] != '1')) {
+    return false;
+  }
+  return true;
+}
+
+void CallbackForTCPFastOpenCheck(bool user_enabled,

[mmenke, 2014/09/05 19:36:42]

Functions should generally be named after what they do, not what calls them.

Suggest calling this SetTCPFastOpenConfig (Options?  Settings?  Or just
SetupTCPFastOpen?  Open to other ideas).

[Jana, 2014/09/05 20:38:57]

Good suggestion -- done. (RegisterTCPFastOpenIntentAndSupport)

+                                 bool system_supported) {
+  g_tcp_fastopen_supported = system_supported;
+  g_tcp_fastopen_user_enabled = user_enabled;
+}
+#endif
+
+// Check if TCP FastOpen option is supported by the OS.
+bool IsTCPFastOpenSupported() {
+  return g_tcp_fastopen_supported;
+}
+
 }  // namespace
 
 //-----------------------------------------------------------------------------
 
+// This is asynchronous because it needs to do file IO, and it isn't allowed to
+// do that on the IO thread.
+void CheckSupportAndMaybeEnableTCPFastOpen(bool user_enabled) {
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+  base::PostTaskAndReplyWithResult(
+      base::WorkerPool::GetTaskRunner(/*task_is_slow=*/false),

[mmenke, 2014/09/05 19:36:42]

File IO isn't considered slow?

[Jana, 2014/09/05 20:38:57]

(This was the code prior to me touching it... don't know why it was so.) This
touches the filesystem (/proc), but not disk -- that should be faster than
standard file I/O. Does that still make it slow?

+      FROM_HERE,
+      base::Bind(SystemSupportsTCPFastOpen),
+      base::Bind(CallbackForTCPFastOpenCheck, user_enabled));
+#endif
+}
+
 TCPSocketLibevent::TCPSocketLibevent(NetLog* net_log,
                                      const NetLog::Source& source)
-    : use_tcp_fastopen_(IsTCPFastOpenEnabled()),
+    : use_tcp_fastopen_if_supported_(false),
       tcp_fastopen_connected_(false),
       fast_open_status_(FAST_OPEN_STATUS_UNKNOWN),
       logging_multiple_connect_attempts_(false),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) {
   net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE,
                       source.ToEventParametersCallback());
 }
 
 TCPSocketLibevent::~TCPSocketLibevent() {
   net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE);
@@ skipping 71 matching lines @@
   if (!logging_multiple_connect_attempts_)
     LogConnectBegin(AddressList(address));
 
   net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT,
                       CreateNetLogIPEndPointCallback(&address));
 
   SockaddrStorage storage;
   if (!address.ToSockAddr(storage.addr, &storage.addr_len))
     return ERR_ADDRESS_INVALID;
 
-  if (use_tcp_fastopen_) {
+  if (use_tcp_fastopen_if_supported_) {
     // With TCP FastOpen, we pretend that the socket is connected.
     DCHECK(!tcp_fastopen_connected_);
     socket_->SetPeerAddress(storage);
     return OK;
   }
 
   int rv = socket_->Connect(storage,
                             base::Bind(&TCPSocketLibevent::ConnectCompleted,
                                        base::Unretained(this), callback));
   if (rv != ERR_IO_PENDING)
     rv = HandleConnectCompleted(rv);
   return rv;
 }
 
 bool TCPSocketLibevent::IsConnected() const {
   if (!socket_)
     return false;
 
-  if (use_tcp_fastopen_ && !tcp_fastopen_connected_ &&
+  if (use_tcp_fastopen_if_supported_ && !tcp_fastopen_connected_ &&
       socket_->HasPeerAddress()) {
     // With TCP FastOpen, we pretend that the socket is connected.
     // This allows GetPeerAddress() to return peer_address_.
     return true;
   }
 
   return socket_->IsConnected();
 }
 
 bool TCPSocketLibevent::IsConnectedAndIdle() const {
@@ skipping 28 matching lines @@
   DCHECK(socket_);
   DCHECK(!callback.is_null());
 
   CompletionCallback write_callback =
       base::Bind(&TCPSocketLibevent::WriteCompleted,
                  // Grab a reference to |buf| so that WriteCompleted() can still
                  // use it when Write() completes, as otherwise, this transfers
                  // ownership of buf to socket.
                  base::Unretained(this), make_scoped_refptr(buf), callback);
   int rv;
-  if (use_tcp_fastopen_ && !tcp_fastopen_connected_) {
+  if (use_tcp_fastopen_if_supported_ && !tcp_fastopen_connected_) {
     rv = TcpFastOpenWrite(buf, buf_len, write_callback);
   } else {
     rv = socket_->Write(buf, buf_len, write_callback);
   }
 
   if (rv != ERR_IO_PENDING)
     rv = HandleWriteCompleted(buf, rv);
   return rv;
 }
 
@@ skipping 110 matching lines @@
   return SetTCPNoDelay(socket_->socket_fd(), no_delay);
 }
 
 void TCPSocketLibevent::Close() {
   socket_.reset();
   tcp_fastopen_connected_ = false;
   fast_open_status_ = FAST_OPEN_STATUS_UNKNOWN;
 }
 
 bool TCPSocketLibevent::UsingTCPFastOpen() const {
-  return use_tcp_fastopen_;
+  return use_tcp_fastopen_if_supported_;
+}
+
+void TCPSocketLibevent::EnableTCPFastOpen() {
+  if (!use_tcp_fastopen_if_supported_ && IsTCPFastOpenSupported())

[mmenke, 2014/09/05 19:36:42]

The "use_tcp_fastopen_if_supported_" check isn't needed, since this just set a
bool.

[Jana, 2014/09/05 20:38:57]

Good catch -- Done.

+    use_tcp_fastopen_if_supported_ = true;

[mmenke, 2014/09/05 19:36:42]

This variable should be renamed to use_tcp_fastopen_ (It's already behind an
IsSupported check)

[Jana, 2014/09/05 20:38:56]

Good suggestion -- done.

 }
 
 bool TCPSocketLibevent::IsValid() const {
   return socket_ != NULL && socket_->socket_fd() != kInvalidSocket;
 }
 
 void TCPSocketLibevent::StartLoggingMultipleConnectAttempts(
     const AddressList& addresses) {
   if (!logging_multiple_connect_attempts_) {
     logging_multiple_connect_attempts_ = true;
@@ skipping 108 matching lines @@
 
   net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT,
                     CreateNetLogSourceAddressCallback(storage.addr,
                                                       storage.addr_len));
 }
 
 void TCPSocketLibevent::ReadCompleted(const scoped_refptr<IOBuffer>& buf,
                                       const CompletionCallback& callback,
                                       int rv) {
   DCHECK_NE(ERR_IO_PENDING, rv);
-  // Records fast open status regardless of error in asynchronous case.
+  // Records TCP FastOpen status regardless of error in asynchronous case.
   // TODO(rdsmith,jri): Change histogram name to indicate it could be called on
   // error.
   RecordFastOpenStatus();
   callback.Run(HandleReadCompleted(buf.get(), rv));
 }
 
 int TCPSocketLibevent::HandleReadCompleted(IOBuffer* buf, int rv) {
   if (rv < 0) {
     net_log_.AddEvent(NetLog::TYPE_SOCKET_READ_ERROR,
                       CreateNetLogSocketErrorCallback(rv, errno));
@@ skipping 74 matching lines @@
   if (rv != ERR_IO_PENDING) {
     fast_open_status_ = FAST_OPEN_ERROR;
     return rv;
   }
 
   fast_open_status_ = FAST_OPEN_SLOW_CONNECT_RETURN;
   return socket_->WaitForWrite(buf, buf_len, callback);
 }
 
 void TCPSocketLibevent::RecordFastOpenStatus() {
-  if (use_tcp_fastopen_ &&
+  if (use_tcp_fastopen_if_supported_ &&
       (fast_open_status_ == FAST_OPEN_FAST_CONNECT_RETURN ||
        fast_open_status_ == FAST_OPEN_SLOW_CONNECT_RETURN)) {
     DCHECK_NE(FAST_OPEN_STATUS_UNKNOWN, fast_open_status_);
     bool getsockopt_success(false);
     bool server_acked_data(false);
 #if defined(TCP_INFO)
-    // Probe to see the if the socket used TCP Fast Open.
+    // Probe to see the if the socket used TCP FastOpen.
     tcp_info info;
     socklen_t info_len = sizeof(tcp_info);
     getsockopt_success =
         getsockopt(socket_->socket_fd(), IPPROTO_TCP, TCP_INFO,
                    &info, &info_len) == 0 &&
         info_len == sizeof(tcp_info);
     server_acked_data = getsockopt_success &&
         (info.tcpi_options & TCPI_OPT_SYN_DATA);
 #endif
     if (getsockopt_success) {
       if (fast_open_status_ == FAST_OPEN_FAST_CONNECT_RETURN) {
         fast_open_status_ = (server_acked_data ? FAST_OPEN_SYN_DATA_ACK :
                              FAST_OPEN_SYN_DATA_NACK);
       } else {
         fast_open_status_ = (server_acked_data ? FAST_OPEN_NO_SYN_DATA_ACK :
                              FAST_OPEN_NO_SYN_DATA_NACK);
       }
     } else {
       fast_open_status_ = (fast_open_status_ == FAST_OPEN_FAST_CONNECT_RETURN ?
                            FAST_OPEN_SYN_DATA_FAILED :
                            FAST_OPEN_NO_SYN_DATA_FAILED);
     }
   }
 }
 
 }  // namespace net