| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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_client_socket_win.h" | |
| 6 | |
| 7 #include <mstcpip.h> | |
| 8 | |
| 9 #include "base/basictypes.h" | |
| 10 #include "base/compiler_specific.h" | |
| 11 #include "base/metrics/stats_counters.h" | |
| 12 #include "base/strings/string_util.h" | |
| 13 #include "base/win/object_watcher.h" | |
| 14 #include "base/win/windows_version.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_log.h" | |
| 20 #include "net/base/net_util.h" | |
| 21 #include "net/base/network_change_notifier.h" | |
| 22 #include "net/base/winsock_init.h" | |
| 23 #include "net/base/winsock_util.h" | |
| 24 #include "net/socket/socket_descriptor.h" | |
| 25 #include "net/socket/socket_net_log_params.h" | |
| 26 | |
| 27 namespace net { | |
| 28 | |
| 29 namespace { | |
| 30 | |
| 31 const int kTCPKeepAliveSeconds = 45; | |
| 32 bool g_disable_overlapped_reads = false; | |
| 33 | |
| 34 bool SetSocketReceiveBufferSize(SOCKET socket, int32 size) { | |
| 35 int rv = setsockopt(socket, SOL_SOCKET, SO_RCVBUF, | |
| 36 reinterpret_cast<const char*>(&size), sizeof(size)); | |
| 37 DCHECK(!rv) << "Could not set socket receive buffer size: " << GetLastError(); | |
| 38 return rv == 0; | |
| 39 } | |
| 40 | |
| 41 bool SetSocketSendBufferSize(SOCKET socket, int32 size) { | |
| 42 int rv = setsockopt(socket, SOL_SOCKET, SO_SNDBUF, | |
| 43 reinterpret_cast<const char*>(&size), sizeof(size)); | |
| 44 DCHECK(!rv) << "Could not set socket send buffer size: " << GetLastError(); | |
| 45 return rv == 0; | |
| 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 // Sets socket parameters. Returns the OS error code (or 0 on | |
| 100 // success). | |
| 101 int SetupSocket(SOCKET socket) { | |
| 102 // Increase the socket buffer sizes from the default sizes for WinXP. In | |
| 103 // performance testing, there is substantial benefit by increasing from 8KB | |
| 104 // to 64KB. | |
| 105 // See also: | |
| 106 // http://support.microsoft.com/kb/823764/EN-US | |
| 107 // On Vista, if we manually set these sizes, Vista turns off its receive | |
| 108 // window auto-tuning feature. | |
| 109 // http://blogs.msdn.com/wndp/archive/2006/05/05/Winhec-blog-tcpip-2.aspx | |
| 110 // Since Vista's auto-tune is better than any static value we can could set, | |
| 111 // only change these on pre-vista machines. | |
| 112 if (base::win::GetVersion() < base::win::VERSION_VISTA) { | |
| 113 const int32 kSocketBufferSize = 64 * 1024; | |
| 114 SetSocketReceiveBufferSize(socket, kSocketBufferSize); | |
| 115 SetSocketSendBufferSize(socket, kSocketBufferSize); | |
| 116 } | |
| 117 | |
| 118 DisableNagle(socket, true); | |
| 119 SetTCPKeepAlive(socket, true, kTCPKeepAliveSeconds); | |
| 120 return 0; | |
| 121 } | |
| 122 | |
| 123 // Creates a new socket and sets default parameters for it. Returns | |
| 124 // the OS error code (or 0 on success). | |
| 125 int CreateSocket(int family, SOCKET* socket) { | |
| 126 *socket = CreatePlatformSocket(family, SOCK_STREAM, IPPROTO_TCP); | |
| 127 if (*socket == INVALID_SOCKET) { | |
| 128 int os_error = WSAGetLastError(); | |
| 129 LOG(ERROR) << "CreatePlatformSocket failed: " << os_error; | |
| 130 return os_error; | |
| 131 } | |
| 132 int error = SetupSocket(*socket); | |
| 133 if (error) { | |
| 134 if (closesocket(*socket) < 0) | |
| 135 PLOG(ERROR) << "closesocket"; | |
| 136 *socket = INVALID_SOCKET; | |
| 137 return error; | |
| 138 } | |
| 139 return 0; | |
| 140 } | |
| 141 | |
| 142 int MapConnectError(int os_error) { | |
| 143 switch (os_error) { | |
| 144 // connect fails with WSAEACCES when Windows Firewall blocks the | |
| 145 // connection. | |
| 146 case WSAEACCES: | |
| 147 return ERR_NETWORK_ACCESS_DENIED; | |
| 148 case WSAETIMEDOUT: | |
| 149 return ERR_CONNECTION_TIMED_OUT; | |
| 150 default: { | |
| 151 int net_error = MapSystemError(os_error); | |
| 152 if (net_error == ERR_FAILED) | |
| 153 return ERR_CONNECTION_FAILED; // More specific than ERR_FAILED. | |
| 154 | |
| 155 // Give a more specific error when the user is offline. | |
| 156 if (net_error == ERR_ADDRESS_UNREACHABLE && | |
| 157 NetworkChangeNotifier::IsOffline()) { | |
| 158 return ERR_INTERNET_DISCONNECTED; | |
| 159 } | |
| 160 | |
| 161 return net_error; | |
| 162 } | |
| 163 } | |
| 164 } | |
| 165 | |
| 166 } // namespace | |
| 167 | |
| 168 //----------------------------------------------------------------------------- | |
| 169 | |
| 170 // This class encapsulates all the state that has to be preserved as long as | |
| 171 // there is a network IO operation in progress. If the owner TCPClientSocketWin | |
| 172 // is destroyed while an operation is in progress, the Core is detached and it | |
| 173 // lives until the operation completes and the OS doesn't reference any resource | |
| 174 // declared on this class anymore. | |
| 175 class TCPClientSocketWin::Core : public base::RefCounted<Core> { | |
| 176 public: | |
| 177 explicit Core(TCPClientSocketWin* socket); | |
| 178 | |
| 179 // Start watching for the end of a read or write operation. | |
| 180 void WatchForRead(); | |
| 181 void WatchForWrite(); | |
| 182 | |
| 183 // The TCPClientSocketWin is going away. | |
| 184 void Detach() { socket_ = NULL; } | |
| 185 | |
| 186 // The separate OVERLAPPED variables for asynchronous operation. | |
| 187 // |read_overlapped_| is used for both Connect() and Read(). | |
| 188 // |write_overlapped_| is only used for Write(); | |
| 189 OVERLAPPED read_overlapped_; | |
| 190 OVERLAPPED write_overlapped_; | |
| 191 | |
| 192 // The buffers used in Read() and Write(). | |
| 193 scoped_refptr<IOBuffer> read_iobuffer_; | |
| 194 scoped_refptr<IOBuffer> write_iobuffer_; | |
| 195 int read_buffer_length_; | |
| 196 int write_buffer_length_; | |
| 197 | |
| 198 bool non_blocking_reads_initialized_; | |
| 199 | |
| 200 private: | |
| 201 friend class base::RefCounted<Core>; | |
| 202 | |
| 203 class ReadDelegate : public base::win::ObjectWatcher::Delegate { | |
| 204 public: | |
| 205 explicit ReadDelegate(Core* core) : core_(core) {} | |
| 206 virtual ~ReadDelegate() {} | |
| 207 | |
| 208 // base::ObjectWatcher::Delegate methods: | |
| 209 virtual void OnObjectSignaled(HANDLE object); | |
| 210 | |
| 211 private: | |
| 212 Core* const core_; | |
| 213 }; | |
| 214 | |
| 215 class WriteDelegate : public base::win::ObjectWatcher::Delegate { | |
| 216 public: | |
| 217 explicit WriteDelegate(Core* core) : core_(core) {} | |
| 218 virtual ~WriteDelegate() {} | |
| 219 | |
| 220 // base::ObjectWatcher::Delegate methods: | |
| 221 virtual void OnObjectSignaled(HANDLE object); | |
| 222 | |
| 223 private: | |
| 224 Core* const core_; | |
| 225 }; | |
| 226 | |
| 227 ~Core(); | |
| 228 | |
| 229 // The socket that created this object. | |
| 230 TCPClientSocketWin* socket_; | |
| 231 | |
| 232 // |reader_| handles the signals from |read_watcher_|. | |
| 233 ReadDelegate reader_; | |
| 234 // |writer_| handles the signals from |write_watcher_|. | |
| 235 WriteDelegate writer_; | |
| 236 | |
| 237 // |read_watcher_| watches for events from Connect() and Read(). | |
| 238 base::win::ObjectWatcher read_watcher_; | |
| 239 // |write_watcher_| watches for events from Write(); | |
| 240 base::win::ObjectWatcher write_watcher_; | |
| 241 | |
| 242 DISALLOW_COPY_AND_ASSIGN(Core); | |
| 243 }; | |
| 244 | |
| 245 TCPClientSocketWin::Core::Core( | |
| 246 TCPClientSocketWin* socket) | |
| 247 : read_buffer_length_(0), | |
| 248 write_buffer_length_(0), | |
| 249 non_blocking_reads_initialized_(false), | |
| 250 socket_(socket), | |
| 251 reader_(this), | |
| 252 writer_(this) { | |
| 253 memset(&read_overlapped_, 0, sizeof(read_overlapped_)); | |
| 254 memset(&write_overlapped_, 0, sizeof(write_overlapped_)); | |
| 255 | |
| 256 read_overlapped_.hEvent = WSACreateEvent(); | |
| 257 write_overlapped_.hEvent = WSACreateEvent(); | |
| 258 } | |
| 259 | |
| 260 TCPClientSocketWin::Core::~Core() { | |
| 261 // Make sure the message loop is not watching this object anymore. | |
| 262 read_watcher_.StopWatching(); | |
| 263 write_watcher_.StopWatching(); | |
| 264 | |
| 265 WSACloseEvent(read_overlapped_.hEvent); | |
| 266 memset(&read_overlapped_, 0xaf, sizeof(read_overlapped_)); | |
| 267 WSACloseEvent(write_overlapped_.hEvent); | |
| 268 memset(&write_overlapped_, 0xaf, sizeof(write_overlapped_)); | |
| 269 } | |
| 270 | |
| 271 void TCPClientSocketWin::Core::WatchForRead() { | |
| 272 // We grab an extra reference because there is an IO operation in progress. | |
| 273 // Balanced in ReadDelegate::OnObjectSignaled(). | |
| 274 AddRef(); | |
| 275 read_watcher_.StartWatching(read_overlapped_.hEvent, &reader_); | |
| 276 } | |
| 277 | |
| 278 void TCPClientSocketWin::Core::WatchForWrite() { | |
| 279 // We grab an extra reference because there is an IO operation in progress. | |
| 280 // Balanced in WriteDelegate::OnObjectSignaled(). | |
| 281 AddRef(); | |
| 282 write_watcher_.StartWatching(write_overlapped_.hEvent, &writer_); | |
| 283 } | |
| 284 | |
| 285 void TCPClientSocketWin::Core::ReadDelegate::OnObjectSignaled( | |
| 286 HANDLE object) { | |
| 287 DCHECK_EQ(object, core_->read_overlapped_.hEvent); | |
| 288 if (core_->socket_) { | |
| 289 if (core_->socket_->waiting_connect()) | |
| 290 core_->socket_->DidCompleteConnect(); | |
| 291 else | |
| 292 core_->socket_->DidSignalRead(); | |
| 293 } | |
| 294 | |
| 295 core_->Release(); | |
| 296 } | |
| 297 | |
| 298 void TCPClientSocketWin::Core::WriteDelegate::OnObjectSignaled( | |
| 299 HANDLE object) { | |
| 300 DCHECK_EQ(object, core_->write_overlapped_.hEvent); | |
| 301 if (core_->socket_) | |
| 302 core_->socket_->DidCompleteWrite(); | |
| 303 | |
| 304 core_->Release(); | |
| 305 } | |
| 306 | |
| 307 //----------------------------------------------------------------------------- | |
| 308 | |
| 309 TCPClientSocketWin::TCPClientSocketWin(const AddressList& addresses, | |
| 310 net::NetLog* net_log, | |
| 311 const net::NetLog::Source& source) | |
| 312 : socket_(INVALID_SOCKET), | |
| 313 bound_socket_(INVALID_SOCKET), | |
| 314 addresses_(addresses), | |
| 315 current_address_index_(-1), | |
| 316 waiting_read_(false), | |
| 317 waiting_write_(false), | |
| 318 next_connect_state_(CONNECT_STATE_NONE), | |
| 319 connect_os_error_(0), | |
| 320 net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)), | |
| 321 previously_disconnected_(false) { | |
| 322 net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE, | |
| 323 source.ToEventParametersCallback()); | |
| 324 EnsureWinsockInit(); | |
| 325 } | |
| 326 | |
| 327 TCPClientSocketWin::~TCPClientSocketWin() { | |
| 328 Disconnect(); | |
| 329 net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE); | |
| 330 } | |
| 331 | |
| 332 int TCPClientSocketWin::AdoptSocket(SOCKET socket) { | |
| 333 DCHECK_EQ(socket_, INVALID_SOCKET); | |
| 334 | |
| 335 int error = SetupSocket(socket); | |
| 336 if (error) | |
| 337 return MapSystemError(error); | |
| 338 | |
| 339 socket_ = socket; | |
| 340 SetNonBlocking(socket_); | |
| 341 | |
| 342 core_ = new Core(this); | |
| 343 current_address_index_ = 0; | |
| 344 use_history_.set_was_ever_connected(); | |
| 345 | |
| 346 return OK; | |
| 347 } | |
| 348 | |
| 349 int TCPClientSocketWin::Bind(const IPEndPoint& address) { | |
| 350 if (current_address_index_ >= 0 || bind_address_.get()) { | |
| 351 // Cannot bind the socket if we are already connected or connecting. | |
| 352 return ERR_UNEXPECTED; | |
| 353 } | |
| 354 | |
| 355 SockaddrStorage storage; | |
| 356 if (!address.ToSockAddr(storage.addr, &storage.addr_len)) | |
| 357 return ERR_INVALID_ARGUMENT; | |
| 358 | |
| 359 // Create |bound_socket_| and try to bind it to |address|. | |
| 360 int error = CreateSocket(address.GetSockAddrFamily(), &bound_socket_); | |
| 361 if (error) | |
| 362 return MapSystemError(error); | |
| 363 | |
| 364 if (bind(bound_socket_, storage.addr, storage.addr_len)) { | |
| 365 error = errno; | |
| 366 if (closesocket(bound_socket_) < 0) | |
| 367 PLOG(ERROR) << "closesocket"; | |
| 368 bound_socket_ = INVALID_SOCKET; | |
| 369 return MapSystemError(error); | |
| 370 } | |
| 371 | |
| 372 bind_address_.reset(new IPEndPoint(address)); | |
| 373 | |
| 374 return 0; | |
| 375 } | |
| 376 | |
| 377 | |
| 378 int TCPClientSocketWin::Connect(const CompletionCallback& callback) { | |
| 379 DCHECK(CalledOnValidThread()); | |
| 380 | |
| 381 // If already connected, then just return OK. | |
| 382 if (socket_ != INVALID_SOCKET) | |
| 383 return OK; | |
| 384 | |
| 385 base::StatsCounter connects("tcp.connect"); | |
| 386 connects.Increment(); | |
| 387 | |
| 388 net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT, | |
| 389 addresses_.CreateNetLogCallback()); | |
| 390 | |
| 391 // We will try to connect to each address in addresses_. Start with the | |
| 392 // first one in the list. | |
| 393 next_connect_state_ = CONNECT_STATE_CONNECT; | |
| 394 current_address_index_ = 0; | |
| 395 | |
| 396 int rv = DoConnectLoop(OK); | |
| 397 if (rv == ERR_IO_PENDING) { | |
| 398 // Synchronous operation not supported. | |
| 399 DCHECK(!callback.is_null()); | |
| 400 // TODO(ajwong): Is setting read_callback_ the right thing to do here?? | |
| 401 read_callback_ = callback; | |
| 402 } else { | |
| 403 LogConnectCompletion(rv); | |
| 404 } | |
| 405 | |
| 406 return rv; | |
| 407 } | |
| 408 | |
| 409 int TCPClientSocketWin::DoConnectLoop(int result) { | |
| 410 DCHECK_NE(next_connect_state_, CONNECT_STATE_NONE); | |
| 411 | |
| 412 int rv = result; | |
| 413 do { | |
| 414 ConnectState state = next_connect_state_; | |
| 415 next_connect_state_ = CONNECT_STATE_NONE; | |
| 416 switch (state) { | |
| 417 case CONNECT_STATE_CONNECT: | |
| 418 DCHECK_EQ(OK, rv); | |
| 419 rv = DoConnect(); | |
| 420 break; | |
| 421 case CONNECT_STATE_CONNECT_COMPLETE: | |
| 422 rv = DoConnectComplete(rv); | |
| 423 break; | |
| 424 default: | |
| 425 LOG(DFATAL) << "bad state " << state; | |
| 426 rv = ERR_UNEXPECTED; | |
| 427 break; | |
| 428 } | |
| 429 } while (rv != ERR_IO_PENDING && next_connect_state_ != CONNECT_STATE_NONE); | |
| 430 | |
| 431 return rv; | |
| 432 } | |
| 433 | |
| 434 int TCPClientSocketWin::DoConnect() { | |
| 435 DCHECK_GE(current_address_index_, 0); | |
| 436 DCHECK_LT(current_address_index_, static_cast<int>(addresses_.size())); | |
| 437 DCHECK_EQ(0, connect_os_error_); | |
| 438 | |
| 439 const IPEndPoint& endpoint = addresses_[current_address_index_]; | |
| 440 | |
| 441 if (previously_disconnected_) { | |
| 442 use_history_.Reset(); | |
| 443 previously_disconnected_ = false; | |
| 444 } | |
| 445 | |
| 446 net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT, | |
| 447 CreateNetLogIPEndPointCallback(&endpoint)); | |
| 448 | |
| 449 next_connect_state_ = CONNECT_STATE_CONNECT_COMPLETE; | |
| 450 | |
| 451 if (bound_socket_ != INVALID_SOCKET) { | |
| 452 DCHECK(bind_address_.get()); | |
| 453 socket_ = bound_socket_; | |
| 454 bound_socket_ = INVALID_SOCKET; | |
| 455 } else { | |
| 456 connect_os_error_ = CreateSocket(endpoint.GetSockAddrFamily(), &socket_); | |
| 457 if (connect_os_error_ != 0) | |
| 458 return MapSystemError(connect_os_error_); | |
| 459 | |
| 460 if (bind_address_.get()) { | |
| 461 SockaddrStorage storage; | |
| 462 if (!bind_address_->ToSockAddr(storage.addr, &storage.addr_len)) | |
| 463 return ERR_INVALID_ARGUMENT; | |
| 464 if (bind(socket_, storage.addr, storage.addr_len)) | |
| 465 return MapSystemError(errno); | |
| 466 } | |
| 467 } | |
| 468 | |
| 469 DCHECK(!core_); | |
| 470 core_ = new Core(this); | |
| 471 // WSAEventSelect sets the socket to non-blocking mode as a side effect. | |
| 472 // Our connect() and recv() calls require that the socket be non-blocking. | |
| 473 WSAEventSelect(socket_, core_->read_overlapped_.hEvent, FD_CONNECT); | |
| 474 | |
| 475 SockaddrStorage storage; | |
| 476 if (!endpoint.ToSockAddr(storage.addr, &storage.addr_len)) | |
| 477 return ERR_INVALID_ARGUMENT; | |
| 478 if (!connect(socket_, storage.addr, storage.addr_len)) { | |
| 479 // Connected without waiting! | |
| 480 // | |
| 481 // The MSDN page for connect says: | |
| 482 // With a nonblocking socket, the connection attempt cannot be completed | |
| 483 // immediately. In this case, connect will return SOCKET_ERROR, and | |
| 484 // WSAGetLastError will return WSAEWOULDBLOCK. | |
| 485 // which implies that for a nonblocking socket, connect never returns 0. | |
| 486 // It's not documented whether the event object will be signaled or not | |
| 487 // if connect does return 0. So the code below is essentially dead code | |
| 488 // and we don't know if it's correct. | |
| 489 NOTREACHED(); | |
| 490 | |
| 491 if (ResetEventIfSignaled(core_->read_overlapped_.hEvent)) | |
| 492 return OK; | |
| 493 } else { | |
| 494 int os_error = WSAGetLastError(); | |
| 495 if (os_error != WSAEWOULDBLOCK) { | |
| 496 LOG(ERROR) << "connect failed: " << os_error; | |
| 497 connect_os_error_ = os_error; | |
| 498 return MapConnectError(os_error); | |
| 499 } | |
| 500 } | |
| 501 | |
| 502 core_->WatchForRead(); | |
| 503 return ERR_IO_PENDING; | |
| 504 } | |
| 505 | |
| 506 int TCPClientSocketWin::DoConnectComplete(int result) { | |
| 507 // Log the end of this attempt (and any OS error it threw). | |
| 508 int os_error = connect_os_error_; | |
| 509 connect_os_error_ = 0; | |
| 510 if (result != OK) { | |
| 511 net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT, | |
| 512 NetLog::IntegerCallback("os_error", os_error)); | |
| 513 } else { | |
| 514 net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT); | |
| 515 } | |
| 516 | |
| 517 if (result == OK) { | |
| 518 use_history_.set_was_ever_connected(); | |
| 519 return OK; // Done! | |
| 520 } | |
| 521 | |
| 522 // Close whatever partially connected socket we currently have. | |
| 523 DoDisconnect(); | |
| 524 | |
| 525 // Try to fall back to the next address in the list. | |
| 526 if (current_address_index_ + 1 < static_cast<int>(addresses_.size())) { | |
| 527 next_connect_state_ = CONNECT_STATE_CONNECT; | |
| 528 ++current_address_index_; | |
| 529 return OK; | |
| 530 } | |
| 531 | |
| 532 // Otherwise there is nothing to fall back to, so give up. | |
| 533 return result; | |
| 534 } | |
| 535 | |
| 536 void TCPClientSocketWin::Disconnect() { | |
| 537 DCHECK(CalledOnValidThread()); | |
| 538 | |
| 539 DoDisconnect(); | |
| 540 current_address_index_ = -1; | |
| 541 bind_address_.reset(); | |
| 542 } | |
| 543 | |
| 544 void TCPClientSocketWin::DoDisconnect() { | |
| 545 DCHECK(CalledOnValidThread()); | |
| 546 | |
| 547 if (socket_ == INVALID_SOCKET) | |
| 548 return; | |
| 549 | |
| 550 // Note: don't use CancelIo to cancel pending IO because it doesn't work | |
| 551 // when there is a Winsock layered service provider. | |
| 552 | |
| 553 // In most socket implementations, closing a socket results in a graceful | |
| 554 // connection shutdown, but in Winsock we have to call shutdown explicitly. | |
| 555 // See the MSDN page "Graceful Shutdown, Linger Options, and Socket Closure" | |
| 556 // at http://msdn.microsoft.com/en-us/library/ms738547.aspx | |
| 557 shutdown(socket_, SD_SEND); | |
| 558 | |
| 559 // This cancels any pending IO. | |
| 560 closesocket(socket_); | |
| 561 socket_ = INVALID_SOCKET; | |
| 562 | |
| 563 if (waiting_connect()) { | |
| 564 // We closed the socket, so this notification will never come. | |
| 565 // From MSDN' WSAEventSelect documentation: | |
| 566 // "Closing a socket with closesocket also cancels the association and | |
| 567 // selection of network events specified in WSAEventSelect for the socket". | |
| 568 core_->Release(); | |
| 569 } | |
| 570 | |
| 571 waiting_read_ = false; | |
| 572 waiting_write_ = false; | |
| 573 | |
| 574 core_->Detach(); | |
| 575 core_ = NULL; | |
| 576 | |
| 577 previously_disconnected_ = true; | |
| 578 } | |
| 579 | |
| 580 bool TCPClientSocketWin::IsConnected() const { | |
| 581 DCHECK(CalledOnValidThread()); | |
| 582 | |
| 583 if (socket_ == INVALID_SOCKET || waiting_connect()) | |
| 584 return false; | |
| 585 | |
| 586 if (waiting_read_) | |
| 587 return true; | |
| 588 | |
| 589 // Check if connection is alive. | |
| 590 char c; | |
| 591 int rv = recv(socket_, &c, 1, MSG_PEEK); | |
| 592 if (rv == 0) | |
| 593 return false; | |
| 594 if (rv == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK) | |
| 595 return false; | |
| 596 | |
| 597 return true; | |
| 598 } | |
| 599 | |
| 600 bool TCPClientSocketWin::IsConnectedAndIdle() const { | |
| 601 DCHECK(CalledOnValidThread()); | |
| 602 | |
| 603 if (socket_ == INVALID_SOCKET || waiting_connect()) | |
| 604 return false; | |
| 605 | |
| 606 if (waiting_read_) | |
| 607 return true; | |
| 608 | |
| 609 // Check if connection is alive and we haven't received any data | |
| 610 // unexpectedly. | |
| 611 char c; | |
| 612 int rv = recv(socket_, &c, 1, MSG_PEEK); | |
| 613 if (rv >= 0) | |
| 614 return false; | |
| 615 if (WSAGetLastError() != WSAEWOULDBLOCK) | |
| 616 return false; | |
| 617 | |
| 618 return true; | |
| 619 } | |
| 620 | |
| 621 int TCPClientSocketWin::GetPeerAddress(IPEndPoint* address) const { | |
| 622 DCHECK(CalledOnValidThread()); | |
| 623 DCHECK(address); | |
| 624 if (!IsConnected()) | |
| 625 return ERR_SOCKET_NOT_CONNECTED; | |
| 626 *address = addresses_[current_address_index_]; | |
| 627 return OK; | |
| 628 } | |
| 629 | |
| 630 int TCPClientSocketWin::GetLocalAddress(IPEndPoint* address) const { | |
| 631 DCHECK(CalledOnValidThread()); | |
| 632 DCHECK(address); | |
| 633 if (socket_ == INVALID_SOCKET) { | |
| 634 if (bind_address_.get()) { | |
| 635 *address = *bind_address_; | |
| 636 return OK; | |
| 637 } | |
| 638 return ERR_SOCKET_NOT_CONNECTED; | |
| 639 } | |
| 640 | |
| 641 struct sockaddr_storage addr_storage; | |
| 642 socklen_t addr_len = sizeof(addr_storage); | |
| 643 struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage); | |
| 644 if (getsockname(socket_, addr, &addr_len)) | |
| 645 return MapSystemError(WSAGetLastError()); | |
| 646 if (!address->FromSockAddr(addr, addr_len)) | |
| 647 return ERR_FAILED; | |
| 648 return OK; | |
| 649 } | |
| 650 | |
| 651 void TCPClientSocketWin::SetSubresourceSpeculation() { | |
| 652 use_history_.set_subresource_speculation(); | |
| 653 } | |
| 654 | |
| 655 void TCPClientSocketWin::SetOmniboxSpeculation() { | |
| 656 use_history_.set_omnibox_speculation(); | |
| 657 } | |
| 658 | |
| 659 bool TCPClientSocketWin::WasEverUsed() const { | |
| 660 return use_history_.was_used_to_convey_data(); | |
| 661 } | |
| 662 | |
| 663 bool TCPClientSocketWin::UsingTCPFastOpen() const { | |
| 664 // Not supported on windows. | |
| 665 return false; | |
| 666 } | |
| 667 | |
| 668 bool TCPClientSocketWin::WasNpnNegotiated() const { | |
| 669 return false; | |
| 670 } | |
| 671 | |
| 672 NextProto TCPClientSocketWin::GetNegotiatedProtocol() const { | |
| 673 return kProtoUnknown; | |
| 674 } | |
| 675 | |
| 676 bool TCPClientSocketWin::GetSSLInfo(SSLInfo* ssl_info) { | |
| 677 return false; | |
| 678 } | |
| 679 | |
| 680 int TCPClientSocketWin::Read(IOBuffer* buf, | |
| 681 int buf_len, | |
| 682 const CompletionCallback& callback) { | |
| 683 DCHECK(CalledOnValidThread()); | |
| 684 DCHECK_NE(socket_, INVALID_SOCKET); | |
| 685 DCHECK(!waiting_read_); | |
| 686 DCHECK(read_callback_.is_null()); | |
| 687 DCHECK(!core_->read_iobuffer_); | |
| 688 | |
| 689 return DoRead(buf, buf_len, callback); | |
| 690 } | |
| 691 | |
| 692 int TCPClientSocketWin::Write(IOBuffer* buf, | |
| 693 int buf_len, | |
| 694 const CompletionCallback& callback) { | |
| 695 DCHECK(CalledOnValidThread()); | |
| 696 DCHECK_NE(socket_, INVALID_SOCKET); | |
| 697 DCHECK(!waiting_write_); | |
| 698 DCHECK(write_callback_.is_null()); | |
| 699 DCHECK_GT(buf_len, 0); | |
| 700 DCHECK(!core_->write_iobuffer_); | |
| 701 | |
| 702 base::StatsCounter writes("tcp.writes"); | |
| 703 writes.Increment(); | |
| 704 | |
| 705 WSABUF write_buffer; | |
| 706 write_buffer.len = buf_len; | |
| 707 write_buffer.buf = buf->data(); | |
| 708 | |
| 709 // TODO(wtc): Remove the assertion after enough testing. | |
| 710 AssertEventNotSignaled(core_->write_overlapped_.hEvent); | |
| 711 DWORD num; | |
| 712 int rv = WSASend(socket_, &write_buffer, 1, &num, 0, | |
| 713 &core_->write_overlapped_, NULL); | |
| 714 if (rv == 0) { | |
| 715 if (ResetEventIfSignaled(core_->write_overlapped_.hEvent)) { | |
| 716 rv = static_cast<int>(num); | |
| 717 if (rv > buf_len || rv < 0) { | |
| 718 // It seems that some winsock interceptors report that more was written | |
| 719 // than was available. Treat this as an error. http://crbug.com/27870 | |
| 720 LOG(ERROR) << "Detected broken LSP: Asked to write " << buf_len | |
| 721 << " bytes, but " << rv << " bytes reported."; | |
| 722 return ERR_WINSOCK_UNEXPECTED_WRITTEN_BYTES; | |
| 723 } | |
| 724 base::StatsCounter write_bytes("tcp.write_bytes"); | |
| 725 write_bytes.Add(rv); | |
| 726 if (rv > 0) | |
| 727 use_history_.set_was_used_to_convey_data(); | |
| 728 net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT, rv, | |
| 729 buf->data()); | |
| 730 return rv; | |
| 731 } | |
| 732 } else { | |
| 733 int os_error = WSAGetLastError(); | |
| 734 if (os_error != WSA_IO_PENDING) { | |
| 735 int net_error = MapSystemError(os_error); | |
| 736 net_log_.AddEvent(NetLog::TYPE_SOCKET_WRITE_ERROR, | |
| 737 CreateNetLogSocketErrorCallback(net_error, os_error)); | |
| 738 return net_error; | |
| 739 } | |
| 740 } | |
| 741 waiting_write_ = true; | |
| 742 write_callback_ = callback; | |
| 743 core_->write_iobuffer_ = buf; | |
| 744 core_->write_buffer_length_ = buf_len; | |
| 745 core_->WatchForWrite(); | |
| 746 return ERR_IO_PENDING; | |
| 747 } | |
| 748 | |
| 749 bool TCPClientSocketWin::SetReceiveBufferSize(int32 size) { | |
| 750 DCHECK(CalledOnValidThread()); | |
| 751 return SetSocketReceiveBufferSize(socket_, size); | |
| 752 } | |
| 753 | |
| 754 bool TCPClientSocketWin::SetSendBufferSize(int32 size) { | |
| 755 DCHECK(CalledOnValidThread()); | |
| 756 return SetSocketSendBufferSize(socket_, size); | |
| 757 } | |
| 758 | |
| 759 bool TCPClientSocketWin::SetKeepAlive(bool enable, int delay) { | |
| 760 return SetTCPKeepAlive(socket_, enable, delay); | |
| 761 } | |
| 762 | |
| 763 bool TCPClientSocketWin::SetNoDelay(bool no_delay) { | |
| 764 return DisableNagle(socket_, no_delay); | |
| 765 } | |
| 766 | |
| 767 void TCPClientSocketWin::LogConnectCompletion(int net_error) { | |
| 768 if (net_error == OK) | |
| 769 UpdateConnectionTypeHistograms(CONNECTION_ANY); | |
| 770 | |
| 771 if (net_error != OK) { | |
| 772 net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_CONNECT, net_error); | |
| 773 return; | |
| 774 } | |
| 775 | |
| 776 struct sockaddr_storage source_address; | |
| 777 socklen_t addrlen = sizeof(source_address); | |
| 778 int rv = getsockname( | |
| 779 socket_, reinterpret_cast<struct sockaddr*>(&source_address), &addrlen); | |
| 780 if (rv != 0) { | |
| 781 LOG(ERROR) << "getsockname() [rv: " << rv | |
| 782 << "] error: " << WSAGetLastError(); | |
| 783 NOTREACHED(); | |
| 784 net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_CONNECT, rv); | |
| 785 return; | |
| 786 } | |
| 787 | |
| 788 net_log_.EndEvent( | |
| 789 NetLog::TYPE_TCP_CONNECT, | |
| 790 CreateNetLogSourceAddressCallback( | |
| 791 reinterpret_cast<const struct sockaddr*>(&source_address), | |
| 792 sizeof(source_address))); | |
| 793 } | |
| 794 | |
| 795 int TCPClientSocketWin::DoRead(IOBuffer* buf, int buf_len, | |
| 796 const CompletionCallback& callback) { | |
| 797 if (!core_->non_blocking_reads_initialized_) { | |
| 798 WSAEventSelect(socket_, core_->read_overlapped_.hEvent, | |
| 799 FD_READ | FD_CLOSE); | |
| 800 core_->non_blocking_reads_initialized_ = true; | |
| 801 } | |
| 802 int rv = recv(socket_, buf->data(), buf_len, 0); | |
| 803 if (rv == SOCKET_ERROR) { | |
| 804 int os_error = WSAGetLastError(); | |
| 805 if (os_error != WSAEWOULDBLOCK) { | |
| 806 int net_error = MapSystemError(os_error); | |
| 807 net_log_.AddEvent( | |
| 808 NetLog::TYPE_SOCKET_READ_ERROR, | |
| 809 CreateNetLogSocketErrorCallback(net_error, os_error)); | |
| 810 return net_error; | |
| 811 } | |
| 812 } else { | |
| 813 base::StatsCounter read_bytes("tcp.read_bytes"); | |
| 814 if (rv > 0) { | |
| 815 use_history_.set_was_used_to_convey_data(); | |
| 816 read_bytes.Add(rv); | |
| 817 } | |
| 818 net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED, rv, | |
| 819 buf->data()); | |
| 820 return rv; | |
| 821 } | |
| 822 | |
| 823 waiting_read_ = true; | |
| 824 read_callback_ = callback; | |
| 825 core_->read_iobuffer_ = buf; | |
| 826 core_->read_buffer_length_ = buf_len; | |
| 827 core_->WatchForRead(); | |
| 828 return ERR_IO_PENDING; | |
| 829 } | |
| 830 | |
| 831 void TCPClientSocketWin::DoReadCallback(int rv) { | |
| 832 DCHECK_NE(rv, ERR_IO_PENDING); | |
| 833 DCHECK(!read_callback_.is_null()); | |
| 834 | |
| 835 // Since Run may result in Read being called, clear read_callback_ up front. | |
| 836 CompletionCallback c = read_callback_; | |
| 837 read_callback_.Reset(); | |
| 838 c.Run(rv); | |
| 839 } | |
| 840 | |
| 841 void TCPClientSocketWin::DoWriteCallback(int rv) { | |
| 842 DCHECK_NE(rv, ERR_IO_PENDING); | |
| 843 DCHECK(!write_callback_.is_null()); | |
| 844 | |
| 845 // Since Run may result in Write being called, clear write_callback_ up front. | |
| 846 CompletionCallback c = write_callback_; | |
| 847 write_callback_.Reset(); | |
| 848 c.Run(rv); | |
| 849 } | |
| 850 | |
| 851 void TCPClientSocketWin::DidCompleteConnect() { | |
| 852 DCHECK_EQ(next_connect_state_, CONNECT_STATE_CONNECT_COMPLETE); | |
| 853 int result; | |
| 854 | |
| 855 WSANETWORKEVENTS events; | |
| 856 int rv = WSAEnumNetworkEvents(socket_, core_->read_overlapped_.hEvent, | |
| 857 &events); | |
| 858 int os_error = 0; | |
| 859 if (rv == SOCKET_ERROR) { | |
| 860 NOTREACHED(); | |
| 861 os_error = WSAGetLastError(); | |
| 862 result = MapSystemError(os_error); | |
| 863 } else if (events.lNetworkEvents & FD_CONNECT) { | |
| 864 os_error = events.iErrorCode[FD_CONNECT_BIT]; | |
| 865 result = MapConnectError(os_error); | |
| 866 } else { | |
| 867 NOTREACHED(); | |
| 868 result = ERR_UNEXPECTED; | |
| 869 } | |
| 870 | |
| 871 connect_os_error_ = os_error; | |
| 872 rv = DoConnectLoop(result); | |
| 873 if (rv != ERR_IO_PENDING) { | |
| 874 LogConnectCompletion(rv); | |
| 875 DoReadCallback(rv); | |
| 876 } | |
| 877 } | |
| 878 | |
| 879 void TCPClientSocketWin::DidCompleteWrite() { | |
| 880 DCHECK(waiting_write_); | |
| 881 | |
| 882 DWORD num_bytes, flags; | |
| 883 BOOL ok = WSAGetOverlappedResult(socket_, &core_->write_overlapped_, | |
| 884 &num_bytes, FALSE, &flags); | |
| 885 WSAResetEvent(core_->write_overlapped_.hEvent); | |
| 886 waiting_write_ = false; | |
| 887 int rv; | |
| 888 if (!ok) { | |
| 889 int os_error = WSAGetLastError(); | |
| 890 rv = MapSystemError(os_error); | |
| 891 net_log_.AddEvent(NetLog::TYPE_SOCKET_WRITE_ERROR, | |
| 892 CreateNetLogSocketErrorCallback(rv, os_error)); | |
| 893 } else { | |
| 894 rv = static_cast<int>(num_bytes); | |
| 895 if (rv > core_->write_buffer_length_ || rv < 0) { | |
| 896 // It seems that some winsock interceptors report that more was written | |
| 897 // than was available. Treat this as an error. http://crbug.com/27870 | |
| 898 LOG(ERROR) << "Detected broken LSP: Asked to write " | |
| 899 << core_->write_buffer_length_ << " bytes, but " << rv | |
| 900 << " bytes reported."; | |
| 901 rv = ERR_WINSOCK_UNEXPECTED_WRITTEN_BYTES; | |
| 902 } else { | |
| 903 base::StatsCounter write_bytes("tcp.write_bytes"); | |
| 904 write_bytes.Add(num_bytes); | |
| 905 if (num_bytes > 0) | |
| 906 use_history_.set_was_used_to_convey_data(); | |
| 907 net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT, num_bytes, | |
| 908 core_->write_iobuffer_->data()); | |
| 909 } | |
| 910 } | |
| 911 core_->write_iobuffer_ = NULL; | |
| 912 DoWriteCallback(rv); | |
| 913 } | |
| 914 | |
| 915 void TCPClientSocketWin::DidSignalRead() { | |
| 916 DCHECK(waiting_read_); | |
| 917 int os_error = 0; | |
| 918 WSANETWORKEVENTS network_events; | |
| 919 int rv = WSAEnumNetworkEvents(socket_, core_->read_overlapped_.hEvent, | |
| 920 &network_events); | |
| 921 if (rv == SOCKET_ERROR) { | |
| 922 os_error = WSAGetLastError(); | |
| 923 rv = MapSystemError(os_error); | |
| 924 } else if (network_events.lNetworkEvents) { | |
| 925 DCHECK_EQ(network_events.lNetworkEvents & ~(FD_READ | FD_CLOSE), 0); | |
| 926 // If network_events.lNetworkEvents is FD_CLOSE and | |
| 927 // network_events.iErrorCode[FD_CLOSE_BIT] is 0, it is a graceful | |
| 928 // connection closure. It is tempting to directly set rv to 0 in | |
| 929 // this case, but the MSDN pages for WSAEventSelect and | |
| 930 // WSAAsyncSelect recommend we still call DoRead(): | |
| 931 // FD_CLOSE should only be posted after all data is read from a | |
| 932 // socket, but an application should check for remaining data upon | |
| 933 // receipt of FD_CLOSE to avoid any possibility of losing data. | |
| 934 // | |
| 935 // If network_events.iErrorCode[FD_READ_BIT] or | |
| 936 // network_events.iErrorCode[FD_CLOSE_BIT] is nonzero, still call | |
| 937 // DoRead() because recv() reports a more accurate error code | |
| 938 // (WSAECONNRESET vs. WSAECONNABORTED) when the connection was | |
| 939 // reset. | |
| 940 rv = DoRead(core_->read_iobuffer_, core_->read_buffer_length_, | |
| 941 read_callback_); | |
| 942 if (rv == ERR_IO_PENDING) | |
| 943 return; | |
| 944 } else { | |
| 945 // This may happen because Read() may succeed synchronously and | |
| 946 // consume all the received data without resetting the event object. | |
| 947 core_->WatchForRead(); | |
| 948 return; | |
| 949 } | |
| 950 waiting_read_ = false; | |
| 951 core_->read_iobuffer_ = NULL; | |
| 952 core_->read_buffer_length_ = 0; | |
| 953 DoReadCallback(rv); | |
| 954 } | |
| 955 | |
| 956 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 23881002:
Windows only: Move client socket functionality from TCPClientSocket into TCPSocket. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src