POSIX: don't leak FDs when launching child Processes.

base/process_util_linux.cc

 // Copyright (c) 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 "base/process_util.h"
 
 #include <ctype.h>
 #include <dirent.h>
+#include <fcntl.h>
+#include <unistd.h>
 #include <string>
 #include <sys/types.h>
 #include <sys/wait.h>
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/platform_thread.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/time.h"
 
 namespace {
 
 enum ParsingState {
   KEY_NAME,
   KEY_VALUE
 };
 
 }  // namespace
 
 namespace base {
 
 bool LaunchApp(const std::vector<std::string>& argv,
+               const file_handle_mapping_vector& fds_to_remap,
                bool wait, ProcessHandle* process_handle) {
   bool retval = true;
 
   char* argv_copy[argv.size() + 1];
   for (size_t i = 0; i < argv.size(); i++) {
     argv_copy[i] = new char[argv[i].size() + 1];
     strcpy(argv_copy[i], argv[i].c_str());
   }
   argv_copy[argv.size()] = NULL;
 
+  // Make sure we don't leak any FDs to the child process by marking all FDs
+  // as close-on-exec.
+  int max_files = GetMaxFilesOpenInProcess();
+  for (int i = STDERR_FILENO + 1; i < max_files; i++) {
+    int flags = fcntl(i, F_GETFD);
+    if (flags != -1) {
+      fcntl(i, F_SETFD, flags | FD_CLOEXEC);
+    }
+  }
+
   int pid = fork();
   if (pid == 0) {
+    for (file_handle_mapping_vector::const_iterator it = fds_to_remap.begin();
+         it != fds_to_remap.end();
+         ++it) {
+      int src_fd = it->first;
+      int dest_fd = it->second;
+      if (src_fd == dest_fd) {
+        int flags = fcntl(src_fd, F_GETFD);
+        if (flags != -1) {
+          fcntl(src_fd, F_SETFD, flags & ~FD_CLOEXEC);
+        }
+      } else {
+        dup2(src_fd, dest_fd);
+      }
+    }
+
     execvp(argv_copy[0], argv_copy);
   } else if (pid < 0) {
     retval = false;
   } else {
     if (wait)
       waitpid(pid, 0, 0);
 
     if(process_handle)
       *process_handle = pid;
   }
 
   for (size_t i = 0; i < argv.size(); i++)
     delete[] argv_copy[i];
 
   return retval;
 }
 
 bool LaunchApp(const CommandLine& cl,
                bool wait, bool start_hidden, ProcessHandle* process_handle) {
-  return LaunchApp(cl.argv(), wait, process_handle);
+  file_handle_mapping_vector no_files;
+  return LaunchApp(cl.argv(), no_files, wait, process_handle);
 }
 
 // Attempts to kill the process identified by the given process
 // entry structure.  Ignores specified exit_code; linux can't force that.
 // Returns true if this is successful, false otherwise.
 bool KillProcess(int process_id, int exit_code, bool wait) {
   bool result = false;
 
   int status = kill(process_id, SIGTERM);
   if (!status && wait) {
@@ skipping 27 matching lines @@
 
   if (WIFEXITED(status)) {
     int exitcode = WEXITSTATUS(status);
     return (exitcode != 0);
   }
 
   return false;
 }
 
 NamedProcessIterator::NamedProcessIterator(const std::wstring& executable_name,
-                                           const ProcessFilter* filter) 
+                                           const ProcessFilter* filter)
     :
        executable_name_(executable_name),
        filter_(filter) {
     procfs_dir_ = opendir("/proc");
   }
 
 NamedProcessIterator::~NamedProcessIterator() {
   if (procfs_dir_) {
     closedir(procfs_dir_);
     procfs_dir_ = 0;
@@ skipping 188 matching lines @@
           (*io_counters).WriteTransferCount = StringToInt64(tokenizer.token());
         }
         state = KEY_NAME;
         break;
     }
   }
   return true;
 }
 
 }  // namespace base