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>
@@ skipping 55 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 event;
+  event.fd = event_fd;
+  event.was_fired = false;
+  events_.push_back(event);
+}
+
+bool Socket::DidReceiveEventOnFd(int fd) const {
+  for (size_t i = 0; i < events_.size(); ++i)
+    if (events_[i].fd == fd)
+      return events_[i].was_fired;
+  return false;
+}
+
+bool Socket::DidReceiveEvent() const {
+  for (size_t i = 0; i < events_.size(); ++i)
+    if (events_[i].was_fired)
+      return true;
+  return false;
+}
+
 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 (events_.empty() || 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);
-
+  for (size_t i = 0; i < events_.size(); ++i)
+    FD_SET(events_[i].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;
-  if (FD_ISSET(exit_notifier_fd_, &read_fds)) {
-    exited_ = true;
+  int max_fd = socket_;
+  for (size_t i = 0; i < events_.size(); ++i)
+    if (events_[i].fd > max_fd)
+      max_fd = events_[i].fd;
+  if (HANDLE_EINTR(
+          select(max_fd + 1, &read_fds, &write_fds, NULL, tv_ptr)) <= 0) {
     return false;
   }
-  return true;
+  bool event_was_fired = false;
+  for (size_t i = 0; i < events_.size(); ++i) {
+    if (FD_ISSET(events_[i].fd, &read_fds)) {
+      events_[i].was_fired = true;
+      event_was_fired = true;
+    }
+  }
+  return !event_was_fired;
 }
 
 // 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