Upstream the android python scripts changes that enable the new Forwarder2 to be used in our test f…

tools/android/forwarder2/socket.cc

 // Copyright (c) 2012 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 "tools/android/forwarder2/socket.h"
 
 #include <arpa/inet.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <netinet/in.h>
@@ skipping 18 matching lines @@
   do {                                                        \
     int local_errno = errno;                                  \
     (void) HANDLE_EINTR(Func);                                \
     errno = local_errno;                                      \
   } while (false);
 
 
 namespace {
 const int kNoTimeout = -1;
 const int kConnectTimeOut = 10;  // Seconds.
+
+bool FamilyIsTCP(int family) {
+  return family == AF_INET || family == AF_INET6;
+}
 }  // namespace
 
 namespace forwarder2 {
 
 bool Socket::BindUnix(const std::string& path, bool abstract) {
   errno = 0;
   if (!InitUnixSocket(path, abstract) || !BindAndListen()) {
     Close();
     return false;
   }
@@ skipping 73 matching lines @@
   // For abstract sockets we need one extra byte for the leading zero.
   if ((abstract && path.size() + 2 /* '\0' */ > kPathMax) ||
       (!abstract && path.size() + 1 /* '\0' */ > kPathMax)) {
     LOG(ERROR) << "The provided path is too big to create a unix "
                << "domain socket: " << path;
     return false;
   }
   abstract_ = abstract;
   family_ = PF_UNIX;
   addr_.addr_un.sun_family = family_;
-
   if (abstract) {
     // Copied from net/base/unix_domain_socket_posix.cc
     // Convert the path given into abstract socket name. It must start with
     // the '\0' character, so we are adding it. |addr_len| must specify the
     // length of the structure exactly, as potentially the socket name may
     // have '\0' characters embedded (although we don't support this).
     // Note that addr_.addr_un.sun_path is already zero initialized.
     memcpy(addr_.addr_un.sun_path + 1, path.c_str(), path.size());
     addr_len_ = path.size() + offsetof(struct sockaddr_un, sun_path) + 1;
   } else {
     memcpy(addr_.addr_un.sun_path, path.c_str(), path.size());
     addr_len_ = sizeof(sockaddr_un);
   }
-
   addr_ptr_ = reinterpret_cast<sockaddr*>(&addr_.addr_un);
   return InitSocketInternal();
 }
 
 bool Socket::InitTcpSocket(const std::string& host, int port) {
   port_ = port;
-
   if (host.empty()) {
     // Use localhost: INADDR_LOOPBACK
     family_ = AF_INET;
     addr_.addr4.sin_family = family_;
     addr_.addr4.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
   } else if (!Resolve(host)) {
     return false;
   }
-  CHECK(family_ == AF_INET || family_ == AF_INET6)
-      << "Invalid socket family.";
+  CHECK(FamilyIsTCP(family_)) << "Invalid socket family.";
   if (family_ == AF_INET) {
     addr_.addr4.sin_port = htons(port_);
     addr_ptr_ = reinterpret_cast<sockaddr*>(&addr_.addr4);
     addr_len_ = sizeof(addr_.addr4);
   } else if (family_ == AF_INET6) {
     addr_.addr6.sin6_port = htons(port_);
     addr_ptr_ = reinterpret_cast<sockaddr*>(&addr_.addr6);
     addr_len_ = sizeof(addr_.addr6);
   }
   return InitSocketInternal();
 }
 
 bool Socket::BindAndListen() {
   errno = 0;
   if (HANDLE_EINTR(bind(socket_, addr_ptr_, addr_len_)) < 0 ||
       HANDLE_EINTR(listen(socket_, 5)) < 0) {
     SetSocketError();
     return false;
   }
-  if (port_ == 0) {
+  if (port_ == 0 && FamilyIsTCP(family_)) {
     SockAddr addr;
     memset(&addr, 0, sizeof(addr));
     socklen_t addrlen = 0;
     sockaddr* addr_ptr = NULL;
     uint16* port_ptr = NULL;
     if (family_ == AF_INET) {
       addr_ptr = reinterpret_cast<sockaddr*>(&addr.addr4);
       port_ptr = &addr.addr4.sin_port;
       addrlen = sizeof(addr.addr4);
     } else if (family_ == AF_INET6) {
@@ skipping 24 matching lines @@
     SetSocketError();
     return false;
   }
 
   tools::DisableNagle(new_socket_fd);
   new_socket->socket_ = new_socket_fd;
   return true;
 }
 
 bool Socket::Connect() {
-  // Set non-block because we use select.
-  fcntl(socket_, F_SETFL, fcntl(socket_, F_GETFL) | O_NONBLOCK);
+  // Set non-block because we use select for connect.
+  const int kFlags = fcntl(socket_, F_GETFL);
+  DCHECK(!(kFlags & O_NONBLOCK));
+  fcntl(socket_, F_SETFL, kFlags | O_NONBLOCK);
   errno = 0;
   if (HANDLE_EINTR(connect(socket_, addr_ptr_, addr_len_)) < 0 &&
       errno != EINPROGRESS) {
     SetSocketError();
+    PRESERVE_ERRNO_HANDLE_EINTR(fcntl(socket_, F_SETFL, kFlags));
     return false;
   }
   // Wait for connection to complete, or receive a notification.
   if (!WaitForEvent(WRITE, kConnectTimeOut)) {
     SetSocketError();
+    PRESERVE_ERRNO_HANDLE_EINTR(fcntl(socket_, F_SETFL, kFlags));
     return false;
   }
+  // Disable non-block since our code assumes blocking semantics.
+  fcntl(socket_, F_SETFL, kFlags);
   return true;
 }
 
 bool Socket::Resolve(const std::string& host) {
   struct addrinfo hints;
   struct addrinfo* res;
   memset(&hints, 0, sizeof(hints));
   hints.ai_family = AF_UNSPEC;
   hints.ai_socktype = SOCK_STREAM;
   hints.ai_flags |= AI_CANONNAME;
@@ skipping 13 matching lines @@
     case AF_INET6:
       memcpy(&addr_.addr6,
              reinterpret_cast<sockaddr_in6*>(res->ai_addr),
              sizeof(sockaddr_in6));
       break;
   }
   return true;
 }
 
 int Socket::GetPort() {
-  if (family_ != AF_INET && family_ != AF_INET6) {
+  if (!FamilyIsTCP(family_)) {
     LOG(ERROR) << "Can't call GetPort() on an unix domain socket.";
     return 0;
   }
   return port_;
 }
 
 bool Socket::IsFdInSet(const fd_set& fds) const {
   if (IsClosed())
     return false;
   return FD_ISSET(socket_, &fds);
@@ skipping 83 matching lines @@
   return !FD_ISSET(exit_notifier_fd_, &read_fds);
 }
 
 // static
 int Socket::GetHighestFileDescriptor(
     const Socket& s1, const Socket& s2) {
   return std::max(s1.socket_, s2.socket_);
 }
 
 }  // namespace forwarder