Support HTTP test-server based net unit tests on Android.

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>
 #include <stdio.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 
 #include "base/eintr_wrapper.h"
 #include "base/logging.h"
 #include "base/safe_strerror_posix.h"
 #include "tools/android/common/net.h"
-
-// This is used in Close and Shutdown.
-// Preserving errno for Close() is important because the function is very often
-// used in cleanup code, after an error occurred, and it is very easy to pass an
-// invalid file descriptor to close() in this context, or more rarely, a
-// spurious signal might make close() return -1 + setting errno to EINTR,
-// masking the real reason for the original error. This leads to very unpleasant
-// debugging sessions.
-#define PRESERVE_ERRNO_HANDLE_EINTR(Func)                     \
-  do {                                                        \
-    int local_errno = errno;                                  \
-    (void) HANDLE_EINTR(Func);                                \
-    errno = local_errno;                                      \
-  } while (false);
-
+#include "tools/android/forwarder2/common.h"
 
 namespace {
 const int kNoTimeout = -1;
 const int kConnectTimeOut = 10;  // Seconds.
 
 bool FamilyIsTCP(int family) {
   return family == AF_INET || family == AF_INET6;
 }
 }  // namespace
 
@@ skipping 36 matching lines @@
 }
 
 Socket::Socket()
     : socket_(-1),
       port_(0),
       socket_error_(false),
       family_(AF_INET),
       abstract_(false),
       addr_ptr_(reinterpret_cast<sockaddr*>(&addr_.addr4)),
       addr_len_(sizeof(sockaddr)),
-      exit_notifier_fd_(-1) {
+      exit_notifier_fd_(-1),
+      exited_(false) {
   memset(&addr_, 0, sizeof(addr_));
 }
 
 Socket::~Socket() {
-  CHECK(IsClosed());
+  Close();
 }
 
 void Socket::Shutdown() {
   if (!IsClosed()) {
     PRESERVE_ERRNO_HANDLE_EINTR(shutdown(socket_, SHUT_RDWR));
   }
 }
 
 void Socket::Close() {
   if (!IsClosed()) {
-    PRESERVE_ERRNO_HANDLE_EINTR(close(socket_));
+    CloseFD(socket_);
     socket_ = -1;
   }
 }
 
 bool Socket::InitSocketInternal() {
   socket_ = socket(family_, SOCK_STREAM, 0);
   if (socket_ < 0)
     return false;
   tools::DisableNagle(socket_);
   int reuse_addr = 1;
@@ skipping 117 matching lines @@
     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.
+  int socket_errno;
+  socklen_t opt_len = sizeof(socket_errno);
+  if (!getsockopt(socket_, SOL_SOCKET, SO_ERROR, &socket_errno, &opt_len) < 0) {

[Nico, 2013/07/02 01:07:22]

The "!" here is wrong, right?

[Philippe, 2013/07/02 09:35:38]

Yeah, good catch!

+    LOG(ERROR) << "getsockopt(): " << safe_strerror(errno);
+    SetSocketError();
+    PRESERVE_ERRNO_HANDLE_EINTR(fcntl(socket_, F_SETFL, kFlags));
+    return false;
+  }
+  if (socket_errno != 0) {
+    LOG(ERROR) << "Could not connect to host: " << safe_strerror(socket_errno);
+    SetSocketError();
+    PRESERVE_ERRNO_HANDLE_EINTR(fcntl(socket_, F_SETFL, kFlags));
+    return false;
+  }
   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;
@@ skipping 34 matching lines @@
   return FD_ISSET(socket_, &fds);
 }
 
 bool Socket::AddFdToSet(fd_set* fds) const {
   if (IsClosed())
     return false;
   FD_SET(socket_, fds);
   return true;
 }
 
-int Socket::ReadNumBytes(char* buffer, size_t num_bytes) {
+int Socket::ReadNumBytes(void* buffer, size_t num_bytes) {
   int bytes_read = 0;
   int ret = 1;
   while (bytes_read < num_bytes && ret > 0) {
-    ret = Read(buffer + bytes_read, num_bytes - bytes_read);
+    ret = Read(static_cast<char*>(buffer) + bytes_read, num_bytes - bytes_read);
     if (ret >= 0)
       bytes_read += ret;
   }
   return bytes_read;
 }
 
 void Socket::SetSocketError() {
   socket_error_ = true;
   // We never use non-blocking socket.
   DCHECK(errno != EAGAIN && errno != EWOULDBLOCK);
   Close();
 }
 
-int Socket::Read(char* buffer, size_t buffer_size) {
+int Socket::Read(void* buffer, size_t buffer_size) {
   if (!WaitForEvent(READ, kNoTimeout)) {
     SetSocketError();
     return 0;
   }
   int ret = HANDLE_EINTR(read(socket_, buffer, buffer_size));
   if (ret < 0)
     SetSocketError();
   return ret;
 }
 
-int Socket::Write(const char* buffer, size_t count) {
+int Socket::Write(const void* buffer, size_t count) {
   int ret = HANDLE_EINTR(send(socket_, buffer, count, MSG_NOSIGNAL));
   if (ret < 0)
     SetSocketError();
   return ret;
 }
 
 int Socket::WriteString(const std::string& buffer) {
   return WriteNumBytes(buffer.c_str(), buffer.size());
 }
 
-int Socket::WriteNumBytes(const char* buffer, size_t num_bytes) {
+int Socket::WriteNumBytes(const void* buffer, size_t num_bytes) {
   int bytes_written = 0;
   int ret = 1;
   while (bytes_written < num_bytes && ret > 0) {
-    ret = Write(buffer + bytes_written, num_bytes - bytes_written);
+    ret = Write(static_cast<const char*>(buffer) + bytes_written,
+                num_bytes - bytes_written);
     if (ret >= 0)
       bytes_written += ret;
   }
   return bytes_written;
 }
 
-bool Socket::WaitForEvent(EventType type, int timeout_secs) const {
+bool Socket::WaitForEvent(EventType type, int timeout_secs) {
   if (exit_notifier_fd_ == -1 || socket_ == -1)
     return true;
   const int nfds = std::max(socket_, exit_notifier_fd_) + 1;
   fd_set read_fds;
   fd_set write_fds;
   FD_ZERO(&read_fds);
   FD_ZERO(&write_fds);
   if (type == READ)
     FD_SET(socket_, &read_fds);
   else
     FD_SET(socket_, &write_fds);
   FD_SET(exit_notifier_fd_, &read_fds);
 
   timeval tv = {};
   timeval* tv_ptr = NULL;
   if (timeout_secs > 0) {
     tv.tv_sec = timeout_secs;
     tv.tv_usec = 0;
     tv_ptr = &tv;
   }
   if (HANDLE_EINTR(select(nfds, &read_fds, &write_fds, NULL, tv_ptr)) <= 0)
     return false;
-  return !FD_ISSET(exit_notifier_fd_, &read_fds);
+  if (FD_ISSET(exit_notifier_fd_, &read_fds)) {
+    exited_ = true;
+    return false;
+  }
+  return true;
 }
 
 // static
 int Socket::GetHighestFileDescriptor(
     const Socket& s1, const Socket& s2) {
   return std::max(s1.socket_, s2.socket_);
 }
 
 }  // namespace forwarder