kern_return_t test_sdm_AFCOperationCreateGetConnectionInfo(SDMMD_AMDeviceRef sdm, CFTypeRef *response) {
kern_return_t sdm_return = kAMDUndefinedError;
kern_return_t result = SDMMD_AMDeviceConnect(sdm);
if (SDM_MD_CallSuccessful(result)) {
result = SDMMD_AMDeviceStartSession(sdm);
if (SDM_MD_CallSuccessful(result)) {
SDMMD_AMConnectionRef test_sdm_afc_conn;
if (SDMMD_AMDeviceGetInterfaceType(sdm) == kAMDInterfaceConnectionTypeIndirect) {
result = SDMMD_AMDeviceSecureStartService(sdm, CFSTR(AMSVC_AFC), NULL, &test_sdm_afc_conn);
}
else {
result = SDMMD_AMDeviceStartService(sdm, CFSTR(AMSVC_AFC), NULL, &test_sdm_afc_conn);
}
if (SDM_MD_CallSuccessful(result)) {
SDMMD_AFCConnectionRef afc = SDMMD_AFCConnectionCreate(test_sdm_afc_conn);
if (afc) {
SDMMD_AFCOperationRef conn_info = SDMMD_AFCOperationCreateGetConnectionInfo();
result = SDMMD_AFCProcessOperation(afc, &conn_info);
if (SDM_MD_CallSuccessful(result)) {
CFTypeRef test = SDMMD_AFCOperationGetPacketResponse(conn_info);
if (test) {
*response = test;
sdm_return = kAMDSuccess;
}
}
CFSafeRelease(afc);
}
}
SDMMD_AMDeviceStopSession(sdm);
}
SDMMD_AMDeviceDisconnect(sdm);
}
return sdm_return;
}
sdmmd_return_t SDMMD_copy_image(SDMMD_AMDeviceRef device, CFStringRef path)
{
sdmmd_return_t result = kAMDUndefinedError;
if (device) {
result = kAMDSuccess; //SDMMD_AMDeviceConnect(device);
CheckErrorAndReturn(result);
result = SDMMD_AMDeviceStartSession(device);
CheckErrorAndReturn(result);
SDMMD_AMConnectionRef copyConn = NULL;
result = SDMMD_AMDeviceSecureStartService(device, CFSTR(AMSVC_AFC), NULL, ©Conn);
CheckErrorAndReturn(result);
SDMMD_AFCConnectionRef copyAFCConn = SDMMD_AFCConnectionCreate(copyConn);
SDMMD_AFCOperationRef makeStaging = SDMMD_AFCOperationCreateMakeDirectory(CFSTR("PublicStaging"));
result = SDMMD_AFCProcessOperation(copyAFCConn, &makeStaging);
CheckErrorAndReturn(result);
// SDM copy file AFC
char *pathString = SDMCFStringGetString(path);
result = SDMMD_AMDeviceCopyFile(SDMMD_Default_AFC_CopyFile_Callback, NULL, NULL, copyAFCConn, pathString, "PublicStaging/staging.dimage");
Safe(free, pathString);
CFSafeRelease(makeStaging);
CFSafeRelease(copyAFCConn);
CFSafeRelease(copyConn);
}
ExitLabelAndReturn(result);
}
kern_return_t test_sdm_AFCConnectionCreate(SDMMD_AMDeviceRef sdm) {
kern_return_t sdm_return = kAMDUndefinedError;
kern_return_t result = SDMMD_AMDeviceConnect(sdm);
if (SDM_MD_CallSuccessful(result)) {
result = SDMMD_AMDeviceStartSession(sdm);
if (SDM_MD_CallSuccessful(result)) {
SDMMD_AMConnectionRef test_sdm_afc_conn;
if (SDMMD_AMDeviceGetInterfaceType(sdm) == kAMDInterfaceConnectionTypeIndirect) {
result = SDMMD_AMDeviceSecureStartService(sdm, CFSTR(AMSVC_AFC), NULL, &test_sdm_afc_conn);
}
else {
result = SDMMD_AMDeviceStartService(sdm, CFSTR(AMSVC_AFC), NULL, &test_sdm_afc_conn);
}
if (SDM_MD_CallSuccessful(result)) {
SDMMD_AFCConnectionRef afc = SDMMD_AFCConnectionCreate(test_sdm_afc_conn);
if (afc) {
sdm_return = kAMDSuccess;
CFSafeRelease(test_sdm_afc_conn);
CFSafeRelease(afc);
}
}
SDMMD_AMDeviceStopSession(sdm);
}
SDMMD_AMDeviceDisconnect(sdm);
}
return sdm_return;
}
sdmmd_return_t SDMMD_AMDeviceInstallApp(SDMMD_AMDeviceRef device, CFStringRef path) {
sdmmd_return_t result = kAMDNotConnectedError;
SDMMD_AMConnectionRef connection = NULL;
if (device) {
result = SDMMD_AMDeviceConnect(device);
CheckErrorAndReturn(result);
result = SDMMD_AMDeviceStartSession(device);
CheckErrorAndReturn(result);
result = SDMMD_AMDeviceSecureStartService(device, CFSTR(AMSVC_AFC), NULL, &connection);
CheckErrorAndReturn(result);
CFStringRef keys[] = { CFSTR("PackageType") };
CFStringRef values[] = { CFSTR("Developer") };
CFDictionaryRef options = CFDictionaryCreate(NULL, (const void **)&keys, (const void **)&values, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
result = SDMMD_AMDeviceInstallApplication(device, path, options, SDMMD_Default_install_callback, NULL);
CheckErrorAndReturn(result);
result = SDMMD_AMDeviceStopSession(device);
CheckErrorAndReturn(result);
result = SDMMD_AMDeviceDisconnect(device);
CheckErrorAndReturn(result);
}
ExitLabelAndReturn(result);
}
sdmmd_return_t SDMMD_AMDeviceCopyApplication(SDMMD_AMDeviceRef device, CFStringRef path) {
sdmmd_return_t result = kAMDNotConnectedError;
SDMMD_AMConnectionRef connection = NULL;
if (device) {
result = SDMMD_AMDeviceConnect(device);
CheckErrorAndReturn(result);
result = SDMMD_AMDeviceStartSession(device);
CheckErrorAndReturn(result);
result = SDMMD_AMDeviceSecureStartService(device, CFSTR(AMSVC_AFC), NULL, &connection);
CheckErrorAndReturn(result);
result = SDMMD_AMDeviceTransferApplication(connection, path, NULL, SDMMD_Default_transfer_callback, NULL);
CheckErrorAndReturn(result);
result = SDMMD_AMDServiceConnectionInvalidate(connection);
CheckErrorAndReturn(result);
result = SDMMD_AMDeviceStopSession(device);
CheckErrorAndReturn(result);
result = SDMMD_AMDeviceDisconnect(device);
CheckErrorAndReturn(result);
}
ExitLabelAndReturn(result);
}
sdmmd_return_t SDMMD_AMDeviceLookupApplications(SDMMD_AMDeviceRef device, CFDictionaryRef options, CFDictionaryRef *response)
{
sdmmd_return_t result = kAMDInvalidArgumentError;
if (device) {
if (options) {
CFDictionaryRef options_dict = NULL;
SDMMD_AMConnectionRef conn = SDMMD_AMDServiceConnectionCreate(0, NULL, options_dict);
result = SDMMD_AMDeviceSecureStartService(device, CFSTR(AMSVC_INSTALLATION_PROXY), NULL, &conn);
if (result == 0) {
CFMutableDictionaryRef dict = SDMMD_create_dict();
result = kAMDNoResourcesError;
if (dict) {
result = SDMMD_perform_command(conn, CFSTR("Browse"), 0, SDMMD_browse_callback, 2, dict, CFSTR("ClientOptions"), options);
if (!result) {
*response = dict;
}
}
}
else {
printf("%s: Was unable to start the install service on the device: %i\n", __FUNCTION__, device->ivars.device_id);
}
//CFSafeRelease(conn);
}
}
return result;
}
sdmmd_return_t SDMMD_AMDeviceSecureInstallApplication(SDMMD_AMConnectionRef conn, SDMMD_AMDeviceRef device, CFURLRef path, CFDictionaryRef options, CallBack installCallback, void *unknown)
{
sdmmd_return_t result = kAMDSuccess;
SDMMD_AMConnectionRef connection = NULL;
bool hasConnection = (conn ? true : false);
if (device) {
result = SDMMD_AMDeviceSecureStartService(device, CFSTR(AMSVC_INSTALLATION_PROXY), NULL, &connection);
if (result == 0) {
hasConnection = true;
}
else {
printf("%s: Was unable to start the install service on the device 0x%x.\n", __FUNCTION__, result);
}
}
if (hasConnection) {
CFStringRef lastComp = CFURLCopyLastPathComponent(path);
if (CFStringGetLength(lastComp) == 0) {
CFSafeRelease(lastComp);
CFURLRef pathURL = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault, path);
lastComp = CFURLCopyLastPathComponent(pathURL);
CFSafeRelease(pathURL);
}
if (lastComp) {
CFStringRef format = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("PublicStaging/%@"), lastComp);
if (format) {
char *appName = SDMCFStringGetString(format);
printf("%s: Attempting install of %s.\n", __FUNCTION__, appName);
result = SDMMD_perform_command(connection, CFSTR("Install"), 0, installCallback, 4, unknown, CFSTR("PackagePath"), format, CFSTR("ClientOptions"), options);
if (result) {
printf("%s: Old style of install failed for (%s).\n", __FUNCTION__, appName);
}
Safe(free, appName);
}
else {
printf("%s: Unable to create CFString!\n", __FUNCTION__);
}
CFSafeRelease(format);
}
else {
char *lastCompString = SDMCFStringGetString(lastComp);
printf("%s: Could not copy last path component from url %s.\n", __FUNCTION__, lastCompString);
Safe(free, lastCompString);
}
CFSafeRelease(lastComp);
}
CFSafeRelease(connection);
char *pathString = SDMCFURLGetString(path);
printf("%s: Installation of package %s returned 0x%x.\n", __FUNCTION__, pathString, result);
Safe(free, pathString);
return result;
}
kern_return_t test_sdm_AFCFileDescriptorCreateReadOperation(SDMMD_AMDeviceRef sdm, CFTypeRef *response) {
kern_return_t sdm_return = kAMDUndefinedError;
kern_return_t result = SDMMD_AMDeviceConnect(sdm);
if (SDM_MD_CallSuccessful(result)) {
result = SDMMD_AMDeviceStartSession(sdm);
if (SDM_MD_CallSuccessful(result)) {
SDMMD_AMConnectionRef test_sdm_afc_conn;
if (SDMMD_AMDeviceGetInterfaceType(sdm) == kAMDInterfaceConnectionTypeIndirect) {
result = SDMMD_AMDeviceSecureStartService(sdm, CFSTR(AMSVC_AFC), NULL, &test_sdm_afc_conn);
}
else {
result = SDMMD_AMDeviceStartService(sdm, CFSTR(AMSVC_AFC), NULL, &test_sdm_afc_conn);
}
if (SDM_MD_CallSuccessful(result)) {
SDMMD_AFCConnectionRef afc = SDMMD_AFCConnectionCreate(test_sdm_afc_conn);
if (afc) {
SDMMD_AFCOperationRef file_info = SDMMD_AFCOperationCreateGetFileInfo(CFSTR(kTestCreateFileForAFC));
result = SDMMD_AFCProcessOperation(afc, &file_info);
if (SDM_MD_CallSuccessful(result)) {
CFTypeRef file_info_response = SDMMD_AFCOperationGetPacketResponse(file_info);
int32_t size = CFStringGetIntValue(CFDictionaryGetValue(file_info_response, AFC_File_Info_Keys[AFC_File_Info_Key_size]));
SDMMD_AFCOperationRef file_ref = SDMMD_AFCOperationCreateFileRefOpen(CFSTR(kTestCreateFileForAFC), 2);
result = SDMMD_AFCProcessOperation(afc, &file_ref);
if (SDM_MD_CallSuccessful(result)) {
uint64_t fd = 0;
CFTypeRef file_ref_response = SDMMD_AFCOperationGetPacketResponse(file_ref);
memcpy(&fd, CFDataGetBytePtr(file_ref_response), sizeof(uint64_t));
SDMMD_AFCOperationRef file_ref_read = SDMMD_AFCFileDescriptorCreateReadOperation(fd, size);
result = SDMMD_AFCProcessOperation(afc, &file_ref_read);
if (SDM_MD_CallSuccessful(result)) {
CFTypeRef file_ref_read_response = SDMMD_AFCOperationGetPacketResponse(file_ref_read);
if (file_ref_read_response) {
*response = file_ref_read_response;
sdm_return = kAMDSuccess;
}
}
}
}
CFSafeRelease(afc);
}
}
SDMMD_AMDeviceStopSession(sdm);
}
SDMMD_AMDeviceDisconnect(sdm);
}
return sdm_return;
}
kern_return_t test_sdm_AMDeviceSecureStartService(SDMMD_AMDeviceRef sdm) {
kern_return_t sdm_return = kAMDUndefinedError;
kern_return_t result = SDMMD_AMDeviceConnect(sdm);
if (SDM_MD_CallSuccessful(result)) {
result = SDMMD_AMDeviceStartSession(sdm);
if (SDM_MD_CallSuccessful(result)) {
SDMMD_AMConnectionRef test_sdm_conn;
sdm_return = SDMMD_AMDeviceSecureStartService(sdm, CFSTR(AMSVC_MOBILE_IMAGE_MOUNT), NULL, &test_sdm_conn);
if (sdm_return != kAMDSuccess) {
printf("\t\tSDMMD_AMDeviceSecureStartService: %08x %s\n",sdm_return,SDMMD_AMDErrorString(sdm_return));
}
SDMMD_AMDeviceStopSession(sdm);
}
SDMMD_AMDeviceDisconnect(sdm);
}
return sdm_return;
}
kern_return_t test_sdm_AFCFileDescriptorCreateWriteOperation(SDMMD_AMDeviceRef sdm, CFTypeRef *response) {
kern_return_t sdm_return = kAMDUndefinedError;
kern_return_t result = SDMMD_AMDeviceConnect(sdm);
if (SDM_MD_CallSuccessful(result)) {
result = SDMMD_AMDeviceStartSession(sdm);
if (SDM_MD_CallSuccessful(result)) {
SDMMD_AMConnectionRef test_sdm_afc_conn;
if (SDMMD_AMDeviceGetInterfaceType(sdm) == kAMDInterfaceConnectionTypeIndirect) {
result = SDMMD_AMDeviceSecureStartService(sdm, CFSTR(AMSVC_AFC), NULL, &test_sdm_afc_conn);
}
else {
result = SDMMD_AMDeviceStartService(sdm, CFSTR(AMSVC_AFC), NULL, &test_sdm_afc_conn);
}
if (SDM_MD_CallSuccessful(result)) {
SDMMD_AFCConnectionRef afc = SDMMD_AFCConnectionCreate(test_sdm_afc_conn);
if (afc) {
SDMMD_AFCOperationRef file_ref = SDMMD_AFCOperationCreateFileRefOpen(CFSTR(kTestCreateFileForAFC), 2);
result = SDMMD_AFCProcessOperation(afc, &file_ref);
if (SDM_MD_CallSuccessful(result)) {
uint64_t fd = 0;
CFTypeRef file_ref_response = SDMMD_AFCOperationGetPacketResponse(file_ref);
memcpy(&fd, CFDataGetBytePtr(file_ref_response), sizeof(uint64_t));
CFDataRef write_data = CFDataCreate(kCFAllocatorDefault, (const UInt8 *)test_write_bytes, strlen(test_write_bytes));
SDMMD_AFCOperationRef file_ref_read = SDMMD_AFCFileDescriptorCreateWriteOperation(fd, write_data);
result = SDMMD_AFCProcessOperation(afc, &file_ref_read);
if (SDM_MD_CallSuccessful(result)) {
CFTypeRef file_ref_read_response = SDMMD_AFCOperationGetPacketResponse(file_ref_read);
if (file_ref_read_response) {
*response = file_ref_read_response;
sdm_return = kAMDSuccess;
}
}
}
CFSafeRelease(afc);
}
}
SDMMD_AMDeviceStopSession(sdm);
}
SDMMD_AMDeviceDisconnect(sdm);
}
return sdm_return;
}
kern_return_t test_sdm_AMDeviceStartService(SDMMD_AMDeviceRef sdm) {
kern_return_t sdm_return = kAMDUndefinedError;
kern_return_t result = SDMMD_AMDeviceConnect(sdm);
if (SDM_MD_CallSuccessful(result)) {
result = SDMMD_AMDeviceStartSession(sdm);
if (SDM_MD_CallSuccessful(result)) {
SDMMD_AMConnectionRef test_sdm_conn;
if (SDMMD_AMDeviceGetInterfaceType(sdm) == kAMDInterfaceConnectionTypeIndirect) {
sdm_return = SDMMD_AMDeviceSecureStartService(sdm, CFSTR(AMSVC_AFC), NULL, &test_sdm_conn);
}
else {
sdm_return = SDMMD_AMDeviceStartService(sdm, CFSTR(AMSVC_AFC), NULL, &test_sdm_conn);
}
if (sdm_return != kAMDSuccess) {
printf("\t\tSDMMD_AMDeviceStartService: %08x %s\n",sdm_return,SDMMD_AMDErrorString(sdm_return));
}
SDMMD_AMDeviceStopSession(sdm);
}
SDMMD_AMDeviceDisconnect(sdm);
}
return sdm_return;
}
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));
}
}
}
