Add routine to close file descriptors on exec

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 "base/process_util.h"
-
+#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 "base/basictypes.h"
 #include "base/logging.h"
+#include "base/process_util.h"
 #include "base/sys_info.h"
 #include "base/time.h"
 
 const int kMicrosecondsPerSecond = 1000000;
 
 namespace base {
 
 int GetCurrentProcId() {
   return getpid();
 }
@@ skipping 23 matching lines @@
         break;
       }
       sleep(1);
     }
   }
   if (!result)
     DLOG(ERROR) << "Unable to terminate process.";
   return result;
 }
 
-int GetMaxFilesOpenInProcess() {
-  struct rlimit rlimit;
-  if (getrlimit(RLIMIT_NOFILE, &rlimit) != 0) {
-    return 0;
+// A class to handle auto-closing of DIR*'s.
+class ScopedDIRClose {
+ public:
+  inline void operator()(DIR* x) const {
+    if (x) {
+      closedir(x);
+    }
+  }
+};
+typedef scoped_ptr_malloc<DIR, ScopedDIRClose> ScopedDIR;
+
+// Sets all file descriptors to close on exec except for stdin, stdout
+// and stderr.
+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;
+    return;
   }
 
-  // rlim_t is a uint64 - clip to maxint.
-  // We do this since we use the value of this function to close FD #s in a loop
-  // if we didn't clamp the value, doing this would be too time consuming.
-  rlim_t max_int = static_cast<rlim_t>(std::numeric_limits<int32>::max());
-  if (rlimit.rlim_cur > max_int) {
-    return max_int;
+  struct dirent *ent;
+  while ((ent = readdir(dir))) {
+    // Skip . and .. entries.
+    if (ent->d_name[0] == '.')
+      continue;
+    int i = atoi(ent->d_name);
+    // We don't close stdin, stdout or stderr.
+    if (i <= STDERR_FILENO)
+      continue;
+
+    int flags = fcntl(i, F_GETFD);
+    if ((flags == -1) || (fcntl(i, F_SETFD, flags | FD_CLOEXEC) == -1)) {
+      DLOG(ERROR) << "fcntl failure.";
+    }
   }
-
-  return rlimit.rlim_cur;
 }
 
 ProcessMetrics::ProcessMetrics(ProcessHandle process) : process_(process),
                                                         last_time_(0),
                                                         last_system_time_(0) {
   processor_count_ = base::SysInfo::NumberOfProcessors();
 }
 
 // static
 ProcessMetrics* ProcessMetrics::CreateProcessMetrics(ProcessHandle process) {
@@ skipping 149 matching lines @@
   int cpu = static_cast<int>((system_time_delta * 100 + time_delta / 2) /
                              time_delta);
 
   last_system_time_ = system_time;
   last_time_ = time;
 
   return cpu;
 }
 
 }  // namespace base