The Tor Browser: comparison dom/system/gonk/OpenFileFinder.cpp

--1:000000000000
+:3fa2a30cbe9a
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this file,
+* You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "OpenFileFinder.h"
+#include "mozilla/FileUtils.h"
+#include "nsPrintfCString.h"
+#include <sys/stat.h>
+#include <errno.h>
+#define USE_DEBUG 0
+#undef LOG
+#define LOG(args...)  __android_log_print(ANDROID_LOG_INFO,  "OpenFileFinder", ## args)
+#define LOGW(args...) __android_log_print(ANDROID_LOG_WARN,  "OpenFileFinder", ## args)
+#define ERR(args...)  __android_log_print(ANDROID_LOG_ERROR, "OpenFileFinder", ## args)
+#if USE_DEBUG
+#define DBG(args...)  __android_log_print(ANDROID_LOG_DEBUG, "OpenFileFinder" , ## args)
+#else
+#define DBG(args...)
+#endif
+namespace mozilla {
+namespace system {
+OpenFileFinder::OpenFileFinder(const nsACString& aPath,
+bool aCheckIsB2gOrDescendant /* = true */)
+: mPath(aPath),
+mProcDir(nullptr),
+mFdDir(nullptr),
+mPid(0),
+mCheckIsB2gOrDescendant(aCheckIsB2gOrDescendant)
+{
+// We assume that we're running in the parent process
+mMyPid = getpid();
+}
+OpenFileFinder::~OpenFileFinder()
+{
+Close();
+}
+bool
+OpenFileFinder::First(OpenFileFinder::Info* aInfo)
+{
+Close();
+mProcDir = opendir("/proc");
+if (!mProcDir) {
+return false;
+}
+mState = NEXT_PID;
+return Next(aInfo);
+}
+bool
+OpenFileFinder::Next(OpenFileFinder::Info* aInfo)
+{
+// NOTE: This function calls readdir and readlink, neither of which should
+//       block since we're using the proc filesystem, which is a purely
+// kernel in-memory filesystem and doesn't depend on external driver
+// behaviour.
+while (mState != DONE) {
+switch (mState) {
+case NEXT_PID: {
+struct dirent *pidEntry;
+pidEntry = readdir(mProcDir);
+if (!pidEntry) {
+mState = DONE;
+break;
+}
+char *endPtr;
+mPid = strtol(pidEntry->d_name, &endPtr, 10);
+if (mPid == 0 || *endPtr != '\0') {
+// Not a +ve number - ignore
+continue;
+}
+// We've found a /proc/PID directory. Scan open file descriptors.
+if (mFdDir) {
+closedir(mFdDir);
+}
+nsPrintfCString fdDirPath("/proc/%d/fd", mPid);
+mFdDir = opendir(fdDirPath.get());
+if (!mFdDir) {
+continue;
+}
+mState = CHECK_FDS;
+}
+// Fall through
+case CHECK_FDS: {
+struct dirent *fdEntry;
+while((fdEntry = readdir(mFdDir))) {
+if (!strcmp(fdEntry->d_name, ".") ||
+!strcmp(fdEntry->d_name, "..")) {
+continue;
+}
+nsPrintfCString fdSymLink("/proc/%d/fd/%s", mPid, fdEntry->d_name);
+nsCString resolvedPath;
+if (ReadSymLink(fdSymLink, resolvedPath) && PathMatches(resolvedPath)) {
+// We found an open file contained within the directory tree passed
+// into the constructor.
+FillInfo(aInfo, resolvedPath);
+// If sCheckIsB2gOrDescendant is set false, the caller cares about
+// all processes which have open files. If sCheckIsB2gOrDescendant
+// is set false, we only care about the b2g proccess or its descendants.
+if (!mCheckIsB2gOrDescendant || aInfo->mIsB2gOrDescendant) {
+return true;
+}
+LOG("Ignore process(%d), not a b2g process or its descendant.",
+aInfo->mPid);
+}
+}
+// We've checked all of the files for this pid, move onto the next one.
+mState = NEXT_PID;
+continue;
+}
+case DONE:
+default:
+mState = DONE;  // covers the default case
+break;
+}
+}
+return false;
+}
+void
+OpenFileFinder::Close()
+{
+if (mFdDir) {
+closedir(mFdDir);
+}
+if (mProcDir) {
+closedir(mProcDir);
+}
+}
+void
+OpenFileFinder::FillInfo(OpenFileFinder::Info* aInfo, const nsACString& aPath)
+{
+aInfo->mFileName = aPath;
+aInfo->mPid = mPid;
+nsPrintfCString exePath("/proc/%d/exe", mPid);
+ReadSymLink(exePath, aInfo->mExe);
+aInfo->mComm.Truncate();
+aInfo->mAppName.Truncate();
+nsPrintfCString statPath("/proc/%d/stat", mPid);
+nsCString statString;
+statString.SetLength(200);
+char *stat = statString.BeginWriting();
+if (!stat) {
+return;
+}
+ReadSysFile(statPath.get(), stat, statString.Length());
+// The stat line includes the comm field, surrounded by parenthesis.
+// However, the contents of the comm field itself is arbitrary and
+// and can include ')', so we search for the rightmost ) as being
+// the end of the comm field.
+char *closeParen = strrchr(stat, ')');
+if (!closeParen) {
+return;
+}
+char *openParen = strchr(stat, '(');
+if (!openParen) {
+return;
+}
+if (openParen >= closeParen) {
+return;
+}
+nsDependentCSubstring comm(&openParen[1], closeParen - openParen - 1);
+aInfo->mComm = comm;
+// There is a single character field after the comm and then
+// the parent pid (the field we're interested in).
+// ) X ppid
+// 01234
+int ppid = atoi(&closeParen[4]);
+if (mPid == mMyPid) {
+// This is chrome process
+aInfo->mIsB2gOrDescendant = true;
+DBG("Chrome process has open file(s)");
+return;
+}
+// For the rest (non-chrome process), we recursively check the ppid to know
+// it is a descendant of b2g or not. See bug 931456.
+while (ppid != mMyPid && ppid != 1) {
+DBG("Process(%d) is not forked from b2g(%d) or Init(1), keep looking",
+ppid, mMyPid);
+nsPrintfCString ppStatPath("/proc/%d/stat", ppid);
+ReadSysFile(ppStatPath.get(), stat, statString.Length());
+closeParen = strrchr(stat, ')');
+if (!closeParen) {
+return;
+}
+ppid = atoi(&closeParen[4]);
+}
+if (ppid == 1) {
+// This is a not a b2g process.
+DBG("Non-b2g process has open file(s)");
+aInfo->mIsB2gOrDescendant = false;
+return;
+}
+if (ppid == mMyPid) {
+// This is a descendant of b2g.
+DBG("Child process of chrome process has open file(s)");
+aInfo->mIsB2gOrDescendant = true;
+}
+// This looks like a content process. The comm field will be the
+// app name.
+aInfo->mAppName = aInfo->mComm;
+}
+bool
+OpenFileFinder::ReadSymLink(const nsACString& aSymLink, nsACString& aOutPath)
+{
+aOutPath.Truncate();
+const char *symLink = aSymLink.BeginReading();
+// Verify that we actually have a symlink.
+struct stat st;
+if (lstat(symLink, &st)) {
+return false;
+}
+if ((st.st_mode & S_IFMT) != S_IFLNK) {
+return false;
+}
+// Contrary to the documentation st.st_size doesn't seem to be a reliable
+// indication of the length when reading from /proc, so we use a fixed
+// size buffer instead.
+char resolvedSymLink[PATH_MAX];
+ssize_t pathLength = readlink(symLink, resolvedSymLink,
+sizeof(resolvedSymLink) - 1);
+if (pathLength <= 0) {
+return false;
+}
+resolvedSymLink[pathLength] = '\0';
+aOutPath.Assign(resolvedSymLink);
+return true;
+}
+} // system
+} // mozilla

The Tor Browser / file comparison

comparison: dom/system/gonk/OpenFileFinder.cpp

dom/system/gonk/OpenFileFinder.cpp