Replace some deprecated usages of readdir_r with readdir

sandbox/linux/services/proc_util.cc

 // Copyright 2014 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 "sandbox/linux/services/proc_util.h"
 
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <string.h>
@@ skipping 33 matching lines @@
   int proc_self_fd = HANDLE_EINTR(
       openat(proc_fd, "self/fd/", O_DIRECTORY | O_RDONLY | O_CLOEXEC));
   PCHECK(0 <= proc_self_fd);
 
   // Ownership of proc_self_fd is transferred here, it must not be closed
   // or modified afterwards except via dir.
   ScopedDIR dir(fdopendir(proc_self_fd));
   CHECK(dir);
 
   int count = 0;
-  struct dirent e;
-  struct dirent* de;
-  while (!readdir_r(dir.get(), &e, &de) && de) {
-    if (strcmp(e.d_name, ".") == 0 || strcmp(e.d_name, "..") == 0) {
+  for (struct dirent* e = readdir(dir.get()); e; e = readdir(dir.get())) {

[Jorge Lucangeli Obes, 2016/10/19 15:50:16]

Are these calls to readdir guaranteed to not race each other? What happens if
more than one thread in the same process is using proc_util.cc?

[dcheng, 2016/10/19 22:11:39]

My understanding (and the condition on which I LGTMed the base changes) is that
readdir's on "different directory streams" are safe, even if simultaneously
called.

Since the directory stream is scoped to just this function, in theory, it should
be OK.

+    if (strcmp(e->d_name, ".") == 0 || strcmp(e->d_name, "..") == 0) {
       continue;
     }
 
     int fd_num;
-    CHECK(base::StringToInt(e.d_name, &fd_num));
+    CHECK(base::StringToInt(e->d_name, &fd_num));
     if (fd_num == proc_fd || fd_num == proc_self_fd) {
       continue;
     }
 
     ++count;
   }
   return count;
 }
 
 bool ProcUtil::HasOpenDirectory(int proc_fd) {
   DCHECK_LE(0, proc_fd);
   int proc_self_fd =
       openat(proc_fd, "self/fd/", O_DIRECTORY | O_RDONLY | O_CLOEXEC);
 
   PCHECK(0 <= proc_self_fd);
 
   // Ownership of proc_self_fd is transferred here, it must not be closed
   // or modified afterwards except via dir.
   ScopedDIR dir(fdopendir(proc_self_fd));
   CHECK(dir);
 
-  struct dirent e;
-  struct dirent* de;
-  while (!readdir_r(dir.get(), &e, &de) && de) {
-    if (strcmp(e.d_name, ".") == 0 || strcmp(e.d_name, "..") == 0) {
+  for (struct dirent *e = readdir(dir.get()); e; e = readdir(dir.get())) {
+    if (strcmp(e->d_name, ".") == 0 || strcmp(e->d_name, "..") == 0) {
       continue;
     }
 
     int fd_num;
-    CHECK(base::StringToInt(e.d_name, &fd_num));
+    CHECK(base::StringToInt(e->d_name, &fd_num));
     if (fd_num == proc_fd || fd_num == proc_self_fd) {
       continue;
     }
 
     struct stat s;
     // It's OK to use proc_self_fd here, fstatat won't modify it.
-    CHECK(fstatat(proc_self_fd, e.d_name, &s, 0) == 0);
+    CHECK(fstatat(proc_self_fd, e->d_name, &s, 0) == 0);
     if (S_ISDIR(s.st_mode)) {
       return true;
     }
   }
 
   // No open unmanaged directories found.
   return false;
 }
 
 bool ProcUtil::HasOpenDirectory() {
   base::ScopedFD proc_fd(
       HANDLE_EINTR(open("/proc/", O_DIRECTORY | O_RDONLY | O_CLOEXEC)));
   return HasOpenDirectory(proc_fd.get());
 }
 
 // static
 base::ScopedFD ProcUtil::OpenProc() {
   return OpenDirectory("/proc/");
 }
 
 }  // namespace sandbox