1f982c2d22
We previously passed in a 8192 byte buffer but this wasn't large enough. We now calculate the size we need and then add 128 to it and get the environment. If we pass exactly the number of bytes it says is needs, the sysctl() returns junk. Adding 1 seemed to do the trick, but to err on the side of caution, I added a few bytes more. <rdar://problem/21883842> llvm-svn: 242729
1557 lines
53 KiB
C++
1557 lines
53 KiB
C++
//===-- Host.mm -------------------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Host/Host.h"
|
|
|
|
#include <AvailabilityMacros.h>
|
|
|
|
#if !defined(MAC_OS_X_VERSION_10_7) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7
|
|
#define NO_XPC_SERVICES 1
|
|
#endif
|
|
|
|
#if !defined(NO_XPC_SERVICES)
|
|
#define __XPC_PRIVATE_H__
|
|
#include <xpc/xpc.h>
|
|
#include "launcherXPCService/LauncherXPCService.h"
|
|
#endif
|
|
|
|
#include "llvm/Support/Host.h"
|
|
|
|
#include <asl.h>
|
|
#include <crt_externs.h>
|
|
#include <execinfo.h>
|
|
#include <grp.h>
|
|
#include <libproc.h>
|
|
#include <pwd.h>
|
|
#include <spawn.h>
|
|
#include <stdio.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/sysctl.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
|
|
#include "lldb/Core/ArchSpec.h"
|
|
#include "lldb/Core/Communication.h"
|
|
#include "lldb/Core/DataBufferHeap.h"
|
|
#include "lldb/Core/DataExtractor.h"
|
|
#include "lldb/Core/Log.h"
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/ModuleSpec.h"
|
|
#include "lldb/Core/StreamFile.h"
|
|
#include "lldb/Core/StreamString.h"
|
|
#include "lldb/Core/StructuredData.h"
|
|
#include "lldb/Host/ConnectionFileDescriptor.h"
|
|
#include "lldb/Host/Endian.h"
|
|
#include "lldb/Host/FileSpec.h"
|
|
#include "lldb/Host/FileSystem.h"
|
|
#include "lldb/Host/HostInfo.h"
|
|
#include "lldb/Host/ThreadLauncher.h"
|
|
#include "lldb/Target/Platform.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Utility/CleanUp.h"
|
|
#include "lldb/Utility/NameMatches.h"
|
|
|
|
#include "cfcpp/CFCBundle.h"
|
|
#include "cfcpp/CFCMutableArray.h"
|
|
#include "cfcpp/CFCMutableDictionary.h"
|
|
#include "cfcpp/CFCReleaser.h"
|
|
#include "cfcpp/CFCString.h"
|
|
|
|
|
|
#include <objc/objc-auto.h>
|
|
|
|
#include <CoreFoundation/CoreFoundation.h>
|
|
#include <Foundation/Foundation.h>
|
|
|
|
#ifndef _POSIX_SPAWN_DISABLE_ASLR
|
|
#define _POSIX_SPAWN_DISABLE_ASLR 0x0100
|
|
#endif
|
|
|
|
extern "C"
|
|
{
|
|
int __pthread_chdir(const char *path);
|
|
int __pthread_fchdir (int fildes);
|
|
}
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
bool
|
|
Host::GetBundleDirectory (const FileSpec &file, FileSpec &bundle_directory)
|
|
{
|
|
#if defined (__APPLE__)
|
|
if (file.GetFileType () == FileSpec::eFileTypeDirectory)
|
|
{
|
|
char path[PATH_MAX];
|
|
if (file.GetPath(path, sizeof(path)))
|
|
{
|
|
CFCBundle bundle (path);
|
|
if (bundle.GetPath (path, sizeof(path)))
|
|
{
|
|
bundle_directory.SetFile (path, false);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
bundle_directory.Clear();
|
|
return false;
|
|
}
|
|
|
|
|
|
bool
|
|
Host::ResolveExecutableInBundle (FileSpec &file)
|
|
{
|
|
#if defined (__APPLE__)
|
|
if (file.GetFileType () == FileSpec::eFileTypeDirectory)
|
|
{
|
|
char path[PATH_MAX];
|
|
if (file.GetPath(path, sizeof(path)))
|
|
{
|
|
CFCBundle bundle (path);
|
|
CFCReleaser<CFURLRef> url(bundle.CopyExecutableURL ());
|
|
if (url.get())
|
|
{
|
|
if (::CFURLGetFileSystemRepresentation (url.get(), YES, (UInt8*)path, sizeof(path)))
|
|
{
|
|
file.SetFile(path, false);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
static void *
|
|
AcceptPIDFromInferior (void *arg)
|
|
{
|
|
const char *connect_url = (const char *)arg;
|
|
ConnectionFileDescriptor file_conn;
|
|
Error error;
|
|
if (file_conn.Connect (connect_url, &error) == eConnectionStatusSuccess)
|
|
{
|
|
char pid_str[256];
|
|
::memset (pid_str, 0, sizeof(pid_str));
|
|
ConnectionStatus status;
|
|
const size_t pid_str_len = file_conn.Read (pid_str, sizeof(pid_str), 0, status, NULL);
|
|
if (pid_str_len > 0)
|
|
{
|
|
int pid = atoi (pid_str);
|
|
return (void *)(intptr_t)pid;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static bool
|
|
WaitForProcessToSIGSTOP (const lldb::pid_t pid, const int timeout_in_seconds)
|
|
{
|
|
const int time_delta_usecs = 100000;
|
|
const int num_retries = timeout_in_seconds/time_delta_usecs;
|
|
for (int i=0; i<num_retries; i++)
|
|
{
|
|
struct proc_bsdinfo bsd_info;
|
|
int error = ::proc_pidinfo (pid, PROC_PIDTBSDINFO,
|
|
(uint64_t) 0,
|
|
&bsd_info,
|
|
PROC_PIDTBSDINFO_SIZE);
|
|
|
|
switch (error)
|
|
{
|
|
case EINVAL:
|
|
case ENOTSUP:
|
|
case ESRCH:
|
|
case EPERM:
|
|
return false;
|
|
|
|
default:
|
|
break;
|
|
|
|
case 0:
|
|
if (bsd_info.pbi_status == SSTOP)
|
|
return true;
|
|
}
|
|
::usleep (time_delta_usecs);
|
|
}
|
|
return false;
|
|
}
|
|
#if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__)
|
|
|
|
//static lldb::pid_t
|
|
//LaunchInNewTerminalWithCommandFile
|
|
//(
|
|
// const char **argv,
|
|
// const char **envp,
|
|
// const char *working_dir,
|
|
// const ArchSpec *arch_spec,
|
|
// bool stop_at_entry,
|
|
// bool disable_aslr
|
|
//)
|
|
//{
|
|
// if (!argv || !argv[0])
|
|
// return LLDB_INVALID_PROCESS_ID;
|
|
//
|
|
// OSStatus error = 0;
|
|
//
|
|
// FileSpec program (argv[0], false);
|
|
//
|
|
//
|
|
// std::string unix_socket_name;
|
|
//
|
|
// char temp_file_path[PATH_MAX];
|
|
// const char *tmpdir = ::getenv ("TMPDIR");
|
|
// if (tmpdir == NULL)
|
|
// tmpdir = "/tmp/";
|
|
// ::snprintf (temp_file_path, sizeof(temp_file_path), "%s%s-XXXXXX", tmpdir, program.GetFilename().AsCString());
|
|
//
|
|
// if (::mktemp (temp_file_path) == NULL)
|
|
// return LLDB_INVALID_PROCESS_ID;
|
|
//
|
|
// unix_socket_name.assign (temp_file_path);
|
|
//
|
|
// ::strlcat (temp_file_path, ".command", sizeof (temp_file_path));
|
|
//
|
|
// StreamFile command_file;
|
|
// command_file.GetFile().Open (temp_file_path,
|
|
// File::eOpenOptionWrite | File::eOpenOptionCanCreate,
|
|
// lldb::eFilePermissionsDefault);
|
|
//
|
|
// if (!command_file.GetFile().IsValid())
|
|
// return LLDB_INVALID_PROCESS_ID;
|
|
//
|
|
// FileSpec darwin_debug_file_spec;
|
|
// if (!HostInfo::GetLLDBPath (ePathTypeSupportExecutableDir, darwin_debug_file_spec))
|
|
// return LLDB_INVALID_PROCESS_ID;
|
|
// darwin_debug_file_spec.GetFilename().SetCString("darwin-debug");
|
|
//
|
|
// if (!darwin_debug_file_spec.Exists())
|
|
// return LLDB_INVALID_PROCESS_ID;
|
|
//
|
|
// char launcher_path[PATH_MAX];
|
|
// darwin_debug_file_spec.GetPath(launcher_path, sizeof(launcher_path));
|
|
// command_file.Printf("\"%s\" ", launcher_path);
|
|
//
|
|
// command_file.Printf("--unix-socket=%s ", unix_socket_name.c_str());
|
|
//
|
|
// if (arch_spec && arch_spec->IsValid())
|
|
// {
|
|
// command_file.Printf("--arch=%s ", arch_spec->GetArchitectureName());
|
|
// }
|
|
//
|
|
// if (disable_aslr)
|
|
// {
|
|
// command_file.PutCString("--disable-aslr ");
|
|
// }
|
|
//
|
|
// command_file.PutCString("-- ");
|
|
//
|
|
// if (argv)
|
|
// {
|
|
// for (size_t i=0; argv[i] != NULL; ++i)
|
|
// {
|
|
// command_file.Printf("\"%s\" ", argv[i]);
|
|
// }
|
|
// }
|
|
// command_file.PutCString("\necho Process exited with status $?\n");
|
|
// command_file.GetFile().Close();
|
|
// if (::chmod (temp_file_path, S_IRWXU | S_IRWXG) != 0)
|
|
// return LLDB_INVALID_PROCESS_ID;
|
|
//
|
|
// CFCMutableDictionary cf_env_dict;
|
|
//
|
|
// const bool can_create = true;
|
|
// if (envp)
|
|
// {
|
|
// for (size_t i=0; envp[i] != NULL; ++i)
|
|
// {
|
|
// const char *env_entry = envp[i];
|
|
// const char *equal_pos = strchr(env_entry, '=');
|
|
// if (equal_pos)
|
|
// {
|
|
// std::string env_key (env_entry, equal_pos);
|
|
// std::string env_val (equal_pos + 1);
|
|
// CFCString cf_env_key (env_key.c_str(), kCFStringEncodingUTF8);
|
|
// CFCString cf_env_val (env_val.c_str(), kCFStringEncodingUTF8);
|
|
// cf_env_dict.AddValue (cf_env_key.get(), cf_env_val.get(), can_create);
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
// LSApplicationParameters app_params;
|
|
// ::memset (&app_params, 0, sizeof (app_params));
|
|
// app_params.flags = kLSLaunchDontAddToRecents | kLSLaunchAsync;
|
|
// app_params.argv = NULL;
|
|
// app_params.environment = (CFDictionaryRef)cf_env_dict.get();
|
|
//
|
|
// CFCReleaser<CFURLRef> command_file_url (::CFURLCreateFromFileSystemRepresentation (NULL,
|
|
// (const UInt8 *)temp_file_path,
|
|
// strlen(temp_file_path),
|
|
// false));
|
|
//
|
|
// CFCMutableArray urls;
|
|
//
|
|
// // Terminal.app will open the ".command" file we have created
|
|
// // and run our process inside it which will wait at the entry point
|
|
// // for us to attach.
|
|
// urls.AppendValue(command_file_url.get());
|
|
//
|
|
//
|
|
// lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
|
|
//
|
|
// Error lldb_error;
|
|
// // Sleep and wait a bit for debugserver to start to listen...
|
|
// char connect_url[128];
|
|
// ::snprintf (connect_url, sizeof(connect_url), "unix-accept://%s", unix_socket_name.c_str());
|
|
//
|
|
// // Spawn a new thread to accept incoming connection on the connect_url
|
|
// // so we can grab the pid from the inferior
|
|
// lldb::thread_t accept_thread = Host::ThreadCreate (unix_socket_name.c_str(),
|
|
// AcceptPIDFromInferior,
|
|
// connect_url,
|
|
// &lldb_error);
|
|
//
|
|
// ProcessSerialNumber psn;
|
|
// error = LSOpenURLsWithRole(urls.get(), kLSRolesShell, NULL, &app_params, &psn, 1);
|
|
// if (error == noErr)
|
|
// {
|
|
// thread_result_t accept_thread_result = NULL;
|
|
// if (Host::ThreadJoin (accept_thread, &accept_thread_result, &lldb_error))
|
|
// {
|
|
// if (accept_thread_result)
|
|
// {
|
|
// pid = (intptr_t)accept_thread_result;
|
|
//
|
|
// // Wait for process to be stopped the entry point by watching
|
|
// // for the process status to be set to SSTOP which indicates it it
|
|
// // SIGSTOP'ed at the entry point
|
|
// WaitForProcessToSIGSTOP (pid, 5);
|
|
// }
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// Host::ThreadCancel (accept_thread, &lldb_error);
|
|
// }
|
|
//
|
|
// return pid;
|
|
//}
|
|
|
|
const char *applscript_in_new_tty =
|
|
"tell application \"Terminal\"\n"
|
|
" do script \"%s\"\n"
|
|
"end tell\n";
|
|
|
|
|
|
const char *applscript_in_existing_tty = "\
|
|
set the_shell_script to \"%s\"\n\
|
|
tell application \"Terminal\"\n\
|
|
repeat with the_window in (get windows)\n\
|
|
repeat with the_tab in tabs of the_window\n\
|
|
set the_tty to tty in the_tab\n\
|
|
if the_tty contains \"%s\" then\n\
|
|
if the_tab is not busy then\n\
|
|
set selected of the_tab to true\n\
|
|
set frontmost of the_window to true\n\
|
|
do script the_shell_script in the_tab\n\
|
|
return\n\
|
|
end if\n\
|
|
end if\n\
|
|
end repeat\n\
|
|
end repeat\n\
|
|
do script the_shell_script\n\
|
|
end tell\n";
|
|
|
|
|
|
static Error
|
|
LaunchInNewTerminalWithAppleScript (const char *exe_path, ProcessLaunchInfo &launch_info)
|
|
{
|
|
Error error;
|
|
char unix_socket_name[PATH_MAX] = "/tmp/XXXXXX";
|
|
if (::mktemp (unix_socket_name) == NULL)
|
|
{
|
|
error.SetErrorString ("failed to make temporary path for a unix socket");
|
|
return error;
|
|
}
|
|
|
|
StreamString command;
|
|
FileSpec darwin_debug_file_spec;
|
|
if (!HostInfo::GetLLDBPath(ePathTypeSupportExecutableDir, darwin_debug_file_spec))
|
|
{
|
|
error.SetErrorString ("can't locate the 'darwin-debug' executable");
|
|
return error;
|
|
}
|
|
|
|
darwin_debug_file_spec.GetFilename().SetCString("darwin-debug");
|
|
|
|
if (!darwin_debug_file_spec.Exists())
|
|
{
|
|
error.SetErrorStringWithFormat ("the 'darwin-debug' executable doesn't exists at '%s'",
|
|
darwin_debug_file_spec.GetPath().c_str());
|
|
return error;
|
|
}
|
|
|
|
char launcher_path[PATH_MAX];
|
|
darwin_debug_file_spec.GetPath(launcher_path, sizeof(launcher_path));
|
|
|
|
const ArchSpec &arch_spec = launch_info.GetArchitecture();
|
|
// Only set the architecture if it is valid and if it isn't Haswell (x86_64h).
|
|
if (arch_spec.IsValid() && arch_spec.GetCore() != ArchSpec::eCore_x86_64_x86_64h)
|
|
command.Printf("arch -arch %s ", arch_spec.GetArchitectureName());
|
|
|
|
command.Printf("'%s' --unix-socket=%s", launcher_path, unix_socket_name);
|
|
|
|
if (arch_spec.IsValid())
|
|
command.Printf(" --arch=%s", arch_spec.GetArchitectureName());
|
|
|
|
FileSpec working_dir{launch_info.GetWorkingDirectory()};
|
|
if (working_dir)
|
|
command.Printf(" --working-dir '%s'", working_dir.GetCString());
|
|
else
|
|
{
|
|
char cwd[PATH_MAX];
|
|
if (getcwd(cwd, PATH_MAX))
|
|
command.Printf(" --working-dir '%s'", cwd);
|
|
}
|
|
|
|
if (launch_info.GetFlags().Test (eLaunchFlagDisableASLR))
|
|
command.PutCString(" --disable-aslr");
|
|
|
|
// We are launching on this host in a terminal. So compare the environment on the host
|
|
// to what is supplied in the launch_info. Any items that aren't in the host environment
|
|
// need to be sent to darwin-debug. If we send all environment entries, we might blow the
|
|
// max command line length, so we only send user modified entries.
|
|
const char **envp = launch_info.GetEnvironmentEntries().GetConstArgumentVector ();
|
|
|
|
StringList host_env;
|
|
const size_t host_env_count = Host::GetEnvironment (host_env);
|
|
|
|
if (envp && envp[0])
|
|
{
|
|
const char *env_entry;
|
|
for (size_t env_idx = 0; (env_entry = envp[env_idx]) != NULL; ++env_idx)
|
|
{
|
|
bool add_entry = true;
|
|
for (size_t i=0; i<host_env_count; ++i)
|
|
{
|
|
const char *host_env_entry = host_env.GetStringAtIndex(i);
|
|
if (strcmp(env_entry, host_env_entry) == 0)
|
|
{
|
|
add_entry = false;
|
|
break;
|
|
}
|
|
}
|
|
if (add_entry)
|
|
{
|
|
command.Printf(" --env='%s'", env_entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
command.PutCString(" -- ");
|
|
|
|
const char **argv = launch_info.GetArguments().GetConstArgumentVector ();
|
|
if (argv)
|
|
{
|
|
for (size_t i=0; argv[i] != NULL; ++i)
|
|
{
|
|
if (i==0)
|
|
command.Printf(" '%s'", exe_path);
|
|
else
|
|
command.Printf(" '%s'", argv[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
command.Printf(" '%s'", exe_path);
|
|
}
|
|
command.PutCString (" ; echo Process exited with status $?");
|
|
if (launch_info.GetFlags().Test(lldb::eLaunchFlagCloseTTYOnExit))
|
|
command.PutCString (" ; exit");
|
|
|
|
StreamString applescript_source;
|
|
|
|
const char *tty_command = command.GetString().c_str();
|
|
// if (tty_name && tty_name[0])
|
|
// {
|
|
// applescript_source.Printf (applscript_in_existing_tty,
|
|
// tty_command,
|
|
// tty_name);
|
|
// }
|
|
// else
|
|
// {
|
|
applescript_source.Printf (applscript_in_new_tty,
|
|
tty_command);
|
|
// }
|
|
|
|
|
|
|
|
const char *script_source = applescript_source.GetString().c_str();
|
|
//puts (script_source);
|
|
NSAppleScript* applescript = [[NSAppleScript alloc] initWithSource:[NSString stringWithCString:script_source encoding:NSUTF8StringEncoding]];
|
|
|
|
lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
|
|
|
|
Error lldb_error;
|
|
// Sleep and wait a bit for debugserver to start to listen...
|
|
ConnectionFileDescriptor file_conn;
|
|
char connect_url[128];
|
|
::snprintf (connect_url, sizeof(connect_url), "unix-accept://%s", unix_socket_name);
|
|
|
|
// Spawn a new thread to accept incoming connection on the connect_url
|
|
// so we can grab the pid from the inferior. We have to do this because we
|
|
// are sending an AppleScript that will launch a process in Terminal.app,
|
|
// in a shell and the shell will fork/exec a couple of times before we get
|
|
// to the process that we wanted to launch. So when our process actually
|
|
// gets launched, we will handshake with it and get the process ID for it.
|
|
HostThread accept_thread = ThreadLauncher::LaunchThread(unix_socket_name, AcceptPIDFromInferior, connect_url, &lldb_error);
|
|
|
|
[applescript executeAndReturnError:nil];
|
|
|
|
thread_result_t accept_thread_result = NULL;
|
|
lldb_error = accept_thread.Join(&accept_thread_result);
|
|
if (lldb_error.Success() && accept_thread_result)
|
|
{
|
|
pid = (intptr_t)accept_thread_result;
|
|
|
|
// Wait for process to be stopped at the entry point by watching
|
|
// for the process status to be set to SSTOP which indicates it it
|
|
// SIGSTOP'ed at the entry point
|
|
WaitForProcessToSIGSTOP(pid, 5);
|
|
}
|
|
|
|
FileSystem::Unlink(FileSpec{unix_socket_name, false});
|
|
[applescript release];
|
|
if (pid != LLDB_INVALID_PROCESS_ID)
|
|
launch_info.SetProcessID (pid);
|
|
return error;
|
|
}
|
|
|
|
#endif // #if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__)
|
|
|
|
|
|
// On MacOSX CrashReporter will display a string for each shared library if
|
|
// the shared library has an exported symbol named "__crashreporter_info__".
|
|
|
|
static Mutex&
|
|
GetCrashReporterMutex ()
|
|
{
|
|
static Mutex g_mutex;
|
|
return g_mutex;
|
|
}
|
|
|
|
extern "C" {
|
|
const char *__crashreporter_info__ = NULL;
|
|
}
|
|
|
|
asm(".desc ___crashreporter_info__, 0x10");
|
|
|
|
void
|
|
Host::SetCrashDescriptionWithFormat (const char *format, ...)
|
|
{
|
|
static StreamString g_crash_description;
|
|
Mutex::Locker locker (GetCrashReporterMutex ());
|
|
|
|
if (format)
|
|
{
|
|
va_list args;
|
|
va_start (args, format);
|
|
g_crash_description.GetString().clear();
|
|
g_crash_description.PrintfVarArg(format, args);
|
|
va_end (args);
|
|
__crashreporter_info__ = g_crash_description.GetData();
|
|
}
|
|
else
|
|
{
|
|
__crashreporter_info__ = NULL;
|
|
}
|
|
}
|
|
|
|
void
|
|
Host::SetCrashDescription (const char *cstr)
|
|
{
|
|
Mutex::Locker locker (GetCrashReporterMutex ());
|
|
static std::string g_crash_description;
|
|
if (cstr)
|
|
{
|
|
g_crash_description.assign (cstr);
|
|
__crashreporter_info__ = g_crash_description.c_str();
|
|
}
|
|
else
|
|
{
|
|
__crashreporter_info__ = NULL;
|
|
}
|
|
}
|
|
|
|
bool
|
|
Host::OpenFileInExternalEditor (const FileSpec &file_spec, uint32_t line_no)
|
|
{
|
|
#if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
|
|
return false;
|
|
#else
|
|
// We attach this to an 'odoc' event to specify a particular selection
|
|
typedef struct {
|
|
int16_t reserved0; // must be zero
|
|
int16_t fLineNumber;
|
|
int32_t fSelStart;
|
|
int32_t fSelEnd;
|
|
uint32_t reserved1; // must be zero
|
|
uint32_t reserved2; // must be zero
|
|
} BabelAESelInfo;
|
|
|
|
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_HOST));
|
|
char file_path[PATH_MAX];
|
|
file_spec.GetPath(file_path, PATH_MAX);
|
|
CFCString file_cfstr (file_path, kCFStringEncodingUTF8);
|
|
CFCReleaser<CFURLRef> file_URL (::CFURLCreateWithFileSystemPath (NULL,
|
|
file_cfstr.get(),
|
|
kCFURLPOSIXPathStyle,
|
|
false));
|
|
|
|
if (log)
|
|
log->Printf("Sending source file: \"%s\" and line: %d to external editor.\n", file_path, line_no);
|
|
|
|
long error;
|
|
BabelAESelInfo file_and_line_info =
|
|
{
|
|
0, // reserved0
|
|
(int16_t)(line_no - 1), // fLineNumber (zero based line number)
|
|
1, // fSelStart
|
|
1024, // fSelEnd
|
|
0, // reserved1
|
|
0 // reserved2
|
|
};
|
|
|
|
AEKeyDesc file_and_line_desc;
|
|
|
|
error = ::AECreateDesc (typeUTF8Text,
|
|
&file_and_line_info,
|
|
sizeof (file_and_line_info),
|
|
&(file_and_line_desc.descContent));
|
|
|
|
if (error != noErr)
|
|
{
|
|
if (log)
|
|
log->Printf("Error creating AEDesc: %ld.\n", error);
|
|
return false;
|
|
}
|
|
|
|
file_and_line_desc.descKey = keyAEPosition;
|
|
|
|
static std::string g_app_name;
|
|
static FSRef g_app_fsref;
|
|
|
|
LSApplicationParameters app_params;
|
|
::memset (&app_params, 0, sizeof (app_params));
|
|
app_params.flags = kLSLaunchDefaults |
|
|
kLSLaunchDontAddToRecents |
|
|
kLSLaunchDontSwitch;
|
|
|
|
char *external_editor = ::getenv ("LLDB_EXTERNAL_EDITOR");
|
|
|
|
if (external_editor)
|
|
{
|
|
if (log)
|
|
log->Printf("Looking for external editor \"%s\".\n", external_editor);
|
|
|
|
if (g_app_name.empty() || strcmp (g_app_name.c_str(), external_editor) != 0)
|
|
{
|
|
CFCString editor_name (external_editor, kCFStringEncodingUTF8);
|
|
error = ::LSFindApplicationForInfo (kLSUnknownCreator,
|
|
NULL,
|
|
editor_name.get(),
|
|
&g_app_fsref,
|
|
NULL);
|
|
|
|
// If we found the app, then store away the name so we don't have to re-look it up.
|
|
if (error != noErr)
|
|
{
|
|
if (log)
|
|
log->Printf("Could not find External Editor application, error: %ld.\n", error);
|
|
return false;
|
|
}
|
|
|
|
}
|
|
app_params.application = &g_app_fsref;
|
|
}
|
|
|
|
ProcessSerialNumber psn;
|
|
CFCReleaser<CFArrayRef> file_array(CFArrayCreate (NULL, (const void **) file_URL.ptr_address(false), 1, NULL));
|
|
error = ::LSOpenURLsWithRole (file_array.get(),
|
|
kLSRolesAll,
|
|
&file_and_line_desc,
|
|
&app_params,
|
|
&psn,
|
|
1);
|
|
|
|
AEDisposeDesc (&(file_and_line_desc.descContent));
|
|
|
|
if (error != noErr)
|
|
{
|
|
if (log)
|
|
log->Printf("LSOpenURLsWithRole failed, error: %ld.\n", error);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
#endif // #if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__)
|
|
}
|
|
|
|
size_t
|
|
Host::GetEnvironment (StringList &env)
|
|
{
|
|
char **host_env = *_NSGetEnviron();
|
|
char *env_entry;
|
|
size_t i;
|
|
for (i=0; (env_entry = host_env[i]) != NULL; ++i)
|
|
env.AppendString(env_entry);
|
|
return i;
|
|
|
|
}
|
|
|
|
static bool
|
|
GetMacOSXProcessCPUType (ProcessInstanceInfo &process_info)
|
|
{
|
|
if (process_info.ProcessIDIsValid())
|
|
{
|
|
// Make a new mib to stay thread safe
|
|
int mib[CTL_MAXNAME]={0,};
|
|
size_t mib_len = CTL_MAXNAME;
|
|
if (::sysctlnametomib("sysctl.proc_cputype", mib, &mib_len))
|
|
return false;
|
|
|
|
mib[mib_len] = process_info.GetProcessID();
|
|
mib_len++;
|
|
|
|
cpu_type_t cpu, sub = 0;
|
|
size_t len = sizeof(cpu);
|
|
if (::sysctl (mib, mib_len, &cpu, &len, 0, 0) == 0)
|
|
{
|
|
switch (cpu)
|
|
{
|
|
case CPU_TYPE_I386: sub = CPU_SUBTYPE_I386_ALL; break;
|
|
case CPU_TYPE_X86_64: sub = CPU_SUBTYPE_X86_64_ALL; break;
|
|
|
|
#if defined (CPU_TYPE_ARM64) && defined (CPU_SUBTYPE_ARM64_ALL)
|
|
case CPU_TYPE_ARM64: sub = CPU_SUBTYPE_ARM64_ALL; break;
|
|
#endif
|
|
|
|
case CPU_TYPE_ARM:
|
|
{
|
|
// Note that we fetched the cpu type from the PROCESS but we can't get a cpusubtype of the
|
|
// process -- we can only get the host's cpu subtype.
|
|
uint32_t cpusubtype = 0;
|
|
len = sizeof(cpusubtype);
|
|
if (::sysctlbyname("hw.cpusubtype", &cpusubtype, &len, NULL, 0) == 0)
|
|
sub = cpusubtype;
|
|
|
|
bool host_cpu_is_64bit;
|
|
uint32_t is64bit_capable;
|
|
size_t is64bit_capable_len = sizeof (is64bit_capable);
|
|
if (sysctlbyname("hw.cpu64bit_capable", &is64bit_capable, &is64bit_capable_len, NULL, 0) == 0)
|
|
host_cpu_is_64bit = true;
|
|
else
|
|
host_cpu_is_64bit = false;
|
|
|
|
// if the host is an armv8 device, its cpusubtype will be in CPU_SUBTYPE_ARM64 numbering
|
|
// and we need to rewrite it to a reasonable CPU_SUBTYPE_ARM value instead.
|
|
|
|
if (host_cpu_is_64bit)
|
|
{
|
|
sub = CPU_SUBTYPE_ARM_V7;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
process_info.GetArchitecture ().SetArchitecture (eArchTypeMachO, cpu, sub);
|
|
return true;
|
|
}
|
|
}
|
|
process_info.GetArchitecture().Clear();
|
|
return false;
|
|
}
|
|
|
|
static bool
|
|
GetMacOSXProcessArgs (const ProcessInstanceInfoMatch *match_info_ptr,
|
|
ProcessInstanceInfo &process_info)
|
|
{
|
|
if (process_info.ProcessIDIsValid())
|
|
{
|
|
int proc_args_mib[3] = { CTL_KERN, KERN_PROCARGS2, (int)process_info.GetProcessID() };
|
|
|
|
size_t arg_data_size = 0;
|
|
if (::sysctl (proc_args_mib, 3, nullptr, &arg_data_size, NULL, 0) || arg_data_size == 0)
|
|
arg_data_size = 8192;
|
|
|
|
// Add a few bytes to the calculated length, I know we need to add at least one byte
|
|
// to this number otherwise we get junk back, so add 128 just in case...
|
|
DataBufferHeap arg_data(arg_data_size+128, 0);
|
|
arg_data_size = arg_data.GetByteSize();
|
|
if (::sysctl (proc_args_mib, 3, arg_data.GetBytes(), &arg_data_size , NULL, 0) == 0)
|
|
{
|
|
DataExtractor data (arg_data.GetBytes(), arg_data_size, lldb::endian::InlHostByteOrder(), sizeof(void *));
|
|
lldb::offset_t offset = 0;
|
|
uint32_t argc = data.GetU32 (&offset);
|
|
llvm::Triple &triple = process_info.GetArchitecture().GetTriple();
|
|
const llvm::Triple::ArchType triple_arch = triple.getArch();
|
|
const bool check_for_ios_simulator = (triple_arch == llvm::Triple::x86 || triple_arch == llvm::Triple::x86_64);
|
|
const char *cstr = data.GetCStr (&offset);
|
|
if (cstr)
|
|
{
|
|
process_info.GetExecutableFile().SetFile(cstr, false);
|
|
|
|
if (match_info_ptr == NULL ||
|
|
NameMatches (process_info.GetExecutableFile().GetFilename().GetCString(),
|
|
match_info_ptr->GetNameMatchType(),
|
|
match_info_ptr->GetProcessInfo().GetName()))
|
|
{
|
|
// Skip NULLs
|
|
while (1)
|
|
{
|
|
const uint8_t *p = data.PeekData(offset, 1);
|
|
if ((p == NULL) || (*p != '\0'))
|
|
break;
|
|
++offset;
|
|
}
|
|
// Now extract all arguments
|
|
Args &proc_args = process_info.GetArguments();
|
|
for (int i=0; i<static_cast<int>(argc); ++i)
|
|
{
|
|
cstr = data.GetCStr(&offset);
|
|
if (cstr)
|
|
proc_args.AppendArgument(cstr);
|
|
}
|
|
|
|
Args &proc_env = process_info.GetEnvironmentEntries ();
|
|
while ((cstr = data.GetCStr(&offset)))
|
|
{
|
|
if (cstr[0] == '\0')
|
|
break;
|
|
|
|
if (check_for_ios_simulator)
|
|
{
|
|
if (strncmp(cstr, "SIMULATOR_UDID=", strlen("SIMULATOR_UDID=")) == 0)
|
|
process_info.GetArchitecture().GetTriple().setOS(llvm::Triple::IOS);
|
|
else
|
|
process_info.GetArchitecture().GetTriple().setOS(llvm::Triple::MacOSX);
|
|
}
|
|
|
|
proc_env.AppendArgument(cstr);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool
|
|
GetMacOSXProcessUserAndGroup (ProcessInstanceInfo &process_info)
|
|
{
|
|
if (process_info.ProcessIDIsValid())
|
|
{
|
|
int mib[4];
|
|
mib[0] = CTL_KERN;
|
|
mib[1] = KERN_PROC;
|
|
mib[2] = KERN_PROC_PID;
|
|
mib[3] = process_info.GetProcessID();
|
|
struct kinfo_proc proc_kinfo;
|
|
size_t proc_kinfo_size = sizeof(struct kinfo_proc);
|
|
|
|
if (::sysctl (mib, 4, &proc_kinfo, &proc_kinfo_size, NULL, 0) == 0)
|
|
{
|
|
if (proc_kinfo_size > 0)
|
|
{
|
|
process_info.SetParentProcessID (proc_kinfo.kp_eproc.e_ppid);
|
|
process_info.SetUserID (proc_kinfo.kp_eproc.e_pcred.p_ruid);
|
|
process_info.SetGroupID (proc_kinfo.kp_eproc.e_pcred.p_rgid);
|
|
process_info.SetEffectiveUserID (proc_kinfo.kp_eproc.e_ucred.cr_uid);
|
|
if (proc_kinfo.kp_eproc.e_ucred.cr_ngroups > 0)
|
|
process_info.SetEffectiveGroupID (proc_kinfo.kp_eproc.e_ucred.cr_groups[0]);
|
|
else
|
|
process_info.SetEffectiveGroupID (UINT32_MAX);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
process_info.SetParentProcessID (LLDB_INVALID_PROCESS_ID);
|
|
process_info.SetUserID (UINT32_MAX);
|
|
process_info.SetGroupID (UINT32_MAX);
|
|
process_info.SetEffectiveUserID (UINT32_MAX);
|
|
process_info.SetEffectiveGroupID (UINT32_MAX);
|
|
return false;
|
|
}
|
|
|
|
|
|
uint32_t
|
|
Host::FindProcesses (const ProcessInstanceInfoMatch &match_info, ProcessInstanceInfoList &process_infos)
|
|
{
|
|
std::vector<struct kinfo_proc> kinfos;
|
|
|
|
int mib[3] = { CTL_KERN, KERN_PROC, KERN_PROC_ALL };
|
|
|
|
size_t pid_data_size = 0;
|
|
if (::sysctl (mib, 4, NULL, &pid_data_size, NULL, 0) != 0)
|
|
return 0;
|
|
|
|
// Add a few extra in case a few more show up
|
|
const size_t estimated_pid_count = (pid_data_size / sizeof(struct kinfo_proc)) + 10;
|
|
|
|
kinfos.resize (estimated_pid_count);
|
|
pid_data_size = kinfos.size() * sizeof(struct kinfo_proc);
|
|
|
|
if (::sysctl (mib, 4, &kinfos[0], &pid_data_size, NULL, 0) != 0)
|
|
return 0;
|
|
|
|
const size_t actual_pid_count = (pid_data_size / sizeof(struct kinfo_proc));
|
|
|
|
bool all_users = match_info.GetMatchAllUsers();
|
|
const lldb::pid_t our_pid = getpid();
|
|
const uid_t our_uid = getuid();
|
|
for (size_t i = 0; i < actual_pid_count; i++)
|
|
{
|
|
const struct kinfo_proc &kinfo = kinfos[i];
|
|
|
|
bool kinfo_user_matches = false;
|
|
if (all_users)
|
|
kinfo_user_matches = true;
|
|
else
|
|
kinfo_user_matches = kinfo.kp_eproc.e_pcred.p_ruid == our_uid;
|
|
|
|
// Special case, if lldb is being run as root we can attach to anything.
|
|
if (our_uid == 0)
|
|
kinfo_user_matches = true;
|
|
|
|
if (kinfo_user_matches == false || // Make sure the user is acceptable
|
|
static_cast<lldb::pid_t>(kinfo.kp_proc.p_pid) == our_pid || // Skip this process
|
|
kinfo.kp_proc.p_pid == 0 || // Skip kernel (kernel pid is zero)
|
|
kinfo.kp_proc.p_stat == SZOMB || // Zombies are bad, they like brains...
|
|
kinfo.kp_proc.p_flag & P_TRACED || // Being debugged?
|
|
kinfo.kp_proc.p_flag & P_WEXIT || // Working on exiting?
|
|
kinfo.kp_proc.p_flag & P_TRANSLATED) // Skip translated ppc (Rosetta)
|
|
continue;
|
|
|
|
ProcessInstanceInfo process_info;
|
|
process_info.SetProcessID (kinfo.kp_proc.p_pid);
|
|
process_info.SetParentProcessID (kinfo.kp_eproc.e_ppid);
|
|
process_info.SetUserID (kinfo.kp_eproc.e_pcred.p_ruid);
|
|
process_info.SetGroupID (kinfo.kp_eproc.e_pcred.p_rgid);
|
|
process_info.SetEffectiveUserID (kinfo.kp_eproc.e_ucred.cr_uid);
|
|
if (kinfo.kp_eproc.e_ucred.cr_ngroups > 0)
|
|
process_info.SetEffectiveGroupID (kinfo.kp_eproc.e_ucred.cr_groups[0]);
|
|
else
|
|
process_info.SetEffectiveGroupID (UINT32_MAX);
|
|
|
|
// Make sure our info matches before we go fetch the name and cpu type
|
|
if (match_info.Matches (process_info))
|
|
{
|
|
// Get CPU type first so we can know to look for iOS simulator is we have x86 or x86_64
|
|
if (GetMacOSXProcessCPUType (process_info))
|
|
{
|
|
if (GetMacOSXProcessArgs (&match_info, process_info))
|
|
{
|
|
if (match_info.Matches (process_info))
|
|
process_infos.Append (process_info);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return process_infos.GetSize();
|
|
}
|
|
|
|
bool
|
|
Host::GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info)
|
|
{
|
|
process_info.SetProcessID(pid);
|
|
bool success = false;
|
|
|
|
// Get CPU type first so we can know to look for iOS simulator is we have x86 or x86_64
|
|
if (GetMacOSXProcessCPUType (process_info))
|
|
success = true;
|
|
|
|
if (GetMacOSXProcessArgs (NULL, process_info))
|
|
success = true;
|
|
|
|
if (GetMacOSXProcessUserAndGroup (process_info))
|
|
success = true;
|
|
|
|
if (success)
|
|
return true;
|
|
|
|
process_info.Clear();
|
|
return false;
|
|
}
|
|
|
|
#if !NO_XPC_SERVICES
|
|
static void
|
|
PackageXPCArguments (xpc_object_t message, const char *prefix, const Args& args)
|
|
{
|
|
size_t count = args.GetArgumentCount();
|
|
char buf[50]; // long enough for 'argXXX'
|
|
memset(buf, 0, 50);
|
|
sprintf(buf, "%sCount", prefix);
|
|
xpc_dictionary_set_int64(message, buf, count);
|
|
for (size_t i=0; i<count; i++) {
|
|
memset(buf, 0, 50);
|
|
sprintf(buf, "%s%zi", prefix, i);
|
|
xpc_dictionary_set_string(message, buf, args.GetArgumentAtIndex(i));
|
|
}
|
|
}
|
|
|
|
/*
|
|
A valid authorizationRef means that
|
|
- there is the LaunchUsingXPCRightName rights in the /etc/authorization
|
|
- we have successfully copied the rights to be send over the XPC wire
|
|
Once obtained, it will be valid for as long as the process lives.
|
|
*/
|
|
static AuthorizationRef authorizationRef = NULL;
|
|
static Error
|
|
getXPCAuthorization (ProcessLaunchInfo &launch_info)
|
|
{
|
|
Error error;
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_HOST | LIBLLDB_LOG_PROCESS));
|
|
|
|
if ((launch_info.GetUserID() == 0) && !authorizationRef)
|
|
{
|
|
OSStatus createStatus = AuthorizationCreate(NULL, kAuthorizationEmptyEnvironment, kAuthorizationFlagDefaults, &authorizationRef);
|
|
if (createStatus != errAuthorizationSuccess)
|
|
{
|
|
error.SetError(1, eErrorTypeGeneric);
|
|
error.SetErrorString("Can't create authorizationRef.");
|
|
if (log)
|
|
{
|
|
error.PutToLog(log, "%s", error.AsCString());
|
|
}
|
|
return error;
|
|
}
|
|
|
|
OSStatus rightsStatus = AuthorizationRightGet(LaunchUsingXPCRightName, NULL);
|
|
if (rightsStatus != errAuthorizationSuccess)
|
|
{
|
|
// No rights in the security database, Create it with the right prompt.
|
|
CFStringRef prompt = CFSTR("Xcode is trying to take control of a root process.");
|
|
CFStringRef keys[] = { CFSTR("en") };
|
|
CFTypeRef values[] = { prompt };
|
|
CFDictionaryRef promptDict = CFDictionaryCreate(kCFAllocatorDefault, (const void **)keys, (const void **)values, 1, &kCFCopyStringDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
|
|
|
|
CFStringRef keys1[] = { CFSTR("class"), CFSTR("group"), CFSTR("comment"), CFSTR("default-prompt"), CFSTR("shared") };
|
|
CFTypeRef values1[] = { CFSTR("user"), CFSTR("admin"), CFSTR(LaunchUsingXPCRightName), promptDict, kCFBooleanFalse };
|
|
CFDictionaryRef dict = CFDictionaryCreate(kCFAllocatorDefault, (const void **)keys1, (const void **)values1, 5, &kCFCopyStringDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
|
|
rightsStatus = AuthorizationRightSet(authorizationRef, LaunchUsingXPCRightName, dict, NULL, NULL, NULL);
|
|
CFRelease(promptDict);
|
|
CFRelease(dict);
|
|
}
|
|
|
|
OSStatus copyRightStatus = errAuthorizationDenied;
|
|
if (rightsStatus == errAuthorizationSuccess)
|
|
{
|
|
AuthorizationItem item1 = { LaunchUsingXPCRightName, 0, NULL, 0 };
|
|
AuthorizationItem items[] = {item1};
|
|
AuthorizationRights requestedRights = {1, items };
|
|
AuthorizationFlags authorizationFlags = kAuthorizationFlagInteractionAllowed | kAuthorizationFlagExtendRights;
|
|
copyRightStatus = AuthorizationCopyRights(authorizationRef, &requestedRights, kAuthorizationEmptyEnvironment, authorizationFlags, NULL);
|
|
}
|
|
|
|
if (copyRightStatus != errAuthorizationSuccess)
|
|
{
|
|
// Eventually when the commandline supports running as root and the user is not
|
|
// logged in in the current audit session, we will need the trick in gdb where
|
|
// we ask the user to type in the root passwd in the terminal.
|
|
error.SetError(2, eErrorTypeGeneric);
|
|
error.SetErrorStringWithFormat("Launching as root needs root authorization.");
|
|
if (log)
|
|
{
|
|
error.PutToLog(log, "%s", error.AsCString());
|
|
}
|
|
|
|
if (authorizationRef)
|
|
{
|
|
AuthorizationFree(authorizationRef, kAuthorizationFlagDefaults);
|
|
authorizationRef = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
return error;
|
|
}
|
|
#endif
|
|
|
|
static Error
|
|
LaunchProcessXPC(const char *exe_path, ProcessLaunchInfo &launch_info, lldb::pid_t &pid)
|
|
{
|
|
#if !NO_XPC_SERVICES
|
|
Error error = getXPCAuthorization(launch_info);
|
|
if (error.Fail())
|
|
return error;
|
|
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_HOST | LIBLLDB_LOG_PROCESS));
|
|
|
|
uid_t requested_uid = launch_info.GetUserID();
|
|
const char *xpc_service = nil;
|
|
bool send_auth = false;
|
|
AuthorizationExternalForm extForm;
|
|
if ((requested_uid == UINT32_MAX) || (requested_uid == HostInfo::GetEffectiveUserID()))
|
|
{
|
|
xpc_service = "com.apple.lldb.launcherXPCService";
|
|
}
|
|
else if (requested_uid == 0)
|
|
{
|
|
if (AuthorizationMakeExternalForm(authorizationRef, &extForm) == errAuthorizationSuccess)
|
|
{
|
|
send_auth = true;
|
|
}
|
|
else
|
|
{
|
|
error.SetError(3, eErrorTypeGeneric);
|
|
error.SetErrorStringWithFormat("Launching root via XPC needs to externalize authorization reference.");
|
|
if (log)
|
|
{
|
|
error.PutToLog(log, "%s", error.AsCString());
|
|
}
|
|
return error;
|
|
}
|
|
xpc_service = "com.apple.lldb.launcherRootXPCService";
|
|
}
|
|
else
|
|
{
|
|
error.SetError(4, eErrorTypeGeneric);
|
|
error.SetErrorStringWithFormat("Launching via XPC is only currently available for either the login user or root.");
|
|
if (log)
|
|
{
|
|
error.PutToLog(log, "%s", error.AsCString());
|
|
}
|
|
return error;
|
|
}
|
|
|
|
xpc_connection_t conn = xpc_connection_create(xpc_service, NULL);
|
|
|
|
xpc_connection_set_event_handler(conn, ^(xpc_object_t event) {
|
|
xpc_type_t type = xpc_get_type(event);
|
|
|
|
if (type == XPC_TYPE_ERROR) {
|
|
if (event == XPC_ERROR_CONNECTION_INTERRUPTED) {
|
|
// The service has either canceled itself, crashed, or been terminated.
|
|
// The XPC connection is still valid and sending a message to it will re-launch the service.
|
|
// If the service is state-full, this is the time to initialize the new service.
|
|
return;
|
|
} else if (event == XPC_ERROR_CONNECTION_INVALID) {
|
|
// The service is invalid. Either the service name supplied to xpc_connection_create() is incorrect
|
|
// or we (this process) have canceled the service; we can do any cleanup of application state at this point.
|
|
// printf("Service disconnected");
|
|
return;
|
|
} else {
|
|
// printf("Unexpected error from service: %s", xpc_dictionary_get_string(event, XPC_ERROR_KEY_DESCRIPTION));
|
|
}
|
|
|
|
} else {
|
|
// printf("Received unexpected event in handler");
|
|
}
|
|
});
|
|
|
|
xpc_connection_set_finalizer_f (conn, xpc_finalizer_t(xpc_release));
|
|
xpc_connection_resume (conn);
|
|
xpc_object_t message = xpc_dictionary_create (nil, nil, 0);
|
|
|
|
if (send_auth)
|
|
{
|
|
xpc_dictionary_set_data(message, LauncherXPCServiceAuthKey, extForm.bytes, sizeof(AuthorizationExternalForm));
|
|
}
|
|
|
|
PackageXPCArguments(message, LauncherXPCServiceArgPrefxKey, launch_info.GetArguments());
|
|
PackageXPCArguments(message, LauncherXPCServiceEnvPrefxKey, launch_info.GetEnvironmentEntries());
|
|
|
|
// Posix spawn stuff.
|
|
xpc_dictionary_set_int64(message, LauncherXPCServiceCPUTypeKey, launch_info.GetArchitecture().GetMachOCPUType());
|
|
xpc_dictionary_set_int64(message, LauncherXPCServicePosixspawnFlagsKey, Host::GetPosixspawnFlags(launch_info));
|
|
const FileAction *file_action = launch_info.GetFileActionForFD(STDIN_FILENO);
|
|
if (file_action && file_action->GetPath())
|
|
{
|
|
xpc_dictionary_set_string(message, LauncherXPCServiceStdInPathKeyKey, file_action->GetPath());
|
|
}
|
|
file_action = launch_info.GetFileActionForFD(STDOUT_FILENO);
|
|
if (file_action && file_action->GetPath())
|
|
{
|
|
xpc_dictionary_set_string(message, LauncherXPCServiceStdOutPathKeyKey, file_action->GetPath());
|
|
}
|
|
file_action = launch_info.GetFileActionForFD(STDERR_FILENO);
|
|
if (file_action && file_action->GetPath())
|
|
{
|
|
xpc_dictionary_set_string(message, LauncherXPCServiceStdErrPathKeyKey, file_action->GetPath());
|
|
}
|
|
|
|
xpc_object_t reply = xpc_connection_send_message_with_reply_sync(conn, message);
|
|
xpc_type_t returnType = xpc_get_type(reply);
|
|
if (returnType == XPC_TYPE_DICTIONARY)
|
|
{
|
|
pid = xpc_dictionary_get_int64(reply, LauncherXPCServiceChildPIDKey);
|
|
if (pid == 0)
|
|
{
|
|
int errorType = xpc_dictionary_get_int64(reply, LauncherXPCServiceErrorTypeKey);
|
|
int errorCode = xpc_dictionary_get_int64(reply, LauncherXPCServiceCodeTypeKey);
|
|
|
|
error.SetError(errorCode, eErrorTypeGeneric);
|
|
error.SetErrorStringWithFormat("Problems with launching via XPC. Error type : %i, code : %i", errorType, errorCode);
|
|
if (log)
|
|
{
|
|
error.PutToLog(log, "%s", error.AsCString());
|
|
}
|
|
|
|
if (authorizationRef)
|
|
{
|
|
AuthorizationFree(authorizationRef, kAuthorizationFlagDefaults);
|
|
authorizationRef = NULL;
|
|
}
|
|
}
|
|
}
|
|
else if (returnType == XPC_TYPE_ERROR)
|
|
{
|
|
error.SetError(5, eErrorTypeGeneric);
|
|
error.SetErrorStringWithFormat("Problems with launching via XPC. XPC error : %s", xpc_dictionary_get_string(reply, XPC_ERROR_KEY_DESCRIPTION));
|
|
if (log)
|
|
{
|
|
error.PutToLog(log, "%s", error.AsCString());
|
|
}
|
|
}
|
|
|
|
return error;
|
|
#else
|
|
Error error;
|
|
return error;
|
|
#endif
|
|
}
|
|
|
|
static bool
|
|
ShouldLaunchUsingXPC(ProcessLaunchInfo &launch_info)
|
|
{
|
|
bool result = false;
|
|
|
|
#if !NO_XPC_SERVICES
|
|
bool launchingAsRoot = launch_info.GetUserID() == 0;
|
|
bool currentUserIsRoot = HostInfo::GetEffectiveUserID() == 0;
|
|
|
|
if (launchingAsRoot && !currentUserIsRoot)
|
|
{
|
|
// If current user is already root, we don't need XPC's help.
|
|
result = true;
|
|
}
|
|
#endif
|
|
|
|
return result;
|
|
}
|
|
|
|
Error
|
|
Host::LaunchProcess (ProcessLaunchInfo &launch_info)
|
|
{
|
|
Error error;
|
|
char exe_path[PATH_MAX];
|
|
PlatformSP host_platform_sp (Platform::GetHostPlatform ());
|
|
|
|
ModuleSpec exe_module_spec(launch_info.GetExecutableFile(), launch_info.GetArchitecture());
|
|
|
|
FileSpec::FileType file_type = exe_module_spec.GetFileSpec().GetFileType();
|
|
if (file_type != FileSpec::eFileTypeRegular)
|
|
{
|
|
lldb::ModuleSP exe_module_sp;
|
|
error = host_platform_sp->ResolveExecutable (exe_module_spec,
|
|
exe_module_sp,
|
|
NULL);
|
|
|
|
if (error.Fail())
|
|
return error;
|
|
|
|
if (exe_module_sp)
|
|
exe_module_spec.GetFileSpec() = exe_module_sp->GetFileSpec();
|
|
}
|
|
|
|
if (exe_module_spec.GetFileSpec().Exists())
|
|
{
|
|
exe_module_spec.GetFileSpec().GetPath (exe_path, sizeof(exe_path));
|
|
}
|
|
else
|
|
{
|
|
launch_info.GetExecutableFile().GetPath (exe_path, sizeof(exe_path));
|
|
error.SetErrorStringWithFormat ("executable doesn't exist: '%s'", exe_path);
|
|
return error;
|
|
}
|
|
|
|
if (launch_info.GetFlags().Test (eLaunchFlagLaunchInTTY))
|
|
{
|
|
#if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__)
|
|
return LaunchInNewTerminalWithAppleScript (exe_path, launch_info);
|
|
#else
|
|
error.SetErrorString ("launching a process in a new terminal is not supported on iOS devices");
|
|
return error;
|
|
#endif
|
|
}
|
|
|
|
lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
|
|
|
|
if (ShouldLaunchUsingXPC(launch_info))
|
|
{
|
|
error = LaunchProcessXPC(exe_path, launch_info, pid);
|
|
}
|
|
else
|
|
{
|
|
error = LaunchProcessPosixSpawn(exe_path, launch_info, pid);
|
|
}
|
|
|
|
if (pid != LLDB_INVALID_PROCESS_ID)
|
|
{
|
|
// If all went well, then set the process ID into the launch info
|
|
launch_info.SetProcessID(pid);
|
|
|
|
// Make sure we reap any processes we spawn or we will have zombies.
|
|
if (!launch_info.MonitorProcess())
|
|
{
|
|
const bool monitor_signals = false;
|
|
Host::MonitorChildProcessCallback callback = nullptr;
|
|
|
|
if (!launch_info.GetFlags().Test(lldb::eLaunchFlagDontSetExitStatus))
|
|
callback = Process::SetProcessExitStatus;
|
|
|
|
StartMonitoringChildProcess (callback,
|
|
NULL,
|
|
pid,
|
|
monitor_signals);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Invalid process ID, something didn't go well
|
|
if (error.Success())
|
|
error.SetErrorString ("process launch failed for unknown reasons");
|
|
}
|
|
return error;
|
|
}
|
|
|
|
Error
|
|
Host::ShellExpandArguments (ProcessLaunchInfo &launch_info)
|
|
{
|
|
Error error;
|
|
if (launch_info.GetFlags().Test(eLaunchFlagShellExpandArguments))
|
|
{
|
|
FileSpec expand_tool_spec;
|
|
if (!HostInfo::GetLLDBPath(lldb::ePathTypeSupportExecutableDir, expand_tool_spec))
|
|
{
|
|
error.SetErrorString("could not find argdumper tool");
|
|
return error;
|
|
}
|
|
expand_tool_spec.AppendPathComponent("argdumper");
|
|
if (!expand_tool_spec.Exists())
|
|
{
|
|
error.SetErrorString("could not find argdumper tool");
|
|
return error;
|
|
}
|
|
|
|
Args expand_command(expand_tool_spec.GetPath().c_str());
|
|
expand_command.AppendArguments (launch_info.GetArguments());
|
|
|
|
int status;
|
|
std::string output;
|
|
RunShellCommand(expand_command, launch_info.GetWorkingDirectory(), &status, nullptr, &output, 10);
|
|
|
|
if (status != 0)
|
|
{
|
|
error.SetErrorStringWithFormat("argdumper exited with error %d", status);
|
|
return error;
|
|
}
|
|
|
|
auto data_sp = StructuredData::ParseJSON(output);
|
|
if (!data_sp)
|
|
{
|
|
error.SetErrorString("invalid JSON");
|
|
return error;
|
|
}
|
|
|
|
auto dict_sp = data_sp->GetAsDictionary();
|
|
if (!data_sp)
|
|
{
|
|
error.SetErrorString("invalid JSON");
|
|
return error;
|
|
}
|
|
|
|
auto args_sp = dict_sp->GetObjectForDotSeparatedPath("arguments");
|
|
if (!args_sp)
|
|
{
|
|
error.SetErrorString("invalid JSON");
|
|
return error;
|
|
}
|
|
|
|
auto args_array_sp = args_sp->GetAsArray();
|
|
if (!args_array_sp)
|
|
{
|
|
error.SetErrorString("invalid JSON");
|
|
return error;
|
|
}
|
|
|
|
launch_info.GetArguments().Clear();
|
|
|
|
for (size_t i = 0;
|
|
i < args_array_sp->GetSize();
|
|
i++)
|
|
{
|
|
auto item_sp = args_array_sp->GetItemAtIndex(i);
|
|
if (!item_sp)
|
|
continue;
|
|
auto str_sp = item_sp->GetAsString();
|
|
if (!str_sp)
|
|
continue;
|
|
|
|
launch_info.GetArguments().AppendArgument(str_sp->GetValue().c_str());
|
|
}
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
HostThread
|
|
Host::StartMonitoringChildProcess(Host::MonitorChildProcessCallback callback, void *callback_baton, lldb::pid_t pid, bool monitor_signals)
|
|
{
|
|
unsigned long mask = DISPATCH_PROC_EXIT;
|
|
if (monitor_signals)
|
|
mask |= DISPATCH_PROC_SIGNAL;
|
|
|
|
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_HOST | LIBLLDB_LOG_PROCESS));
|
|
|
|
|
|
dispatch_source_t source = ::dispatch_source_create (DISPATCH_SOURCE_TYPE_PROC,
|
|
pid,
|
|
mask,
|
|
::dispatch_get_global_queue (DISPATCH_QUEUE_PRIORITY_DEFAULT,0));
|
|
|
|
if (log)
|
|
log->Printf ("Host::StartMonitoringChildProcess (callback=%p, baton=%p, pid=%i, monitor_signals=%i) source = %p\n",
|
|
callback,
|
|
callback_baton,
|
|
(int)pid,
|
|
monitor_signals,
|
|
source);
|
|
|
|
if (source)
|
|
{
|
|
::dispatch_source_set_cancel_handler (source, ^{
|
|
::dispatch_release (source);
|
|
});
|
|
::dispatch_source_set_event_handler (source, ^{
|
|
|
|
int status= 0;
|
|
int wait_pid = 0;
|
|
bool cancel = false;
|
|
bool exited = false;
|
|
do
|
|
{
|
|
wait_pid = ::waitpid (pid, &status, 0);
|
|
} while (wait_pid < 0 && errno == EINTR);
|
|
|
|
if (wait_pid >= 0)
|
|
{
|
|
int signal = 0;
|
|
int exit_status = 0;
|
|
const char *status_cstr = NULL;
|
|
if (WIFSTOPPED(status))
|
|
{
|
|
signal = WSTOPSIG(status);
|
|
status_cstr = "STOPPED";
|
|
}
|
|
else if (WIFEXITED(status))
|
|
{
|
|
exit_status = WEXITSTATUS(status);
|
|
status_cstr = "EXITED";
|
|
exited = true;
|
|
}
|
|
else if (WIFSIGNALED(status))
|
|
{
|
|
signal = WTERMSIG(status);
|
|
status_cstr = "SIGNALED";
|
|
exited = true;
|
|
exit_status = -1;
|
|
}
|
|
else
|
|
{
|
|
status_cstr = "???";
|
|
}
|
|
|
|
if (log)
|
|
log->Printf ("::waitpid (pid = %llu, &status, 0) => pid = %i, status = 0x%8.8x (%s), signal = %i, exit_status = %i",
|
|
pid,
|
|
wait_pid,
|
|
status,
|
|
status_cstr,
|
|
signal,
|
|
exit_status);
|
|
|
|
if (callback)
|
|
cancel = callback (callback_baton, pid, exited, signal, exit_status);
|
|
|
|
if (exited || cancel)
|
|
{
|
|
::dispatch_source_cancel(source);
|
|
}
|
|
}
|
|
});
|
|
|
|
::dispatch_resume (source);
|
|
}
|
|
return HostThread();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Log to both stderr and to ASL Logging when running on MacOSX.
|
|
//----------------------------------------------------------------------
|
|
void
|
|
Host::SystemLog (SystemLogType type, const char *format, va_list args)
|
|
{
|
|
if (format && format[0])
|
|
{
|
|
static aslmsg g_aslmsg = NULL;
|
|
if (g_aslmsg == NULL)
|
|
{
|
|
g_aslmsg = ::asl_new (ASL_TYPE_MSG);
|
|
char asl_key_sender[PATH_MAX];
|
|
snprintf(asl_key_sender, sizeof(asl_key_sender), "com.apple.LLDB.framework");
|
|
::asl_set (g_aslmsg, ASL_KEY_SENDER, asl_key_sender);
|
|
}
|
|
|
|
// Copy the va_list so we can log this message twice
|
|
va_list copy_args;
|
|
va_copy (copy_args, args);
|
|
// Log to stderr
|
|
::vfprintf (stderr, format, copy_args);
|
|
va_end (copy_args);
|
|
|
|
int asl_level;
|
|
switch (type)
|
|
{
|
|
case eSystemLogError:
|
|
asl_level = ASL_LEVEL_ERR;
|
|
break;
|
|
|
|
case eSystemLogWarning:
|
|
asl_level = ASL_LEVEL_WARNING;
|
|
break;
|
|
}
|
|
|
|
// Log to ASL
|
|
::asl_vlog (NULL, g_aslmsg, asl_level, format, args);
|
|
}
|
|
}
|
|
|
|
lldb::DataBufferSP
|
|
Host::GetAuxvData(lldb_private::Process *process)
|
|
{
|
|
return lldb::DataBufferSP();
|
|
}
|