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