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