Add device port unmapping support to forwarder2.

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 <unistd.h>
 
+#include <algorithm>
+
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/safe_strerror_posix.h"
 #include "tools/android/common/net.h"
 #include "tools/android/forwarder2/common.h"
 
 namespace {
 const int kNoTimeout = -1;
 const int kConnectTimeOut = 10;  // Seconds.
 
@@ skipping 39 matching lines @@
   }
   return true;
 }
 
 Socket::Socket()
     : socket_(-1),
       port_(0),
       socket_error_(false),
       family_(AF_INET),
       addr_ptr_(reinterpret_cast<sockaddr*>(&addr_.addr4)),
-      addr_len_(sizeof(sockaddr)),
-      exit_notifier_fd_(-1),
-      exited_(false) {
+      addr_len_(sizeof(sockaddr)) {
   memset(&addr_, 0, sizeof(addr_));
 }
 
 Socket::~Socket() {
   Close();
 }
 
 void Socket::Shutdown() {
   if (!IsClosed()) {
     PRESERVE_ERRNO_HANDLE_EINTR(shutdown(socket_, SHUT_RDWR));
@@ skipping 234 matching lines @@
   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());
 }
 
+void Socket::AddEventFd(int event_fd) {
+  event_fds_.push_back(event_fd);
+  std::sort(event_fds_.begin(), event_fds_.end());
+}
+
+bool Socket::DidReceiveEventOnFd(int fd) const {
+  return std::find(
+      fired_events_.begin(), fired_events_.end(), fd) != fired_events_.end();
+}
+
 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(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) {
-  if (exit_notifier_fd_ == -1 || socket_ == -1)
+  if (event_fds_.empty() || socket_ == -1)
     return true;
-  const int nfds = std::max(socket_, exit_notifier_fd_) + 1;
+  const int nfds = std::max(socket_, event_fds_.back()) + 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);
-
+  for (std::vector<int>::const_iterator it = event_fds_.begin();
+       it != event_fds_.end(); ++it) {
+    FD_SET(*it, &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;
-  if (FD_ISSET(exit_notifier_fd_, &read_fds)) {
-    exited_ = true;
-    return false;
+  for (std::vector<int>::const_iterator it = event_fds_.begin();
+       it != event_fds_.end(); ++it) {
+    if (FD_ISSET(*it, &read_fds))
+      fired_events_.push_back(*it);
   }
-  return true;
+  return fired_events_.empty();
 }
 
 // static
 int Socket::GetHighestFileDescriptor(const Socket& s1, const Socket& s2) {
   return std::max(s1.socket_, s2.socket_);
 }
 
 // static
 pid_t Socket::GetUnixDomainSocketProcessOwner(const std::string& path) {
   Socket socket;
   if (!socket.ConnectUnix(path))
     return -1;
   ucred ucred;
   socklen_t len = sizeof(ucred);
   if (getsockopt(socket.socket_, SOL_SOCKET, SO_PEERCRED, &ucred, &len) == -1) {
     CHECK_NE(ENOPROTOOPT, errno);
     return -1;
   }
   return ucred.pid;
 }
 
 }  // namespace forwarder2