base/process/process_iterator.h

   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 {
  35   ProcessId pid() const { return th32ProcessID; }
  36   ProcessId parent_pid() const { return th32ParentProcessID; }
  37   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:
 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();
 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_