1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 // This file contains methods to iterate over processes on the system. 6 7 #ifndef BASE_PROCESS_PROCESS_ITERATOR_H_ 8 #define BASE_PROCESS_PROCESS_ITERATOR_H_ 9 10 #include <list> 11 #include <string> 12 #include <vector> 13 14 #include "base/base_export.h" 15 #include "base/basictypes.h" 16 #include "base/files/file_path.h" 17 #include "base/process/process.h" 18 #include "build/build_config.h" 19 20 #if defined(OS_WIN) 21 #include <windows.h> 22 #include <tlhelp32.h> 23 #elif defined(OS_MACOSX) || defined(OS_OPENBSD) 24 #include <sys/sysctl.h> 25 #elif defined(OS_FREEBSD) 26 #include <sys/user.h> 27 #elif defined(OS_POSIX) 28 #include <dirent.h> 29 #endif 30 31 namespace base { 32 33 #if defined(OS_WIN) 34 struct ProcessEntry : public PROCESSENTRY32 { pidProcessEntry35 ProcessId pid() const { return th32ProcessID; } parent_pidProcessEntry36 ProcessId parent_pid() const { return th32ParentProcessID; } exe_fileProcessEntry37 const wchar_t* exe_file() const { return szExeFile; } 38 }; 39 40 // Process access masks. These constants provide platform-independent 41 // definitions for the standard Windows access masks. 42 // See http://msdn.microsoft.com/en-us/library/ms684880(VS.85).aspx for 43 // the specific semantics of each mask value. 44 const uint32 kProcessAccessTerminate = PROCESS_TERMINATE; 45 const uint32 kProcessAccessCreateThread = PROCESS_CREATE_THREAD; 46 const uint32 kProcessAccessSetSessionId = PROCESS_SET_SESSIONID; 47 const uint32 kProcessAccessVMOperation = PROCESS_VM_OPERATION; 48 const uint32 kProcessAccessVMRead = PROCESS_VM_READ; 49 const uint32 kProcessAccessVMWrite = PROCESS_VM_WRITE; 50 const uint32 kProcessAccessDuplicateHandle = PROCESS_DUP_HANDLE; 51 const uint32 kProcessAccessCreateProcess = PROCESS_CREATE_PROCESS; 52 const uint32 kProcessAccessSetQuota = PROCESS_SET_QUOTA; 53 const uint32 kProcessAccessSetInformation = PROCESS_SET_INFORMATION; 54 const uint32 kProcessAccessQueryInformation = PROCESS_QUERY_INFORMATION; 55 const uint32 kProcessAccessSuspendResume = PROCESS_SUSPEND_RESUME; 56 const uint32 kProcessAccessQueryLimitedInfomation = 57 PROCESS_QUERY_LIMITED_INFORMATION; 58 const uint32 kProcessAccessWaitForTermination = SYNCHRONIZE; 59 #elif defined(OS_POSIX) 60 struct BASE_EXPORT ProcessEntry { 61 ProcessEntry(); 62 ~ProcessEntry(); 63 64 ProcessId pid() const { return pid_; } 65 ProcessId parent_pid() const { return ppid_; } 66 ProcessId gid() const { return gid_; } 67 const char* exe_file() const { return exe_file_.c_str(); } 68 const std::vector<std::string>& cmd_line_args() const { 69 return cmd_line_args_; 70 } 71 72 ProcessId pid_; 73 ProcessId ppid_; 74 ProcessId gid_; 75 std::string exe_file_; 76 std::vector<std::string> cmd_line_args_; 77 }; 78 79 // Process access masks. They are not used on Posix because access checking 80 // does not happen during handle creation. 81 const uint32 kProcessAccessTerminate = 0; 82 const uint32 kProcessAccessCreateThread = 0; 83 const uint32 kProcessAccessSetSessionId = 0; 84 const uint32 kProcessAccessVMOperation = 0; 85 const uint32 kProcessAccessVMRead = 0; 86 const uint32 kProcessAccessVMWrite = 0; 87 const uint32 kProcessAccessDuplicateHandle = 0; 88 const uint32 kProcessAccessCreateProcess = 0; 89 const uint32 kProcessAccessSetQuota = 0; 90 const uint32 kProcessAccessSetInformation = 0; 91 const uint32 kProcessAccessQueryInformation = 0; 92 const uint32 kProcessAccessSuspendResume = 0; 93 const uint32 kProcessAccessQueryLimitedInfomation = 0; 94 const uint32 kProcessAccessWaitForTermination = 0; 95 #endif // defined(OS_POSIX) 96 97 // Used to filter processes by process ID. 98 class ProcessFilter { 99 public: 100 // Returns true to indicate set-inclusion and false otherwise. This method 101 // should not have side-effects and should be idempotent. 102 virtual bool Includes(const ProcessEntry& entry) const = 0; 103 104 protected: ~ProcessFilter()105 virtual ~ProcessFilter() {} 106 }; 107 108 // This class provides a way to iterate through a list of processes on the 109 // current machine with a specified filter. 110 // To use, create an instance and then call NextProcessEntry() until it returns 111 // false. 112 class BASE_EXPORT ProcessIterator { 113 public: 114 typedef std::list<ProcessEntry> ProcessEntries; 115 116 explicit ProcessIterator(const ProcessFilter* filter); 117 virtual ~ProcessIterator(); 118 119 // If there's another process that matches the given executable name, 120 // returns a const pointer to the corresponding PROCESSENTRY32. 121 // If there are no more matching processes, returns NULL. 122 // The returned pointer will remain valid until NextProcessEntry() 123 // is called again or this NamedProcessIterator goes out of scope. 124 const ProcessEntry* NextProcessEntry(); 125 126 // Takes a snapshot of all the ProcessEntry found. 127 ProcessEntries Snapshot(); 128 129 protected: 130 virtual bool IncludeEntry(); entry()131 const ProcessEntry& entry() { return entry_; } 132 133 private: 134 // Determines whether there's another process (regardless of executable) 135 // left in the list of all processes. Returns true and sets entry_ to 136 // that process's info if there is one, false otherwise. 137 bool CheckForNextProcess(); 138 139 // Initializes a PROCESSENTRY32 data structure so that it's ready for 140 // use with Process32First/Process32Next. 141 void InitProcessEntry(ProcessEntry* entry); 142 143 #if defined(OS_WIN) 144 HANDLE snapshot_; 145 bool started_iteration_; 146 #elif defined(OS_MACOSX) || defined(OS_BSD) 147 std::vector<kinfo_proc> kinfo_procs_; 148 size_t index_of_kinfo_proc_; 149 #elif defined(OS_POSIX) 150 DIR* procfs_dir_; 151 #endif 152 ProcessEntry entry_; 153 const ProcessFilter* filter_; 154 155 DISALLOW_COPY_AND_ASSIGN(ProcessIterator); 156 }; 157 158 // This class provides a way to iterate through the list of processes 159 // on the current machine that were started from the given executable 160 // name. To use, create an instance and then call NextProcessEntry() 161 // until it returns false. 162 class BASE_EXPORT NamedProcessIterator : public ProcessIterator { 163 public: 164 NamedProcessIterator(const FilePath::StringType& executable_name, 165 const ProcessFilter* filter); 166 virtual ~NamedProcessIterator(); 167 168 protected: 169 virtual bool IncludeEntry() OVERRIDE; 170 171 private: 172 FilePath::StringType executable_name_; 173 174 DISALLOW_COPY_AND_ASSIGN(NamedProcessIterator); 175 }; 176 177 // Returns the number of processes on the machine that are running from the 178 // given executable name. If filter is non-null, then only processes selected 179 // by the filter will be counted. 180 BASE_EXPORT int GetProcessCount(const FilePath::StringType& executable_name, 181 const ProcessFilter* filter); 182 183 } // namespace base 184 185 #endif // BASE_PROCESS_PROCESS_ITERATOR_H_ 186