void InstallProfileToDevice(char *udid, char *path)
{
SDMMD_AMDeviceRef device = FindDeviceFromUDID(udid);
if (device) {
SDMMD_AMDeviceConnect(device);
SDMMD_AMDeviceStartSession(device);
SDMMD_AMConnectionRef conn = NULL;
SDMMD_AMDeviceStartService(device, CFSTR(AMSVC_MCINSTALL), NULL, &conn);
CFDataRef config_data = CFDataCreateFromFilePath(path);
CFMutableDictionaryRef request = SDMMD_create_dict();
CFDictionaryAddValue(request, CFSTR("RequestType"), CFSTR("InstallProfile"));
CFDictionaryAddValue(request, CFSTR("Payload"), config_data);
SDMMD_ServiceSendMessage(SDMMD_TranslateConnectionToSocket(conn), request, kCFPropertyListXMLFormat_v1_0);
CFSafeRelease(request);
CFSafeRelease(config_data);
CFPropertyListRef response = NULL;
SDMMD_ServiceReceiveMessage(SDMMD_TranslateConnectionToSocket(conn), &response);
CFSafeRelease(response);
CFSafeRelease(conn);
SDMMD_AMDeviceStopSession(device);
SDMMD_AMDeviceDisconnect(device);
}
}
void SetupDeviceForDevelopment(char *udid)
{
SDMMD_AMDeviceRef device = FindDeviceFromUDID(udid);
if (device) {
SDMMD_AMDeviceMountDeveloperImage(device);
}
}
void LookupAppsOnDevice(char *udid)
{
SDMMD_AMDeviceRef device = FindDeviceFromUDID(udid);
if (device) {
sdmmd_return_t result = SDMMD_AMDeviceConnect(device);
if (SDM_MD_CallSuccessful(result)) {
result = SDMMD_AMDeviceStartSession(device);
if (SDM_MD_CallSuccessful(result)) {
CFDictionaryRef response;
//CFMutableArrayRef lookupValues = CFArrayCreateMutable(kCFAllocatorDefault, 0x0, &kCFTypeArrayCallBacks);
//CFArrayAppendValue(lookupValues, CFSTR(kAppLookupKeyCFBundleIdentifier));
//CFArrayAppendValue(lookupValues, CFSTR("SequenceNumber"));
CFArrayRef lookupValues = SDMMD_ApplicationLookupDictionary();
CFMutableDictionaryRef optionsDict = SDMMD_create_dict();
CFDictionarySetValue(optionsDict, CFSTR("ReturnAttributes"), lookupValues);
//CFDictionarySetValue(optionsDict, CFSTR("com.apple.mobile_installation.metadata"), kCFBooleanTrue);
//CFDictionarySetValue(optionsDict, CFSTR("BundleIDs"), kCFBooleanTrue);
result = SDMMD_AMDeviceLookupApplications(device, optionsDict, &response);
if (SDM_MD_CallSuccessful(result)) {
PrintCFDictionary(response);
}
SDMMD_AMDeviceStopSession(device);
}
SDMMD_AMDeviceDisconnect(device);
}
}
}
void SpringboardQuery(char *udid) {
SDMMD_AMDeviceRef device = FindDeviceFromUDID(udid);
if (device) {
//struct SpringboardDeviceInfo *info = CreateSpringboardInfoFromDevice(device);
SDMMD_AMConnectionRef springboard = AttachToDeviceAndService(device, AMSVC_SPRINGBOARD_SERVICES);
CFMutableDictionaryRef request = SDMMD_create_dict();
CFDictionarySetValue(request, CFSTR(kCommand), CFSTR(kCommandGetIconState));
CFDictionarySetValue(request, CFSTR(kFormatVersion), CFSTR("2"));
SocketConnection socket = SDMMD_TranslateConnectionToSocket(springboard);
sdmmd_return_t result = SDMMD_ServiceSendMessage(socket, request, kCFPropertyListBinaryFormat_v1_0);
if (result == kAMDSuccess) {
CFPropertyListRef response = NULL;
result = SDMMD_ServiceReceiveMessage(socket, &response);
if (result == kAMDSuccess && response) {
PrintCFType(response);
}
}
/*
CFMutableDictionaryRef setrequest = SDMMD_create_dict();
CFDictionarySetValue(setrequest, CFSTR(kCommand), CFSTR(kCommandSetIconState));
CFDictionarySetValue(setrequest, CFSTR("iconState"), newformat);
result = SDMMD_ServiceSendMessage(socket, setrequest, kCFPropertyListBinaryFormat_v1_0);
if (result == kAMDSuccess) {
CFPropertyListRef response = NULL;
result = SDMMD_ServiceReceiveMessage(socket, &response);
if (result == kAMDSuccess && response) {
PrintCFType(response);
}
}
*/
}
}
void InstallApplicationOnDevice(char *udid, char *app_path) {
SDMMD_AMDeviceRef device = FindDeviceFromUDID(udid);
if (device) {
CFStringRef path = CFStringCreateWithBytes(kCFAllocatorDefault, (UInt8 *)app_path, strlen(app_path), kCFStringEncodingUTF8, false);
SDMMD_AMDeviceInstallApp(device, path);
CFSafeRelease(path);
}
}
void InstallAppToDevice(char *udid, char *path)
{
SDMMD_AMDeviceRef device = FindDeviceFromUDID(udid);
if (device) {
CFStringRef app_path = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%s"), path);
SDMMD_AMDeviceCopyApplication(device, app_path);
SDMMD_AMDeviceInstallApp(device, app_path);
CFSafeRelease(app_path);
}
}
void WhatDoesThisDo(char *udid)
{
SDMMD_AMDeviceRef device = FindDeviceFromUDID(udid);
if (device) {
sdmmd_return_t result = kAMDInvalidArgumentError;
SDMMD_AMDeviceConnect(device);
SDMMD_AMDeviceStartSession(device);
CFDictionaryRef dict = NULL;
SDMMD_AMConnectionRef conn = SDMMD_AMDServiceConnectionCreate(0, NULL, dict);
result = SDMMD_AMDeviceSecureStartService(device, CFSTR(AMSVC_DIAG_RELAY), NULL, &conn);
if (result == 0) {
CFMutableDictionaryRef optionsDict = SDMMD_create_dict();
CFDictionarySetValue(optionsDict, CFSTR("Request"), CFSTR("GasGauge"));
result = SDMMD_ServiceSendMessage(SDMMD_TranslateConnectionToSocket(conn), optionsDict, kCFPropertyListXMLFormat_v1_0);
CFMutableDictionaryRef response;
result = SDMMD_ServiceReceiveMessage(SDMMD_TranslateConnectionToSocket(conn), (CFPropertyListRef *)&response);
if (SDM_MD_CallSuccessful(result)) {
PrintCFType(response);
}
result = SDMMD_ServiceReceiveMessage(SDMMD_TranslateConnectionToSocket(conn), (CFPropertyListRef *)&response);
if (SDM_MD_CallSuccessful(result)) {
PrintCFType(response);
}
result = SDMMD_ServiceReceiveMessage(SDMMD_TranslateConnectionToSocket(conn), (CFPropertyListRef *)&response);
if (SDM_MD_CallSuccessful(result)) {
PrintCFType(response);
}
}
else {
printf("%s: Was unable to start the service on the device: %i\n", __FUNCTION__, SDMMD_AMDeviceUSBDeviceID(device));
}
}
}
void StartDebuggingAndDetach(char *udid, char *app_path) {
SDMMD_AMDeviceRef device = FindDeviceFromUDID(udid);
if (device) {
CFStringRef bundleId = CFStringCreateWithBytes(kCFAllocatorDefault, (UInt8 *)app_path, strlen(app_path), kCFStringEncodingUTF8, false);
CFURLRef relative_url = CFURLCreateWithFileSystemPath(NULL, bundleId, kCFURLPOSIXPathStyle, false);
CFURLRef disk_app_url = CFURLCopyAbsoluteURL(relative_url);
CFStringRef bundle_identifier = copy_disk_app_identifier(disk_app_url);
SDMMD_AMDebugConnectionRef debug = SDMMD_AMDebugConnectionCreateForDevice(device);
SDMMD_AMDebugConnectionStart(debug);
uintptr_t socket = SDMMD_AMDServiceConnectionGetSocket(debug->connection);
CFSocketContext context = { 0, (void*)socket, NULL, NULL, NULL };
CFSocketRef fdvendor = CFSocketCreate(NULL, AF_UNIX, 0, 0, kCFSocketAcceptCallBack, &socket_callback, &context);
int yes = 1;
setsockopt(CFSocketGetNative(fdvendor), SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
struct sockaddr_un address;
memset(&address, 0, sizeof(address));
address.sun_family = AF_UNIX;
strcpy(address.sun_path, SDM_LLDB_SOCKET);
address.sun_len = SUN_LEN(&address);
CFDataRef address_data = CFDataCreate(NULL, (const UInt8 *)&address, sizeof(address));
unlink(SDM_LLDB_SOCKET);
CFSocketSetAddress(fdvendor, address_data);
CFRelease(address_data);
CFRunLoopAddSource(CFRunLoopGetMain(), CFSocketCreateRunLoopSource(NULL, fdvendor, 0), kCFRunLoopCommonModes);
SDMMD_AMDeviceRef device = SDMMD_AMDServiceConnectionGetDevice(debug->connection);
CFMutableStringRef cmds = CFStringCreateMutableCopy(NULL, 0, LLDB_PREP_CMDS);
CFRange range = { 0, CFStringGetLength(cmds) };
CFURLRef device_app_url = copy_device_app_url(device, bundle_identifier);
CFStringRef device_app_path = CFURLCopyFileSystemPath(device_app_url, kCFURLPOSIXPathStyle);
CFStringFindAndReplace(cmds, CFSTR("{DEVICE_PATH}"), device_app_path, range, 0);
range.length = CFStringGetLength(cmds);
CFStringRef disk_app_path = CFURLCopyFileSystemPath(disk_app_url, kCFURLPOSIXPathStyle);
CFStringFindAndReplace(cmds, CFSTR("{APP_PATH}"), 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);
CFDataRef cmds_data = CFStringCreateExternalRepresentation(NULL, cmds, kCFStringEncodingASCII, 0);
FILE *out = fopen(PREP_CMDS_PATH, "w");
fwrite(CFDataGetBytePtr(cmds_data), CFDataGetLength(cmds_data), 1, out);
fclose(out);
CFSafeRelease(cmds);
CFSafeRelease(bundle_identifier);
CFSafeRelease(device_app_url);
CFSafeRelease(device_app_path);
CFSafeRelease(disk_app_path);
CFSafeRelease(device_container_url);
CFSafeRelease(device_container_path);
CFSafeRelease(dcp_noprivate);
CFSafeRelease(disk_container_url);
CFSafeRelease(disk_container_path);
CFSafeRelease(cmds_data);
signal(SIGHUP, exit);
pid_t parent = getpid();
int pid = fork();
if (pid == 0) {
system("xcrun -sdk iphoneos lldb /tmp/sdmmd-lldb-prep");
kill(parent, SIGHUP);
_exit(0);
}
CFRunLoopRun();
}
}
void RunAppOnDeviceWithIdentifier(char *udid, char *identifier, bool waitForDebugger)
{
SDMMD_AMDeviceRef device = FindDeviceFromUDID(udid);
if (device) {
sdmmd_return_t result = SDMMD_AMDeviceConnect(device);
if (SDM_MD_CallSuccessful(result)) {
result = SDMMD_AMDeviceStartSession(device);
if (SDM_MD_CallSuccessful(result)) {
CFDictionaryRef response;
CFArrayRef lookupValues = SDMMD_ApplicationLookupDictionary();
CFMutableDictionaryRef optionsDict = SDMMD_create_dict();
CFDictionarySetValue(optionsDict, CFSTR("ReturnAttributes"), lookupValues);
result = SDMMD_AMDeviceLookupApplications(device, optionsDict, &response);
if (SDM_MD_CallSuccessful(result)) {
CFStringRef bundleIdentifier = CFStringCreateWithCString(kCFAllocatorDefault, identifier, kCFStringEncodingUTF8);
CFDictionaryRef details = NULL;
if (CFDictionaryContainsKey(response, bundleIdentifier)) {
details = CFDictionaryGetValue(response, bundleIdentifier);
}
CFSafeRelease(bundleIdentifier);
if (details) {
SDMMD_AMDeviceStopSession(device);
SDMMD_AMDeviceDisconnect(device);
SDMMD_AMDebugConnectionRef dconn = SDMMD_AMDebugConnectionCreateForDevice(device);
sdmmd_return_t result = SDMMD_AMDebugConnectionStart(dconn);
bool launchSuccess = false;
if (SDM_MD_CallSuccessful(result)) {
// setting max packet size
CFMutableArrayRef maxPacketArgs = CFArrayCreateMutable(kCFAllocatorDefault, 0x0, &kCFTypeArrayCallBacks);
CFArrayAppendValue(maxPacketArgs, CFSTR("1024"));
DebuggerCommandRef maxPacket = SDMMD_CreateDebuggingCommand(kDebugQSetMaxPacketSize, NULL, maxPacketArgs);
CFSafeRelease(maxPacketArgs);
CFDataRef maxPacketResponse = NULL;
result = SDMMD_DebuggingSend(dconn, maxPacket, &maxPacketResponse);
CFSafeRelease(maxPacketResponse);
SDMMD_DebuggingCommandRelease(maxPacket);
// setting the working directory
CFStringRef path = CFDictionaryGetValue(details, CFSTR("Path"));
CFStringRef container = CFDictionaryGetValue(details, CFSTR("Container"));
if (!container) {
CFURLRef pathURL = CFURLCreateWithString(kCFAllocatorDefault, path, NULL);
CFURLRef containerURL = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault, pathURL);
container = CFURLGetString(containerURL);
CFSafeRelease(pathURL);
}
CFMutableArrayRef containerPathArgs = CFArrayCreateMutable(kCFAllocatorDefault, 0x0, &kCFTypeArrayCallBacks);
CFArrayAppendValue(containerPathArgs, container);
DebuggerCommandRef containerPath = SDMMD_CreateDebuggingCommand(kDebugQSetWorkingDir, NULL, containerPathArgs);
CFSafeRelease(containerPathArgs);
CFDataRef containerPathResponse = NULL;
result = SDMMD_DebuggingSend(dconn, containerPath, &containerPathResponse);
CFSafeRelease(containerPathResponse);
SDMMD_DebuggingCommandRelease(containerPath);
// setting launch args
CFStringRef commandFormat = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("A%d,0,"), (uint32_t)CFStringGetLength(path) * 0x2);
CFMutableArrayRef setLaunchArgsArgs = CFArrayCreateMutable(kCFAllocatorDefault, 0x0, &kCFTypeArrayCallBacks);
CFArrayAppendValue(setLaunchArgsArgs, path);
DebuggerCommandRef setLaunchArgs = SDMMD_CreateDebuggingCommand(kDebugCUSTOMCOMMAND, commandFormat, setLaunchArgsArgs);
CFSafeRelease(setLaunchArgsArgs);
CFSafeRelease(commandFormat);
CFDataRef setLaunchArgsResponse = NULL;
result = SDMMD_DebuggingSend(dconn, setLaunchArgs, &setLaunchArgsResponse);
CFSafeRelease(setLaunchArgsResponse);
SDMMD_DebuggingCommandRelease(setLaunchArgs);
// Check for launch success
CFMutableArrayRef launchSuccessArgs = CFArrayCreateMutable(kCFAllocatorDefault, 0x0, &kCFTypeArrayCallBacks);
DebuggerCommandRef launchSuccessCommand = SDMMD_CreateDebuggingCommand(kDebugqLaunchSuccess, NULL, launchSuccessArgs);
CFSafeRelease(launchSuccessArgs);
CFDataRef launchSuccessResponse = NULL;
result = SDMMD_DebuggingSend(dconn, launchSuccessCommand, &launchSuccessResponse);
if (launchSuccessResponse) {
char *launchSuccessResponseAsString = (char *)CFDataGetBytePtr(launchSuccessResponse);
launchSuccess = !strncmp(launchSuccessResponseAsString, "OK", 2);
if (!launchSuccess) {
printf("Launch failure: %s\n", launchSuccessResponseAsString);
}
}
CFSafeRelease(launchSuccessResponse);
SDMMD_DebuggingCommandRelease(launchSuccessCommand);
if (launchSuccess) {
printf("Launch success\n");
if (!waitForDebugger) {
printf("Continuing with execution...\n");
// setting thread to attach
CFMutableArrayRef setThreadArgs = CFArrayCreateMutable(kCFAllocatorDefault, 0x0, &kCFTypeArrayCallBacks);
CFArrayAppendValue(setThreadArgs, CFSTR(""));
DebuggerCommandRef setThread = SDMMD_CreateDebuggingCommand(kDebugCUSTOMCOMMAND, CFSTR("Hc0"), setThreadArgs);
CFSafeRelease(setThreadArgs);
CFDataRef setThreadResponse = NULL;
result = SDMMD_DebuggingSend(dconn, setThread, &setThreadResponse);
CFSafeRelease(setThreadResponse);
SDMMD_DebuggingCommandRelease(setThread);
// setting continue with execution
CFMutableArrayRef contArgs = CFArrayCreateMutable(kCFAllocatorDefault, 0x0, &kCFTypeArrayCallBacks);
CFArrayAppendValue(contArgs, CFSTR(""));
DebuggerCommandRef cont = SDMMD_CreateDebuggingCommand(kDebugc, NULL, contArgs);
CFSafeRelease(contArgs);
CFDataRef contResponse = NULL;
result = SDMMD_DebuggingSend(dconn, cont, &contResponse);
CFSafeRelease(contResponse);
SDMMD_DebuggingCommandRelease(cont);
}
else {
printf("Waiting for debugger to attach...\n");
CFRunLoopRun();
}
}
}
/*
sdmmd_return_t result = SDMMD_StartDebuggingSessionOnDevice(device, &connection);
if (SDM_MD_CallSuccessful(result)) {
bool launchSuccess = false;
CFStringRef path = CFDictionaryGetValue(details, CFSTR("Path"));
CFStringRef encodedPath = SDMMD_EncodeDebuggingString(path);
CFStringRef container = CFDictionaryGetValue(details, CFSTR("Container"));
if (!container) {
CFURLRef pathURL = CFURLCreateWithString(kCFAllocatorDefault, path, NULL);
CFURLRef containerURL = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault, pathURL);
container = CFURLGetString(containerURL);
CFSafeRelease(pathURL);
//CFSafeRelease(containerURL);
}
if (container) {
CFStringRef containerPath = SDMMD_EncodeDebuggingString(container);
sdmmd_debug_return_t dresult;
CFStringRef maxPacket = SDMMD_EncodeDebuggingString(CFSTR("1024"));
dresult = SDMMD_DebuggingSend(connection, KnownDebugCommands[kDebugQSetMaxPacketSize], maxPacket);
CFSafeRelease(maxPacket);
dresult = SDMMD_DebuggingSend(connection, KnownDebugCommands[kDebugQSetWorkingDir], containerPath);
CFSafeRelease(containerPath);
CFStringRef commandFormat = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%d,0,%s"), (uint32_t)CFStringGetLength(encodedPath), CFStringGetCStringPtr(encodedPath, kCFStringEncodingUTF8));
dresult = SDMMD_DebuggingSend(connection, KnownDebugCommands[kDebugA], commandFormat);
CFSafeRelease(commandFormat);
dresult = SDMMD_DebuggingSend(connection, KnownDebugCommands[kDebugH], CFSTR("c0"));
dresult = SDMMD_DebuggingSend(connection, KnownDebugCommands[kDebugc], CFSTR(""));
launchSuccess = true;
}
CFSafeRelease(encodedPath);
if (launchSuccess) {
CFRunLoopRun();
}
}
*/
}
}
}
}
}
}
