POSIX: Add code for shuffling file descriptors.

base/process_util_posix.cc

 // Copyright (c) 2006-2008 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 <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/resource.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include <limits>
+#include <set>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/platform_thread.h"
 #include "base/process_util.h"
 #include "base/scoped_ptr.h"
 #include "base/sys_info.h"
 #include "base/time.h"
 #include "base/waitable_event.h"
 
@@ skipping 55 matching lines @@
 class ScopedDIRClose {
  public:
   inline void operator()(DIR* x) const {
     if (x) {
       closedir(x);
     }
   }
 };
 typedef scoped_ptr_malloc<DIR, ScopedDIRClose> ScopedDIR;
 
+void CloseSuperfluousFds(const base::InjectiveMultimap& saved_mapping) {
+  std::set<int> saved_fds;
+
+  // Don't close stdin, stdout and stderr
+  saved_fds.insert(STDIN_FILENO);
+  saved_fds.insert(STDOUT_FILENO);
+  saved_fds.insert(STDERR_FILENO);
+
+  for (base::InjectiveMultimap::const_iterator
+       i = saved_mapping.begin(); i != saved_mapping.end(); ++i) {
+    saved_fds.insert(i->dest);
+  }
+
+#if defined(OS_LINUX)
+  static const char fd_dir[] = "/proc/self/fd";
+#elif defined(OS_MACOSX)
+  static const char fd_dir[] = "/dev/fd";
+#endif
+
+  ScopedDIR dir_closer(opendir(fd_dir));
+  DIR *dir = dir_closer.get();
+  if (NULL == dir) {
+    DLOG(ERROR) << "Unable to open " << fd_dir;
+    return;
+  }
+
+  struct dirent *ent;
+  while ((ent = readdir(dir))) {
+    // Skip . and .. entries.
+    if (ent->d_name[0] == '.')
+      continue;
+
+    char *endptr;
+    errno = 0;
+    const long int fd = strtol(ent->d_name, &endptr, 10);
+    if (ent->d_name[0] == 0 || *endptr || fd < 0 || fd >= INT_MAX || errno)
+      continue;
+    if (saved_fds.find(fd) != saved_fds.end())
+      continue;
+
+    int result;
+    do {
+      result = close(fd);
+    } while (result == -1 && errno == EINTR);
+  }
+}
+
 // Sets all file descriptors to close on exec except for stdin, stdout
 // and stderr.
+// TODO(agl): Remove this function. It's fundamentally broken for multithreaded
+// apps.
 void SetAllFDsToCloseOnExec() {
 #if defined(OS_LINUX)
   const char fd_dir[] = "/proc/self/fd";
 #elif defined(OS_MACOSX)
   const char fd_dir[] = "/dev/fd";
 #endif
   ScopedDIR dir_closer(opendir(fd_dir));
   DIR *dir = dir_closer.get();
   if (NULL == dir) {
     DLOG(ERROR) << "Unable to open " << fd_dir;
@@ skipping 237 matching lines @@
     case -1:  // error
       close(pipe_fd[0]);
       close(pipe_fd[1]);
       return false;
     case 0:  // child
       {
         int dev_null = open("/dev/null", O_WRONLY);
         if (dev_null < 0)
           exit(127);
 
-        int rv;
-        do {
-          rv = dup2(pipe_fd[1], STDOUT_FILENO);
-        } while (rv == -1 && errno == EINTR);
-        do {
-          rv = dup2(dev_null, STDERR_FILENO);
-        } while (rv == -1 && errno == EINTR);
-        if (pipe_fd[0] != STDOUT_FILENO && pipe_fd[0] != STDERR_FILENO)
-          close(pipe_fd[0]);
-        if (pipe_fd[1] != STDOUT_FILENO && pipe_fd[1] != STDERR_FILENO)
-          close(pipe_fd[1]);
-        if (dev_null != STDOUT_FILENO && dev_null != STDERR_FILENO)
-          close(dev_null);
+        InjectiveMultimap fd_shuffle;
+        fd_shuffle.push_back(InjectionArc(pipe_fd[1], STDOUT_FILENO, true));
+        fd_shuffle.push_back(InjectionArc(dev_null, STDERR_FILENO, true));
+        fd_shuffle.push_back(InjectionArc(dev_null, STDIN_FILENO, true));
+
+        if (!ShuffleFileDescriptors(fd_shuffle))
+          exit(127);
+
+        CloseSuperfluousFds(fd_shuffle);
 
         const std::vector<std::string> argv = cl.argv();
         scoped_array<char*> argv_cstr(new char*[argv.size() + 1]);
         for (size_t i = 0; i < argv.size(); i++)
           argv_cstr[i] = const_cast<char*>(argv[i].c_str());
         argv_cstr[argv.size()] = NULL;
         execvp(argv_cstr[0], argv_cstr.get());
         exit(127);
       }
     default:  // parent
@@ skipping 80 matching lines @@
                       const ProcessFilter* filter) {
   bool exited_cleanly =
       WaitForProcessesToExit(executable_name, wait_milliseconds,
                            filter);
   if (!exited_cleanly)
     KillProcesses(executable_name, exit_code, filter);
   return exited_cleanly;
 }
 
 }  // namespace base