Home | History | Annotate | Download | only in socket 
      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 #include "net/socket/tcp_socket.h"
      6 
      7 #include <errno.h>
      8 #include <netinet/tcp.h>
      9 #include <sys/socket.h>
     10 
     11 #include "base/bind.h"
     12 #include "base/logging.h"
     13 #include "base/metrics/histogram.h"
     14 #include "base/metrics/stats_counters.h"
     15 #include "base/posix/eintr_wrapper.h"
     16 #include "base/task_runner_util.h"
     17 #include "base/threading/worker_pool.h"
     18 #include "net/base/address_list.h"
     19 #include "net/base/connection_type_histograms.h"
     20 #include "net/base/io_buffer.h"
     21 #include "net/base/ip_endpoint.h"
     22 #include "net/base/net_errors.h"
     23 #include "net/base/net_util.h"
     24 #include "net/base/network_change_notifier.h"
     25 #include "net/socket/socket_libevent.h"
     26 #include "net/socket/socket_net_log_params.h"
     27 
     28 // If we don't have a definition for TCPI_OPT_SYN_DATA, create one.
     29 #ifndef TCPI_OPT_SYN_DATA
     30 #define TCPI_OPT_SYN_DATA 32
     31 #endif
     32 
     33 namespace net {
     34 
     35 namespace {
     36 
     37 // True if OS supports TCP FastOpen.
     38 bool g_tcp_fastopen_supported = false;
     39 // True if TCP FastOpen is user-enabled for all connections.
     40 // TODO(jri): Change global variable to param in HttpNetworkSession::Params.
     41 bool g_tcp_fastopen_user_enabled = false;
     42 
     43 // SetTCPNoDelay turns on/off buffering in the kernel. By default, TCP sockets
     44 // will wait up to 200ms for more data to complete a packet before transmitting.
     45 // After calling this function, the kernel will not wait. See TCP_NODELAY in
     46 // `man 7 tcp`.
     47 bool SetTCPNoDelay(int fd, bool no_delay) {
     48   int on = no_delay ? 1 : 0;
     49   int error = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
     50   return error == 0;
     51 }
     52 
     53 // SetTCPKeepAlive sets SO_KEEPALIVE.
     54 bool SetTCPKeepAlive(int fd, bool enable, int delay) {
     55   int on = enable ? 1 : 0;
     56   if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on))) {
     57     PLOG(ERROR) << "Failed to set SO_KEEPALIVE on fd: " << fd;
     58     return false;
     59   }
     60 
     61   // If we disabled TCP keep alive, our work is done here.
     62   if (!enable)
     63     return true;
     64 
     65 #if defined(OS_LINUX) || defined(OS_ANDROID)
     66   // Set seconds until first TCP keep alive.
     67   if (setsockopt(fd, SOL_TCP, TCP_KEEPIDLE, &delay, sizeof(delay))) {
     68     PLOG(ERROR) << "Failed to set TCP_KEEPIDLE on fd: " << fd;
     69     return false;
     70   }
     71   // Set seconds between TCP keep alives.
     72   if (setsockopt(fd, SOL_TCP, TCP_KEEPINTVL, &delay, sizeof(delay))) {
     73     PLOG(ERROR) << "Failed to set TCP_KEEPINTVL on fd: " << fd;
     74     return false;
     75   }
     76 #endif
     77   return true;
     78 }
     79 
     80 #if defined(OS_LINUX) || defined(OS_ANDROID)
     81 // Checks if the kernel supports TCP FastOpen.
     82 bool SystemSupportsTCPFastOpen() {
     83   const base::FilePath::CharType kTCPFastOpenProcFilePath[] =
     84       "/proc/sys/net/ipv4/tcp_fastopen";
     85   std::string system_supports_tcp_fastopen;
     86   if (!base::ReadFileToString(base::FilePath(kTCPFastOpenProcFilePath),
     87                               &system_supports_tcp_fastopen)) {
     88     return false;
     89   }
     90   // The read from /proc should return '1' if TCP FastOpen is enabled in the OS.
     91   if (system_supports_tcp_fastopen.empty() ||
     92       (system_supports_tcp_fastopen[0] != '1')) {
     93     return false;
     94   }
     95   return true;
     96 }
     97 
     98 void RegisterTCPFastOpenIntentAndSupport(bool user_enabled,
     99                                          bool system_supported) {
    100   g_tcp_fastopen_supported = system_supported;
    101   g_tcp_fastopen_user_enabled = user_enabled;
    102 }
    103 #endif
    104 
    105 }  // namespace
    106 
    107 //-----------------------------------------------------------------------------
    108 
    109 bool IsTCPFastOpenSupported() {
    110   return g_tcp_fastopen_supported;
    111 }
    112 
    113 bool IsTCPFastOpenUserEnabled() {
    114   return g_tcp_fastopen_user_enabled;
    115 }
    116 
    117 // This is asynchronous because it needs to do file IO, and it isn't allowed to
    118 // do that on the IO thread.
    119 void CheckSupportAndMaybeEnableTCPFastOpen(bool user_enabled) {
    120 #if defined(OS_LINUX) || defined(OS_ANDROID)
    121   base::PostTaskAndReplyWithResult(
    122       base::WorkerPool::GetTaskRunner(/*task_is_slow=*/false).get(),
    123       FROM_HERE,
    124       base::Bind(SystemSupportsTCPFastOpen),
    125       base::Bind(RegisterTCPFastOpenIntentAndSupport, user_enabled));
    126 #endif
    127 }
    128 
    129 TCPSocketLibevent::TCPSocketLibevent(NetLog* net_log,
    130                                      const NetLog::Source& source)
    131     : use_tcp_fastopen_(false),
    132       tcp_fastopen_connected_(false),
    133       fast_open_status_(FAST_OPEN_STATUS_UNKNOWN),
    134       logging_multiple_connect_attempts_(false),
    135       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) {
    136   net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE,
    137                       source.ToEventParametersCallback());
    138 }
    139 
    140 TCPSocketLibevent::~TCPSocketLibevent() {
    141   net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE);
    142   if (tcp_fastopen_connected_) {
    143     UMA_HISTOGRAM_ENUMERATION("Net.TcpFastOpenSocketConnection",
    144                               fast_open_status_, FAST_OPEN_MAX_VALUE);
    145   }
    146 }
    147 
    148 int TCPSocketLibevent::Open(AddressFamily family) {
    149   DCHECK(!socket_);
    150   socket_.reset(new SocketLibevent);
    151   int rv = socket_->Open(ConvertAddressFamily(family));
    152   if (rv != OK)
    153     socket_.reset();
    154   return rv;
    155 }
    156 
    157 int TCPSocketLibevent::AdoptConnectedSocket(int socket_fd,
    158                                             const IPEndPoint& peer_address) {
    159   DCHECK(!socket_);
    160 
    161   SockaddrStorage storage;
    162   if (!peer_address.ToSockAddr(storage.addr, &storage.addr_len) &&
    163       // For backward compatibility, allows the empty address.
    164       !(peer_address == IPEndPoint())) {
    165     return ERR_ADDRESS_INVALID;
    166   }
    167 
    168   socket_.reset(new SocketLibevent);
    169   int rv = socket_->AdoptConnectedSocket(socket_fd, storage);
    170   if (rv != OK)
    171     socket_.reset();
    172   return rv;
    173 }
    174 
    175 int TCPSocketLibevent::Bind(const IPEndPoint& address) {
    176   DCHECK(socket_);
    177 
    178   SockaddrStorage storage;
    179   if (!address.ToSockAddr(storage.addr, &storage.addr_len))
    180     return ERR_ADDRESS_INVALID;
    181 
    182   return socket_->Bind(storage);
    183 }
    184 
    185 int TCPSocketLibevent::Listen(int backlog) {
    186   DCHECK(socket_);
    187   return socket_->Listen(backlog);
    188 }
    189 
    190 int TCPSocketLibevent::Accept(scoped_ptr<TCPSocketLibevent>* tcp_socket,
    191                               IPEndPoint* address,
    192                               const CompletionCallback& callback) {
    193   DCHECK(tcp_socket);
    194   DCHECK(!callback.is_null());
    195   DCHECK(socket_);
    196   DCHECK(!accept_socket_);
    197 
    198   net_log_.BeginEvent(NetLog::TYPE_TCP_ACCEPT);
    199 
    200   int rv = socket_->Accept(
    201       &accept_socket_,
    202       base::Bind(&TCPSocketLibevent::AcceptCompleted,
    203                  base::Unretained(this), tcp_socket, address, callback));
    204   if (rv != ERR_IO_PENDING)
    205     rv = HandleAcceptCompleted(tcp_socket, address, rv);
    206   return rv;
    207 }
    208 
    209 int TCPSocketLibevent::Connect(const IPEndPoint& address,
    210                                const CompletionCallback& callback) {
    211   DCHECK(socket_);
    212 
    213   if (!logging_multiple_connect_attempts_)
    214     LogConnectBegin(AddressList(address));
    215 
    216   net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT,
    217                       CreateNetLogIPEndPointCallback(&address));
    218 
    219   SockaddrStorage storage;
    220   if (!address.ToSockAddr(storage.addr, &storage.addr_len))
    221     return ERR_ADDRESS_INVALID;
    222 
    223   if (use_tcp_fastopen_) {
    224     // With TCP FastOpen, we pretend that the socket is connected.
    225     DCHECK(!tcp_fastopen_connected_);
    226     socket_->SetPeerAddress(storage);
    227     return OK;
    228   }
    229 
    230   int rv = socket_->Connect(storage,
    231                             base::Bind(&TCPSocketLibevent::ConnectCompleted,
    232                                        base::Unretained(this), callback));
    233   if (rv != ERR_IO_PENDING)
    234     rv = HandleConnectCompleted(rv);
    235   return rv;
    236 }
    237 
    238 bool TCPSocketLibevent::IsConnected() const {
    239   if (!socket_)
    240     return false;
    241 
    242   if (use_tcp_fastopen_ && !tcp_fastopen_connected_ &&
    243       socket_->HasPeerAddress()) {
    244     // With TCP FastOpen, we pretend that the socket is connected.
    245     // This allows GetPeerAddress() to return peer_address_.
    246     return true;
    247   }
    248 
    249   return socket_->IsConnected();
    250 }
    251 
    252 bool TCPSocketLibevent::IsConnectedAndIdle() const {
    253   // TODO(wtc): should we also handle the TCP FastOpen case here,
    254   // as we do in IsConnected()?
    255   return socket_ && socket_->IsConnectedAndIdle();
    256 }
    257 
    258 int TCPSocketLibevent::Read(IOBuffer* buf,
    259                             int buf_len,
    260                             const CompletionCallback& callback) {
    261   DCHECK(socket_);
    262   DCHECK(!callback.is_null());
    263 
    264   int rv = socket_->Read(
    265       buf, buf_len,
    266       base::Bind(&TCPSocketLibevent::ReadCompleted,
    267                  // Grab a reference to |buf| so that ReadCompleted() can still
    268                  // use it when Read() completes, as otherwise, this transfers
    269                  // ownership of buf to socket.
    270                  base::Unretained(this), make_scoped_refptr(buf), callback));
    271   if (rv >= 0)
    272     RecordFastOpenStatus();
    273   if (rv != ERR_IO_PENDING)
    274     rv = HandleReadCompleted(buf, rv);
    275   return rv;
    276 }
    277 
    278 int TCPSocketLibevent::Write(IOBuffer* buf,
    279                              int buf_len,
    280                              const CompletionCallback& callback) {
    281   DCHECK(socket_);
    282   DCHECK(!callback.is_null());
    283 
    284   CompletionCallback write_callback =
    285       base::Bind(&TCPSocketLibevent::WriteCompleted,
    286                  // Grab a reference to |buf| so that WriteCompleted() can still
    287                  // use it when Write() completes, as otherwise, this transfers
    288                  // ownership of buf to socket.
    289                  base::Unretained(this), make_scoped_refptr(buf), callback);
    290   int rv;
    291   if (use_tcp_fastopen_ && !tcp_fastopen_connected_) {
    292     rv = TcpFastOpenWrite(buf, buf_len, write_callback);
    293   } else {
    294     rv = socket_->Write(buf, buf_len, write_callback);
    295   }
    296 
    297   if (rv != ERR_IO_PENDING)
    298     rv = HandleWriteCompleted(buf, rv);
    299   return rv;
    300 }
    301 
    302 int TCPSocketLibevent::GetLocalAddress(IPEndPoint* address) const {
    303   DCHECK(address);
    304 
    305   if (!socket_)
    306     return ERR_SOCKET_NOT_CONNECTED;
    307 
    308   SockaddrStorage storage;
    309   int rv = socket_->GetLocalAddress(&storage);
    310   if (rv != OK)
    311     return rv;
    312 
    313   if (!address->FromSockAddr(storage.addr, storage.addr_len))
    314     return ERR_ADDRESS_INVALID;
    315 
    316   return OK;
    317 }
    318 
    319 int TCPSocketLibevent::GetPeerAddress(IPEndPoint* address) const {
    320   DCHECK(address);
    321 
    322   if (!IsConnected())
    323     return ERR_SOCKET_NOT_CONNECTED;
    324 
    325   SockaddrStorage storage;
    326   int rv = socket_->GetPeerAddress(&storage);
    327   if (rv != OK)
    328     return rv;
    329 
    330   if (!address->FromSockAddr(storage.addr, storage.addr_len))
    331     return ERR_ADDRESS_INVALID;
    332 
    333   return OK;
    334 }
    335 
    336 int TCPSocketLibevent::SetDefaultOptionsForServer() {
    337   DCHECK(socket_);
    338   return SetAddressReuse(true);
    339 }
    340 
    341 void TCPSocketLibevent::SetDefaultOptionsForClient() {
    342   DCHECK(socket_);
    343 
    344   // This mirrors the behaviour on Windows. See the comment in
    345   // tcp_socket_win.cc after searching for "NODELAY".
    346   // If SetTCPNoDelay fails, we don't care.
    347   SetTCPNoDelay(socket_->socket_fd(), true);
    348 
    349   // TCP keep alive wakes up the radio, which is expensive on mobile. Do not
    350   // enable it there. It's useful to prevent TCP middleboxes from timing out
    351   // connection mappings. Packets for timed out connection mappings at
    352   // middleboxes will either lead to:
    353   // a) Middleboxes sending TCP RSTs. It's up to higher layers to check for this
    354   // and retry. The HTTP network transaction code does this.
    355   // b) Middleboxes just drop the unrecognized TCP packet. This leads to the TCP
    356   // stack retransmitting packets per TCP stack retransmission timeouts, which
    357   // are very high (on the order of seconds). Given the number of
    358   // retransmissions required before killing the connection, this can lead to
    359   // tens of seconds or even minutes of delay, depending on OS.
    360 #if !defined(OS_ANDROID) && !defined(OS_IOS)
    361   const int kTCPKeepAliveSeconds = 45;
    362 
    363   SetTCPKeepAlive(socket_->socket_fd(), true, kTCPKeepAliveSeconds);
    364 #endif
    365 }
    366 
    367 int TCPSocketLibevent::SetAddressReuse(bool allow) {
    368   DCHECK(socket_);
    369 
    370   // SO_REUSEADDR is useful for server sockets to bind to a recently unbound
    371   // port. When a socket is closed, the end point changes its state to TIME_WAIT
    372   // and wait for 2 MSL (maximum segment lifetime) to ensure the remote peer
    373   // acknowledges its closure. For server sockets, it is usually safe to
    374   // bind to a TIME_WAIT end point immediately, which is a widely adopted
    375   // behavior.
    376   //
    377   // Note that on *nix, SO_REUSEADDR does not enable the TCP socket to bind to
    378   // an end point that is already bound by another socket. To do that one must
    379   // set SO_REUSEPORT instead. This option is not provided on Linux prior
    380   // to 3.9.
    381   //
    382   // SO_REUSEPORT is provided in MacOS X and iOS.
    383   int boolean_value = allow ? 1 : 0;
    384   int rv = setsockopt(socket_->socket_fd(), SOL_SOCKET, SO_REUSEADDR,
    385                       &boolean_value, sizeof(boolean_value));
    386   if (rv < 0)
    387     return MapSystemError(errno);
    388   return OK;
    389 }
    390 
    391 int TCPSocketLibevent::SetReceiveBufferSize(int32 size) {
    392   DCHECK(socket_);
    393   int rv = setsockopt(socket_->socket_fd(), SOL_SOCKET, SO_RCVBUF,
    394                       reinterpret_cast<const char*>(&size), sizeof(size));
    395   return (rv == 0) ? OK : MapSystemError(errno);
    396 }
    397 
    398 int TCPSocketLibevent::SetSendBufferSize(int32 size) {
    399   DCHECK(socket_);
    400   int rv = setsockopt(socket_->socket_fd(), SOL_SOCKET, SO_SNDBUF,
    401                       reinterpret_cast<const char*>(&size), sizeof(size));
    402   return (rv == 0) ? OK : MapSystemError(errno);
    403 }
    404 
    405 bool TCPSocketLibevent::SetKeepAlive(bool enable, int delay) {
    406   DCHECK(socket_);
    407   return SetTCPKeepAlive(socket_->socket_fd(), enable, delay);
    408 }
    409 
    410 bool TCPSocketLibevent::SetNoDelay(bool no_delay) {
    411   DCHECK(socket_);
    412   return SetTCPNoDelay(socket_->socket_fd(), no_delay);
    413 }
    414 
    415 void TCPSocketLibevent::Close() {
    416   socket_.reset();
    417   tcp_fastopen_connected_ = false;
    418   fast_open_status_ = FAST_OPEN_STATUS_UNKNOWN;
    419 }
    420 
    421 bool TCPSocketLibevent::UsingTCPFastOpen() const {
    422   return use_tcp_fastopen_;
    423 }
    424 
    425 void TCPSocketLibevent::EnableTCPFastOpenIfSupported() {
    426   if (IsTCPFastOpenSupported())
    427     use_tcp_fastopen_ = true;
    428 }
    429 
    430 bool TCPSocketLibevent::IsValid() const {
    431   return socket_ != NULL && socket_->socket_fd() != kInvalidSocket;
    432 }
    433 
    434 void TCPSocketLibevent::StartLoggingMultipleConnectAttempts(
    435     const AddressList& addresses) {
    436   if (!logging_multiple_connect_attempts_) {
    437     logging_multiple_connect_attempts_ = true;
    438     LogConnectBegin(addresses);
    439   } else {
    440     NOTREACHED();
    441   }
    442 }
    443 
    444 void TCPSocketLibevent::EndLoggingMultipleConnectAttempts(int net_error) {
    445   if (logging_multiple_connect_attempts_) {
    446     LogConnectEnd(net_error);
    447     logging_multiple_connect_attempts_ = false;
    448   } else {
    449     NOTREACHED();
    450   }
    451 }
    452 
    453 void TCPSocketLibevent::AcceptCompleted(
    454     scoped_ptr<TCPSocketLibevent>* tcp_socket,
    455     IPEndPoint* address,
    456     const CompletionCallback& callback,
    457     int rv) {
    458   DCHECK_NE(ERR_IO_PENDING, rv);
    459   callback.Run(HandleAcceptCompleted(tcp_socket, address, rv));
    460 }
    461 
    462 int TCPSocketLibevent::HandleAcceptCompleted(
    463     scoped_ptr<TCPSocketLibevent>* tcp_socket,
    464     IPEndPoint* address,
    465     int rv) {
    466   if (rv == OK)
    467     rv = BuildTcpSocketLibevent(tcp_socket, address);
    468 
    469   if (rv == OK) {
    470     net_log_.EndEvent(NetLog::TYPE_TCP_ACCEPT,
    471                       CreateNetLogIPEndPointCallback(address));
    472   } else {
    473     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_ACCEPT, rv);
    474   }
    475 
    476   return rv;
    477 }
    478 
    479 int TCPSocketLibevent::BuildTcpSocketLibevent(
    480     scoped_ptr<TCPSocketLibevent>* tcp_socket,
    481     IPEndPoint* address) {
    482   DCHECK(accept_socket_);
    483 
    484   SockaddrStorage storage;
    485   if (accept_socket_->GetPeerAddress(&storage) != OK ||
    486       !address->FromSockAddr(storage.addr, storage.addr_len)) {
    487     accept_socket_.reset();
    488     return ERR_ADDRESS_INVALID;
    489   }
    490 
    491   tcp_socket->reset(new TCPSocketLibevent(net_log_.net_log(),
    492                                           net_log_.source()));
    493   (*tcp_socket)->socket_.reset(accept_socket_.release());
    494   return OK;
    495 }
    496 
    497 void TCPSocketLibevent::ConnectCompleted(const CompletionCallback& callback,
    498                                          int rv) const {
    499   DCHECK_NE(ERR_IO_PENDING, rv);
    500   callback.Run(HandleConnectCompleted(rv));
    501 }
    502 
    503 int TCPSocketLibevent::HandleConnectCompleted(int rv) const {
    504   // Log the end of this attempt (and any OS error it threw).
    505   if (rv != OK) {
    506     net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT,
    507                       NetLog::IntegerCallback("os_error", errno));
    508   } else {
    509     net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT);
    510   }
    511 
    512   // Give a more specific error when the user is offline.
    513   if (rv == ERR_ADDRESS_UNREACHABLE && NetworkChangeNotifier::IsOffline())
    514     rv = ERR_INTERNET_DISCONNECTED;
    515 
    516   if (!logging_multiple_connect_attempts_)
    517     LogConnectEnd(rv);
    518 
    519   return rv;
    520 }
    521 
    522 void TCPSocketLibevent::LogConnectBegin(const AddressList& addresses) const {
    523   base::StatsCounter connects("tcp.connect");
    524   connects.Increment();
    525 
    526   net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT,
    527                       addresses.CreateNetLogCallback());
    528 }
    529 
    530 void TCPSocketLibevent::LogConnectEnd(int net_error) const {
    531   if (net_error != OK) {
    532     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_CONNECT, net_error);
    533     return;
    534   }
    535 
    536   UpdateConnectionTypeHistograms(CONNECTION_ANY);
    537 
    538   SockaddrStorage storage;
    539   int rv = socket_->GetLocalAddress(&storage);
    540   if (rv != OK) {
    541     PLOG(ERROR) << "GetLocalAddress() [rv: " << rv << "] error: ";
    542     NOTREACHED();
    543     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_CONNECT, rv);
    544     return;
    545   }
    546 
    547   net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT,
    548                     CreateNetLogSourceAddressCallback(storage.addr,
    549                                                       storage.addr_len));
    550 }
    551 
    552 void TCPSocketLibevent::ReadCompleted(const scoped_refptr<IOBuffer>& buf,
    553                                       const CompletionCallback& callback,
    554                                       int rv) {
    555   DCHECK_NE(ERR_IO_PENDING, rv);
    556   // Records TCP FastOpen status regardless of error in asynchronous case.
    557   // TODO(rdsmith,jri): Change histogram name to indicate it could be called on
    558   // error.
    559   RecordFastOpenStatus();
    560   callback.Run(HandleReadCompleted(buf.get(), rv));
    561 }
    562 
    563 int TCPSocketLibevent::HandleReadCompleted(IOBuffer* buf, int rv) {
    564   if (rv < 0) {
    565     net_log_.AddEvent(NetLog::TYPE_SOCKET_READ_ERROR,
    566                       CreateNetLogSocketErrorCallback(rv, errno));
    567     return rv;
    568   }
    569 
    570   base::StatsCounter read_bytes("tcp.read_bytes");
    571   read_bytes.Add(rv);
    572   net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED, rv,
    573                                 buf->data());
    574   return rv;
    575 }
    576 
    577 void TCPSocketLibevent::WriteCompleted(const scoped_refptr<IOBuffer>& buf,
    578                                        const CompletionCallback& callback,
    579                                        int rv) const {
    580   DCHECK_NE(ERR_IO_PENDING, rv);
    581   callback.Run(HandleWriteCompleted(buf.get(), rv));
    582 }
    583 
    584 int TCPSocketLibevent::HandleWriteCompleted(IOBuffer* buf, int rv) const {
    585   if (rv < 0) {
    586     net_log_.AddEvent(NetLog::TYPE_SOCKET_WRITE_ERROR,
    587                       CreateNetLogSocketErrorCallback(rv, errno));
    588     return rv;
    589   }
    590 
    591   base::StatsCounter write_bytes("tcp.write_bytes");
    592   write_bytes.Add(rv);
    593   net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT, rv,
    594                                 buf->data());
    595   return rv;
    596 }
    597 
    598 int TCPSocketLibevent::TcpFastOpenWrite(
    599     IOBuffer* buf,
    600     int buf_len,
    601     const CompletionCallback& callback) {
    602   SockaddrStorage storage;
    603   int rv = socket_->GetPeerAddress(&storage);
    604   if (rv != OK)
    605     return rv;
    606 
    607   int flags = 0x20000000;  // Magic flag to enable TCP_FASTOPEN.
    608 #if defined(OS_LINUX) || defined(OS_ANDROID)
    609   // sendto() will fail with EPIPE when the system doesn't support TCP Fast
    610   // Open. Theoretically that shouldn't happen since the caller should check
    611   // for system support on startup, but users may dynamically disable TCP Fast
    612   // Open via sysctl.
    613   flags |= MSG_NOSIGNAL;
    614 #endif // defined(OS_LINUX) || defined(OS_ANDROID)
    615   rv = HANDLE_EINTR(sendto(socket_->socket_fd(),
    616                            buf->data(),
    617                            buf_len,
    618                            flags,
    619                            storage.addr,
    620                            storage.addr_len));
    621   tcp_fastopen_connected_ = true;
    622 
    623   if (rv >= 0) {
    624     fast_open_status_ = FAST_OPEN_FAST_CONNECT_RETURN;
    625     return rv;
    626   }
    627 
    628   DCHECK_NE(EPIPE, errno);
    629 
    630   // If errno == EINPROGRESS, that means the kernel didn't have a cookie
    631   // and would block. The kernel is internally doing a connect() though.
    632   // Remap EINPROGRESS to EAGAIN so we treat this the same as our other
    633   // asynchronous cases. Note that the user buffer has not been copied to
    634   // kernel space.
    635   if (errno == EINPROGRESS) {
    636     rv = ERR_IO_PENDING;
    637   } else {
    638     rv = MapSystemError(errno);
    639   }
    640 
    641   if (rv != ERR_IO_PENDING) {
    642     fast_open_status_ = FAST_OPEN_ERROR;
    643     return rv;
    644   }
    645 
    646   fast_open_status_ = FAST_OPEN_SLOW_CONNECT_RETURN;
    647   return socket_->WaitForWrite(buf, buf_len, callback);
    648 }
    649 
    650 void TCPSocketLibevent::RecordFastOpenStatus() {
    651   if (use_tcp_fastopen_ &&
    652       (fast_open_status_ == FAST_OPEN_FAST_CONNECT_RETURN ||
    653        fast_open_status_ == FAST_OPEN_SLOW_CONNECT_RETURN)) {
    654     DCHECK_NE(FAST_OPEN_STATUS_UNKNOWN, fast_open_status_);
    655     bool getsockopt_success(false);
    656     bool server_acked_data(false);
    657 #if defined(TCP_INFO)
    658     // Probe to see the if the socket used TCP FastOpen.
    659     tcp_info info;
    660     socklen_t info_len = sizeof(tcp_info);
    661     getsockopt_success =
    662         getsockopt(socket_->socket_fd(), IPPROTO_TCP, TCP_INFO,
    663                    &info, &info_len) == 0 &&
    664         info_len == sizeof(tcp_info);
    665     server_acked_data = getsockopt_success &&
    666         (info.tcpi_options & TCPI_OPT_SYN_DATA);
    667 #endif
    668     if (getsockopt_success) {
    669       if (fast_open_status_ == FAST_OPEN_FAST_CONNECT_RETURN) {
    670         fast_open_status_ = (server_acked_data ? FAST_OPEN_SYN_DATA_ACK :
    671                              FAST_OPEN_SYN_DATA_NACK);
    672       } else {
    673         fast_open_status_ = (server_acked_data ? FAST_OPEN_NO_SYN_DATA_ACK :
    674                              FAST_OPEN_NO_SYN_DATA_NACK);
    675       }
    676     } else {
    677       fast_open_status_ = (fast_open_status_ == FAST_OPEN_FAST_CONNECT_RETURN ?
    678                            FAST_OPEN_SYN_DATA_FAILED :
    679                            FAST_OPEN_NO_SYN_DATA_FAILED);
    680     }
    681   }
    682 }
    683 
    684 }  // namespace net
    685