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 #include "net/socket/tcp_socket_win.h"
      7 
      8 #include <mstcpip.h>
      9 
     10 #include "base/callback_helpers.h"
     11 #include "base/logging.h"
     12 #include "base/metrics/stats_counters.h"
     13 #include "base/win/windows_version.h"
     14 #include "net/base/address_list.h"
     15 #include "net/base/connection_type_histograms.h"
     16 #include "net/base/io_buffer.h"
     17 #include "net/base/ip_endpoint.h"
     18 #include "net/base/net_errors.h"
     19 #include "net/base/net_util.h"
     20 #include "net/base/network_change_notifier.h"
     21 #include "net/base/winsock_init.h"
     22 #include "net/base/winsock_util.h"
     23 #include "net/socket/socket_descriptor.h"
     24 #include "net/socket/socket_net_log_params.h"
     25 
     26 namespace net {
     27 
     28 namespace {
     29 
     30 const int kTCPKeepAliveSeconds = 45;
     31 
     32 int SetSocketReceiveBufferSize(SOCKET socket, int32 size) {
     33   int rv = setsockopt(socket, SOL_SOCKET, SO_RCVBUF,
     34                       reinterpret_cast<const char*>(&size), sizeof(size));
     35   int net_error = (rv == 0) ? OK : MapSystemError(WSAGetLastError());
     36   DCHECK(!rv) << "Could not set socket receive buffer size: " << net_error;
     37   return net_error;
     38 }
     39 
     40 int SetSocketSendBufferSize(SOCKET socket, int32 size) {
     41   int rv = setsockopt(socket, SOL_SOCKET, SO_SNDBUF,
     42                       reinterpret_cast<const char*>(&size), sizeof(size));
     43   int net_error = (rv == 0) ? OK : MapSystemError(WSAGetLastError());
     44   DCHECK(!rv) << "Could not set socket send buffer size: " << net_error;
     45   return net_error;
     46 }
     47 
     48 // Disable Nagle.
     49 // The Nagle implementation on windows is governed by RFC 896.  The idea
     50 // behind Nagle is to reduce small packets on the network.  When Nagle is
     51 // enabled, if a partial packet has been sent, the TCP stack will disallow
     52 // further *partial* packets until an ACK has been received from the other
     53 // side.  Good applications should always strive to send as much data as
     54 // possible and avoid partial-packet sends.  However, in most real world
     55 // applications, there are edge cases where this does not happen, and two
     56 // partial packets may be sent back to back.  For a browser, it is NEVER
     57 // a benefit to delay for an RTT before the second packet is sent.
     58 //
     59 // As a practical example in Chromium today, consider the case of a small
     60 // POST.  I have verified this:
     61 //     Client writes 649 bytes of header  (partial packet #1)
     62 //     Client writes 50 bytes of POST data (partial packet #2)
     63 // In the above example, with Nagle, a RTT delay is inserted between these
     64 // two sends due to nagle.  RTTs can easily be 100ms or more.  The best
     65 // fix is to make sure that for POSTing data, we write as much data as
     66 // possible and minimize partial packets.  We will fix that.  But disabling
     67 // Nagle also ensure we don't run into this delay in other edge cases.
     68 // See also:
     69 //    http://technet.microsoft.com/en-us/library/bb726981.aspx
     70 bool DisableNagle(SOCKET socket, bool disable) {
     71   BOOL val = disable ? TRUE : FALSE;
     72   int rv = setsockopt(socket, IPPROTO_TCP, TCP_NODELAY,
     73                       reinterpret_cast<const char*>(&val),
     74                       sizeof(val));
     75   DCHECK(!rv) << "Could not disable nagle";
     76   return rv == 0;
     77 }
     78 
     79 // Enable TCP Keep-Alive to prevent NAT routers from timing out TCP
     80 // connections. See http://crbug.com/27400 for details.
     81 bool SetTCPKeepAlive(SOCKET socket, BOOL enable, int delay_secs) {
     82   int delay = delay_secs * 1000;
     83   struct tcp_keepalive keepalive_vals = {
     84     enable ? 1 : 0,  // TCP keep-alive on.
     85     delay,  // Delay seconds before sending first TCP keep-alive packet.
     86     delay,  // Delay seconds between sending TCP keep-alive packets.
     87   };
     88   DWORD bytes_returned = 0xABAB;
     89   int rv = WSAIoctl(socket, SIO_KEEPALIVE_VALS, &keepalive_vals,
     90                     sizeof(keepalive_vals), NULL, 0,
     91                     &bytes_returned, NULL, NULL);
     92   DCHECK(!rv) << "Could not enable TCP Keep-Alive for socket: " << socket
     93               << " [error: " << WSAGetLastError() << "].";
     94 
     95   // Disregard any failure in disabling nagle or enabling TCP Keep-Alive.
     96   return rv == 0;
     97 }
     98 
     99 int MapConnectError(int os_error) {
    100   switch (os_error) {
    101     // connect fails with WSAEACCES when Windows Firewall blocks the
    102     // connection.
    103     case WSAEACCES:
    104       return ERR_NETWORK_ACCESS_DENIED;
    105     case WSAETIMEDOUT:
    106       return ERR_CONNECTION_TIMED_OUT;
    107     default: {
    108       int net_error = MapSystemError(os_error);
    109       if (net_error == ERR_FAILED)
    110         return ERR_CONNECTION_FAILED;  // More specific than ERR_FAILED.
    111 
    112       // Give a more specific error when the user is offline.
    113       if (net_error == ERR_ADDRESS_UNREACHABLE &&
    114           NetworkChangeNotifier::IsOffline()) {
    115         return ERR_INTERNET_DISCONNECTED;
    116       }
    117 
    118       return net_error;
    119     }
    120   }
    121 }
    122 
    123 }  // namespace
    124 
    125 //-----------------------------------------------------------------------------
    126 
    127 // Nothing to do for Windows since it doesn't support TCP FastOpen.
    128 // TODO(jri): Remove these along with the corresponding global variables.
    129 bool IsTCPFastOpenSupported() { return false; }
    130 bool IsTCPFastOpenUserEnabled() { return false; }
    131 void CheckSupportAndMaybeEnableTCPFastOpen(bool user_enabled) {}
    132 
    133 // This class encapsulates all the state that has to be preserved as long as
    134 // there is a network IO operation in progress. If the owner TCPSocketWin is
    135 // destroyed while an operation is in progress, the Core is detached and it
    136 // lives until the operation completes and the OS doesn't reference any resource
    137 // declared on this class anymore.
    138 class TCPSocketWin::Core : public base::RefCounted<Core> {
    139  public:
    140   explicit Core(TCPSocketWin* socket);
    141 
    142   // Start watching for the end of a read or write operation.
    143   void WatchForRead();
    144   void WatchForWrite();
    145 
    146   // The TCPSocketWin is going away.
    147   void Detach() { socket_ = NULL; }
    148 
    149   // The separate OVERLAPPED variables for asynchronous operation.
    150   // |read_overlapped_| is used for both Connect() and Read().
    151   // |write_overlapped_| is only used for Write();
    152   OVERLAPPED read_overlapped_;
    153   OVERLAPPED write_overlapped_;
    154 
    155   // The buffers used in Read() and Write().
    156   scoped_refptr<IOBuffer> read_iobuffer_;
    157   scoped_refptr<IOBuffer> write_iobuffer_;
    158   int read_buffer_length_;
    159   int write_buffer_length_;
    160 
    161   bool non_blocking_reads_initialized_;
    162 
    163  private:
    164   friend class base::RefCounted<Core>;
    165 
    166   class ReadDelegate : public base::win::ObjectWatcher::Delegate {
    167    public:
    168     explicit ReadDelegate(Core* core) : core_(core) {}
    169     virtual ~ReadDelegate() {}
    170 
    171     // base::ObjectWatcher::Delegate methods:
    172     virtual void OnObjectSignaled(HANDLE object);
    173 
    174    private:
    175     Core* const core_;
    176   };
    177 
    178   class WriteDelegate : public base::win::ObjectWatcher::Delegate {
    179    public:
    180     explicit WriteDelegate(Core* core) : core_(core) {}
    181     virtual ~WriteDelegate() {}
    182 
    183     // base::ObjectWatcher::Delegate methods:
    184     virtual void OnObjectSignaled(HANDLE object);
    185 
    186    private:
    187     Core* const core_;
    188   };
    189 
    190   ~Core();
    191 
    192   // The socket that created this object.
    193   TCPSocketWin* socket_;
    194 
    195   // |reader_| handles the signals from |read_watcher_|.
    196   ReadDelegate reader_;
    197   // |writer_| handles the signals from |write_watcher_|.
    198   WriteDelegate writer_;
    199 
    200   // |read_watcher_| watches for events from Connect() and Read().
    201   base::win::ObjectWatcher read_watcher_;
    202   // |write_watcher_| watches for events from Write();
    203   base::win::ObjectWatcher write_watcher_;
    204 
    205   DISALLOW_COPY_AND_ASSIGN(Core);
    206 };
    207 
    208 TCPSocketWin::Core::Core(TCPSocketWin* socket)
    209     : read_buffer_length_(0),
    210       write_buffer_length_(0),
    211       non_blocking_reads_initialized_(false),
    212       socket_(socket),
    213       reader_(this),
    214       writer_(this) {
    215   memset(&read_overlapped_, 0, sizeof(read_overlapped_));
    216   memset(&write_overlapped_, 0, sizeof(write_overlapped_));
    217 
    218   read_overlapped_.hEvent = WSACreateEvent();
    219   write_overlapped_.hEvent = WSACreateEvent();
    220 }
    221 
    222 TCPSocketWin::Core::~Core() {
    223   // Make sure the message loop is not watching this object anymore.
    224   read_watcher_.StopWatching();
    225   write_watcher_.StopWatching();
    226 
    227   WSACloseEvent(read_overlapped_.hEvent);
    228   memset(&read_overlapped_, 0xaf, sizeof(read_overlapped_));
    229   WSACloseEvent(write_overlapped_.hEvent);
    230   memset(&write_overlapped_, 0xaf, sizeof(write_overlapped_));
    231 }
    232 
    233 void TCPSocketWin::Core::WatchForRead() {
    234   // We grab an extra reference because there is an IO operation in progress.
    235   // Balanced in ReadDelegate::OnObjectSignaled().
    236   AddRef();
    237   read_watcher_.StartWatching(read_overlapped_.hEvent, &reader_);
    238 }
    239 
    240 void TCPSocketWin::Core::WatchForWrite() {
    241   // We grab an extra reference because there is an IO operation in progress.
    242   // Balanced in WriteDelegate::OnObjectSignaled().
    243   AddRef();
    244   write_watcher_.StartWatching(write_overlapped_.hEvent, &writer_);
    245 }
    246 
    247 void TCPSocketWin::Core::ReadDelegate::OnObjectSignaled(HANDLE object) {
    248   DCHECK_EQ(object, core_->read_overlapped_.hEvent);
    249   if (core_->socket_) {
    250     if (core_->socket_->waiting_connect_)
    251       core_->socket_->DidCompleteConnect();
    252     else
    253       core_->socket_->DidSignalRead();
    254   }
    255 
    256   core_->Release();
    257 }
    258 
    259 void TCPSocketWin::Core::WriteDelegate::OnObjectSignaled(
    260     HANDLE object) {
    261   DCHECK_EQ(object, core_->write_overlapped_.hEvent);
    262   if (core_->socket_)
    263     core_->socket_->DidCompleteWrite();
    264 
    265   core_->Release();
    266 }
    267 
    268 //-----------------------------------------------------------------------------
    269 
    270 TCPSocketWin::TCPSocketWin(net::NetLog* net_log,
    271                            const net::NetLog::Source& source)
    272     : socket_(INVALID_SOCKET),
    273       accept_event_(WSA_INVALID_EVENT),
    274       accept_socket_(NULL),
    275       accept_address_(NULL),
    276       waiting_connect_(false),
    277       waiting_read_(false),
    278       waiting_write_(false),
    279       connect_os_error_(0),
    280       logging_multiple_connect_attempts_(false),
    281       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) {
    282   net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE,
    283                       source.ToEventParametersCallback());
    284   EnsureWinsockInit();
    285 }
    286 
    287 TCPSocketWin::~TCPSocketWin() {
    288   Close();
    289   net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE);
    290 }
    291 
    292 int TCPSocketWin::Open(AddressFamily family) {
    293   DCHECK(CalledOnValidThread());
    294   DCHECK_EQ(socket_, INVALID_SOCKET);
    295 
    296   socket_ = CreatePlatformSocket(ConvertAddressFamily(family), SOCK_STREAM,
    297                                  IPPROTO_TCP);
    298   if (socket_ == INVALID_SOCKET) {
    299     PLOG(ERROR) << "CreatePlatformSocket() returned an error";
    300     return MapSystemError(WSAGetLastError());
    301   }
    302 
    303   if (SetNonBlocking(socket_)) {
    304     int result = MapSystemError(WSAGetLastError());
    305     Close();
    306     return result;
    307   }
    308 
    309   return OK;
    310 }
    311 
    312 int TCPSocketWin::AdoptConnectedSocket(SOCKET socket,
    313                                        const IPEndPoint& peer_address) {
    314   DCHECK(CalledOnValidThread());
    315   DCHECK_EQ(socket_, INVALID_SOCKET);
    316   DCHECK(!core_);
    317 
    318   socket_ = socket;
    319 
    320   if (SetNonBlocking(socket_)) {
    321     int result = MapSystemError(WSAGetLastError());
    322     Close();
    323     return result;
    324   }
    325 
    326   core_ = new Core(this);
    327   peer_address_.reset(new IPEndPoint(peer_address));
    328 
    329   return OK;
    330 }
    331 
    332 int TCPSocketWin::AdoptListenSocket(SOCKET socket) {
    333   DCHECK(CalledOnValidThread());
    334   DCHECK_EQ(socket_, INVALID_SOCKET);
    335 
    336   socket_ = socket;
    337 
    338   if (SetNonBlocking(socket_)) {
    339     int result = MapSystemError(WSAGetLastError());
    340     Close();
    341     return result;
    342   }
    343 
    344   // |core_| is not needed for sockets that are used to accept connections.
    345   // The operation here is more like Open but with an existing socket.
    346 
    347   return OK;
    348 }
    349 
    350 int TCPSocketWin::Bind(const IPEndPoint& address) {
    351   DCHECK(CalledOnValidThread());
    352   DCHECK_NE(socket_, INVALID_SOCKET);
    353 
    354   SockaddrStorage storage;
    355   if (!address.ToSockAddr(storage.addr, &storage.addr_len))
    356     return ERR_ADDRESS_INVALID;
    357 
    358   int result = bind(socket_, storage.addr, storage.addr_len);
    359   if (result < 0) {
    360     PLOG(ERROR) << "bind() returned an error";
    361     return MapSystemError(WSAGetLastError());
    362   }
    363 
    364   return OK;
    365 }
    366 
    367 int TCPSocketWin::Listen(int backlog) {
    368   DCHECK(CalledOnValidThread());
    369   DCHECK_GT(backlog, 0);
    370   DCHECK_NE(socket_, INVALID_SOCKET);
    371   DCHECK_EQ(accept_event_, WSA_INVALID_EVENT);
    372 
    373   accept_event_ = WSACreateEvent();
    374   if (accept_event_ == WSA_INVALID_EVENT) {
    375     PLOG(ERROR) << "WSACreateEvent()";
    376     return MapSystemError(WSAGetLastError());
    377   }
    378 
    379   int result = listen(socket_, backlog);
    380   if (result < 0) {
    381     PLOG(ERROR) << "listen() returned an error";
    382     return MapSystemError(WSAGetLastError());
    383   }
    384 
    385   return OK;
    386 }
    387 
    388 int TCPSocketWin::Accept(scoped_ptr<TCPSocketWin>* socket,
    389                          IPEndPoint* address,
    390                          const CompletionCallback& callback) {
    391   DCHECK(CalledOnValidThread());
    392   DCHECK(socket);
    393   DCHECK(address);
    394   DCHECK(!callback.is_null());
    395   DCHECK(accept_callback_.is_null());
    396 
    397   net_log_.BeginEvent(NetLog::TYPE_TCP_ACCEPT);
    398 
    399   int result = AcceptInternal(socket, address);
    400 
    401   if (result == ERR_IO_PENDING) {
    402     // Start watching.
    403     WSAEventSelect(socket_, accept_event_, FD_ACCEPT);
    404     accept_watcher_.StartWatching(accept_event_, this);
    405 
    406     accept_socket_ = socket;
    407     accept_address_ = address;
    408     accept_callback_ = callback;
    409   }
    410 
    411   return result;
    412 }
    413 
    414 int TCPSocketWin::Connect(const IPEndPoint& address,
    415                           const CompletionCallback& callback) {
    416   DCHECK(CalledOnValidThread());
    417   DCHECK_NE(socket_, INVALID_SOCKET);
    418   DCHECK(!waiting_connect_);
    419 
    420   // |peer_address_| and |core_| will be non-NULL if Connect() has been called.
    421   // Unless Close() is called to reset the internal state, a second call to
    422   // Connect() is not allowed.
    423   // Please note that we enforce this even if the previous Connect() has
    424   // completed and failed. Although it is allowed to connect the same |socket_|
    425   // again after a connection attempt failed on Windows, it results in
    426   // unspecified behavior according to POSIX. Therefore, we make it behave in
    427   // the same way as TCPSocketLibevent.
    428   DCHECK(!peer_address_ && !core_);
    429 
    430   if (!logging_multiple_connect_attempts_)
    431     LogConnectBegin(AddressList(address));
    432 
    433   peer_address_.reset(new IPEndPoint(address));
    434 
    435   int rv = DoConnect();
    436   if (rv == ERR_IO_PENDING) {
    437     // Synchronous operation not supported.
    438     DCHECK(!callback.is_null());
    439     read_callback_ = callback;
    440     waiting_connect_ = true;
    441   } else {
    442     DoConnectComplete(rv);
    443   }
    444 
    445   return rv;
    446 }
    447 
    448 bool TCPSocketWin::IsConnected() const {
    449   DCHECK(CalledOnValidThread());
    450 
    451   if (socket_ == INVALID_SOCKET || waiting_connect_)
    452     return false;
    453 
    454   if (waiting_read_)
    455     return true;
    456 
    457   // Check if connection is alive.
    458   char c;
    459   int rv = recv(socket_, &c, 1, MSG_PEEK);
    460   if (rv == 0)
    461     return false;
    462   if (rv == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
    463     return false;
    464 
    465   return true;
    466 }
    467 
    468 bool TCPSocketWin::IsConnectedAndIdle() const {
    469   DCHECK(CalledOnValidThread());
    470 
    471   if (socket_ == INVALID_SOCKET || waiting_connect_)
    472     return false;
    473 
    474   if (waiting_read_)
    475     return true;
    476 
    477   // Check if connection is alive and we haven't received any data
    478   // unexpectedly.
    479   char c;
    480   int rv = recv(socket_, &c, 1, MSG_PEEK);
    481   if (rv >= 0)
    482     return false;
    483   if (WSAGetLastError() != WSAEWOULDBLOCK)
    484     return false;
    485 
    486   return true;
    487 }
    488 
    489 int TCPSocketWin::Read(IOBuffer* buf,
    490                        int buf_len,
    491                        const CompletionCallback& callback) {
    492   DCHECK(CalledOnValidThread());
    493   DCHECK_NE(socket_, INVALID_SOCKET);
    494   DCHECK(!waiting_read_);
    495   DCHECK(read_callback_.is_null());
    496   DCHECK(!core_->read_iobuffer_);
    497 
    498   return DoRead(buf, buf_len, callback);
    499 }
    500 
    501 int TCPSocketWin::Write(IOBuffer* buf,
    502                         int buf_len,
    503                         const CompletionCallback& callback) {
    504   DCHECK(CalledOnValidThread());
    505   DCHECK_NE(socket_, INVALID_SOCKET);
    506   DCHECK(!waiting_write_);
    507   DCHECK(write_callback_.is_null());
    508   DCHECK_GT(buf_len, 0);
    509   DCHECK(!core_->write_iobuffer_);
    510 
    511   base::StatsCounter writes("tcp.writes");
    512   writes.Increment();
    513 
    514   WSABUF write_buffer;
    515   write_buffer.len = buf_len;
    516   write_buffer.buf = buf->data();
    517 
    518   // TODO(wtc): Remove the assertion after enough testing.
    519   AssertEventNotSignaled(core_->write_overlapped_.hEvent);
    520   DWORD num;
    521   int rv = WSASend(socket_, &write_buffer, 1, &num, 0,
    522                    &core_->write_overlapped_, NULL);
    523   if (rv == 0) {
    524     if (ResetEventIfSignaled(core_->write_overlapped_.hEvent)) {
    525       rv = static_cast<int>(num);
    526       if (rv > buf_len || rv < 0) {
    527         // It seems that some winsock interceptors report that more was written
    528         // than was available. Treat this as an error.  http://crbug.com/27870
    529         LOG(ERROR) << "Detected broken LSP: Asked to write " << buf_len
    530                    << " bytes, but " << rv << " bytes reported.";
    531         return ERR_WINSOCK_UNEXPECTED_WRITTEN_BYTES;
    532       }
    533       base::StatsCounter write_bytes("tcp.write_bytes");
    534       write_bytes.Add(rv);
    535       net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT, rv,
    536                                     buf->data());
    537       return rv;
    538     }
    539   } else {
    540     int os_error = WSAGetLastError();
    541     if (os_error != WSA_IO_PENDING) {
    542       int net_error = MapSystemError(os_error);
    543       net_log_.AddEvent(NetLog::TYPE_SOCKET_WRITE_ERROR,
    544                         CreateNetLogSocketErrorCallback(net_error, os_error));
    545       return net_error;
    546     }
    547   }
    548   waiting_write_ = true;
    549   write_callback_ = callback;
    550   core_->write_iobuffer_ = buf;
    551   core_->write_buffer_length_ = buf_len;
    552   core_->WatchForWrite();
    553   return ERR_IO_PENDING;
    554 }
    555 
    556 int TCPSocketWin::GetLocalAddress(IPEndPoint* address) const {
    557   DCHECK(CalledOnValidThread());
    558   DCHECK(address);
    559 
    560   SockaddrStorage storage;
    561   if (getsockname(socket_, storage.addr, &storage.addr_len))
    562     return MapSystemError(WSAGetLastError());
    563   if (!address->FromSockAddr(storage.addr, storage.addr_len))
    564     return ERR_ADDRESS_INVALID;
    565 
    566   return OK;
    567 }
    568 
    569 int TCPSocketWin::GetPeerAddress(IPEndPoint* address) const {
    570   DCHECK(CalledOnValidThread());
    571   DCHECK(address);
    572   if (!IsConnected())
    573     return ERR_SOCKET_NOT_CONNECTED;
    574   *address = *peer_address_;
    575   return OK;
    576 }
    577 
    578 int TCPSocketWin::SetDefaultOptionsForServer() {
    579   return SetExclusiveAddrUse();
    580 }
    581 
    582 void TCPSocketWin::SetDefaultOptionsForClient() {
    583   // Increase the socket buffer sizes from the default sizes for WinXP.  In
    584   // performance testing, there is substantial benefit by increasing from 8KB
    585   // to 64KB.
    586   // See also:
    587   //    http://support.microsoft.com/kb/823764/EN-US
    588   // On Vista, if we manually set these sizes, Vista turns off its receive
    589   // window auto-tuning feature.
    590   //    http://blogs.msdn.com/wndp/archive/2006/05/05/Winhec-blog-tcpip-2.aspx
    591   // Since Vista's auto-tune is better than any static value we can could set,
    592   // only change these on pre-vista machines.
    593   if (base::win::GetVersion() < base::win::VERSION_VISTA) {
    594     const int32 kSocketBufferSize = 64 * 1024;
    595     SetSocketReceiveBufferSize(socket_, kSocketBufferSize);
    596     SetSocketSendBufferSize(socket_, kSocketBufferSize);
    597   }
    598 
    599   DisableNagle(socket_, true);
    600   SetTCPKeepAlive(socket_, true, kTCPKeepAliveSeconds);
    601 }
    602 
    603 int TCPSocketWin::SetExclusiveAddrUse() {
    604   // On Windows, a bound end point can be hijacked by another process by
    605   // setting SO_REUSEADDR. Therefore a Windows-only option SO_EXCLUSIVEADDRUSE
    606   // was introduced in Windows NT 4.0 SP4. If the socket that is bound to the
    607   // end point has SO_EXCLUSIVEADDRUSE enabled, it is not possible for another
    608   // socket to forcibly bind to the end point until the end point is unbound.
    609   // It is recommend that all server applications must use SO_EXCLUSIVEADDRUSE.
    610   // MSDN: http://goo.gl/M6fjQ.
    611   //
    612   // Unlike on *nix, on Windows a TCP server socket can always bind to an end
    613   // point in TIME_WAIT state without setting SO_REUSEADDR, therefore it is not
    614   // needed here.
    615   //
    616   // SO_EXCLUSIVEADDRUSE will prevent a TCP client socket from binding to an end
    617   // point in TIME_WAIT status. It does not have this effect for a TCP server
    618   // socket.
    619 
    620   BOOL true_value = 1;
    621   int rv = setsockopt(socket_, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
    622                       reinterpret_cast<const char*>(&true_value),
    623                       sizeof(true_value));
    624   if (rv < 0)
    625     return MapSystemError(errno);
    626   return OK;
    627 }
    628 
    629 int TCPSocketWin::SetReceiveBufferSize(int32 size) {
    630   DCHECK(CalledOnValidThread());
    631   return SetSocketReceiveBufferSize(socket_, size);
    632 }
    633 
    634 int TCPSocketWin::SetSendBufferSize(int32 size) {
    635   DCHECK(CalledOnValidThread());
    636   return SetSocketSendBufferSize(socket_, size);
    637 }
    638 
    639 bool TCPSocketWin::SetKeepAlive(bool enable, int delay) {
    640   return SetTCPKeepAlive(socket_, enable, delay);
    641 }
    642 
    643 bool TCPSocketWin::SetNoDelay(bool no_delay) {
    644   return DisableNagle(socket_, no_delay);
    645 }
    646 
    647 void TCPSocketWin::Close() {
    648   DCHECK(CalledOnValidThread());
    649 
    650   if (socket_ != INVALID_SOCKET) {
    651     // Only log the close event if there's actually a socket to close.
    652     net_log_.AddEvent(NetLog::EventType::TYPE_SOCKET_CLOSED);
    653 
    654     // Note: don't use CancelIo to cancel pending IO because it doesn't work
    655     // when there is a Winsock layered service provider.
    656 
    657     // In most socket implementations, closing a socket results in a graceful
    658     // connection shutdown, but in Winsock we have to call shutdown explicitly.
    659     // See the MSDN page "Graceful Shutdown, Linger Options, and Socket Closure"
    660     // at http://msdn.microsoft.com/en-us/library/ms738547.aspx
    661     shutdown(socket_, SD_SEND);
    662 
    663     // This cancels any pending IO.
    664     if (closesocket(socket_) < 0)
    665       PLOG(ERROR) << "closesocket";
    666     socket_ = INVALID_SOCKET;
    667   }
    668 
    669   if (!accept_callback_.is_null()) {
    670     accept_watcher_.StopWatching();
    671     accept_socket_ = NULL;
    672     accept_address_ = NULL;
    673     accept_callback_.Reset();
    674   }
    675 
    676   if (accept_event_) {
    677     WSACloseEvent(accept_event_);
    678     accept_event_ = WSA_INVALID_EVENT;
    679   }
    680 
    681   if (core_) {
    682     if (waiting_connect_) {
    683       // We closed the socket, so this notification will never come.
    684       // From MSDN' WSAEventSelect documentation:
    685       // "Closing a socket with closesocket also cancels the association and
    686       // selection of network events specified in WSAEventSelect for the
    687       // socket".
    688       core_->Release();
    689     }
    690     core_->Detach();
    691     core_ = NULL;
    692   }
    693 
    694   waiting_connect_ = false;
    695   waiting_read_ = false;
    696   waiting_write_ = false;
    697 
    698   read_callback_.Reset();
    699   write_callback_.Reset();
    700   peer_address_.reset();
    701   connect_os_error_ = 0;
    702 }
    703 
    704 void TCPSocketWin::StartLoggingMultipleConnectAttempts(
    705     const AddressList& addresses) {
    706   if (!logging_multiple_connect_attempts_) {
    707     logging_multiple_connect_attempts_ = true;
    708     LogConnectBegin(addresses);
    709   } else {
    710     NOTREACHED();
    711   }
    712 }
    713 
    714 void TCPSocketWin::EndLoggingMultipleConnectAttempts(int net_error) {
    715   if (logging_multiple_connect_attempts_) {
    716     LogConnectEnd(net_error);
    717     logging_multiple_connect_attempts_ = false;
    718   } else {
    719     NOTREACHED();
    720   }
    721 }
    722 
    723 int TCPSocketWin::AcceptInternal(scoped_ptr<TCPSocketWin>* socket,
    724                                  IPEndPoint* address) {
    725   SockaddrStorage storage;
    726   int new_socket = accept(socket_, storage.addr, &storage.addr_len);
    727   if (new_socket < 0) {
    728     int net_error = MapSystemError(WSAGetLastError());
    729     if (net_error != ERR_IO_PENDING)
    730       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_ACCEPT, net_error);
    731     return net_error;
    732   }
    733 
    734   IPEndPoint ip_end_point;
    735   if (!ip_end_point.FromSockAddr(storage.addr, storage.addr_len)) {
    736     NOTREACHED();
    737     if (closesocket(new_socket) < 0)
    738       PLOG(ERROR) << "closesocket";
    739     int net_error = ERR_ADDRESS_INVALID;
    740     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_ACCEPT, net_error);
    741     return net_error;
    742   }
    743   scoped_ptr<TCPSocketWin> tcp_socket(new TCPSocketWin(
    744       net_log_.net_log(), net_log_.source()));
    745   int adopt_result = tcp_socket->AdoptConnectedSocket(new_socket, ip_end_point);
    746   if (adopt_result != OK) {
    747     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_ACCEPT, adopt_result);
    748     return adopt_result;
    749   }
    750   *socket = tcp_socket.Pass();
    751   *address = ip_end_point;
    752   net_log_.EndEvent(NetLog::TYPE_TCP_ACCEPT,
    753                     CreateNetLogIPEndPointCallback(&ip_end_point));
    754   return OK;
    755 }
    756 
    757 void TCPSocketWin::OnObjectSignaled(HANDLE object) {
    758   WSANETWORKEVENTS ev;
    759   if (WSAEnumNetworkEvents(socket_, accept_event_, &ev) == SOCKET_ERROR) {
    760     PLOG(ERROR) << "WSAEnumNetworkEvents()";
    761     return;
    762   }
    763 
    764   if (ev.lNetworkEvents & FD_ACCEPT) {
    765     int result = AcceptInternal(accept_socket_, accept_address_);
    766     if (result != ERR_IO_PENDING) {
    767       accept_socket_ = NULL;
    768       accept_address_ = NULL;
    769       base::ResetAndReturn(&accept_callback_).Run(result);
    770     }
    771   } else {
    772     // This happens when a client opens a connection and closes it before we
    773     // have a chance to accept it.
    774     DCHECK(ev.lNetworkEvents == 0);
    775 
    776     // Start watching the next FD_ACCEPT event.
    777     WSAEventSelect(socket_, accept_event_, FD_ACCEPT);
    778     accept_watcher_.StartWatching(accept_event_, this);
    779   }
    780 }
    781 
    782 int TCPSocketWin::DoConnect() {
    783   DCHECK_EQ(connect_os_error_, 0);
    784   DCHECK(!core_);
    785 
    786   net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT,
    787                       CreateNetLogIPEndPointCallback(peer_address_.get()));
    788 
    789   core_ = new Core(this);
    790   // WSAEventSelect sets the socket to non-blocking mode as a side effect.
    791   // Our connect() and recv() calls require that the socket be non-blocking.
    792   WSAEventSelect(socket_, core_->read_overlapped_.hEvent, FD_CONNECT);
    793 
    794   SockaddrStorage storage;
    795   if (!peer_address_->ToSockAddr(storage.addr, &storage.addr_len))
    796     return ERR_ADDRESS_INVALID;
    797   if (!connect(socket_, storage.addr, storage.addr_len)) {
    798     // Connected without waiting!
    799     //
    800     // The MSDN page for connect says:
    801     //   With a nonblocking socket, the connection attempt cannot be completed
    802     //   immediately. In this case, connect will return SOCKET_ERROR, and
    803     //   WSAGetLastError will return WSAEWOULDBLOCK.
    804     // which implies that for a nonblocking socket, connect never returns 0.
    805     // It's not documented whether the event object will be signaled or not
    806     // if connect does return 0.  So the code below is essentially dead code
    807     // and we don't know if it's correct.
    808     NOTREACHED();
    809 
    810     if (ResetEventIfSignaled(core_->read_overlapped_.hEvent))
    811       return OK;
    812   } else {
    813     int os_error = WSAGetLastError();
    814     if (os_error != WSAEWOULDBLOCK) {
    815       LOG(ERROR) << "connect failed: " << os_error;
    816       connect_os_error_ = os_error;
    817       int rv = MapConnectError(os_error);
    818       CHECK_NE(ERR_IO_PENDING, rv);
    819       return rv;
    820     }
    821   }
    822 
    823   core_->WatchForRead();
    824   return ERR_IO_PENDING;
    825 }
    826 
    827 void TCPSocketWin::DoConnectComplete(int result) {
    828   // Log the end of this attempt (and any OS error it threw).
    829   int os_error = connect_os_error_;
    830   connect_os_error_ = 0;
    831   if (result != OK) {
    832     net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT,
    833                       NetLog::IntegerCallback("os_error", os_error));
    834   } else {
    835     net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT);
    836   }
    837 
    838   if (!logging_multiple_connect_attempts_)
    839     LogConnectEnd(result);
    840 }
    841 
    842 void TCPSocketWin::LogConnectBegin(const AddressList& addresses) {
    843   base::StatsCounter connects("tcp.connect");
    844   connects.Increment();
    845 
    846   net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT,
    847                       addresses.CreateNetLogCallback());
    848 }
    849 
    850 void TCPSocketWin::LogConnectEnd(int net_error) {
    851   if (net_error == OK)
    852     UpdateConnectionTypeHistograms(CONNECTION_ANY);
    853 
    854   if (net_error != OK) {
    855     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_CONNECT, net_error);
    856     return;
    857   }
    858 
    859   struct sockaddr_storage source_address;
    860   socklen_t addrlen = sizeof(source_address);
    861   int rv = getsockname(
    862       socket_, reinterpret_cast<struct sockaddr*>(&source_address), &addrlen);
    863   if (rv != 0) {
    864     LOG(ERROR) << "getsockname() [rv: " << rv
    865                << "] error: " << WSAGetLastError();
    866     NOTREACHED();
    867     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_CONNECT, rv);
    868     return;
    869   }
    870 
    871   net_log_.EndEvent(
    872       NetLog::TYPE_TCP_CONNECT,
    873       CreateNetLogSourceAddressCallback(
    874           reinterpret_cast<const struct sockaddr*>(&source_address),
    875           sizeof(source_address)));
    876 }
    877 
    878 int TCPSocketWin::DoRead(IOBuffer* buf, int buf_len,
    879                          const CompletionCallback& callback) {
    880   if (!core_->non_blocking_reads_initialized_) {
    881     WSAEventSelect(socket_, core_->read_overlapped_.hEvent,
    882                    FD_READ | FD_CLOSE);
    883     core_->non_blocking_reads_initialized_ = true;
    884   }
    885   int rv = recv(socket_, buf->data(), buf_len, 0);
    886   if (rv == SOCKET_ERROR) {
    887     int os_error = WSAGetLastError();
    888     if (os_error != WSAEWOULDBLOCK) {
    889       int net_error = MapSystemError(os_error);
    890       net_log_.AddEvent(
    891           NetLog::TYPE_SOCKET_READ_ERROR,
    892           CreateNetLogSocketErrorCallback(net_error, os_error));
    893       return net_error;
    894     }
    895   } else {
    896     base::StatsCounter read_bytes("tcp.read_bytes");
    897     if (rv > 0)
    898       read_bytes.Add(rv);
    899     net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED, rv,
    900                                   buf->data());
    901     return rv;
    902   }
    903 
    904   waiting_read_ = true;
    905   read_callback_ = callback;
    906   core_->read_iobuffer_ = buf;
    907   core_->read_buffer_length_ = buf_len;
    908   core_->WatchForRead();
    909   return ERR_IO_PENDING;
    910 }
    911 
    912 void TCPSocketWin::DidCompleteConnect() {
    913   DCHECK(waiting_connect_);
    914   DCHECK(!read_callback_.is_null());
    915   int result;
    916 
    917   WSANETWORKEVENTS events;
    918   int rv = WSAEnumNetworkEvents(socket_, core_->read_overlapped_.hEvent,
    919                                 &events);
    920   int os_error = 0;
    921   if (rv == SOCKET_ERROR) {
    922     NOTREACHED();
    923     os_error = WSAGetLastError();
    924     result = MapSystemError(os_error);
    925   } else if (events.lNetworkEvents & FD_CONNECT) {
    926     os_error = events.iErrorCode[FD_CONNECT_BIT];
    927     result = MapConnectError(os_error);
    928   } else {
    929     NOTREACHED();
    930     result = ERR_UNEXPECTED;
    931   }
    932 
    933   connect_os_error_ = os_error;
    934   DoConnectComplete(result);
    935   waiting_connect_ = false;
    936 
    937   DCHECK_NE(result, ERR_IO_PENDING);
    938   base::ResetAndReturn(&read_callback_).Run(result);
    939 }
    940 
    941 void TCPSocketWin::DidCompleteWrite() {
    942   DCHECK(waiting_write_);
    943   DCHECK(!write_callback_.is_null());
    944 
    945   DWORD num_bytes, flags;
    946   BOOL ok = WSAGetOverlappedResult(socket_, &core_->write_overlapped_,
    947                                    &num_bytes, FALSE, &flags);
    948   WSAResetEvent(core_->write_overlapped_.hEvent);
    949   waiting_write_ = false;
    950   int rv;
    951   if (!ok) {
    952     int os_error = WSAGetLastError();
    953     rv = MapSystemError(os_error);
    954     net_log_.AddEvent(NetLog::TYPE_SOCKET_WRITE_ERROR,
    955                       CreateNetLogSocketErrorCallback(rv, os_error));
    956   } else {
    957     rv = static_cast<int>(num_bytes);
    958     if (rv > core_->write_buffer_length_ || rv < 0) {
    959       // It seems that some winsock interceptors report that more was written
    960       // than was available. Treat this as an error.  http://crbug.com/27870
    961       LOG(ERROR) << "Detected broken LSP: Asked to write "
    962                  << core_->write_buffer_length_ << " bytes, but " << rv
    963                  << " bytes reported.";
    964       rv = ERR_WINSOCK_UNEXPECTED_WRITTEN_BYTES;
    965     } else {
    966       base::StatsCounter write_bytes("tcp.write_bytes");
    967       write_bytes.Add(num_bytes);
    968       net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT, num_bytes,
    969                                     core_->write_iobuffer_->data());
    970     }
    971   }
    972 
    973   core_->write_iobuffer_ = NULL;
    974 
    975   DCHECK_NE(rv, ERR_IO_PENDING);
    976   base::ResetAndReturn(&write_callback_).Run(rv);
    977 }
    978 
    979 void TCPSocketWin::DidSignalRead() {
    980   DCHECK(waiting_read_);
    981   DCHECK(!read_callback_.is_null());
    982 
    983   int os_error = 0;
    984   WSANETWORKEVENTS network_events;
    985   int rv = WSAEnumNetworkEvents(socket_, core_->read_overlapped_.hEvent,
    986                                 &network_events);
    987   if (rv == SOCKET_ERROR) {
    988     os_error = WSAGetLastError();
    989     rv = MapSystemError(os_error);
    990   } else if (network_events.lNetworkEvents) {
    991     DCHECK_EQ(network_events.lNetworkEvents & ~(FD_READ | FD_CLOSE), 0);
    992     // If network_events.lNetworkEvents is FD_CLOSE and
    993     // network_events.iErrorCode[FD_CLOSE_BIT] is 0, it is a graceful
    994     // connection closure. It is tempting to directly set rv to 0 in
    995     // this case, but the MSDN pages for WSAEventSelect and
    996     // WSAAsyncSelect recommend we still call DoRead():
    997     //   FD_CLOSE should only be posted after all data is read from a
    998     //   socket, but an application should check for remaining data upon
    999     //   receipt of FD_CLOSE to avoid any possibility of losing data.
   1000     //
   1001     // If network_events.iErrorCode[FD_READ_BIT] or
   1002     // network_events.iErrorCode[FD_CLOSE_BIT] is nonzero, still call
   1003     // DoRead() because recv() reports a more accurate error code
   1004     // (WSAECONNRESET vs. WSAECONNABORTED) when the connection was
   1005     // reset.
   1006     rv = DoRead(core_->read_iobuffer_, core_->read_buffer_length_,
   1007                 read_callback_);
   1008     if (rv == ERR_IO_PENDING)
   1009       return;
   1010   } else {
   1011     // This may happen because Read() may succeed synchronously and
   1012     // consume all the received data without resetting the event object.
   1013     core_->WatchForRead();
   1014     return;
   1015   }
   1016 
   1017   waiting_read_ = false;
   1018   core_->read_iobuffer_ = NULL;
   1019   core_->read_buffer_length_ = 0;
   1020 
   1021   DCHECK_NE(rv, ERR_IO_PENDING);
   1022   base::ResetAndReturn(&read_callback_).Run(rv);
   1023 }
   1024 
   1025 }  // namespace net
   1026