#if defined (__APPLE__)
#include <getopt.h>
#include <limits.h>
#include <mach/machine.h>
#include <signal.h>
#include <spawn.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/un.h>
#include <string>
#ifndef _POSIX_SPAWN_DISABLE_ASLR
#define _POSIX_SPAWN_DISABLE_ASLR 0x0100
#endif
#define streq(a,b) strcmp(a,b) == 0
static struct option g_long_options[] =
{
{ "arch", required_argument, NULL, 'a' },
{ "disable-aslr", no_argument, NULL, 'd' },
{ "no-env", no_argument, NULL, 'e' },
{ "help", no_argument, NULL, 'h' },
{ "setsid", no_argument, NULL, 's' },
{ "unix-socket", required_argument, NULL, 'u' },
{ "working-dir", required_argument, NULL, 'w' },
{ NULL, 0, NULL, 0 }
};
static void
usage()
{
puts (
"NAME\n"
" darwin-debug -- posix spawn a process that is stopped at the entry point\n"
" for debugging.\n"
"\n"
"SYNOPSIS\n"
" darwin-debug --unix-socket=<SOCKET> [--arch=<ARCH>] [--working-dir=<PATH>] [--disable-aslr] [--no-env] [--setsid] [--help] -- <PROGRAM> [<PROGRAM-ARG> <PROGRAM-ARG> ....]\n"
"\n"
"DESCRIPTION\n"
" darwin-debug will exec itself into a child process <PROGRAM> that is\n"
" halted for debugging. It does this by using posix_spawn() along with\n"
" darwin specific posix_spawn flags that allows exec only (no fork), and\n"
" stop at the program entry point. Any program arguments <PROGRAM-ARG> are\n"
" passed on to the exec as the arguments for the new process. The current\n"
" environment will be passed to the new process unless the \"--no-env\"\n"
" option is used. A unix socket must be supplied using the\n"
" --unix-socket=<SOCKET> option so the calling program can handshake with\n"
" this process and get its process id.\n"
"\n"
"EXAMPLE\n"
" darwin-debug --arch=i386 -- /bin/ls -al /tmp\n"
);
exit (1);
}
static void
exit_with_errno (int err, const char *prefix)
{
if (err)
{
fprintf (stderr,
"%s%s",
prefix ? prefix : "",
strerror(err));
exit (err);
}
}
pid_t
posix_spawn_for_debug
(
char *const *argv,
char *const *envp,
const char *working_dir,
cpu_type_t cpu_type,
int disable_aslr)
{
pid_t pid = 0;
const char *path = argv[0];
posix_spawnattr_t attr;
exit_with_errno (::posix_spawnattr_init (&attr), "::posix_spawnattr_init (&attr) error: ");
short flags = POSIX_SPAWN_START_SUSPENDED | POSIX_SPAWN_SETEXEC | POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK;
if (disable_aslr)
flags |= _POSIX_SPAWN_DISABLE_ASLR;
sigset_t no_signals;
sigset_t all_signals;
sigemptyset (&no_signals);
sigfillset (&all_signals);
::posix_spawnattr_setsigmask(&attr, &no_signals);
::posix_spawnattr_setsigdefault(&attr, &all_signals);
exit_with_errno (::posix_spawnattr_setflags (&attr, flags), "::posix_spawnattr_setflags (&attr, flags) error: ");
if (cpu_type != 0)
{
size_t ocount = 0;
exit_with_errno (::posix_spawnattr_setbinpref_np (&attr, 1, &cpu_type, &ocount), "posix_spawnattr_setbinpref_np () error: ");
}
if (working_dir)
::chdir (working_dir);
exit_with_errno (::posix_spawnp (&pid, path, NULL, &attr, (char * const*)argv, (char * const*)envp), "posix_spawn() error: ");
::posix_spawnattr_destroy (&attr);
return pid;
}
int main (int argc, char *const *argv, char *const *envp, const char **apple)
{
#if defined (DEBUG_LLDB_LAUNCHER)
const char *program_name = strrchr(apple[0], '/');
if (program_name)
program_name++; else
program_name = apple[0];
printf("%s called with:\n", program_name);
for (int i=0; i<argc; ++i)
printf("argv[%u] = '%s'\n", i, argv[i]);
#endif
cpu_type_t cpu_type = 0;
bool show_usage = false;
int ch;
int disable_aslr = 0; int pass_env = 1;
std::string unix_socket_name;
std::string working_dir;
while ((ch = getopt_long(argc, argv, "a:dehsu:?", g_long_options, NULL)) != -1)
{
switch (ch)
{
case 0:
break;
case 'a': if (optarg)
{
if (streq (optarg, "i386"))
cpu_type = CPU_TYPE_I386;
else if (streq (optarg, "x86_64"))
cpu_type = CPU_TYPE_X86_64;
else if (strstr (optarg, "arm") == optarg)
cpu_type = CPU_TYPE_ARM;
else
{
::fprintf (stderr, "error: unsupported cpu type '%s'\n", optarg);
::exit (1);
}
}
break;
case 'd':
disable_aslr = 1;
break;
case 'e':
pass_env = 0;
break;
case 's':
::setsid();
break;
case 'u':
unix_socket_name.assign (optarg);
break;
case 'w':
{
struct stat working_dir_stat;
if (stat (optarg, &working_dir_stat) == 0)
working_dir.assign (optarg);
else
::fprintf(stderr, "warning: working directory doesn't exist: '%s'\n", optarg);
}
break;
case 'h':
case '?':
default:
show_usage = true;
break;
}
}
argc -= optind;
argv += optind;
if (show_usage || argc <= 0 || unix_socket_name.empty())
usage();
#if defined (DEBUG_LLDB_LAUNCHER)
printf ("\n%s post options:\n", program_name);
for (int i=0; i<argc; ++i)
printf ("argv[%u] = '%s'\n", i, argv[i]);
#endif
struct sockaddr_un saddr_un;
int s = ::socket (AF_UNIX, SOCK_STREAM, 0);
if (s < 0)
{
perror("error: socket (AF_UNIX, SOCK_STREAM, 0)");
exit(1);
}
saddr_un.sun_family = AF_UNIX;
::strncpy(saddr_un.sun_path, unix_socket_name.c_str(), sizeof(saddr_un.sun_path) - 1);
saddr_un.sun_path[sizeof(saddr_un.sun_path) - 1] = '\0';
saddr_un.sun_len = SUN_LEN (&saddr_un);
if (::connect (s, (struct sockaddr *)&saddr_un, SUN_LEN (&saddr_un)) < 0)
{
perror("error: connect (socket, &saddr_un, saddr_un_len)");
exit(1);
}
char pid_str[64];
const int pid_str_len = ::snprintf (pid_str, sizeof(pid_str), "%i", ::getpid());
const int bytes_sent = ::send (s, pid_str, pid_str_len, 0);
if (pid_str_len != bytes_sent)
{
perror("error: send (s, pid_str, pid_str_len, 0)");
exit (1);
}
close (s);
system("clear");
printf ("Launching: '%s'\n", argv[0]);
if (working_dir.empty())
{
char cwd[PATH_MAX];
const char *cwd_ptr = getcwd(cwd, sizeof(cwd));
printf ("Working directory: '%s'\n", cwd_ptr);
}
else
{
printf ("Working directory: '%s'\n", working_dir.c_str());
}
printf ("%i arguments:\n", argc);
for (int i=0; i<argc; ++i)
printf ("argv[%u] = '%s'\n", i, argv[i]);
posix_spawn_for_debug (argv,
pass_env ? envp : NULL,
working_dir.empty() ? NULL : working_dir.c_str(),
cpu_type,
disable_aslr);
return 0;
}
#endif // #if defined (__APPLE__)