1 // Copyright 2013 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/process/process_iterator.h"
6
7 #include <errno.h>
8 #include <sys/types.h>
9 #include <stddef.h>
10 #include <sys/sysctl.h>
11 #include <unistd.h>
12
13 #include "base/logging.h"
14 #include "base/strings/string_split.h"
15 #include "base/strings/string_util.h"
16
17 namespace base {
18
ProcessIterator(const ProcessFilter * filter)19 ProcessIterator::ProcessIterator(const ProcessFilter* filter)
20 : filter_(filter) {
21 int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_UID, getuid() };
22
23 bool done = false;
24 int try_num = 1;
25 const int max_tries = 10;
26
27 do {
28 size_t len = 0;
29 if (sysctl(mib, std::size(mib), NULL, &len, NULL, 0) < 0) {
30 LOG(ERROR) << "failed to get the size needed for the process list";
31 kinfo_procs_.resize(0);
32 done = true;
33 } else {
34 size_t num_of_kinfo_proc = len / sizeof(struct kinfo_proc);
35 // Leave some spare room for process table growth (more could show up
36 // between when we check and now)
37 num_of_kinfo_proc += 16;
38 kinfo_procs_.resize(num_of_kinfo_proc);
39 len = num_of_kinfo_proc * sizeof(struct kinfo_proc);
40 if (sysctl(mib, std::size(mib), &kinfo_procs_[0], &len, NULL, 0) < 0) {
41 // If we get a mem error, it just means we need a bigger buffer, so
42 // loop around again. Anything else is a real error and give up.
43 if (errno != ENOMEM) {
44 LOG(ERROR) << "failed to get the process list";
45 kinfo_procs_.resize(0);
46 done = true;
47 }
48 } else {
49 // Got the list, just make sure we're sized exactly right
50 size_t num_of_kinfo_proc = len / sizeof(struct kinfo_proc);
51 kinfo_procs_.resize(num_of_kinfo_proc);
52 done = true;
53 }
54 }
55 } while (!done && (try_num++ < max_tries));
56
57 if (!done) {
58 LOG(ERROR) << "failed to collect the process list in a few tries";
59 kinfo_procs_.resize(0);
60 }
61 }
62
63 ProcessIterator::~ProcessIterator() = default;
64
CheckForNextProcess()65 bool ProcessIterator::CheckForNextProcess() {
66 std::string data;
67
68 for (; index_of_kinfo_proc_ < kinfo_procs_.size(); ++index_of_kinfo_proc_) {
69 size_t length;
70 struct kinfo_proc kinfo = kinfo_procs_[index_of_kinfo_proc_];
71 int mib[] = { CTL_KERN, KERN_PROC_ARGS, kinfo.ki_pid };
72
73 if ((kinfo.ki_pid > 0) && (kinfo.ki_stat == SZOMB))
74 continue;
75
76 length = 0;
77 if (sysctl(mib, std::size(mib), NULL, &length, NULL, 0) < 0) {
78 LOG(ERROR) << "failed to figure out the buffer size for a command line";
79 continue;
80 }
81
82 data.resize(length);
83
84 if (sysctl(mib, std::size(mib), &data[0], &length, NULL, 0) < 0) {
85 LOG(ERROR) << "failed to fetch a commandline";
86 continue;
87 }
88
89 std::string delimiters;
90 delimiters.push_back('\0');
91 entry_.cmd_line_args_ = SplitString(data, delimiters,
92 KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
93
94 size_t exec_name_end = data.find('\0');
95 if (exec_name_end == std::string::npos) {
96 LOG(ERROR) << "command line data didn't match expected format";
97 continue;
98 }
99
100 entry_.pid_ = kinfo.ki_pid;
101 entry_.ppid_ = kinfo.ki_ppid;
102 entry_.gid_ = kinfo.ki_pgid;
103
104 size_t last_slash = data.rfind('/', exec_name_end);
105 if (last_slash == std::string::npos) {
106 entry_.exe_file_.assign(data, 0, exec_name_end);
107 } else {
108 entry_.exe_file_.assign(data, last_slash + 1,
109 exec_name_end - last_slash - 1);
110 }
111
112 // Start w/ the next entry next time through
113 ++index_of_kinfo_proc_;
114
115 return true;
116 }
117 return false;
118 }
119
IncludeEntry()120 bool NamedProcessIterator::IncludeEntry() {
121 if (executable_name_ != entry().exe_file())
122 return false;
123
124 return ProcessIterator::IncludeEntry();
125 }
126
127 } // namespace base
128