Non-blocking connect() attempts may fail synchronously

net/socket/tcp_client_socket_libevent.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/socket/tcp_client_socket_libevent.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <sys/socket.h>
@@ skipping 60 matching lines @@
 
 int MapConnectError(int err) {
   switch (err) {
     case ETIMEDOUT:
       return ERR_CONNECTION_TIMED_OUT;
     default:
       return MapPosixError(err);
   }
 }
 
+// Given err, an errno from a connect() attempt, returns true if connect()
+// should be retried with another address.
+bool ShouldTryNextAddress(int err) {
+  switch (err) {
+    case EADDRNOTAVAIL:
+    case EAFNOSUPPORT:
+    case ECONNREFUSED:
+    case ECONNRESET:
+    case EACCES:
+    case EPERM:
+    case ENETUNREACH:
+    case EHOSTUNREACH:
+    case ENETDOWN:
+    case ETIMEDOUT:
+      return true;
+    default:
+      return false;
+  }
+}
+
 }  // namespace
 
 //-----------------------------------------------------------------------------
 
 TCPClientSocketLibevent::TCPClientSocketLibevent(const AddressList& addresses)
     : socket_(kInvalidSocket),
       addresses_(addresses),
       current_ai_(addresses_.head()),
       waiting_connect_(false),
       read_watcher_(this),
       write_watcher_(this),
       read_callback_(NULL),
       write_callback_(NULL) {
 }
 
 TCPClientSocketLibevent::~TCPClientSocketLibevent() {
   Disconnect();
 }
 
 int TCPClientSocketLibevent::Connect(CompletionCallback* callback) {
   // If already connected, then just return OK.
   if (socket_ != kInvalidSocket)
     return OK;
 
   DCHECK(!waiting_connect_);
 
   TRACE_EVENT_BEGIN("socket.connect", this, "");
-  const addrinfo* ai = current_ai_;
-  DCHECK(ai);
 
-  int rv = CreateSocket(ai);
-  if (rv != OK)
-    return rv;
+  while (true) {
+    DCHECK(current_ai_);
 
-  if (!HANDLE_EINTR(connect(socket_, ai->ai_addr,
-                            static_cast<int>(ai->ai_addrlen)))) {
-    TRACE_EVENT_END("socket.connect", this, "");
-    // Connected without waiting!
-    return OK;
+    int rv = CreateSocket(current_ai_);
+    if (rv != OK)
+      return rv;
+
+    if (!HANDLE_EINTR(connect(socket_, current_ai_->ai_addr,
+                              static_cast<int>(current_ai_->ai_addrlen)))) {
+      TRACE_EVENT_END("socket.connect", this, "");
+      // Connected without waiting!
+      return OK;
+    }
+
+    int error_code = errno;
+    if (error_code == EINPROGRESS)
+      break;
+
+    close(socket_);
+    socket_ = kInvalidSocket;
+
+    if (current_ai_->ai_next && ShouldTryNextAddress(error_code)) {
+      // connect() can fail synchronously for an address even on a
+      // non-blocking socket.  As an example, this can happen when there is
+      // no route to the host.  Retry using the next address in the list.
+      current_ai_ = current_ai_->ai_next;
+    } else {
+      DLOG(INFO) << "connect failed: " << error_code;
+      return MapConnectError(error_code);
+    }
   }
 
   // Synchronous operation not supported
   DCHECK(callback);
 
-  if (errno != EINPROGRESS) {
-    DLOG(INFO) << "connect failed: " << errno;
-    close(socket_);
-    socket_ = kInvalidSocket;
-    return MapConnectError(errno);
-  }
-
   // Initialize write_socket_watcher_ and link it to our MessagePump.
   // POLLOUT is set if the connection is established.
   // POLLIN is set if the connection fails.
   if (!MessageLoopForIO::current()->WatchFileDescriptor(
           socket_, true, MessageLoopForIO::WATCH_WRITE, &write_socket_watcher_,
           &write_watcher_)) {
     DLOG(INFO) << "WatchFileDescriptor failed: " << errno;
     close(socket_);
     socket_ = kInvalidSocket;
     return MapPosixError(errno);
@@ skipping 175 matching lines @@
 
   // Check to see if connect succeeded
   int error_code = 0;
   socklen_t len = sizeof(error_code);
   if (getsockopt(socket_, SOL_SOCKET, SO_ERROR, &error_code, &len) < 0)
     error_code = errno;
 
   if (error_code == EINPROGRESS || error_code == EALREADY) {
     NOTREACHED();  // This indicates a bug in libevent or our code.
     result = ERR_IO_PENDING;
-  } else if (current_ai_->ai_next && (
-             error_code == EADDRNOTAVAIL ||
-             error_code == EAFNOSUPPORT ||
-             error_code == ECONNREFUSED ||
-             error_code == ENETUNREACH ||
-             error_code == EHOSTUNREACH ||
-             error_code == ETIMEDOUT)) {
+  } else if (current_ai_->ai_next && ShouldTryNextAddress(error_code)) {
     // This address failed, try next one in list.
     const addrinfo* next = current_ai_->ai_next;
     Disconnect();
     current_ai_ = next;
     result = Connect(write_callback_);
   } else {
     result = MapConnectError(error_code);
     bool ok = write_socket_watcher_.StopWatchingFileDescriptor();
     DCHECK(ok);
     waiting_connect_ = false;
@@ skipping 48 matching lines @@
     DoWriteCallback(result);
   }
 }
 
 int TCPClientSocketLibevent::GetPeerName(struct sockaddr *name,
                                          socklen_t *namelen) {
   return ::getpeername(socket_, name, namelen);
 }
 
 }  // namespace net