Use the new forwarder2's Daemon implementation in device_forwarder.

tools/android/forwarder2/daemon.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/daemon.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
-#include <stdio.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
+#include <cstring>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/eintr_wrapper.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/safe_strerror_posix.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "tools/android/forwarder2/common.h"
+#include "tools/android/forwarder2/socket.h"
 
 namespace forwarder2 {
 namespace {
 
-const char kLogFilePath[] = "/tmp/host_forwarder_log";
+const int kBufferSize = 256;
 
 class FileDescriptorAutoCloser {
  public:
   explicit FileDescriptorAutoCloser(int fd) : fd_(fd) {
     DCHECK(fd_ >= 0);
   }
 
   ~FileDescriptorAutoCloser() {
     if (fd_ > -1)
       CloseFD(fd_);
   }
 
   int Release() {
     const int fd = fd_;
     fd_ = -1;
     return fd;
   }
 
  private:
   int fd_;
 
   DISALLOW_COPY_AND_ASSIGN(FileDescriptorAutoCloser);
 };
 
-// Handles creation and destruction of the PID file.
-class PIDFile {
- public:
-  static scoped_ptr<PIDFile> Create(const std::string& path) {
-    scoped_ptr<PIDFile> pid_file;
-    const int pid_file_fd = HANDLE_EINTR(
-        open(path.c_str(), O_CREAT | O_WRONLY, 0600));
-    if (pid_file_fd < 0) {
-      PError("open()");
-      return pid_file.Pass();
-    }
-    FileDescriptorAutoCloser fd_closer(pid_file_fd);
-    struct flock lock_info = {};
-    lock_info.l_type = F_WRLCK;
-    lock_info.l_whence = SEEK_CUR;
-    if (HANDLE_EINTR(fcntl(pid_file_fd, F_SETLK, &lock_info)) < 0) {
-      if (errno == EAGAIN || errno == EACCES) {
-        LOG(ERROR) << "Daemon already running (PID file already locked)";
-        return pid_file.Pass();
-      }
-      PError("lockf()");
-      return pid_file.Pass();
-    }
-    const std::string pid_string = base::StringPrintf("%d\n", getpid());
-    CHECK(HANDLE_EINTR(write(pid_file_fd, pid_string.c_str(),
-                             pid_string.length())));
-    pid_file.reset(new PIDFile(fd_closer.Release(), path));
-    return pid_file.Pass();
-  }
-
-  ~PIDFile() {
-    CloseFD(fd_);  // This also releases the lock.
-    if (remove(path_.c_str()) < 0)
-      PError("remove");
-  }
-
- private:
-  PIDFile(int fd, const std::string& path) : fd_(fd), path_(path) {
-    DCHECK(fd_ >= 0);
-  }
-
-  const int fd_;
-  const std::string path_;
-
-  DISALLOW_COPY_AND_ASSIGN(PIDFile);
-};
-
-// Takes ownership of |data|.
-void ReleaseDaemonResourcesAtExit(void* data) {
-  DCHECK(data);
-  delete reinterpret_cast<PIDFile*>(data);
+void InitLoggingForDaemon(const std::string& log_file) {
+  CHECK(
+      logging::InitLogging(
+          log_file.c_str(),
+          log_file.empty() ?
+              logging::LOG_ONLY_TO_SYSTEM_DEBUG_LOG : logging::LOG_ONLY_TO_FILE,
+          logging::DONT_LOCK_LOG_FILE, logging::APPEND_TO_OLD_LOG_FILE,
+          logging::ENABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS));
 }
 
-void InitLogging(const char* log_file) {
-  CHECK(
-      logging::InitLogging(
-          log_file,
-          logging::LOG_ONLY_TO_FILE,
-          logging::DONT_LOCK_LOG_FILE,
-          logging::APPEND_TO_OLD_LOG_FILE,
-          logging::ENABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS));
+bool RunServerAcceptLoop(const std::string& welcome_message,
+                         Socket* server_socket,
+                         Daemon::ServerDelegate* server_delegate) {
+  bool failed = false;
+  for (;;) {
+    scoped_ptr<Socket> client_socket(new Socket());
+    if (!server_socket->Accept(client_socket.get())) {
+      if (server_socket->exited())
+        break;
+      PError("Accept()");
+      failed = true;
+      break;
+    }
+    if (!client_socket->Write(welcome_message.c_str(),
+                              welcome_message.length() + 1)) {
+      PError("Write()");
+      failed = true;
+      continue;
+    }
+    server_delegate->OnClientConnected(client_socket.Pass());
+  }
+  server_delegate->OnServerExited();
+  return !failed;
 }
 
 void SigChildHandler(int signal_number) {
   DCHECK_EQ(signal_number, SIGCHLD);
+  SIGNAL_SAFE_LOG(ERROR, "Caught unexpected SIGCHLD");
   // The daemon should not terminate while its parent is still running.
   int status;
   pid_t child_pid = waitpid(-1 /* any child */, &status, WNOHANG);
   if (child_pid < 0) {
     PError("waitpid");
     return;
   }
   if (child_pid == 0)
     return;
   // Avoid using StringAppendF() since it's unsafe in a signal handler due to
@@ skipping 27 matching lines @@
   }
   if (lock_info.l_type == F_UNLCK) {
     *lock_owner_pid = 0;
     return true;
   }
   CHECK_EQ(F_WRLCK /* exclusive lock */, lock_info.l_type);
   *lock_owner_pid = lock_info.l_pid;
   return true;
 }
 
+scoped_ptr<Socket> ConnectToUnixDomainSocket(
+    const std::string& socket_name,
+    int tries_count,
+    int idle_time_msec,
+    const std::string& expected_welcome_message) {
+  for (int i = 0; i < tries_count; ++i) {
+    scoped_ptr<Socket> socket(new Socket());
+    if (!socket->ConnectUnix(socket_name, true)) {
+      if (idle_time_msec)
+        usleep(idle_time_msec * 1000);
+      continue;
+    }
+    char buf[kBufferSize];
+    DCHECK(expected_welcome_message.length() + 1 <= sizeof(buf));
+    memset(buf, 0, sizeof(buf));
+    if (socket->Read(buf, sizeof(buf)) < 0) {
+      perror("read");
+      continue;
+    }
+    if (expected_welcome_message != buf) {
+      LOG(ERROR) << "Unexpected message read from daemon: " << buf;
+      break;
+    }
+    return socket.Pass();
+  }
+  return scoped_ptr<Socket>(NULL);
+}
+
 }  // namespace
 
-Daemon::Daemon(const std::string& pid_file_path)
-    : pid_file_path_(pid_file_path) {
+// Handles creation and destruction of the PID file.
+class Daemon::PIDFile {
+ public:
+  static scoped_ptr<PIDFile> Create(const std::string& path) {
+    scoped_ptr<PIDFile> pid_file;
+    const int pid_file_fd = HANDLE_EINTR(
+        open(path.c_str(), O_CREAT | O_WRONLY, 0600));
+    if (pid_file_fd < 0) {
+      PError("open()");
+      return pid_file.Pass();
+    }
+    FileDescriptorAutoCloser fd_closer(pid_file_fd);
+    struct flock lock_info = {};
+    lock_info.l_type = F_WRLCK;
+    lock_info.l_whence = SEEK_CUR;
+    if (HANDLE_EINTR(fcntl(pid_file_fd, F_SETLK, &lock_info)) < 0) {
+      if (errno == EAGAIN || errno == EACCES) {
+        LOG(ERROR) << "Daemon already running (PID file already locked)";
+        return pid_file.Pass();
+      }
+      PError("lockf()");
+      return pid_file.Pass();
+    }
+    const std::string pid_string = base::StringPrintf("%d\n", getpid());
+    CHECK(HANDLE_EINTR(write(pid_file_fd, pid_string.c_str(),
+                             pid_string.length())));
+    pid_file.reset(new PIDFile(fd_closer.Release(), path));
+    return pid_file.Pass();
+  }
+
+  ~PIDFile() {
+    CloseFD(fd_);  // This also releases the lock.
+    if (remove(path_.c_str()) < 0)
+      PError("remove");
+  }
+
+ private:
+  PIDFile(int fd, const std::string& path) : fd_(fd), path_(path) {
+    DCHECK(fd_ >= 0);
+  }
+
+  const int fd_;
+  const std::string path_;
+
+  DISALLOW_COPY_AND_ASSIGN(PIDFile);
+};
+
+Daemon::Daemon(const std::string& log_file_path,
+               const std::string& pid_file_path,
+               const std::string& identifier,
+               ClientDelegate* client_delegate,
+               ServerDelegate* server_delegate,
+               GetExitNotifierFDCallback get_exit_fd_callback)
+  : log_file_path_(log_file_path),
+    pid_file_path_(pid_file_path),
+    identifier_(identifier),
+    client_delegate_(client_delegate),
+    server_delegate_(server_delegate),
+    get_exit_fd_callback_(get_exit_fd_callback) {
+  DCHECK(client_delegate_);
+  DCHECK(server_delegate_);
+  DCHECK(get_exit_fd_callback_);
 }
 
-bool Daemon::Spawn(bool* is_daemon) {
-  switch (fork()) {
-    case -1:
-      *is_daemon = false;
-      PError("fork()");
+Daemon::~Daemon() {}
+
+bool Daemon::SpawnIfNeeded() {
+  const int kSingleTry = 1;
+  const int kNoIdleTime = 0;
+  scoped_ptr<Socket> client_socket = ConnectToUnixDomainSocket(
+      identifier_, kSingleTry, kNoIdleTime, identifier_);
+  if (!client_socket) {
+    switch (fork()) {
+      case -1:
+        PError("fork()");
+        return false;
+      // Child.
+      case 0: {
+        DCHECK(!pid_file_);
+        pid_file_ = PIDFile::Create(pid_file_path_);
+        if (!pid_file_)
+          return false;

[digit1, 2012/11/19 15:27:43]

Returning from this function in case of error in the child seems a bit
dangerous. It's probably better to exit(1) directly instead, since this will be
detected after 200ms by the parent code below.

This is not an issue in this version of the code, because the caller will do a
'return 1' followed by 'exit(1)' in the child process when this happens, but
it's easy to imagine a change in the caller code that doesn't take into account
that the function can return in two different PIDs.

Another commonly implemented option is to make the parent wait for the child by
creating an anonymous pipe and have the child send a single byte through it to
the parent to indicate success/failure. Just mentioning it here, no need to
implement this here right now.

[Philippe, 2012/11/19 17:18:59]

Good point.

+        if (setsid() < 0) {  // Detach the child process from its parent.
+          PError("setsid()");
+          return false;
+        }
+        InitLoggingForDaemon(log_file_path_);
+        CloseFD(STDIN_FILENO);
+        CloseFD(STDOUT_FILENO);
+        CloseFD(STDERR_FILENO);
+        const int null_fd = open("/dev/null", O_RDWR);
+        CHECK_EQ(null_fd, STDIN_FILENO);
+        CHECK_EQ(dup(null_fd), STDOUT_FILENO);
+        CHECK_EQ(dup(null_fd), STDERR_FILENO);
+        Socket command_socket;
+        if (!command_socket.BindUnix(identifier_, true)) {
+          PError("bind()");
+          return false;
+        }
+        server_delegate_->Init();
+        command_socket.set_exit_notifier_fd(get_exit_fd_callback_());
+        return !RunServerAcceptLoop(
+            identifier_, &command_socket, server_delegate_);
+      }
+      default:
+        break;
+    }
+  }
+  // Parent.
+  signal(SIGCHLD, SigChildHandler);

[digit1, 2012/11/19 15:27:43]

since you're writing a general Daemon class, you might want to store the hold
SIGCHLD handler, and restore it on scope exit (with an appropriate template).
Use sigprocmask() instead of sigmask() to ensure you save the SA_SIGINFO flag
associated with the previous signal handler.

[Philippe, 2012/11/19 17:18:59]

Done. Note that I didn't use an extra RAII object this time for restoring the
sigaction to avoid making this file more complicated.

+  if (!client_socket) {
+    const int kConnectTries = 20;
+    const int kConnectIdleTimeMSec = 10;
+    client_socket = ConnectToUnixDomainSocket(
+        identifier_, kConnectTries, kConnectIdleTimeMSec, identifier_);
+    if (!client_socket) {
+      LOG(ERROR) << "Could not connect to daemon's Unix Daemon socket";
       return false;
-    case 0: {  // Child.
-      *is_daemon = true;
-      scoped_ptr<PIDFile> pid_file = PIDFile::Create(pid_file_path_);
-      if (!pid_file)
-        return false;
-      base::AtExitManager::RegisterCallback(
-          &ReleaseDaemonResourcesAtExit, pid_file.release());
-      if (setsid() < 0) {  // Detach the child process from its parent.
-        PError("setsid");
-        return false;
-      }
-      CloseFD(STDOUT_FILENO);
-      CloseFD(STDERR_FILENO);
-      InitLogging(kLogFilePath);
-      break;
     }
-    default:  // Parent.
-      *is_daemon = false;
-      signal(SIGCHLD, SigChildHandler);
   }
+  client_delegate_->OnDaemonReady(client_socket.get());
   return true;
 }
 
 bool Daemon::Kill() {
   int pid_file_fd = HANDLE_EINTR(open(pid_file_path_.c_str(), O_WRONLY));
   if (pid_file_fd < 0) {
     if (errno == ENOENT)
       return true;
     LOG(ERROR) << "Could not open " << pid_file_path_ << " in write mode: "
                << safe_strerror(errno);
@@ skipping 36 matching lines @@
       return true;
     }
     usleep(kIdleTimeMS * 1000);
   }
   LOG(ERROR) << "Timed out while killing daemon. "
                 "It might still be tearing down.";
   return false;
 }
 
 }  // namespace forwarder2