b9c1b51e45
*** to conform to clang-format’s LLVM style. This kind of mass change has
*** two obvious implications:
Firstly, merging this particular commit into a downstream fork may be a huge
effort. Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit. The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):
find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;
The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.
Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit. There are alternatives available that will attempt
to look through this change and find the appropriate prior commit. YMMV.
llvm-svn: 280751
236 lines
8.8 KiB
C++
236 lines
8.8 KiB
C++
//===-- RNBServices.cpp -----------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Created by Christopher Friesen on 3/21/08.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "RNBServices.h"
|
|
|
|
#include "CFString.h"
|
|
#include "DNBLog.h"
|
|
#include "MacOSX/CFUtils.h"
|
|
#include <CoreFoundation/CoreFoundation.h>
|
|
#include <libproc.h>
|
|
#include <sys/sysctl.h>
|
|
#include <unistd.h>
|
|
#include <vector>
|
|
|
|
// For now only SpringBoard has a notion of "Applications" that it can list for
|
|
// us.
|
|
// So we have to use the SpringBoard API's here.
|
|
#if defined(WITH_SPRINGBOARD) || defined(WITH_BKS)
|
|
#include <SpringBoardServices/SpringBoardServices.h>
|
|
#endif
|
|
|
|
// From DNB.cpp
|
|
size_t GetAllInfos(std::vector<struct kinfo_proc> &proc_infos);
|
|
|
|
int GetProcesses(CFMutableArrayRef plistMutableArray, bool all_users) {
|
|
if (plistMutableArray == NULL)
|
|
return -1;
|
|
|
|
// Running as root, get all processes
|
|
std::vector<struct kinfo_proc> proc_infos;
|
|
const size_t num_proc_infos = GetAllInfos(proc_infos);
|
|
if (num_proc_infos > 0) {
|
|
const pid_t our_pid = getpid();
|
|
const uid_t our_uid = getuid();
|
|
uint32_t i;
|
|
CFAllocatorRef alloc = kCFAllocatorDefault;
|
|
|
|
for (i = 0; i < num_proc_infos; i++) {
|
|
struct kinfo_proc &proc_info = proc_infos[i];
|
|
|
|
bool kinfo_user_matches;
|
|
// Special case, if lldb is being run as root we can attach to anything.
|
|
if (all_users)
|
|
kinfo_user_matches = true;
|
|
else
|
|
kinfo_user_matches = proc_info.kp_eproc.e_pcred.p_ruid == our_uid;
|
|
|
|
const pid_t pid = proc_info.kp_proc.p_pid;
|
|
// Skip zombie processes and processes with unset status
|
|
if (kinfo_user_matches == false || // User is acceptable
|
|
pid == our_pid || // Skip this process
|
|
pid == 0 || // Skip kernel (kernel pid is zero)
|
|
proc_info.kp_proc.p_stat ==
|
|
SZOMB || // Zombies are bad, they like brains...
|
|
proc_info.kp_proc.p_flag & P_TRACED || // Being debugged?
|
|
proc_info.kp_proc.p_flag & P_WEXIT || // Working on exiting?
|
|
proc_info.kp_proc.p_flag &
|
|
P_TRANSLATED) // Skip translated ppc (Rosetta)
|
|
continue;
|
|
|
|
// Create a new mutable dictionary for each application
|
|
CFReleaser<CFMutableDictionaryRef> appInfoDict(
|
|
::CFDictionaryCreateMutable(alloc, 0, &kCFTypeDictionaryKeyCallBacks,
|
|
&kCFTypeDictionaryValueCallBacks));
|
|
|
|
// Get the process id for the app (if there is one)
|
|
const int32_t pid_int32 = pid;
|
|
CFReleaser<CFNumberRef> pidCFNumber(
|
|
::CFNumberCreate(alloc, kCFNumberSInt32Type, &pid_int32));
|
|
::CFDictionarySetValue(appInfoDict.get(), DTSERVICES_APP_PID_KEY,
|
|
pidCFNumber.get());
|
|
|
|
// Set the a boolean to indicate if this is the front most
|
|
::CFDictionarySetValue(appInfoDict.get(), DTSERVICES_APP_FRONTMOST_KEY,
|
|
kCFBooleanFalse);
|
|
|
|
const char *pid_basename = proc_info.kp_proc.p_comm;
|
|
char proc_path_buf[PATH_MAX];
|
|
|
|
int return_val = proc_pidpath(pid, proc_path_buf, PATH_MAX);
|
|
if (return_val > 0) {
|
|
// Okay, now search backwards from that to see if there is a
|
|
// slash in the name. Note, even though we got all the args we don't
|
|
// care
|
|
// because the list data is just a bunch of concatenated null terminated
|
|
// strings
|
|
// so strrchr will start from the end of argv0.
|
|
|
|
pid_basename = strrchr(proc_path_buf, '/');
|
|
if (pid_basename) {
|
|
// Skip the '/'
|
|
++pid_basename;
|
|
} else {
|
|
// We didn't find a directory delimiter in the process argv[0], just
|
|
// use what was in there
|
|
pid_basename = proc_path_buf;
|
|
}
|
|
CFString cf_pid_path(proc_path_buf);
|
|
if (cf_pid_path.get())
|
|
::CFDictionarySetValue(appInfoDict.get(), DTSERVICES_APP_PATH_KEY,
|
|
cf_pid_path.get());
|
|
}
|
|
|
|
if (pid_basename && pid_basename[0]) {
|
|
CFString pid_name(pid_basename);
|
|
::CFDictionarySetValue(appInfoDict.get(),
|
|
DTSERVICES_APP_DISPLAY_NAME_KEY, pid_name.get());
|
|
}
|
|
|
|
// Append the application info to the plist array
|
|
::CFArrayAppendValue(plistMutableArray, appInfoDict.get());
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
int ListApplications(std::string &plist, bool opt_runningApps,
|
|
bool opt_debuggable) {
|
|
int result = -1;
|
|
|
|
CFAllocatorRef alloc = kCFAllocatorDefault;
|
|
|
|
// Create a mutable array that we can populate. Specify zero so it can be of
|
|
// any size.
|
|
CFReleaser<CFMutableArrayRef> plistMutableArray(
|
|
::CFArrayCreateMutable(alloc, 0, &kCFTypeArrayCallBacks));
|
|
|
|
const uid_t our_uid = getuid();
|
|
|
|
#if defined(WITH_SPRINGBOARD) || defined(WITH_BKS)
|
|
|
|
if (our_uid == 0) {
|
|
bool all_users = true;
|
|
result = GetProcesses(plistMutableArray.get(), all_users);
|
|
} else {
|
|
CFReleaser<CFStringRef> sbsFrontAppID(
|
|
::SBSCopyFrontmostApplicationDisplayIdentifier());
|
|
CFReleaser<CFArrayRef> sbsAppIDs(::SBSCopyApplicationDisplayIdentifiers(
|
|
opt_runningApps, opt_debuggable));
|
|
|
|
// Need to check the return value from SBSCopyApplicationDisplayIdentifiers.
|
|
CFIndex count = sbsAppIDs.get() ? ::CFArrayGetCount(sbsAppIDs.get()) : 0;
|
|
CFIndex i = 0;
|
|
for (i = 0; i < count; i++) {
|
|
CFStringRef displayIdentifier =
|
|
(CFStringRef)::CFArrayGetValueAtIndex(sbsAppIDs.get(), i);
|
|
|
|
// Create a new mutable dictionary for each application
|
|
CFReleaser<CFMutableDictionaryRef> appInfoDict(
|
|
::CFDictionaryCreateMutable(alloc, 0, &kCFTypeDictionaryKeyCallBacks,
|
|
&kCFTypeDictionaryValueCallBacks));
|
|
|
|
// Get the process id for the app (if there is one)
|
|
pid_t pid = INVALID_NUB_PROCESS;
|
|
if (::SBSProcessIDForDisplayIdentifier((CFStringRef)displayIdentifier,
|
|
&pid) == true) {
|
|
CFReleaser<CFNumberRef> pidCFNumber(
|
|
::CFNumberCreate(alloc, kCFNumberSInt32Type, &pid));
|
|
::CFDictionarySetValue(appInfoDict.get(), DTSERVICES_APP_PID_KEY,
|
|
pidCFNumber.get());
|
|
}
|
|
|
|
// Set the a boolean to indicate if this is the front most
|
|
if (sbsFrontAppID.get() && displayIdentifier &&
|
|
(::CFStringCompare(sbsFrontAppID.get(), displayIdentifier, 0) ==
|
|
kCFCompareEqualTo))
|
|
::CFDictionarySetValue(appInfoDict.get(), DTSERVICES_APP_FRONTMOST_KEY,
|
|
kCFBooleanTrue);
|
|
else
|
|
::CFDictionarySetValue(appInfoDict.get(), DTSERVICES_APP_FRONTMOST_KEY,
|
|
kCFBooleanFalse);
|
|
|
|
CFReleaser<CFStringRef> executablePath(
|
|
::SBSCopyExecutablePathForDisplayIdentifier(displayIdentifier));
|
|
if (executablePath.get() != NULL) {
|
|
::CFDictionarySetValue(appInfoDict.get(), DTSERVICES_APP_PATH_KEY,
|
|
executablePath.get());
|
|
}
|
|
|
|
CFReleaser<CFStringRef> iconImagePath(
|
|
::SBSCopyIconImagePathForDisplayIdentifier(displayIdentifier));
|
|
if (iconImagePath.get() != NULL) {
|
|
::CFDictionarySetValue(appInfoDict.get(), DTSERVICES_APP_ICON_PATH_KEY,
|
|
iconImagePath.get());
|
|
}
|
|
|
|
CFReleaser<CFStringRef> localizedDisplayName(
|
|
::SBSCopyLocalizedApplicationNameForDisplayIdentifier(
|
|
displayIdentifier));
|
|
if (localizedDisplayName.get() != NULL) {
|
|
::CFDictionarySetValue(appInfoDict.get(),
|
|
DTSERVICES_APP_DISPLAY_NAME_KEY,
|
|
localizedDisplayName.get());
|
|
}
|
|
|
|
// Append the application info to the plist array
|
|
::CFArrayAppendValue(plistMutableArray.get(), appInfoDict.get());
|
|
}
|
|
}
|
|
#else // #if defined (WITH_SPRINGBOARD) || defined (WITH_BKS)
|
|
// When root, show all processes
|
|
bool all_users = (our_uid == 0);
|
|
GetProcesses(plistMutableArray.get(), all_users);
|
|
#endif
|
|
|
|
CFReleaser<CFDataRef> plistData(
|
|
::CFPropertyListCreateXMLData(alloc, plistMutableArray.get()));
|
|
|
|
// write plist to service port
|
|
if (plistData.get() != NULL) {
|
|
CFIndex size = ::CFDataGetLength(plistData.get());
|
|
const UInt8 *bytes = ::CFDataGetBytePtr(plistData.get());
|
|
if (bytes != NULL && size > 0) {
|
|
plist.assign((char *)bytes, size);
|
|
return 0; // Success
|
|
} else {
|
|
DNBLogError("empty application property list.");
|
|
result = -2;
|
|
}
|
|
} else {
|
|
DNBLogError("serializing task list.");
|
|
result = -3;
|
|
}
|
|
|
|
return result;
|
|
}
|