From 6812cec67e116d9357fbefaa08af82093dce1d5d Mon Sep 17 00:00:00 2001 From: Mark Mentovai Date: Fri, 14 Nov 2014 17:54:42 -0500 Subject: [PATCH] Move some parts of ProcessReader (in snapshot) to ProcessInfo (in util). MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Also, move ProcessArgumentsForPID() into ProcessInfo. This change prepares for a TaskForPID() implementation that’s capable of operating correctly in a setuid root executable. TaskForPID() belongs in util/mach, but for its permission checks, it must access some process properties that were previously fetched by ProcessReader in snapshot. util can’t depend on snapshot. The generic util-safe process information bits (Is64Bit(), ProcessID(), ParentProcessID(), and StartTime()) are moved from ProcessReader to ProcessInfo (in util), where the current ProcessReader can use it (as it’s OK for snapshot to depend on util), and the future TaskForPID() in util can also use it. ProcessInfo also contains other methods that TaskForPID() will use, providing access to the credentials that the target process holds. ProcessArgumentsForPID() is related, and is also now a part of ProcessInfo. TEST=snapshot_test, util_test R=rsesek@chromium.org Review URL: https://codereview.chromium.org/727973002 --- snapshot/mac/process_reader.cc | 23 +-- snapshot/mac/process_reader.h | 21 ++- util/mac/service_management_test.mm | 12 +- util/posix/process_info.h | 152 ++++++++++++++++++ util/posix/process_info_mac.cc | 233 ++++++++++++++++++++++++++++ util/posix/process_info_test.cc | 148 ++++++++++++++++++ util/posix/process_util.h | 42 ----- util/posix/process_util_mac.cc | 103 ------------ util/posix/process_util_test.cc | 50 ------ util/util.gyp | 6 +- 10 files changed, 561 insertions(+), 229 deletions(-) create mode 100644 util/posix/process_info.h create mode 100644 util/posix/process_info_mac.cc create mode 100644 util/posix/process_info_test.cc delete mode 100644 util/posix/process_util.h delete mode 100644 util/posix/process_util_mac.cc delete mode 100644 util/posix/process_util_test.cc diff --git a/snapshot/mac/process_reader.cc b/snapshot/mac/process_reader.cc index 2c9f417e..76636758 100644 --- a/snapshot/mac/process_reader.cc +++ b/snapshot/mac/process_reader.cc @@ -90,7 +90,7 @@ ProcessReader::Module::~Module() { } ProcessReader::ProcessReader() - : kern_proc_info_(), + : process_info_(), threads_(), modules_(), module_readers_(), @@ -112,23 +112,11 @@ ProcessReader::~ProcessReader() { bool ProcessReader::Initialize(task_t task) { INITIALIZATION_STATE_SET_INITIALIZING(initialized_); - pid_t pid; - kern_return_t kr = pid_for_task(task, &pid); - if (kr != KERN_SUCCESS) { - MACH_LOG(ERROR, kr) << "pid_for_task"; + if (!process_info_.InitializeFromTask(task)) { return false; } - int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid}; - size_t len = sizeof(kern_proc_info_); - if (sysctl(mib, arraysize(mib), &kern_proc_info_, &len, nullptr, 0) != 0) { - PLOG(ERROR) << "sysctl for pid " << pid; - return false; - } - - DCHECK_EQ(kern_proc_info_.kp_proc.p_pid, pid); - - is_64_bit_ = kern_proc_info_.kp_proc.p_flag & P_LP64; + is_64_bit_ = process_info_.Is64Bit(); task_memory_.reset(new TaskMemory(task)); task_ = task; @@ -137,11 +125,6 @@ bool ProcessReader::Initialize(task_t task) { return true; } -void ProcessReader::StartTime(timeval* start_time) const { - INITIALIZATION_STATE_DCHECK_VALID(initialized_); - *start_time = kern_proc_info_.kp_proc.p_starttime; -} - bool ProcessReader::CPUTimes(timeval* user_time, timeval* system_time) const { INITIALIZATION_STATE_DCHECK_VALID(initialized_); diff --git a/snapshot/mac/process_reader.h b/snapshot/mac/process_reader.h index f8e64181..0227adec 100644 --- a/snapshot/mac/process_reader.h +++ b/snapshot/mac/process_reader.h @@ -16,7 +16,6 @@ #define CRASHPAD_SNAPSHOT_MAC_PROCESS_READER_H_ #include -#include #include #include #include @@ -29,6 +28,7 @@ #include "build/build_config.h" #include "util/mach/task_memory.h" #include "util/misc/initialization_state_dcheck.h" +#include "util/posix/process_info.h" #include "util/stdlib/pointer_container.h" namespace crashpad { @@ -112,14 +112,20 @@ class ProcessReader { bool Is64Bit() const { return is_64_bit_; } //! \return The target task’s process ID. - pid_t ProcessID() const { return kern_proc_info_.kp_proc.p_pid; } + pid_t ProcessID() const { return process_info_.ProcessID(); } //! \return The target task’s parent process ID. - pid_t ParentProcessID() const { return kern_proc_info_.kp_eproc.e_ppid; } + pid_t ParentProcessID() const { return process_info_.ParentProcessID(); } + //! \brief Determines the target process’ start time. + //! //! \param[out] start_time The time that the process started. - void StartTime(timeval* start_time) const; + void StartTime(timeval* start_time) const { + process_info_.StartTime(start_time); + } + //! \brief Determines the target process’ execution time. + //! //! \param[out] user_time The amount of time the process has executed code in //! user mode. //! \param[out] system_time The amount of time the process has executed code @@ -206,7 +212,7 @@ class ProcessReader { mach_vm_address_t* region_size, unsigned int user_tag); - kinfo_proc kern_proc_info_; + ProcessInfo process_info_; std::vector threads_; // owns send rights std::vector modules_; PointerVector module_readers_; @@ -214,8 +220,9 @@ class ProcessReader { task_t task_; // weak InitializationStateDcheck initialized_; - // This shadows a bit in kern_proc_info_, but it’s accessed so frequently that - // it’s given a first-class field to save a few bit operations on each access. + // This shadows a method of process_info_, but it’s accessed so frequently + // that it’s given a first-class field to save a call and a few bit operations + // on each access. bool is_64_bit_; bool initialized_threads_; diff --git a/util/mac/service_management_test.mm b/util/mac/service_management_test.mm index e1f76f73..18eb9d60 100644 --- a/util/mac/service_management_test.mm +++ b/util/mac/service_management_test.mm @@ -27,7 +27,7 @@ #include "base/rand_util.h" #include "gtest/gtest.h" #include "util/misc/clock.h" -#include "util/posix/process_util.h" +#include "util/posix/process_info.h" #include "util/stdlib/objc.h" namespace crashpad { @@ -37,18 +37,21 @@ namespace { // Ensures that the process with the specified PID is running, identifying it by // requiring that its argv[argc - 1] compare equal to last_arg. void ExpectProcessIsRunning(pid_t pid, std::string& last_arg) { + ProcessInfo process_info; + ASSERT_TRUE(process_info.Initialize(pid)); + // The process may not have called exec yet, so loop with a small delay while // looking for the cookie. int outer_tries = 10; std::vector job_argv; while (outer_tries--) { - // If the process is in the middle of calling exec, ProcessArgumentsForPID + // If the process is in the middle of calling exec, process_info.Arguments() // may fail. Loop with a small retry delay while waiting for the expected // successful call. int inner_tries = 10; bool success; do { - success = ProcessArgumentsForPID(pid, &job_argv); + success = process_info.Arguments(&job_argv); if (success) { break; } @@ -81,7 +84,8 @@ void ExpectProcessIsNotRunning(pid_t pid, std::string& last_arg) { int tries = 10; std::vector job_argv; while (tries--) { - if (!ProcessArgumentsForPID(pid, &job_argv)) { + ProcessInfo process_info; + if (!process_info.Initialize(pid) || !process_info.Arguments(&job_argv)) { // The PID was not found. return; } diff --git a/util/posix/process_info.h b/util/posix/process_info.h new file mode 100644 index 00000000..4761cf36 --- /dev/null +++ b/util/posix/process_info.h @@ -0,0 +1,152 @@ +// Copyright 2014 The Crashpad Authors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef CRASHPAD_UTIL_POSIX_PROCESS_INFO_H_ +#define CRASHPAD_UTIL_POSIX_PROCESS_INFO_H_ + +#include +#include +#include +#include + +#include +#include +#include + +#include "base/basictypes.h" +#include "build/build_config.h" +#include "util/misc/initialization_state_dcheck.h" + +#if defined(OS_MACOSX) +#include +#endif + +namespace crashpad { + +class ProcessInfo { + public: + ProcessInfo(); + ~ProcessInfo(); + + //! \brief Initializes this object with information about the process whose ID + //! is \a pid. + //! + //! This method must be called successfully prior to calling any other method + //! in this class. This method may only be called once. + //! + //! It is unspecified whether the information that an object of this class + //! returns is loaded at the time Initialize() is called or subsequently, and + //! whether this information is cached in the object or not. + //! + //! \param[in] pid The process ID to obtain information for. + //! + //! \return `true` on success, `false` on failure with a message logged. + bool Initialize(pid_t pid); + +#if defined(OS_MACOSX) || DOXYGEN + //! \brief Initializes this object with information about a process based on + //! its Mach task. + //! + //! This method serves as a stand-in for Initialize() and may be called in its + //! place with the same restrictions and considerations. + //! + //! \param[in] task The Mach task to obtain information for. + //! + //! \return `true` on success, `false` on failure with an message logged. + bool InitializeFromTask(task_t task); +#endif + + //! \return The target task’s process ID. + pid_t ProcessID() const; + + //! \return The target task’s parent process ID. + pid_t ParentProcessID() const; + + //! \return The target process’ real user ID as would be returned to it by + //! `getuid()`. + uid_t RealUserID() const; + + //! \return The target process’ effective user ID as would be returned to it + //! by `geteuid()`. + uid_t EffectiveUserID() const; + + //! \return The target process’ saved set-user ID. + uid_t SavedUserID() const; + + //! \return the target process’ real group ID as would be returned to it by + //! `getgid()`. + gid_t RealGroupID() const; + + //! \return the target process’ effective group ID as would be returned to it + //! by `getegid()`. + gid_t EffectiveGroupID() const; + + //! \return The target process’ saved set-group ID. + gid_t SavedGroupID() const; + + //! \return the target process’ supplementary group list as would be returned + //! to it by `getgroups()`. + std::set SupplementaryGroups() const; + + //! \return All groups that the target process claims membership in, including + //! RealGroupID(), EffectiveGroupID(), SavedGroupID(), and + //! SupplementaryGroups(). + std::set AllGroups() const; + + //! \brief Determines whether the target process has changed privileges. + //! + //! A process is considered to have changed privileges if it has changed its + //! real, effective, or saved set-user or group IDs with the `setuid()`, + //! `seteuid()`, `setreuid()`, `setgid()`, `setegid()`, or `setregid()` system + //! calls since its most recent `execve()`, or if its privileges changed at + //! `execve()` as a result of executing a setuid or setgid executable. + bool DidChangePrivileges() const; + + //! \return `true` if the target task is a 64-bit process. + bool Is64Bit() const; + + //! \brief Determines the target process’ start time. + //! + //! \param[out] start_time The time that the process started. + void StartTime(timeval* start_time) const; + + //! \brief Obtains the arguments used to launch a process. + //! + //! Whether it is possible to obtain this information for a process with + //! different privileges than the running program is system-dependent. + //! + //! \param[out] argv The process’ arguments as passed to its `main()` function + //! as the \a argv parameter, possibly modified by the process. + //! + //! \return `true` on success, with \a argv populated appropriately. + //! Otherwise, `false` with a message logged. + //! + //! \note This function may spuriously return `false` when used to examine a + //! process that it is calling `exec()`. If examining such a process, call + //! this function in a retry loop with a small (100ns) delay to avoid an + //! erroneous assumption that \a pid is not running. + bool Arguments(std::vector* argv) const; + + private: +#if defined(OS_MACOSX) + kinfo_proc kern_proc_info_; +#endif + InitializationStateDcheck initialized_; + + DISALLOW_COPY_AND_ASSIGN(ProcessInfo); +}; + +} // namespace crashpad + +#endif // CRASHPAD_UTIL_POSIX_PROCESS_INFO_H_ diff --git a/util/posix/process_info_mac.cc b/util/posix/process_info_mac.cc new file mode 100644 index 00000000..a5e37538 --- /dev/null +++ b/util/posix/process_info_mac.cc @@ -0,0 +1,233 @@ +// Copyright 2014 The Crashpad Authors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "util/posix/process_info.h" + +#include + +#include "base/logging.h" +#include "base/mac/mach_logging.h" + +namespace crashpad { + +ProcessInfo::ProcessInfo() : kern_proc_info_(), initialized_() { +} + +ProcessInfo::~ProcessInfo() { +} + +bool ProcessInfo::Initialize(pid_t pid) { + INITIALIZATION_STATE_SET_INITIALIZING(initialized_); + + int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid}; + size_t len = sizeof(kern_proc_info_); + if (sysctl(mib, arraysize(mib), &kern_proc_info_, &len, nullptr, 0) != 0) { + PLOG(ERROR) << "sysctl for pid " << pid; + return false; + } + + // This sysctl does not return an error if the pid was not found. 10.9.5 + // xnu-2422.115.4/bsd/kern/kern_sysctl.c sysctl_prochandle() calls + // xnu-2422.115.4/bsd/kern/kern_proc.c proc_iterate(), which provides no + // indication of whether anything was done. To catch this, check that the PID + // has changed from the 0 value it was given when initialized by the + // constructor. + if (kern_proc_info_.kp_proc.p_pid == 0) { + LOG(WARNING) << "pid " << pid << " not found"; + return false; + } + + DCHECK_EQ(kern_proc_info_.kp_proc.p_pid, pid); + + INITIALIZATION_STATE_SET_VALID(initialized_); + return true; +} + +bool ProcessInfo::InitializeFromTask(task_t task) { + pid_t pid; + kern_return_t kr = pid_for_task(task, &pid); + if (kr != KERN_SUCCESS) { + MACH_LOG(ERROR, kr) << "pid_for_task"; + return false; + } + + return Initialize(pid); +} + +pid_t ProcessInfo::ProcessID() const { + INITIALIZATION_STATE_DCHECK_VALID(initialized_); + return kern_proc_info_.kp_proc.p_pid; +} + +pid_t ProcessInfo::ParentProcessID() const { + INITIALIZATION_STATE_DCHECK_VALID(initialized_); + return kern_proc_info_.kp_eproc.e_ppid; +} + +uid_t ProcessInfo::RealUserID() const { + INITIALIZATION_STATE_DCHECK_VALID(initialized_); + return kern_proc_info_.kp_eproc.e_pcred.p_ruid; +} + +uid_t ProcessInfo::EffectiveUserID() const { + INITIALIZATION_STATE_DCHECK_VALID(initialized_); + return kern_proc_info_.kp_eproc.e_ucred.cr_uid; +} + +uid_t ProcessInfo::SavedUserID() const { + INITIALIZATION_STATE_DCHECK_VALID(initialized_); + return kern_proc_info_.kp_eproc.e_pcred.p_svuid; +} + +gid_t ProcessInfo::RealGroupID() const { + INITIALIZATION_STATE_DCHECK_VALID(initialized_); + return kern_proc_info_.kp_eproc.e_pcred.p_rgid; +} + +gid_t ProcessInfo::EffectiveGroupID() const { + INITIALIZATION_STATE_DCHECK_VALID(initialized_); + return kern_proc_info_.kp_eproc.e_ucred.cr_gid; +} + +gid_t ProcessInfo::SavedGroupID() const { + INITIALIZATION_STATE_DCHECK_VALID(initialized_); + return kern_proc_info_.kp_eproc.e_pcred.p_svgid; +} + +std::set ProcessInfo::SupplementaryGroups() const { + INITIALIZATION_STATE_DCHECK_VALID(initialized_); + + const short ngroups = kern_proc_info_.kp_eproc.e_ucred.cr_ngroups; + DCHECK_GE(ngroups, 0); + DCHECK_LT(static_cast(ngroups), + arraysize(kern_proc_info_.kp_eproc.e_ucred.cr_groups)); + + const gid_t* groups = kern_proc_info_.kp_eproc.e_ucred.cr_groups; + return std::set(&groups[0], &groups[ngroups]); +} + +std::set ProcessInfo::AllGroups() const { + INITIALIZATION_STATE_DCHECK_VALID(initialized_); + + std::set all_groups = SupplementaryGroups(); + all_groups.insert(RealGroupID()); + all_groups.insert(EffectiveGroupID()); + all_groups.insert(SavedGroupID()); + return all_groups; +} + +bool ProcessInfo::DidChangePrivileges() const { + INITIALIZATION_STATE_DCHECK_VALID(initialized_); + return kern_proc_info_.kp_proc.p_flag & P_SUGID; +} + +bool ProcessInfo::Is64Bit() const { + INITIALIZATION_STATE_DCHECK_VALID(initialized_); + return kern_proc_info_.kp_proc.p_flag & P_LP64; +} + +void ProcessInfo::StartTime(timeval* start_time) const { + INITIALIZATION_STATE_DCHECK_VALID(initialized_); + *start_time = kern_proc_info_.kp_proc.p_starttime; +} + +bool ProcessInfo::Arguments(std::vector* argv) const { + INITIALIZATION_STATE_DCHECK_VALID(initialized_); + + // The format of KERN_PROCARGS2 is explained in 10.9.2 adv_cmds-153/ps/print.c + // getproclline(). It is an int (argc) followed by the executable’s string + // area. The string area consists of NUL-terminated strings, beginning with + // the executable path, and then starting on an aligned boundary, all of the + // elements of argv, envp, and applev. + + // It is possible for a process to exec() in between the two sysctl() calls + // below. If that happens, and the string area of the new program is larger + // than that of the old one, args_size_estimate will be too small. To detect + // this situation, the second sysctl() attempts to fetch args_size_estimate + + // 1 bytes, expecting to only receive args_size_estimate. If it gets the extra + // byte, it indicates that the string area has grown, and the sysctl() pair + // will be retried a limited number of times. + + size_t args_size_estimate; + size_t args_size; + std::string args; + int tries = 3; + const pid_t pid = ProcessID(); + do { + int mib[] = {CTL_KERN, KERN_PROCARGS2, pid}; + int rv = + sysctl(mib, arraysize(mib), nullptr, &args_size_estimate, nullptr, 0); + if (rv != 0) { + PLOG(ERROR) << "sysctl (size) for pid " << pid; + return false; + } + + args_size = args_size_estimate + 1; + args.resize(args_size); + rv = sysctl(mib, arraysize(mib), &args[0], &args_size, nullptr, 0); + if (rv != 0) { + PLOG(ERROR) << "sysctl (data) for pid " << pid; + return false; + } + } while (args_size == args_size_estimate + 1 && tries--); + + if (args_size == args_size_estimate + 1) { + LOG(ERROR) << "unexpected args_size"; + return false; + } + + // KERN_PROCARGS2 needs to at least contain argc. + if (args_size < sizeof(int)) { + LOG(ERROR) << "tiny args_size"; + return false; + } + args.resize(args_size); + + // Get argc. + int argc; + memcpy(&argc, &args[0], sizeof(argc)); + + // Find the end of the executable path. + size_t start_pos = sizeof(argc); + size_t nul_pos = args.find('\0', start_pos); + if (nul_pos == std::string::npos) { + LOG(ERROR) << "unterminated executable path"; + return false; + } + + // Find the beginning of the string area. + start_pos = args.find_first_not_of('\0', nul_pos); + if (start_pos == std::string::npos) { + LOG(ERROR) << "no string area"; + return false; + } + + std::vector local_argv; + while (argc-- && nul_pos != std::string::npos) { + nul_pos = args.find('\0', start_pos); + local_argv.push_back(args.substr(start_pos, nul_pos - start_pos)); + start_pos = nul_pos + 1; + } + + if (argc >= 0) { + // Not every argument was recovered. + LOG(ERROR) << "did not recover all arguments"; + return false; + } + + argv->swap(local_argv); + return true; +} + +} // namespace crashpad diff --git a/util/posix/process_info_test.cc b/util/posix/process_info_test.cc new file mode 100644 index 00000000..b052e10b --- /dev/null +++ b/util/posix/process_info_test.cc @@ -0,0 +1,148 @@ +// Copyright 2014 The Crashpad Authors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "util/posix/process_info.h" + +#include +#include + +#include +#include +#include + +#include "base/basictypes.h" +#include "build/build_config.h" +#include "gtest/gtest.h" +#include "util/test/errors.h" + +#if defined(OS_MACOSX) +#include +#endif + +namespace crashpad { +namespace test { +namespace { + +void TestSelfProcess(const ProcessInfo& process_info) { + EXPECT_EQ(getpid(), process_info.ProcessID()); + EXPECT_EQ(getppid(), process_info.ParentProcessID()); + + // There’s no system call to obtain the saved set-user ID or saved set-group + // ID in an easy way. Normally, they are the same as the effective user ID and + // effective group ID, so just check against those. + EXPECT_EQ(getuid(), process_info.RealUserID()); + const uid_t euid = geteuid(); + EXPECT_EQ(euid, process_info.EffectiveUserID()); + EXPECT_EQ(euid, process_info.SavedUserID()); + const gid_t gid = getgid(); + EXPECT_EQ(gid, process_info.RealGroupID()); + const gid_t egid = getegid(); + EXPECT_EQ(egid, process_info.EffectiveGroupID()); + EXPECT_EQ(egid, process_info.SavedGroupID()); + + // Test SupplementaryGroups(). + int group_count = getgroups(0, nullptr); + ASSERT_GE(group_count, 0) << ErrnoMessage("getgroups"); + + std::vector group_vector(group_count); + if (group_count > 0) { + group_count = getgroups(group_vector.size(), &group_vector[0]); + ASSERT_GE(group_count, 0) << ErrnoMessage("getgroups"); + ASSERT_EQ(group_vector.size(), implicit_cast(group_count)); + } + + std::set group_set(group_vector.begin(), group_vector.end()); + EXPECT_EQ(group_set, process_info.SupplementaryGroups()); + + // Test AllGroups(), which is SupplementaryGroups() plus the real, effective, + // and saved set-group IDs. The effective and saved set-group IDs are expected + // to be identical (see above). + group_set.insert(gid); + group_set.insert(egid); + + EXPECT_EQ(group_set, process_info.AllGroups()); + + // The test executable isn’t expected to change privileges. + EXPECT_FALSE(process_info.DidChangePrivileges()); + +#if defined(ARCH_CPU_64_BITS) + EXPECT_TRUE(process_info.Is64Bit()); +#else + EXPECT_FALSE(process_info.Is64Bit()); +#endif + + // Test StartTime(). This program must have started at some time in the past. + timeval start_time; + process_info.StartTime(&start_time); + time_t now; + time(&now); + EXPECT_LE(start_time.tv_sec, now); + + std::vector argv; + ASSERT_TRUE(process_info.Arguments(&argv)); + + // gtest argv processing scrambles argv, but it leaves argc and argv[0] + // intact, so test those. + +#if defined(OS_MACOSX) + int expect_argc = *_NSGetArgc(); + char** expect_argv = *_NSGetArgv(); +#else +#error Obtain expect_argc and expect_argv correctly on your system. +#endif + + int argc = implicit_cast(argv.size()); + EXPECT_EQ(expect_argc, argc); + + ASSERT_GE(expect_argc, 1); + ASSERT_GE(argc, 1); + + EXPECT_EQ(std::string(expect_argv[0]), argv[0]); +} + + +TEST(ProcessInfo, Self) { + ProcessInfo process_info; + ASSERT_TRUE(process_info.Initialize(getpid())); + TestSelfProcess(process_info); +} + +#if defined(OS_MACOSX) +TEST(ProcessInfo, SelfTask) { + ProcessInfo process_info; + ASSERT_TRUE(process_info.InitializeFromTask(mach_task_self())); + TestSelfProcess(process_info); +} +#endif + +TEST(ProcessInfo, Pid1) { + // PID 1 is expected to be init or the system’s equivalent. This tests reading + // information about another process. + ProcessInfo process_info; + ASSERT_TRUE(process_info.Initialize(1)); + + EXPECT_EQ(implicit_cast(1), process_info.ProcessID()); + EXPECT_EQ(implicit_cast(0), process_info.ParentProcessID()); + EXPECT_EQ(implicit_cast(0), process_info.RealUserID()); + EXPECT_EQ(implicit_cast(0), process_info.EffectiveUserID()); + EXPECT_EQ(implicit_cast(0), process_info.SavedUserID()); + EXPECT_EQ(implicit_cast(0), process_info.RealGroupID()); + EXPECT_EQ(implicit_cast(0), process_info.EffectiveGroupID()); + EXPECT_EQ(implicit_cast(0), process_info.SavedGroupID()); + EXPECT_FALSE(process_info.AllGroups().empty()); +} + +} // namespace +} // namespace test +} // namespace crashpad diff --git a/util/posix/process_util.h b/util/posix/process_util.h deleted file mode 100644 index 0abe46eb..00000000 --- a/util/posix/process_util.h +++ /dev/null @@ -1,42 +0,0 @@ -// Copyright 2014 The Crashpad Authors. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#ifndef CRASHPAD_UTIL_POSIX_PROCESS_UTIL_POSIX_H_ -#define CRASHPAD_UTIL_POSIX_PROCESS_UTIL_POSIX_H_ - -#include - -#include -#include - -namespace crashpad { - -//! \brief Obtains the arguments used to launch a process. -//! -//! \param[in] pid The process ID of the process to examine. -//! \param[out] argv The process’ arguments as passed to its `main()` function -//! as the \a argv parameter, possibly modified by the process. -//! -//! \return `true` on success, with \a argv populated appropriately. Otherwise, -//! `false`. -//! -//! \note This function may spuriously return `false` when used to examine a -//! process that it is calling `exec()`. If examining such a process, call -//! this function in a retry loop with a small (100ns) delay to avoid an -//! erroneous assumption that \a pid is not running. -bool ProcessArgumentsForPID(pid_t pid, std::vector* argv); - -} // namespace crashpad - -#endif // CRASHPAD_UTIL_POSIX_PROCESS_UTIL_POSIX_H_ diff --git a/util/posix/process_util_mac.cc b/util/posix/process_util_mac.cc deleted file mode 100644 index 2b80d994..00000000 --- a/util/posix/process_util_mac.cc +++ /dev/null @@ -1,103 +0,0 @@ -// Copyright 2014 The Crashpad Authors. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#include "util/posix/process_util.h" - -#include -#include -#include - -#include "base/basictypes.h" - -namespace crashpad { - -bool ProcessArgumentsForPID(pid_t pid, std::vector* argv) { - // The format of KERN_PROCARGS2 is explained in 10.9.2 adv_cmds-153/ps/print.c - // getproclline(). It is an int (argc) followed by the executable’s string - // area. The string area consists of NUL-terminated strings, beginning with - // the executable path, and then starting on an aligned boundary, all of the - // elements of argv, envp, and applev. - - // It is possible for a process to exec() in between the two sysctl() calls - // below. If that happens, and the string area of the new program is larger - // than that of the old one, args_size_estimate will be too small. To detect - // this situation, the second sysctl() attempts to fetch args_size_estimate + - // 1 bytes, expecting to only receive args_size_estimate. If it gets the extra - // byte, it indicates that the string area has grown, and the sysctl() pair - // will be retried a limited number of times. - - size_t args_size_estimate; - size_t args_size; - std::string args; - int tries = 3; - do { - int mib[] = {CTL_KERN, KERN_PROCARGS2, pid}; - int rv = - sysctl(mib, arraysize(mib), nullptr, &args_size_estimate, nullptr, 0); - if (rv != 0) { - return false; - } - - args_size = args_size_estimate + 1; - args.resize(args_size); - rv = sysctl(mib, arraysize(mib), &args[0], &args_size, nullptr, 0); - if (rv != 0) { - return false; - } - } while (args_size == args_size_estimate + 1 && tries--); - - if (args_size == args_size_estimate + 1) { - return false; - } - - // KERN_PROCARGS2 needs to at least contain argc. - if (args_size < sizeof(int)) { - return false; - } - args.resize(args_size); - - // Get argc. - int argc; - memcpy(&argc, &args[0], sizeof(argc)); - - // Find the end of the executable path. - size_t start_pos = sizeof(argc); - size_t nul_pos = args.find('\0', start_pos); - if (nul_pos == std::string::npos) { - return false; - } - - // Find the beginning of the string area. - start_pos = args.find_first_not_of('\0', nul_pos); - if (start_pos == std::string::npos) { - return false; - } - - std::vector local_argv; - while (argc-- && nul_pos != std::string::npos) { - nul_pos = args.find('\0', start_pos); - local_argv.push_back(args.substr(start_pos, nul_pos - start_pos)); - start_pos = nul_pos + 1; - } - - if (argc >= 0) { - // Not every argument was recovered. - return false; - } - - argv->swap(local_argv); - return true; -} - -} // namespace crashpad diff --git a/util/posix/process_util_test.cc b/util/posix/process_util_test.cc deleted file mode 100644 index 41d4a1de..00000000 --- a/util/posix/process_util_test.cc +++ /dev/null @@ -1,50 +0,0 @@ -// Copyright 2014 The Crashpad Authors. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#include "util/posix/process_util.h" - -#include -#include - -#include -#include - -#include "base/basictypes.h" -#include "gtest/gtest.h" - -namespace crashpad { -namespace test { -namespace { - -TEST(ProcessUtil, ProcessArgumentsForPID) { - std::vector argv; - ASSERT_TRUE(ProcessArgumentsForPID(getpid(), &argv)); - - // gtest argv processing scrambles argv, but it leaves argc and argv[0] - // intact, so test those. - - int argc = implicit_cast(argv.size()); - int expect_argc = *_NSGetArgc(); - EXPECT_EQ(expect_argc, argc); - - ASSERT_GE(expect_argc, 1); - ASSERT_GE(argc, 1); - - char** expect_argv = *_NSGetArgv(); - EXPECT_EQ(std::string(expect_argv[0]), argv[0]); -} - -} // namespace -} // namespace test -} // namespace crashpad diff --git a/util/util.gyp b/util/util.gyp index d5ee3496..d60be7fe 100644 --- a/util/util.gyp +++ b/util/util.gyp @@ -82,8 +82,8 @@ 'numeric/in_range_cast.h', 'numeric/int128.h', 'numeric/safe_assignment.h', - 'posix/process_util.h', - 'posix/process_util_mac.cc', + 'posix/process_info.h', + 'posix/process_info_mac.cc', 'posix/symbolic_constants_posix.cc', 'posix/symbolic_constants_posix.h', 'stdlib/cxx.h', @@ -229,7 +229,7 @@ 'numeric/checked_range_test.cc', 'numeric/in_range_cast_test.cc', 'numeric/int128_test.cc', - 'posix/process_util_test.cc', + 'posix/process_info_test.cc', 'posix/symbolic_constants_posix_test.cc', 'stdlib/string_number_conversion_test.cc', 'stdlib/strlcpy_test.cc',