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;
}
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_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_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_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;
}
sdmmd_return_t SDMMD_AMDeviceTransferApplication(SDMMD_AMConnectionRef conn, CFStringRef path, CFDictionaryRef options, CallBack transferCallback, void* unknown) {
sdmmd_return_t result = kAMDInvalidArgumentError;
if (path) {
if (conn) {
char *cpath = calloc(1, sizeof(char[1024]));
ATR_UNUSED struct stat pathStat, remoteStat;
Boolean status = CFStringGetCString(path, cpath, 1024, kCFStringEncodingUTF8);
if (status) {
CFURLRef deviceURL = SDMMD__AMDCFURLCreateFromFileSystemPathWithSmarts(path);
if (deviceURL) {
CFStringRef lastComp = CFURLCopyLastPathComponent(deviceURL);
if (lastComp) {
CFURLRef base = SDMMD__AMDCFURLCreateWithFileSystemPathRelativeToBase(kCFAllocatorDefault, CFSTR("PublicStaging"), 0, true);
CFURLRef copy = CFURLCreateCopyAppendingPathComponent(kCFAllocatorDefault, base, lastComp, true);
char *copyPath = calloc(1024, sizeof(char));
SDMMD__AMDCFURLGetCStringForFileSystemPath(copy, copyPath);
SDMMD_fire_callback_767f4(transferCallback, unknown, 0, CFSTR("PreflightingTransfer"));
//SDMMD_preflight_transfer(&cpath, &pathStat, &remoteStat);
SDMMD_fire_callback_767f4(transferCallback, unknown, 0, CFSTR("TransferingPackage"));
SDMMD_AFCConnectionRef afcConn = SDMMD_AFCConnectionCreate(conn);//(r12, conn, 0x0, 0x0, &var_72);
if (afcConn) {
result = kAMDSuccess;
}
CheckErrorAndReturn(result);
result = SDMMD_AMDeviceCopy(afcConn, cpath, copyPath);
/*
CFDataRef touchResponse;
result = SDMMD_check_can_touch(afcConn, &touchResponse);
CheckErrorAndReturn(result);
CFURLRef parent = CFURLCreateCopyDeletingLastPathComponent(r12, r13);
result = SDMMD_make_path(afcConn, parent);
CheckErrorAndReturn(result);
result = SDMMD_nuke_path(afcConn, r13);
if ((result | 0x8) == 0x8) {
int statResult = lstat(cpath, &pathStat);
if (statResult != 0xff) {
if ((var_84 & 0xffff & 0xf000) != 0xa000) {
if (rax == 0x8000) {
rbx = SDMMD_copy_touch_file(&remoteStat, transferCallback, unknown, afcConn, &cpath, ©Path);
}
else {
if (rax == 0x4000) {
rbx = SDMMD_copy_directory(&remoteStat, transferCallback, unknown, afcConn, &cpath, ©Path);
}
else {
printf("transfer_package: Don't know how to copy this type of file: %s\n", cpath);
}
}
}
else {
rbx = SDMMD_copy_symlink(afcConn, &cpath, ©Path);
}
r14 = 0x0;
if (rbx != 0x0) {
r9 = SDMMD_AFCErrorString(rbx);
printf("transfer_package: Could not copy %s to %s on the device.\n", cpath, copyPath);
result = kAMDUndefinedError;
}
result = SDMMD_AFCConnectionClose(afcConn);
if (result) {
printf("transfer_package: Could not close AFC connection. error: %i\n", result);
}
CFSafeRelease(r12);
}
*/
CFSafeRelease(base);
CFSafeRelease(copy);
}
CFSafeRelease(lastComp);
}
CFSafeRelease(deviceURL);
}
else {
result = kAMDUndefinedError;
}
Safe(free, cpath);
}
}
ExitLabelAndReturn(result);
}
