858 lines
31 KiB
C
858 lines
31 KiB
C
//TODO: don't copy/mount DeveloperDiskImage.dmg if it's already done - Xcode checks this somehow
|
|
|
|
#import <CoreFoundation/CoreFoundation.h>
|
|
#include <unistd.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/un.h>
|
|
#include <sys/sysctl.h>
|
|
#include <stdio.h>
|
|
#include <signal.h>
|
|
#include <getopt.h>
|
|
#include <pwd.h>
|
|
#include <netinet/in.h>
|
|
#include <netinet/tcp.h>
|
|
#include "MobileDevice.h"
|
|
|
|
#define APP_VERSION "1.0.4"
|
|
#define PREP_CMDS_PATH "/tmp/fruitstrap-lldb-prep-cmds-"
|
|
#define LLDB_SHELL "python -u -c \"import time; time.sleep(0.5); print 'run'; time.sleep(2000000)\" | lldb -s " PREP_CMDS_PATH
|
|
|
|
/*
|
|
* Startup script passed to lldb.
|
|
* To see how xcode interacts with lldb, put this into .lldbinit:
|
|
* log enable -v -f /Users/vargaz/lldb.log lldb all
|
|
* log enable -v -f /Users/vargaz/gdb-remote.log gdb-remote all
|
|
*/
|
|
#define LLDB_PREP_CMDS CFSTR("\
|
|
platform select remote-ios --sysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/DeviceSupport/*\n\
|
|
target create \"{disk_app}\"\n\
|
|
script fruitstrap_device_app=\"{device_app}\"\n\
|
|
script fruitstrap_connect_url=\"connect://127.0.0.1:12345\"\n\
|
|
script fruitstrap_handle_command=\"command script add -s asynchronous -f {python_command}.fsrun_command run\"\n\
|
|
command script import \"{python_file_path}\"\n\
|
|
")
|
|
|
|
/*
|
|
* Some things do not seem to work when using the normal commands like process connect/launch, so we invoke them
|
|
* through the python interface. Also, Launch () doesn't seem to work when ran from init_module (), so we add
|
|
* a command which can be used by the user to run it.
|
|
*/
|
|
#define LLDB_FRUITSTRAP_MODULE CFSTR("\
|
|
import lldb\n\
|
|
\n\
|
|
def __lldb_init_module(debugger, internal_dict):\n\
|
|
# These two are passed in by the script which loads us\n\
|
|
device_app=internal_dict['fruitstrap_device_app']\n\
|
|
connect_url=internal_dict['fruitstrap_connect_url']\n\
|
|
handle_command = internal_dict['fruitstrap_handle_command']\n\
|
|
lldb.target.modules[0].SetPlatformFileSpec(lldb.SBFileSpec(device_app))\n\
|
|
lldb.debugger.HandleCommand(handle_command)\n\
|
|
error=lldb.SBError()\n\
|
|
lldb.target.ConnectRemote(lldb.target.GetDebugger().GetListener(),connect_url,None,error)\n\
|
|
\n\
|
|
def fsrun_command(debugger, command, result, internal_dict):\n\
|
|
error=lldb.SBError()\n\
|
|
lldb.target.Launch(lldb.SBLaunchInfo(['{args}']),error)\n\
|
|
print str(error)\n\
|
|
")
|
|
|
|
typedef struct am_device * AMDeviceRef;
|
|
int AMDeviceSecureTransferPath(int zero, AMDeviceRef device, CFURLRef url, CFDictionaryRef options, void *callback, int cbarg);
|
|
int AMDeviceSecureInstallApplication(int zero, AMDeviceRef device, CFURLRef url, CFDictionaryRef options, void *callback, int cbarg);
|
|
int AMDeviceMountImage(AMDeviceRef device, CFStringRef image, CFDictionaryRef options, void *callback, int cbarg);
|
|
int AMDeviceLookupApplications(AMDeviceRef device, int zero, CFDictionaryRef* result);
|
|
|
|
bool found_device = false, debug = false, verbose = false, unbuffered = false, nostart = false, detect_only = false, install = true;
|
|
char *app_path = NULL;
|
|
char *device_id = NULL;
|
|
char *args = NULL;
|
|
int timeout = 0;
|
|
CFStringRef last_path = NULL;
|
|
service_conn_t gdbfd;
|
|
pid_t parent = 0;
|
|
|
|
Boolean path_exists(CFTypeRef path) {
|
|
if (CFGetTypeID(path) == CFStringGetTypeID()) {
|
|
CFURLRef url = CFURLCreateWithFileSystemPath(NULL, path, kCFURLPOSIXPathStyle, true);
|
|
Boolean result = CFURLResourceIsReachable(url, NULL);
|
|
CFRelease(url);
|
|
return result;
|
|
} else if (CFGetTypeID(path) == CFURLGetTypeID()) {
|
|
return CFURLResourceIsReachable(path, NULL);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
CFStringRef find_path(CFStringRef rootPath, CFStringRef namePattern, CFStringRef expression) {
|
|
FILE *fpipe = NULL;
|
|
CFStringRef quotedRootPath = rootPath;
|
|
if (CFStringGetCharacterAtIndex(rootPath, 0) != '`') {
|
|
quotedRootPath = CFStringCreateWithFormat(NULL, NULL, CFSTR("'%@'"), rootPath);
|
|
}
|
|
CFStringRef cf_command = CFStringCreateWithFormat(NULL, NULL, CFSTR("find %@ -name '%@' %@ 2>/dev/null | sort | tail -n 1"), quotedRootPath, namePattern, expression);
|
|
if (quotedRootPath != rootPath) {
|
|
CFRelease(quotedRootPath);
|
|
}
|
|
|
|
char command[1024] = { '\0' };
|
|
CFStringGetCString(cf_command, command, sizeof(command), kCFStringEncodingUTF8);
|
|
CFRelease(cf_command);
|
|
|
|
if (!(fpipe = (FILE *)popen(command, "r")))
|
|
{
|
|
perror("Error encountered while opening pipe");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
char buffer[256] = { '\0' };
|
|
|
|
fgets(buffer, sizeof(buffer), fpipe);
|
|
pclose(fpipe);
|
|
|
|
strtok(buffer, "\n");
|
|
return CFStringCreateWithCString(NULL, buffer, kCFStringEncodingUTF8);
|
|
}
|
|
|
|
CFStringRef copy_long_shot_disk_image_path() {
|
|
return find_path(CFSTR("`xcode-select --print-path`"), CFSTR("DeveloperDiskImage.dmg"), CFSTR(""));
|
|
}
|
|
|
|
CFStringRef copy_xcode_dev_path() {
|
|
static char xcode_dev_path[256] = { '\0' };
|
|
if (strlen(xcode_dev_path) == 0) {
|
|
FILE *fpipe = NULL;
|
|
char *command = "xcode-select -print-path";
|
|
|
|
if (!(fpipe = (FILE *)popen(command, "r")))
|
|
{
|
|
perror("Error encountered while opening pipe");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
char buffer[256] = { '\0' };
|
|
|
|
fgets(buffer, sizeof(buffer), fpipe);
|
|
pclose(fpipe);
|
|
|
|
strtok(buffer, "\n");
|
|
strcpy(xcode_dev_path, buffer);
|
|
}
|
|
return CFStringCreateWithCString(NULL, xcode_dev_path, kCFStringEncodingUTF8);
|
|
}
|
|
|
|
const char *get_home() {
|
|
const char* home = getenv("HOME");
|
|
if (!home) {
|
|
struct passwd *pwd = getpwuid(getuid());
|
|
home = pwd->pw_dir;
|
|
}
|
|
return home;
|
|
}
|
|
|
|
CFStringRef copy_xcode_path_for(CFStringRef subPath, CFStringRef search) {
|
|
CFStringRef xcodeDevPath = copy_xcode_dev_path();
|
|
CFStringRef path;
|
|
bool found = false;
|
|
const char* home = get_home();
|
|
|
|
|
|
// Try using xcode-select --print-path
|
|
if (!found) {
|
|
path = CFStringCreateWithFormat(NULL, NULL, CFSTR("%@/%@/%@"), xcodeDevPath, subPath, search);
|
|
found = path_exists(path);
|
|
}
|
|
// Try find `xcode-select --print-path` with search as a name pattern
|
|
if (!found) {
|
|
path = find_path(CFStringCreateWithFormat(NULL, NULL, CFSTR("%@/%@"), xcodeDevPath, subPath), search, CFSTR("-maxdepth 1"));
|
|
found = CFStringGetLength(path) > 0 && path_exists(path);
|
|
}
|
|
// If not look in the default xcode location (xcode-select is sometimes wrong)
|
|
if (!found) {
|
|
path = CFStringCreateWithFormat(NULL, NULL, CFSTR("/Applications/Xcode.app/Contents/Developer/%@&%@"), subPath, search);
|
|
found = path_exists(path);
|
|
}
|
|
// If not look in the users home directory, Xcode can store device support stuff there
|
|
if (!found) {
|
|
path = CFStringCreateWithFormat(NULL, NULL, CFSTR("%s/Library/Developer/Xcode/%@/%@"), home, subPath, search);
|
|
found = path_exists(path);
|
|
}
|
|
|
|
CFRelease(xcodeDevPath);
|
|
|
|
if (found) {
|
|
return path;
|
|
} else {
|
|
CFRelease(path);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
CFMutableArrayRef get_device_product_version_parts(AMDeviceRef device) {
|
|
CFStringRef version = AMDeviceCopyValue(device, 0, CFSTR("ProductVersion"));
|
|
CFArrayRef parts = CFStringCreateArrayBySeparatingStrings(NULL, version, CFSTR("."));
|
|
CFMutableArrayRef result = CFArrayCreateMutableCopy(NULL, CFArrayGetCount(parts), parts);
|
|
CFRelease(version);
|
|
CFRelease(parts);
|
|
return result;
|
|
}
|
|
|
|
CFStringRef copy_device_support_path(AMDeviceRef device) {
|
|
CFStringRef version = NULL;
|
|
CFStringRef build = AMDeviceCopyValue(device, 0, CFSTR("BuildVersion"));
|
|
CFStringRef path = NULL;
|
|
CFMutableArrayRef version_parts = get_device_product_version_parts(device);
|
|
|
|
while (CFArrayGetCount(version_parts) > 0) {
|
|
version = CFStringCreateByCombiningStrings(NULL, version_parts, CFSTR("."));
|
|
if (path == NULL) {
|
|
path = copy_xcode_path_for(CFSTR("iOS DeviceSupport"), CFStringCreateWithFormat(NULL, NULL, CFSTR("%@ (%@)"), version, build));
|
|
}
|
|
if (path == NULL) {
|
|
path = copy_xcode_path_for(CFSTR("Platforms/iPhoneOS.platform/DeviceSupport"), CFStringCreateWithFormat(NULL, NULL, CFSTR("%@ (%@)"), version, build));
|
|
}
|
|
if (path == NULL) {
|
|
path = copy_xcode_path_for(CFSTR("Platforms/iPhoneOS.platform/DeviceSupport"), CFStringCreateWithFormat(NULL, NULL, CFSTR("%@ (*)"), version));
|
|
}
|
|
if (path == NULL) {
|
|
path = copy_xcode_path_for(CFSTR("Platforms/iPhoneOS.platform/DeviceSupport"), version);
|
|
}
|
|
if (path == NULL) {
|
|
path = copy_xcode_path_for(CFSTR("Platforms/iPhoneOS.platform/DeviceSupport/Latest"), CFSTR(""));
|
|
}
|
|
CFRelease(version);
|
|
if (path != NULL) {
|
|
break;
|
|
}
|
|
CFArrayRemoveValueAtIndex(version_parts, CFArrayGetCount(version_parts) - 1);
|
|
}
|
|
|
|
CFRelease(version_parts);
|
|
CFRelease(build);
|
|
|
|
if (path == NULL)
|
|
{
|
|
printf("[ !! ] Unable to locate DeviceSupport directory.\n[ !! ] This probably means you don't have Xcode installed, you will need to launch the app manually and logging output will not be shown!\n");
|
|
exit(1);
|
|
}
|
|
|
|
return path;
|
|
}
|
|
|
|
CFStringRef copy_developer_disk_image_path(CFStringRef deviceSupportPath) {
|
|
CFStringRef path = CFStringCreateWithFormat(NULL, NULL, CFSTR("%@/%@"), deviceSupportPath, CFSTR("DeveloperDiskImage.dmg"));
|
|
if (!path_exists(path)) {
|
|
CFRelease(path);
|
|
path = NULL;
|
|
}
|
|
|
|
if (path == NULL) {
|
|
// Sometimes Latest seems to be missing in Xcode, in that case use find and hope for the best
|
|
path = copy_long_shot_disk_image_path();
|
|
if (CFStringGetLength(path) < 5) {
|
|
CFRelease(path);
|
|
path = NULL;
|
|
}
|
|
}
|
|
|
|
if (path == NULL)
|
|
{
|
|
printf("[ !! ] Unable to locate DeveloperDiskImage.dmg.\n[ !! ] This probably means you don't have Xcode installed, you will need to launch the app manually and logging output will not be shown!\n");
|
|
exit(1);
|
|
}
|
|
|
|
return path;
|
|
}
|
|
|
|
void mount_callback(CFDictionaryRef dict, int arg) {
|
|
CFStringRef status = CFDictionaryGetValue(dict, CFSTR("Status"));
|
|
|
|
if (CFEqual(status, CFSTR("LookingUpImage"))) {
|
|
printf("[ 0%%] Looking up developer disk image\n");
|
|
} else if (CFEqual(status, CFSTR("CopyingImage"))) {
|
|
printf("[ 30%%] Copying DeveloperDiskImage.dmg to device\n");
|
|
} else if (CFEqual(status, CFSTR("MountingImage"))) {
|
|
printf("[ 90%%] Mounting developer disk image\n");
|
|
}
|
|
}
|
|
|
|
void mount_developer_image(AMDeviceRef device) {
|
|
CFStringRef ds_path = copy_device_support_path(device);
|
|
CFStringRef image_path = copy_developer_disk_image_path(ds_path);
|
|
CFStringRef sig_path = CFStringCreateWithFormat(NULL, NULL, CFSTR("%@.signature"), image_path);
|
|
|
|
if (verbose) {
|
|
printf("Device support path: %s\n", CFStringGetCStringPtr(ds_path, CFStringGetSystemEncoding()));
|
|
printf("Developer disk image: %s\n", CFStringGetCStringPtr(image_path, CFStringGetSystemEncoding()));
|
|
}
|
|
CFRelease(ds_path);
|
|
|
|
FILE* sig = fopen(CFStringGetCStringPtr(sig_path, kCFStringEncodingMacRoman), "rb");
|
|
void *sig_buf = malloc(128);
|
|
assert(fread(sig_buf, 1, 128, sig) == 128);
|
|
fclose(sig);
|
|
CFDataRef sig_data = CFDataCreateWithBytesNoCopy(NULL, sig_buf, 128, NULL);
|
|
CFRelease(sig_path);
|
|
|
|
CFTypeRef keys[] = { CFSTR("ImageSignature"), CFSTR("ImageType") };
|
|
CFTypeRef values[] = { sig_data, CFSTR("Developer") };
|
|
CFDictionaryRef options = CFDictionaryCreate(NULL, (const void **)&keys, (const void **)&values, 2, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
|
|
CFRelease(sig_data);
|
|
|
|
int result = AMDeviceMountImage(device, image_path, options, &mount_callback, 0);
|
|
if (result == 0) {
|
|
printf("[ 95%%] Developer disk image mounted successfully\n");
|
|
} else if (result == 0xe8000076 /* already mounted */) {
|
|
printf("[ 95%%] Developer disk image already mounted\n");
|
|
} else {
|
|
printf("[ !! ] Unable to mount developer disk image. (%x)\n", result);
|
|
exit(1);
|
|
}
|
|
|
|
CFRelease(image_path);
|
|
CFRelease(options);
|
|
}
|
|
|
|
mach_error_t transfer_callback(CFDictionaryRef dict, int arg) {
|
|
int percent;
|
|
CFStringRef status = CFDictionaryGetValue(dict, CFSTR("Status"));
|
|
CFNumberGetValue(CFDictionaryGetValue(dict, CFSTR("PercentComplete")), kCFNumberSInt32Type, &percent);
|
|
|
|
if (CFEqual(status, CFSTR("CopyingFile"))) {
|
|
CFStringRef path = CFDictionaryGetValue(dict, CFSTR("Path"));
|
|
|
|
if ((last_path == NULL || !CFEqual(path, last_path)) && !CFStringHasSuffix(path, CFSTR(".ipa"))) {
|
|
printf("[%3d%%] Copying %s to device\n", percent / 2, CFStringGetCStringPtr(path, kCFStringEncodingMacRoman));
|
|
}
|
|
|
|
if (last_path != NULL) {
|
|
CFRelease(last_path);
|
|
}
|
|
last_path = CFStringCreateCopy(NULL, path);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
mach_error_t install_callback(CFDictionaryRef dict, int arg) {
|
|
int percent;
|
|
CFStringRef status = CFDictionaryGetValue(dict, CFSTR("Status"));
|
|
CFNumberGetValue(CFDictionaryGetValue(dict, CFSTR("PercentComplete")), kCFNumberSInt32Type, &percent);
|
|
|
|
printf("[%3d%%] %s\n", (percent / 2) + 50, CFStringGetCStringPtr(status, kCFStringEncodingMacRoman));
|
|
return 0;
|
|
}
|
|
|
|
CFURLRef copy_device_app_url(AMDeviceRef device, CFStringRef identifier) {
|
|
CFDictionaryRef result;
|
|
assert(AMDeviceLookupApplications(device, 0, &result) == 0);
|
|
|
|
CFDictionaryRef app_dict = CFDictionaryGetValue(result, identifier);
|
|
assert(app_dict != NULL);
|
|
|
|
CFStringRef app_path = CFDictionaryGetValue(app_dict, CFSTR("Path"));
|
|
assert(app_path != NULL);
|
|
|
|
CFURLRef url = CFURLCreateWithFileSystemPath(NULL, app_path, kCFURLPOSIXPathStyle, true);
|
|
CFRelease(result);
|
|
return url;
|
|
}
|
|
|
|
CFStringRef copy_disk_app_identifier(CFURLRef disk_app_url) {
|
|
CFURLRef plist_url = CFURLCreateCopyAppendingPathComponent(NULL, disk_app_url, CFSTR("Info.plist"), false);
|
|
CFReadStreamRef plist_stream = CFReadStreamCreateWithFile(NULL, plist_url);
|
|
CFReadStreamOpen(plist_stream);
|
|
CFPropertyListRef plist = CFPropertyListCreateWithStream(NULL, plist_stream, 0, kCFPropertyListImmutable, NULL, NULL);
|
|
CFStringRef bundle_identifier = CFRetain(CFDictionaryGetValue(plist, CFSTR("CFBundleIdentifier")));
|
|
CFReadStreamClose(plist_stream);
|
|
|
|
CFRelease(plist_url);
|
|
CFRelease(plist_stream);
|
|
CFRelease(plist);
|
|
|
|
return bundle_identifier;
|
|
}
|
|
|
|
void write_lldb_prep_cmds(AMDeviceRef device, CFURLRef disk_app_url) {
|
|
CFMutableStringRef cmds = CFStringCreateMutableCopy(NULL, 0, LLDB_PREP_CMDS);
|
|
CFRange range = { 0, CFStringGetLength(cmds) };
|
|
|
|
CFStringRef ds_path = copy_device_support_path(device);
|
|
CFStringFindAndReplace(cmds, CFSTR("{ds_path}"), ds_path, range, 0);
|
|
range.length = CFStringGetLength(cmds);
|
|
|
|
CFMutableStringRef pmodule = CFStringCreateMutableCopy(NULL, 0, LLDB_FRUITSTRAP_MODULE);
|
|
if (args) {
|
|
CFStringRef cf_args = CFStringCreateWithCString(NULL, args, kCFStringEncodingASCII);
|
|
CFStringFindAndReplace(cmds, CFSTR("{args}"), cf_args, range, 0);
|
|
|
|
//format the arguments 'arg1 arg2 ....' to an argument list ['arg1', 'arg2', ...]
|
|
CFMutableStringRef argsListLLDB = CFStringCreateMutableCopy(NULL, 0, cf_args);
|
|
CFRange rangeLLDB = { 0, CFStringGetLength(argsListLLDB) };
|
|
CFStringFindAndReplace(argsListLLDB, CFSTR(" "), CFSTR(" "), rangeLLDB, 0);//remove multiple spaces
|
|
rangeLLDB.length = CFStringGetLength(argsListLLDB);
|
|
CFStringFindAndReplace(argsListLLDB, CFSTR(" "), CFSTR("', '"), rangeLLDB, 0);
|
|
rangeLLDB.length = CFStringGetLength(pmodule);
|
|
CFStringFindAndReplace(pmodule, CFSTR("{args}"), argsListLLDB, rangeLLDB, 0);
|
|
|
|
CFRelease(cf_args);
|
|
} else {
|
|
CFStringFindAndReplace(cmds, CFSTR(" {args}"), CFSTR(""), range, 0);
|
|
}
|
|
range.length = CFStringGetLength(cmds);
|
|
|
|
CFStringRef bundle_identifier = copy_disk_app_identifier(disk_app_url);
|
|
CFURLRef device_app_url = copy_device_app_url(device, bundle_identifier);
|
|
CFStringRef device_app_path = CFURLCopyFileSystemPath(device_app_url, kCFURLPOSIXPathStyle);
|
|
CFStringFindAndReplace(cmds, CFSTR("{device_app}"), device_app_path, range, 0);
|
|
range.length = CFStringGetLength(cmds);
|
|
|
|
CFStringRef disk_app_path = CFURLCopyFileSystemPath(disk_app_url, kCFURLPOSIXPathStyle);
|
|
CFStringFindAndReplace(cmds, CFSTR("{disk_app}"), disk_app_path, range, 0);
|
|
range.length = CFStringGetLength(cmds);
|
|
|
|
CFURLRef device_container_url = CFURLCreateCopyDeletingLastPathComponent(NULL, device_app_url);
|
|
CFStringRef device_container_path = CFURLCopyFileSystemPath(device_container_url, kCFURLPOSIXPathStyle);
|
|
CFMutableStringRef dcp_noprivate = CFStringCreateMutableCopy(NULL, 0, device_container_path);
|
|
range.length = CFStringGetLength(dcp_noprivate);
|
|
CFStringFindAndReplace(dcp_noprivate, CFSTR("/private/var/"), CFSTR("/var/"), range, 0);
|
|
range.length = CFStringGetLength(cmds);
|
|
CFStringFindAndReplace(cmds, CFSTR("{device_container}"), dcp_noprivate, range, 0);
|
|
range.length = CFStringGetLength(cmds);
|
|
|
|
CFURLRef disk_container_url = CFURLCreateCopyDeletingLastPathComponent(NULL, disk_app_url);
|
|
CFStringRef disk_container_path = CFURLCopyFileSystemPath(disk_container_url, kCFURLPOSIXPathStyle);
|
|
CFStringFindAndReplace(cmds, CFSTR("{disk_container}"), disk_container_path, range, 0);
|
|
|
|
char python_file_path[300] = "/tmp/fruitstrap_";
|
|
char python_command[300] = "fruitstrap_";
|
|
if(device_id != NULL) {
|
|
strcat(python_file_path, device_id);
|
|
strcat(python_command, device_id);
|
|
}
|
|
strcat(python_file_path, ".py");
|
|
|
|
CFStringRef cf_python_command = CFStringCreateWithCString(NULL, python_command, kCFStringEncodingASCII);
|
|
CFStringFindAndReplace(cmds, CFSTR("{python_command}"), cf_python_command, range, 0);
|
|
range.length = CFStringGetLength(cmds);
|
|
CFStringRef cf_python_file_path = CFStringCreateWithCString(NULL, python_file_path, kCFStringEncodingASCII);
|
|
CFStringFindAndReplace(cmds, CFSTR("{python_file_path}"), cf_python_file_path, range, 0);
|
|
range.length = CFStringGetLength(cmds);
|
|
|
|
CFDataRef cmds_data = CFStringCreateExternalRepresentation(NULL, cmds, kCFStringEncodingASCII, 0);
|
|
char prep_cmds_path[300] = PREP_CMDS_PATH;
|
|
if(device_id != NULL)
|
|
strcat(prep_cmds_path, device_id);
|
|
FILE *out = fopen(prep_cmds_path, "w");
|
|
fwrite(CFDataGetBytePtr(cmds_data), CFDataGetLength(cmds_data), 1, out);
|
|
fclose(out);
|
|
|
|
CFDataRef pmodule_data = CFStringCreateExternalRepresentation(NULL, pmodule, kCFStringEncodingASCII, 0);
|
|
|
|
out = fopen(python_file_path, "w");
|
|
fwrite(CFDataGetBytePtr(pmodule_data), CFDataGetLength(pmodule_data), 1, out);
|
|
fclose(out);
|
|
|
|
CFRelease(cmds);
|
|
if (ds_path != NULL) CFRelease(ds_path);
|
|
CFRelease(bundle_identifier);
|
|
CFRelease(device_app_url);
|
|
CFRelease(device_app_path);
|
|
CFRelease(disk_app_path);
|
|
CFRelease(device_container_url);
|
|
CFRelease(device_container_path);
|
|
CFRelease(dcp_noprivate);
|
|
CFRelease(disk_container_url);
|
|
CFRelease(disk_container_path);
|
|
CFRelease(cmds_data);
|
|
CFRelease(cf_python_command);
|
|
CFRelease(cf_python_file_path);
|
|
}
|
|
|
|
CFSocketRef server_socket;
|
|
CFSocketRef lldb_socket;
|
|
CFWriteStreamRef serverWriteStream = NULL;
|
|
CFWriteStreamRef lldbWriteStream = NULL;
|
|
|
|
void
|
|
server_callback (CFSocketRef s, CFSocketCallBackType callbackType, CFDataRef address, const void *data, void *info)
|
|
{
|
|
int res;
|
|
|
|
//PRINT ("server: %s\n", CFDataGetBytePtr (data));
|
|
|
|
if (CFDataGetLength (data) == 0) {
|
|
// FIXME: Close the socket
|
|
//shutdown (CFSocketGetNative (lldb_socket), SHUT_RDWR);
|
|
//close (CFSocketGetNative (lldb_socket));
|
|
return;
|
|
}
|
|
res = write (CFSocketGetNative (lldb_socket), CFDataGetBytePtr (data), CFDataGetLength (data));
|
|
}
|
|
|
|
void lldb_callback(CFSocketRef s, CFSocketCallBackType callbackType, CFDataRef address, const void *data, void *info)
|
|
{
|
|
//PRINT ("lldb: %s\n", CFDataGetBytePtr (data));
|
|
|
|
if (CFDataGetLength (data) == 0)
|
|
return;
|
|
write (gdbfd, CFDataGetBytePtr (data), CFDataGetLength (data));
|
|
}
|
|
|
|
void fdvendor_callback(CFSocketRef s, CFSocketCallBackType callbackType, CFDataRef address, const void *data, void *info) {
|
|
CFSocketNativeHandle socket = (CFSocketNativeHandle)(*((CFSocketNativeHandle *)data));
|
|
|
|
assert (callbackType == kCFSocketAcceptCallBack);
|
|
//PRINT ("callback!\n");
|
|
|
|
lldb_socket = CFSocketCreateWithNative(NULL, socket, kCFSocketDataCallBack, &lldb_callback, NULL);
|
|
CFRunLoopAddSource(CFRunLoopGetMain(), CFSocketCreateRunLoopSource(NULL, lldb_socket, 0), kCFRunLoopCommonModes);
|
|
}
|
|
|
|
void start_remote_debug_server(AMDeviceRef device) {
|
|
char buf [256];
|
|
int res, err, i;
|
|
char msg [256];
|
|
int chsum, len;
|
|
struct stat s;
|
|
socklen_t buflen;
|
|
struct sockaddr name;
|
|
int namelen;
|
|
|
|
assert(AMDeviceStartService(device, CFSTR("com.apple.debugserver"), &gdbfd, NULL) == 0);
|
|
assert (gdbfd);
|
|
|
|
/*
|
|
* The debugserver connection is through a fd handle, while lldb requires a host/port to connect, so create an intermediate
|
|
* socket to transfer data.
|
|
*/
|
|
server_socket = CFSocketCreateWithNative (NULL, gdbfd, kCFSocketDataCallBack, &server_callback, NULL);
|
|
CFRunLoopAddSource(CFRunLoopGetMain(), CFSocketCreateRunLoopSource(NULL, server_socket, 0), kCFRunLoopCommonModes);
|
|
|
|
struct sockaddr_in addr4;
|
|
memset(&addr4, 0, sizeof(addr4));
|
|
addr4.sin_len = sizeof(addr4);
|
|
addr4.sin_family = AF_INET;
|
|
addr4.sin_port = htons(12345);
|
|
addr4.sin_addr.s_addr = htonl(INADDR_ANY);
|
|
|
|
CFSocketRef fdvendor = CFSocketCreate(NULL, PF_INET, 0, 0, kCFSocketAcceptCallBack, &fdvendor_callback, NULL);
|
|
|
|
int yes = 1;
|
|
setsockopt(CFSocketGetNative(fdvendor), SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
|
|
int flag = 1;
|
|
res = setsockopt(CFSocketGetNative(fdvendor), IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(int));
|
|
assert (res == 0);
|
|
|
|
CFDataRef address_data = CFDataCreate(NULL, (const UInt8 *)&addr4, sizeof(addr4));
|
|
|
|
CFSocketSetAddress(fdvendor, address_data);
|
|
CFRelease(address_data);
|
|
CFRunLoopAddSource(CFRunLoopGetMain(), CFSocketCreateRunLoopSource(NULL, fdvendor, 0), kCFRunLoopCommonModes);
|
|
}
|
|
|
|
void kill_ptree_inner(pid_t root, int signum, struct kinfo_proc *kp, int kp_len) {
|
|
int i;
|
|
for (i = 0; i < kp_len; i++) {
|
|
if (kp[i].kp_eproc.e_ppid == root) {
|
|
kill_ptree_inner(kp[i].kp_proc.p_pid, signum, kp, kp_len);
|
|
}
|
|
}
|
|
if (root != getpid()) {
|
|
kill(root, signum);
|
|
}
|
|
}
|
|
|
|
int kill_ptree(pid_t root, int signum) {
|
|
int mib[3];
|
|
size_t len;
|
|
mib[0] = CTL_KERN;
|
|
mib[1] = KERN_PROC;
|
|
mib[2] = KERN_PROC_ALL;
|
|
if (sysctl(mib, 3, NULL, &len, NULL, 0) == -1) {
|
|
return -1;
|
|
}
|
|
|
|
struct kinfo_proc *kp = calloc(1, len);
|
|
if (!kp) {
|
|
return -1;
|
|
}
|
|
|
|
if (sysctl(mib, 3, kp, &len, NULL, 0) == -1) {
|
|
free(kp);
|
|
return -1;
|
|
}
|
|
|
|
kill_ptree_inner(root, signum, kp, len / sizeof(struct kinfo_proc));
|
|
|
|
free(kp);
|
|
return 0;
|
|
}
|
|
|
|
void killed(int signum) {
|
|
// SIGKILL needed to kill lldb, probably a better way to do this.
|
|
kill(0, SIGKILL);
|
|
_exit(0);
|
|
}
|
|
|
|
void lldb_finished_handler(int signum)
|
|
{
|
|
_exit(0);
|
|
}
|
|
|
|
void launch_debugger(AMDeviceRef device, CFURLRef url) {
|
|
AMDeviceConnect(device);
|
|
assert(AMDeviceIsPaired(device));
|
|
assert(AMDeviceValidatePairing(device) == 0);
|
|
assert(AMDeviceStartSession(device) == 0);
|
|
|
|
printf("------ Debug phase ------\n");
|
|
|
|
mount_developer_image(device); // put debugserver on the device
|
|
start_remote_debug_server(device); // start debugserver
|
|
write_lldb_prep_cmds(device, url); // dump the necessary lldb commands into a file
|
|
|
|
CFRelease(url);
|
|
|
|
printf("[100%%] Connecting to remote debug server\n");
|
|
printf("-------------------------\n");
|
|
|
|
signal(SIGHUP, lldb_finished_handler);
|
|
setpgid(getpid(), 0);
|
|
signal(SIGINT, killed);
|
|
signal(SIGTERM, killed);
|
|
|
|
parent = getpid();
|
|
int pid = fork();
|
|
if (pid == 0) {
|
|
char lldb_shell[300] = LLDB_SHELL;
|
|
if(device_id != NULL)
|
|
strcat(lldb_shell, device_id);
|
|
system(lldb_shell); // launch lldb
|
|
kill(parent, SIGHUP); // "No. I am your father."
|
|
_exit(0);
|
|
}
|
|
|
|
}
|
|
|
|
void handle_device(AMDeviceRef device) {
|
|
if (found_device) return; // handle one device only
|
|
CFStringRef found_device_id = AMDeviceCopyDeviceIdentifier(device);
|
|
|
|
if (device_id != NULL) {
|
|
if(strcmp(device_id, CFStringGetCStringPtr(found_device_id, CFStringGetSystemEncoding())) == 0) {
|
|
found_device = true;
|
|
} else {
|
|
return;
|
|
}
|
|
} else {
|
|
found_device = true;
|
|
}
|
|
|
|
if (detect_only) {
|
|
printf("[....] Found device (%s).\n", CFStringGetCStringPtr(found_device_id, CFStringGetSystemEncoding()));
|
|
exit(0);
|
|
}
|
|
|
|
|
|
CFRetain(device); // don't know if this is necessary?
|
|
|
|
CFStringRef path = CFStringCreateWithCString(NULL, app_path, kCFStringEncodingASCII);
|
|
CFURLRef relative_url = CFURLCreateWithFileSystemPath(NULL, path, kCFURLPOSIXPathStyle, false);
|
|
CFURLRef url = CFURLCopyAbsoluteURL(relative_url);
|
|
|
|
CFRelease(relative_url);
|
|
|
|
if(install) {
|
|
printf("[ 0%%] Found device (%s), beginning install\n", CFStringGetCStringPtr(found_device_id, CFStringGetSystemEncoding()));
|
|
|
|
AMDeviceConnect(device);
|
|
assert(AMDeviceIsPaired(device));
|
|
assert(AMDeviceValidatePairing(device) == 0);
|
|
assert(AMDeviceStartSession(device) == 0);
|
|
|
|
|
|
|
|
service_conn_t afcFd;
|
|
assert(AMDeviceStartService(device, CFSTR("com.apple.afc"), &afcFd, NULL) == 0);
|
|
assert(AMDeviceStopSession(device) == 0);
|
|
assert(AMDeviceDisconnect(device) == 0);
|
|
assert(AMDeviceTransferApplication(afcFd, path, NULL, transfer_callback, NULL) == 0);
|
|
|
|
close(afcFd);
|
|
|
|
CFStringRef keys[] = { CFSTR("PackageType") };
|
|
CFStringRef values[] = { CFSTR("Developer") };
|
|
CFDictionaryRef options = CFDictionaryCreate(NULL, (const void **)&keys, (const void **)&values, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
|
|
|
|
AMDeviceConnect(device);
|
|
assert(AMDeviceIsPaired(device));
|
|
assert(AMDeviceValidatePairing(device) == 0);
|
|
assert(AMDeviceStartSession(device) == 0);
|
|
|
|
service_conn_t installFd;
|
|
assert(AMDeviceStartService(device, CFSTR("com.apple.mobile.installation_proxy"), &installFd, NULL) == 0);
|
|
|
|
assert(AMDeviceStopSession(device) == 0);
|
|
assert(AMDeviceDisconnect(device) == 0);
|
|
|
|
mach_error_t result = AMDeviceInstallApplication(installFd, path, options, install_callback, NULL);
|
|
if (result != 0)
|
|
{
|
|
printf("AMDeviceInstallApplication failed: %d\n", result);
|
|
exit(1);
|
|
}
|
|
|
|
close(installFd);
|
|
|
|
CFRelease(path);
|
|
CFRelease(options);
|
|
|
|
printf("[100%%] Installed package %s\n", app_path);
|
|
}
|
|
|
|
if (!debug) exit(0); // no debug phase
|
|
launch_debugger(device, url);
|
|
}
|
|
|
|
void device_callback(struct am_device_notification_callback_info *info, void *arg) {
|
|
switch (info->msg) {
|
|
case ADNCI_MSG_CONNECTED:
|
|
handle_device(info->dev);
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void timeout_callback(CFRunLoopTimerRef timer, void *info) {
|
|
if (!found_device) {
|
|
printf("[....] Timed out waiting for device.\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
void usage(const char* app) {
|
|
printf(
|
|
"Usage: %s [OPTION]...\n"
|
|
" -d, --debug launch the app in GDB after installation\n"
|
|
" -i, --id <device_id> the id of the device to connect to\n"
|
|
" -c, --detect only detect if the device is connected\n"
|
|
" -b, --bundle <bundle.app> the path to the app bundle to be installed\n"
|
|
" -a, --args <args> command line arguments to pass to the app when launching it\n"
|
|
" -t, --timeout <timeout> number of seconds to wait for a device to be connected\n"
|
|
" -u, --unbuffered don't buffer stdout\n"
|
|
" -g, --gdbargs <args> extra arguments to pass to GDB when starting the debugger\n"
|
|
" -x, --gdbexec <file> GDB commands script file\n"
|
|
" -n, --nostart do not start the app when debugging\n"
|
|
" -v, --verbose enable verbose output\n"
|
|
" -m, --noinstall directly start debugging without app install (-d not required) \n"
|
|
" -V, --version print the executable version \n",
|
|
app);
|
|
}
|
|
|
|
void show_version() {
|
|
printf("%s\n", APP_VERSION);
|
|
}
|
|
|
|
int main(int argc, char *argv[]) {
|
|
static struct option longopts[] = {
|
|
{ "debug", no_argument, NULL, 'd' },
|
|
{ "id", required_argument, NULL, 'i' },
|
|
{ "bundle", required_argument, NULL, 'b' },
|
|
{ "args", required_argument, NULL, 'a' },
|
|
{ "verbose", no_argument, NULL, 'v' },
|
|
{ "timeout", required_argument, NULL, 't' },
|
|
{ "gdbexec", no_argument, NULL, 'x' },
|
|
{ "unbuffered", no_argument, NULL, 'u' },
|
|
{ "nostart", no_argument, NULL, 'n' },
|
|
{ "detect", no_argument, NULL, 'c' },
|
|
{ "version", no_argument, NULL, 'V' },
|
|
{ "noinstall", no_argument, NULL, 'm' },
|
|
{ NULL, 0, NULL, 0 },
|
|
};
|
|
char ch;
|
|
|
|
while ((ch = getopt_long(argc, argv, "Vmcdvuni:b:a:t:g:x:", longopts, NULL)) != -1)
|
|
{
|
|
switch (ch) {
|
|
case 'm':
|
|
install = 0;
|
|
debug = 1;
|
|
break;
|
|
case 'd':
|
|
debug = 1;
|
|
break;
|
|
case 'i':
|
|
device_id = optarg;
|
|
break;
|
|
case 'b':
|
|
app_path = optarg;
|
|
break;
|
|
case 'a':
|
|
args = optarg;
|
|
break;
|
|
case 'v':
|
|
verbose = 1;
|
|
break;
|
|
case 't':
|
|
timeout = atoi(optarg);
|
|
break;
|
|
case 'u':
|
|
unbuffered = 1;
|
|
break;
|
|
case 'n':
|
|
nostart = 1;
|
|
break;
|
|
case 'c':
|
|
detect_only = true;
|
|
break;
|
|
case 'V':
|
|
show_version();
|
|
return 1;
|
|
default:
|
|
usage(argv[0]);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if (!app_path && !detect_only) {
|
|
usage(argv[0]);
|
|
exit(0);
|
|
}
|
|
|
|
if (unbuffered) {
|
|
setbuf(stdout, NULL);
|
|
setbuf(stderr, NULL);
|
|
}
|
|
|
|
if (detect_only && timeout == 0) {
|
|
timeout = 5;
|
|
}
|
|
|
|
if (!detect_only) {
|
|
printf("------ Install phase ------\n");
|
|
}
|
|
|
|
if (app_path) {
|
|
assert(access(app_path, F_OK) == 0);
|
|
}
|
|
|
|
AMDSetLogLevel(5); // otherwise syslog gets flooded with crap
|
|
if (timeout > 0)
|
|
{
|
|
CFRunLoopTimerRef timer = CFRunLoopTimerCreate(NULL, CFAbsoluteTimeGetCurrent() + timeout, 0, 0, 0, timeout_callback, NULL);
|
|
CFRunLoopAddTimer(CFRunLoopGetCurrent(), timer, kCFRunLoopCommonModes);
|
|
printf("[....] Waiting up to %d seconds for iOS device to be connected\n", timeout);
|
|
}
|
|
else
|
|
{
|
|
printf("[....] Waiting for iOS device to be connected\n");
|
|
}
|
|
|
|
struct am_device_notification *notify;
|
|
AMDeviceNotificationSubscribe(&device_callback, 0, 0, NULL, ¬ify);
|
|
CFRunLoopRun();
|
|
}
|