static int start_logging(void) { idevice_error_t ret = idevice_new(&device, udid); if (ret != IDEVICE_E_SUCCESS) { fprintf(stderr, "Device with udid %s not found!?\n", udid); return -1; } /* start and connect to syslog_relay service */ syslog_relay_error_t serr = SYSLOG_RELAY_E_UNKNOWN_ERROR; serr = syslog_relay_client_start_service(device, &syslog, "idevicesyslog"); if (serr != SYSLOG_RELAY_E_SUCCESS) { fprintf(stderr, "ERROR: Could not start service com.apple.syslog_relay.\n"); idevice_free(device); device = NULL; return -1; } /* start capturing syslog */ serr = syslog_relay_start_capture(syslog, syslog_callback, NULL); if (serr != SYSLOG_RELAY_E_SUCCESS) { fprintf(stderr, "ERROR: Unable tot start capturing syslog.\n"); syslog_relay_client_free(syslog); syslog = NULL; idevice_free(device); device = NULL; return -1; } fprintf(stdout, "[connected]\n"); fflush(stdout); return 0; }
int restore_check_mode(const char* uuid) { char* type = NULL; uint64_t version = 0; idevice_t device = NULL; restored_client_t restore = NULL; idevice_error_t device_error = IDEVICE_E_SUCCESS; restored_error_t restore_error = RESTORE_E_SUCCESS; device_error = idevice_new(&device, uuid); if (device_error != IDEVICE_E_SUCCESS) { return -1; } restore_error = restored_client_new(device, &restore, "idevicerestore"); if (restore_error != RESTORE_E_SUCCESS) { idevice_free(device); return -1; } restore_error = restored_query_type(restore, &type, &version); if (restore_error != RESTORE_E_SUCCESS) { restored_client_free(restore); idevice_free(device); return -1; } restored_client_free(restore); idevice_free(device); restore = NULL; device = NULL; return 0; }
int normal_check_mode(const char* uuid) { char* type = NULL; idevice_t device = NULL; lockdownd_client_t lockdown = NULL; idevice_error_t device_error = IDEVICE_E_SUCCESS; lockdownd_error_t lockdown_error = IDEVICE_E_SUCCESS; device_error = idevice_new(&device, uuid); if (device_error != IDEVICE_E_SUCCESS) { return -1; } lockdown_error = lockdownd_client_new(device, &lockdown, "idevicerestore"); if (lockdown_error != LOCKDOWN_E_SUCCESS) { idevice_free(device); return -1; } lockdown_error = lockdownd_query_type(lockdown, &type); if (lockdown_error != LOCKDOWN_E_SUCCESS) { lockdownd_client_free(lockdown); idevice_free(device); return -1; } lockdownd_client_free(lockdown); idevice_free(device); lockdown = NULL; device = NULL; return 0; }
int normal_enter_recovery(struct idevicerestore_client_t* client) { idevice_t device = NULL; irecv_client_t recovery = NULL; lockdownd_client_t lockdown = NULL; irecv_error_t recovery_error = IRECV_E_SUCCESS; idevice_error_t device_error = IDEVICE_E_SUCCESS; lockdownd_error_t lockdown_error = LOCKDOWN_E_SUCCESS; device_error = idevice_new(&device, client->uuid); if (device_error != IDEVICE_E_SUCCESS) { error("ERROR: Unable to find device\n"); return -1; } lockdown_error = lockdownd_client_new(device, &lockdown, "idevicerestore"); if (lockdown_error != LOCKDOWN_E_SUCCESS) { error("ERROR: Unable to connect to lockdownd service\n"); idevice_free(device); return -1; } lockdown_error = lockdownd_enter_recovery(lockdown); if (lockdown_error != LOCKDOWN_E_SUCCESS) { error("ERROR: Unable to place device in recovery mode\n"); lockdownd_client_free(lockdown); idevice_free(device); return -1; } lockdownd_client_free(lockdown); idevice_free(device); lockdown = NULL; device = NULL; if (recovery_open_with_timeout(client) < 0) { error("ERROR: Unable to enter recovery mode\n"); return -1; } recovery_error = irecv_send_command(recovery, "setenv auto-boot true"); if (recovery_error != IRECV_E_SUCCESS) { error("ERROR: Unable to reset auto-boot variable\n"); irecv_close(recovery); return -1; } recovery_error = irecv_send_command(recovery, "saveenv"); if (recovery_error != IRECV_E_SUCCESS) { error("ERROR: Unable to save auto-boot variable\n"); irecv_close(recovery); return -1; } //client->mode = &idevicerestore_modes[MODE_RECOVERY]; irecv_close(recovery); recovery = NULL; return 0; }
int restore_check_device(const char* uuid) { int i = 0; char* type = NULL; char* model = NULL; plist_t node = NULL; uint64_t version = 0; idevice_t device = NULL; restored_client_t restore = NULL; idevice_error_t device_error = IDEVICE_E_SUCCESS; restored_error_t restore_error = RESTORE_E_SUCCESS; device_error = idevice_new(&device, uuid); if (device_error != IDEVICE_E_SUCCESS) { return -1; } restore_error = restored_client_new(device, &restore, "idevicerestore"); if (restore_error != RESTORE_E_SUCCESS) { idevice_free(device); return -1; } restore_error = restored_query_type(restore, &type, &version); if (restore_error != RESTORE_E_SUCCESS) { restored_client_free(restore); idevice_free(device); return -1; } restore_error = restored_get_value(restore, "HardwareModel", &node); if (restore_error != RESTORE_E_SUCCESS) { error("ERROR: Unable to get HardwareModel from restored\n"); restored_client_free(restore); idevice_free(device); return -1; } restored_client_free(restore); idevice_free(device); restore = NULL; device = NULL; if (!node || plist_get_node_type(node) != PLIST_STRING) { error("ERROR: Unable to get HardwareModel information\n"); if (node) plist_free(node); return -1; } plist_get_string_val(node, &model); for (i = 0; idevicerestore_devices[i].model != NULL; i++) { if (!strcasecmp(model, idevicerestore_devices[i].model)) { break; } } return idevicerestore_devices[i].device_id; }
int main(int argc, char *argv[]) { lockdownd_client_t client = NULL; idevice_t phone = NULL; GError *err; uint16_t port = 0; afc_client_t afc = NULL; if (argc > 1 && !strcasecmp(argv[1], "--debug")) { idevice_set_debug_level(1); } else { idevice_set_debug_level(0); } if (IDEVICE_E_SUCCESS != idevice_new(&phone, NULL)) { printf("No device found, is it plugged in?\n"); return 1; } if (LOCKDOWN_E_SUCCESS != lockdownd_client_new_with_handshake(phone, &client, "afccheck")) { idevice_free(phone); return 1; } if (LOCKDOWN_E_SUCCESS == lockdownd_start_service(client, "com.apple.afc", &port) && !port) { lockdownd_client_free(client); idevice_free(phone); fprintf(stderr, "Something went wrong when starting AFC."); return 1; } afc_client_new(phone, port, &afc); //makes sure thread environment is available if (!g_thread_supported()) g_thread_init(NULL); GThread *threads[NB_THREADS]; param data[NB_THREADS]; int i = 0; for (i = 0; i < NB_THREADS; i++) { data[i].afc = afc; data[i].id = i + 1; threads[i] = g_thread_create((GThreadFunc) check_afc, data + i, TRUE, &err); } for (i = 0; i < NB_THREADS; i++) { g_thread_join(threads[i]); } lockdownd_client_free(client); idevice_free(phone); return 0; }
int restore_open_with_timeout(const char* uuid, idevice_t* device, restored_client_t* restore) { int i = 0; int attempts = 10; idevice_t context = NULL; restored_client_t client = NULL; idevice_error_t device_error = IDEVICE_E_SUCCESS; restored_error_t restore_error = RESTORE_E_SUCCESS; *device = NULL; *restore = NULL; device_error = idevice_event_subscribe(&restore_device_callback, NULL); if (device_error != IDEVICE_E_SUCCESS) { error("ERROR: Unable to subscribe to device events\n"); return -1; } for (i = 1; i <= attempts; i++) { if (restore_device_connected == 1) { break; } if (i == attempts) { error("ERROR: Unable to connect to device in restore mode\n"); } sleep(2); } device_error = idevice_new(&context, uuid); if (device_error != IDEVICE_E_SUCCESS) { return -1; } restore_error = restored_client_new(context, &client, "idevicerestore"); if (restore_error != RESTORE_E_SUCCESS) { idevice_event_unsubscribe(); idevice_free(context); return -1; } restore_error = restored_query_type(client, NULL, NULL); if (restore_error != RESTORE_E_SUCCESS) { restored_client_free(client); idevice_event_unsubscribe(); idevice_free(context); return -1; } *device = context; *restore = client; return 0; }
int main(int argc, char *argv[]) { lockdownd_client_t client = NULL; idevice_t phone = NULL; idevice_error_t ret = IDEVICE_E_UNKNOWN_ERROR; int i; char uuid[41]; uuid[0] = 0; /* parse cmdline args */ for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--debug")) { idevice_set_debug_level(1); continue; } else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) { print_usage(argc, argv); return 0; } } i--; if (!argv[i] || (strlen(argv[i]) != 40)) { print_usage(argc, argv); return 0; } strcpy(uuid, argv[i]); ret = idevice_new(&phone, uuid); if (ret != IDEVICE_E_SUCCESS) { printf("No device found with uuid %s, is it plugged in?\n", uuid); return -1; } if (LOCKDOWN_E_SUCCESS != lockdownd_client_new(phone, &client, "ideviceenterrecovery")) { idevice_free(phone); return -1; } /* run query and output information */ printf("Telling device with uuid %s to enter recovery mode.}\n", uuid); if(lockdownd_enter_recovery(client) != LOCKDOWN_E_SUCCESS) { printf("Failed to enter recovery mode.\n"); } printf("Device is successfully switching to recovery mode.\n"); lockdownd_client_free(client); idevice_free(phone); return 0; }
int normal_check_device(struct idevicerestore_client_t* client) { int i = 0; idevice_t device = NULL; char* product_type = NULL; plist_t product_type_node = NULL; lockdownd_client_t lockdown = NULL; idevice_error_t device_error = IDEVICE_E_SUCCESS; lockdownd_error_t lockdown_error = IDEVICE_E_SUCCESS; normal_idevice_new(client, &device); if (!device) { return -1; } lockdown_error = lockdownd_client_new_with_handshake(device, &lockdown, "idevicerestore"); if (lockdown_error != LOCKDOWN_E_SUCCESS) { idevice_free(device); return -1; } lockdown_error = lockdownd_get_value(lockdown, NULL, "ProductType", &product_type_node); if (lockdown_error != LOCKDOWN_E_SUCCESS) { lockdownd_client_free(lockdown); idevice_free(device); return -1; } lockdownd_client_free(lockdown); idevice_free(device); lockdown = NULL; device = NULL; if (!product_type_node || plist_get_node_type(product_type_node) != PLIST_STRING) { if (product_type_node) plist_free(product_type_node); return -1; } plist_get_string_val(product_type_node, &product_type); plist_free(product_type_node); for (i = 0; irecv_devices[i].product != NULL; i++) { if (!strcmp(product_type, irecv_devices[i].product)) { break; } } return irecv_devices[i].index; }
/* * Class: com_att_aro_libimobiledevice_Screencapture * Method: startService * Signature: ()V */ JNIEXPORT jstring JNICALL Java_com_att_aro_libimobiledevice_ScreencaptureImpl_startService (JNIEnv * env, jobject obj) { const char * str;// = "SUCCESS"; if (IDEVICE_E_SUCCESS != idevice_new(&device, udid)) { str = "No device found, is it plugged in?\n"; return outPut(env, str); } if(!device) { str = "No device mounted"; return outPut(env, str); } if (LOCKDOWN_E_SUCCESS != lockdownd_client_new_with_handshake(device, &lckd, NULL)) { idevice_free(device); str = "Failed to acquire lock service."; return outPut(env, str); } lockdownd_start_service(lckd, "com.apple.mobile.screenshotr", &service); lockdownd_client_free(lckd); if (service && service->port > 0) { if (screenshotr_client_new(device, service, &shotr) != SCREENSHOTR_E_SUCCESS) { str = "Could not connect to screenshotr service!"; } else { str = "SUCCESS"; } } else { str = "Could not start screenshotr service! Try running Instruments tool from XCode on this device and see if it work, then try this again."; } return outPut(env, str); }
void ibrowserAPI::clean() { if (NULL != device) { idevice_free(device); device = NULL; } if (NULL != instproxy_client) { instproxy_client_free(instproxy_client); instproxy_client = NULL; } if (NULL != lockdownd_client) { lockdownd_client_free(lockdownd_client); lockdownd_client = NULL; } if (NULL != sbservices_client) { sbservices_client_free(sbservices_client); sbservices_client = NULL; } if (NULL != afc_client) { afc_client_free(afc_client); afc_client = NULL; } }
int normal_get_nonce(struct idevicerestore_client_t* client, unsigned char** nonce, int* nonce_size) { idevice_t device = NULL; plist_t nonce_node = NULL; lockdownd_client_t lockdown = NULL; idevice_error_t device_error = IDEVICE_E_SUCCESS; lockdownd_error_t lockdown_error = IDEVICE_E_SUCCESS; device_error = idevice_new(&device, client->udid); if (device_error != IDEVICE_E_SUCCESS) { return -1; } lockdown_error = lockdownd_client_new(device, &lockdown, "idevicerestore"); if (lockdown_error != LOCKDOWN_E_SUCCESS) { error("ERROR: Unable to connect to lockdownd\n"); idevice_free(device); return -1; } lockdown_error = lockdownd_get_value(lockdown, NULL, "ApNonce", &nonce_node); if (lockdown_error != LOCKDOWN_E_SUCCESS) { error("ERROR: Unable to get ApNonce from lockdownd\n"); lockdownd_client_free(lockdown); idevice_free(device); return -1; } if (!nonce_node || plist_get_node_type(nonce_node) != PLIST_DATA) { error("ERROR: Unable to get nonce\n"); lockdownd_client_free(lockdown); idevice_free(device); return -1; } uint64_t n_size = 0; plist_get_data_val(nonce_node, (char**)nonce, &n_size); *nonce_size = (int)n_size; plist_free(nonce_node); lockdownd_client_free(lockdown); idevice_free(device); lockdown = NULL; device = NULL; return 0; }
void ifuse_cleanup(void *data) { afc_client_t afc = (afc_client_t) data; afc_client_free(afc); if (control) { lockdownd_client_free(control); } idevice_free(phone); }
int normal_enter_recovery(struct idevicerestore_client_t* client) { idevice_t device = NULL; irecv_client_t recovery = NULL; lockdownd_client_t lockdown = NULL; irecv_error_t recovery_error = IRECV_E_SUCCESS; idevice_error_t device_error = IDEVICE_E_SUCCESS; lockdownd_error_t lockdown_error = LOCKDOWN_E_SUCCESS; device_error = idevice_new(&device, client->uuid); if (device_error != IDEVICE_E_SUCCESS) { error("ERROR: Unable to find device\n"); return -1; } lockdown_error = lockdownd_client_new(device, &lockdown, "idevicerestore"); if (lockdown_error != LOCKDOWN_E_SUCCESS) { error("ERROR: Unable to connect to lockdownd service\n"); idevice_free(device); return -1; } lockdown_error = lockdownd_enter_recovery(lockdown); if (lockdown_error != LOCKDOWN_E_SUCCESS) { error("ERROR: Unable to place device in recovery mode\n"); lockdownd_client_free(lockdown); idevice_free(device); return -1; } lockdownd_client_free(lockdown); idevice_free(device); lockdown = NULL; device = NULL; if (recovery_client_new(client) < 0) { error("ERROR: Unable to enter recovery mode\n"); return -1; } client->mode = &idevicerestore_modes[MODE_RECOVERY]; recovery = NULL; return 0; }
int normal_get_ecid(struct idevicerestore_client_t* client, uint64_t* ecid) { idevice_t device = NULL; plist_t unique_chip_node = NULL; lockdownd_client_t lockdown = NULL; idevice_error_t device_error = IDEVICE_E_SUCCESS; lockdownd_error_t lockdown_error = IDEVICE_E_SUCCESS; device_error = idevice_new(&device, client->uuid); if (device_error != IDEVICE_E_SUCCESS) { return -1; } lockdown_error = lockdownd_client_new_with_handshake(device, &lockdown, "idevicerestore"); if (lockdown_error != LOCKDOWN_E_SUCCESS) { error("ERROR: Unable to connect to lockdownd\n"); idevice_free(device); return -1; } lockdown_error = lockdownd_get_value(lockdown, NULL, "UniqueChipID", &unique_chip_node); if (lockdown_error != LOCKDOWN_E_SUCCESS) { error("ERROR: Unable to get UniqueChipID from lockdownd\n"); lockdownd_client_free(lockdown); idevice_free(device); return -1; } if (!unique_chip_node || plist_get_node_type(unique_chip_node) != PLIST_UINT) { error("ERROR: Unable to get ECID\n"); lockdownd_client_free(lockdown); idevice_free(device); return -1; } plist_get_uint_val(unique_chip_node, ecid); plist_free(unique_chip_node); lockdownd_client_free(lockdown); idevice_free(device); lockdown = NULL; device = NULL; return 0; }
int normal_check_mode(struct idevicerestore_client_t* client) { idevice_t device = NULL; normal_idevice_new(client, &device); if (!device) { return -1; } idevice_free(device); return 0; }
int itdb_iphone_stop_sync(void *sync_ctx) { lockdownd_client_t client = NULL; itdbprep_t prepdata = sync_ctx; printf("libitdbprep: %s called\n", __func__); if (!prepdata) { printf("%s called but prepdata is NULL!\n", __func__); return -1; } if (!prepdata->afc) { printf("%s called but prepdata->afc is NULL!\n", __func__); } else { /* remove .status-com.apple.itdbprep.command.runPostProcess */ if (afc_remove_path(prepdata->afc, "/iTunes_Control/iTunes/iTunes Library.itlp/DBTemp/.status-com.apple.itdprep.command.runPostProcess") != IDEVICE_E_SUCCESS) { fprintf(stderr, "Could not delete '.status-com.apple.itdprep.command.runPostProcess'\n"); } /* remove ddd.itdbm */ if (afc_remove_path(prepdata->afc, "/iTunes_Control/iTunes/iTunes Library.itlp/DBTemp/ddd.itdbm") != IDEVICE_E_SUCCESS) { fprintf(stderr, "Could not delete 'ddd.itdbm'\n"); } if (prepdata->lockfile) { afc_file_lock(prepdata->afc, prepdata->lockfile, AFC_LOCK_UN); afc_file_close(prepdata->afc, prepdata->lockfile); prepdata->lockfile = 0; } else { printf("%s called but lockfile is 0\n", __func__); } afc_client_free(prepdata->afc); prepdata->afc = NULL; } if (LOCKDOWN_E_SUCCESS != lockdownd_client_new_with_handshake(prepdata->device, &client, "libgpod")) { fprintf(stderr, "Error: Could not establish lockdownd connection!\n"); goto leave; } if(itdb_iphone_post_notification(prepdata->device, client, NP_SYNC_DID_FINISH)) { fprintf(stderr, "failed to post syncDidFinish\n"); } printf("%s: posted syncDidFinish\n", __func__); lockdownd_client_free(client); leave: idevice_free(prepdata->device); g_free(prepdata); return 0; }
SWIGEXPORT jshort JNICALL Java_org_robovm_libimobiledevice_binding_libimobiledeviceJNI_idevice_1free(JNIEnv *jenv, jclass jcls, jlong jarg1) { jshort jresult = 0 ; idevice_t arg1 = (idevice_t) 0 ; idevice_error_t result; (void)jenv; (void)jcls; arg1 = *(idevice_t *)&jarg1; result = (idevice_error_t)idevice_free(arg1); jresult = (jshort)result; return jresult; }
static void stop_logging(void) { fflush(stdout); if (syslog) { syslog_relay_client_free(syslog); syslog = NULL; } if (device) { idevice_free(device); device = NULL; } }
/* * Class: com_att_aro_libimobiledevice_Screencapture * Method: stopService * Signature: ()V */ JNIEXPORT void JNICALL Java_com_att_aro_libimobiledevice_ScreencaptureImpl_stopService (JNIEnv * env, jobject obj) { if(shotr) { screenshotr_client_free(shotr); } if (service) { lockdownd_service_descriptor_free(service); } if(device) { idevice_free(device); } }
int connectAFC() { // create an AFC client . printf(" afc client\n"); afcerr = afc_client_new(gDevice, port, &gAfc); if (afcerr != AFC_E_SUCCESS) { printf("%s afc client error%s\n", KRED, KNRM); lockdownd_client_free(gLockdown); idevice_free(gDevice); return -1; } lockdownd_client_free(gLockdown); gLockdown = NULL; printf(" copying files\n"); return 0; }
int enter_recovery() { lockdownd_client_t client = NULL; idevice_t phone = NULL; idevice_t ret = IDEVICE_E_UNKNOWN_ERROR; ret = idevice_new(&phone, NULL); if (ret == IDEVICE_E_SUCCESS) { if (lockdownd_client_new_with_handshake(phone, &client, "ideviceenterrecovery") != LOCKDOWN_E_SUCCESS) { idevice_free(phone); } } if (lockdownd_enter_recovery(client) != LOCKDOWN_E_SUCCESS) { printf("Failed to enter recovery"); return -1; //Failed to enter recovery } printf("entered recovery"); return 0; //Success! }
void normal_client_free(struct idevicerestore_client_t* client) { struct normal_client_t* normal = NULL; if (client) { normal = client->normal; if(normal) { if(normal->client) { lockdownd_client_free(normal->client); normal->client = NULL; } if(normal->device) { idevice_free(normal->device); normal->device = NULL; } } free(normal); client->normal = NULL; } }
static void gst_afc_src_finalize(GObject* object) { GstAfcSrc* self = GST_AFCSRC(object); free(self->location_); free(self->uuid_); free(self->path_); free(self->buffer_); if (self->file_handle_) afc_file_close(self->afc_, self->file_handle_); if (self->afc_) afc_client_free(self->afc_); if (self->device_) idevice_free(self->device_); G_OBJECT_CLASS(parent_class)->finalize(object); }
Device::~Device() { if (this->mInstProxy != NULL) { instproxy_client_free(this->mInstProxy); } if (this->mLockDown != NULL) { lockdownd_goodbye(this->mLockDown); } if (this->mDevice != NULL) { idevice_free(this->mDevice); } if (this->mScreenShotr != NULL) { screenshotr_client_free(this->mScreenShotr); } if (this->mSb != NULL) { sbservices_client_free(this->mSb); } if (this->mNp != NULL) { np_client_free(this->mNp); } if (this->mFileRelay != NULL) { file_relay_client_free(this->mFileRelay); } }
int itdb_iphone_start_sync(Itdb_Device *device, void **prepdata) { int res = 0; int sync_starting = 0; itdbprep_t pdata_loc = NULL; const char *uuid; lockdownd_client_t client = NULL; #ifdef HAVE_LIBIMOBILEDEVICE_1_1_5 lockdownd_service_descriptor_t service = NULL; #else uint16_t afcport = 0; #endif int i; uuid = itdb_device_get_uuid (device); if (!uuid) { fprintf(stderr, "Couldn't find get device UUID itdbprep processing won't work!"); return -ENODEV; } printf("libitdbprep: %s called with uuid=%s\n", __func__, uuid); *prepdata = NULL; pdata_loc = g_new0 (struct itdbprep_int, 1); res = idevice_new(&pdata_loc->device, uuid); if (IDEVICE_E_SUCCESS != res) { fprintf(stderr, "No iPhone found, is it plugged in?\n"); res = -ENODEV; goto leave_with_err; } if (LOCKDOWN_E_SUCCESS != lockdownd_client_new_with_handshake(pdata_loc->device, &client, "libgpod")) { fprintf(stderr, "Error: Could not establish lockdownd connection!\n"); res = -1; goto leave_with_err; } #ifdef HAVE_LIBIMOBILEDEVICE_1_1_5 lockdownd_start_service(client, "com.apple.afc", &service); if (!service || !service->port) { fprintf(stderr, "Error: Could not start AFC service!\n"); res = -1; goto leave_with_err; } afc_client_new(pdata_loc->device, service, &pdata_loc->afc); #else lockdownd_start_service(client, "com.apple.afc", &afcport); if (!afcport) { fprintf(stderr, "Error: Could not start AFC service!\n"); res = -1; goto leave_with_err; } afc_client_new(pdata_loc->device, afcport, &pdata_loc->afc); #endif if (!pdata_loc->afc) { fprintf(stderr, "Error: Could not start AFC client!\n"); res = -1; goto leave_with_err; } if (itdb_iphone_post_notification(pdata_loc->device, client, NP_SYNC_WILL_START)) { fprintf(stderr, "could not post syncWillStart notification!\n"); res = -1; goto leave_with_err; } printf("%s: posted syncWillStart\n", __func__); sync_starting = 1; /* OPEN AND LOCK /com.apple.itunes.lock_sync */ afc_file_open(pdata_loc->afc, "/com.apple.itunes.lock_sync", AFC_FOPEN_RW, &pdata_loc->lockfile); if (!pdata_loc->lockfile) { fprintf(stderr, "could not open lockfile\n"); res = -1; goto leave_with_err; } if (itdb_iphone_post_notification(pdata_loc->device, client, "com.apple.itunes-mobdev.syncLockRequest")) { fprintf(stderr, "could not post syncLockRequest\n"); res = -1; goto leave_with_err; } printf("%s: posted syncLockRequest\n", __func__); for (i=0; i<LOCK_ATTEMPTS; i++) { fprintf(stderr, "Locking for sync, attempt %d...\n", i); res = afc_file_lock(pdata_loc->afc, pdata_loc->lockfile, AFC_LOCK_EX); if (res == AFC_E_SUCCESS) { break; } else if (res == AFC_E_OP_WOULD_BLOCK) { usleep(LOCK_WAIT); continue; } else { fprintf(stderr, "ERROR: could not lock file! error code: %d\n", res); res = -1; goto leave_with_err; } } if (i == LOCK_ATTEMPTS) { fprintf(stderr, "ERROR: timeout while locking for sync\n"); res = -1; goto leave_with_err; } if (itdb_iphone_post_notification(pdata_loc->device, client, NP_SYNC_DID_START)) { fprintf(stderr, "could not post syncDidStart\n"); res = -1; goto leave_with_err; } printf("%s: posted syncDidStart\n", __func__); lockdownd_client_free(client); client = NULL; *prepdata = pdata_loc; return 0; leave_with_err: if (client && sync_starting) { itdb_iphone_post_notification(pdata_loc->device, client, "com.apple.itunes-mobdev.syncFailedToStart"); printf("%s: posted syncFailedToStart\n", __func__); } if (pdata_loc) { if (pdata_loc->afc) { if (pdata_loc->lockfile) { afc_file_lock(pdata_loc->afc, pdata_loc->lockfile, AFC_LOCK_UN); afc_file_close(pdata_loc->afc, pdata_loc->lockfile); pdata_loc->lockfile = 0; } afc_client_free(pdata_loc->afc); pdata_loc->afc = NULL; } if (pdata_loc->device) { idevice_free(pdata_loc->device); pdata_loc->device = NULL; } g_free(pdata_loc); pdata_loc = NULL; } if (client) { lockdownd_client_free(client); client = NULL; } *prepdata = NULL; return res; }
int main(int argc, char **argv) { idevice_t device = NULL; lockdownd_client_t client = NULL; char **dev_list = NULL; char *devname = NULL; int ret = 0; int i; int mode = MODE_SHOW_ID; const char* udid = NULL; /* parse cmdline args */ for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--debug")) { idevice_set_debug_level(1); continue; } else if (!strcmp(argv[i], "-l") || !strcmp(argv[i], "--list")) { mode = MODE_LIST_DEVICES; continue; } else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) { print_usage(argc, argv); return 0; } } /* check if udid was passed */ if (mode == MODE_SHOW_ID) { i--; if (!argv[i] || (strlen(argv[i]) != 40)) { print_usage(argc, argv); return 0; } udid = argv[i]; } switch (mode) { case MODE_SHOW_ID: idevice_new(&device, udid); if (!device) { fprintf(stderr, "ERROR: No device with UDID=%s attached.\n", udid); return -2; } if (LOCKDOWN_E_SUCCESS != lockdownd_client_new(device, &client, "idevice_id")) { idevice_free(device); fprintf(stderr, "ERROR: Connecting to device failed!\n"); return -2; } if ((LOCKDOWN_E_SUCCESS != lockdownd_get_device_name(client, &devname)) || !devname) { fprintf(stderr, "ERROR: Could not get device name!\n"); ret = -2; } lockdownd_client_free(client); idevice_free(device); if (ret == 0) { printf("%s\n", devname); } if (devname) { free(devname); } return ret; case MODE_LIST_DEVICES: default: if (idevice_get_device_list(&dev_list, &i) < 0) { fprintf(stderr, "ERROR: Unable to retrieve device list!\n"); return -1; } for (i = 0; dev_list[i] != NULL; i++) { printf("%s\n", dev_list[i]); } idevice_device_list_free(dev_list); return 0; } }
int main(int argc, char **argv) { idevice_t device = NULL; lockdownd_client_t lockdown_client = NULL; diagnostics_relay_client_t diagnostics_client = NULL; lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR; uint16_t port = 0; int result = -1; int i; const char *udid = NULL; int cmd = CMD_NONE; char* cmd_arg = NULL; plist_t node = NULL; plist_t keys = NULL; /* parse cmdline args */ for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--debug")) { idevice_set_debug_level(1); continue; } else if (!strcmp(argv[i], "-u") || !strcmp(argv[i], "--udid")) { i++; if (!argv[i] || (strlen(argv[i]) != 40)) { print_usage(argc, argv); result = 0; goto cleanup; } udid = argv[i]; continue; } else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) { print_usage(argc, argv); result = 0; goto cleanup; } else if (!strcmp(argv[i], "sleep")) { cmd = CMD_SLEEP; } else if (!strcmp(argv[i], "restart")) { cmd = CMD_RESTART; } else if (!strcmp(argv[i], "shutdown")) { cmd = CMD_SHUTDOWN; } else if (!strcmp(argv[i], "diagnostics")) { cmd = CMD_DIAGNOSTICS; /* read type */ i++; if (!argv[i] || ((strcmp(argv[i], "All") != 0) && (strcmp(argv[i], "WiFi") != 0) && (strcmp(argv[i], "GasGauge") != 0) && (strcmp(argv[i], "NAND") != 0))) { if (argv[i] == NULL) { cmd_arg = strdup("All"); continue; } if (!strncmp(argv[i], "-", 1)) { cmd_arg = strdup("All"); i--; continue; } printf("Unknown TYPE %s\n", argv[i]); print_usage(argc, argv); goto cleanup; } cmd_arg = strdup(argv[i]); continue; } else if (!strcmp(argv[i], "mobilegestalt")) { cmd = CMD_MOBILEGESTALT; /* read keys */ i++; if (!argv[i] || argv[i] == NULL || (!strncmp(argv[i], "-", 1))) { printf("Please supply the key to query.\n"); print_usage(argc, argv); goto cleanup; } keys = plist_new_array(); while(1) { if (argv[i] && (strlen(argv[i]) >= 2) && (strncmp(argv[i], "-", 1) != 0)) { plist_array_append_item(keys, plist_new_string(argv[i])); i++; } else { i--; break; } } continue; } else if (!strcmp(argv[i], "ioreg")) { cmd = CMD_IOREGISTRY; /* read plane */ i++; if (argv[i]) { cmd_arg = strdup(argv[i]); } continue; } else { print_usage(argc, argv); return 0; } } /* verify options */ if (cmd == CMD_NONE) { print_usage(argc, argv); goto cleanup; } if (IDEVICE_E_SUCCESS != idevice_new(&device, udid)) { if (udid) { printf("No device found with udid %s, is it plugged in?\n", udid); } else { printf("No device found, is it plugged in?\n"); } goto cleanup; } if (LOCKDOWN_E_SUCCESS != lockdownd_client_new_with_handshake(device, &lockdown_client, NULL)) { idevice_free(device); printf("Unable to connect to lockdownd.\n"); goto cleanup; } /* attempt to use newer diagnostics service available on iOS 5 and later */ ret = lockdownd_start_service(lockdown_client, "com.apple.mobile.diagnostics_relay", &port); if (ret != LOCKDOWN_E_SUCCESS) { /* attempt to use older diagnostics service */ ret = lockdownd_start_service(lockdown_client, "com.apple.iosdiagnostics.relay", &port); } lockdownd_client_free(lockdown_client); if ((ret == LOCKDOWN_E_SUCCESS) && (port > 0)) { if (diagnostics_relay_client_new(device, port, &diagnostics_client) != DIAGNOSTICS_RELAY_E_SUCCESS) { printf("Could not connect to diagnostics_relay!\n"); result = -1; } else { switch (cmd) { case CMD_SLEEP: if (diagnostics_relay_sleep(diagnostics_client) == DIAGNOSTICS_RELAY_E_SUCCESS) { printf("Putting device into deep sleep mode.\n"); result = EXIT_SUCCESS; } else { printf("Failed to put device into deep sleep mode.\n"); } break; case CMD_RESTART: if (diagnostics_relay_restart(diagnostics_client, 0) == DIAGNOSTICS_RELAY_E_SUCCESS) { printf("Restarting device.\n"); result = EXIT_SUCCESS; } else { printf("Failed to restart device.\n"); } break; case CMD_SHUTDOWN: if (diagnostics_relay_shutdown(diagnostics_client, 0) == DIAGNOSTICS_RELAY_E_SUCCESS) { printf("Shutting down device.\n"); result = EXIT_SUCCESS; } else { printf("Failed to shutdown device.\n"); } break; case CMD_MOBILEGESTALT: if (diagnostics_relay_query_mobilegestalt(diagnostics_client, keys, &node) == DIAGNOSTICS_RELAY_E_SUCCESS) { if (node) { print_xml(node); result = EXIT_SUCCESS; } } else { printf("Unable to query mobilegestalt keys.\n"); } break; case CMD_IOREGISTRY: if (diagnostics_relay_query_ioregistry_plane(diagnostics_client, cmd_arg == NULL ? "": cmd_arg, &node) == DIAGNOSTICS_RELAY_E_SUCCESS) { if (node) { print_xml(node); result = EXIT_SUCCESS; } } else { printf("Unable to retrieve IORegistry from device.\n"); } break; case CMD_DIAGNOSTICS: default: if (diagnostics_relay_request_diagnostics(diagnostics_client, cmd_arg, &node) == DIAGNOSTICS_RELAY_E_SUCCESS) { if (node) { print_xml(node); result = EXIT_SUCCESS; } } else { printf("Unable to retrieve diagnostics from device.\n"); } break; } diagnostics_relay_goodbye(diagnostics_client); diagnostics_relay_client_free(diagnostics_client); } } else { printf("Could not start diagnostics service!\n"); } idevice_free(device); cleanup: if (node) { plist_free(node); } if (keys) { plist_free(keys); } if (cmd_arg) { free(cmd_arg); } return result; }
static int normal_idevice_new(struct idevicerestore_client_t* client, idevice_t* device) { int num_devices = 0; char **devices = NULL; idevice_get_device_list(&devices, &num_devices); if (num_devices == 0) { return -1; } *device = NULL; idevice_t dev = NULL; idevice_error_t device_error; lockdownd_client_t lockdown = NULL; int j; for (j = 0; j < num_devices; j++) { if (lockdown != NULL) { lockdownd_client_free(lockdown); lockdown = NULL; } if (dev != NULL) { idevice_free(dev); dev = NULL; } device_error = idevice_new(&dev, devices[j]); if (device_error != IDEVICE_E_SUCCESS) { error("ERROR: %s: can't open device with UUID %s", __func__, devices[j]); continue; } if (lockdownd_client_new(dev, &lockdown, "idevicerestore") != LOCKDOWN_E_SUCCESS) { error("ERROR: %s: can't connect to lockdownd on device with UUID %s", __func__, devices[j]); continue; } char* type = NULL; if (lockdownd_query_type(lockdown, &type) != LOCKDOWN_E_SUCCESS) { continue; } if (strcmp(type, "com.apple.mobile.lockdown") != 0) { free(type); continue; } free(type); if (client->ecid != 0) { plist_t node = NULL; if ((lockdownd_get_value(lockdown, NULL, "UniqueChipID", &node) != LOCKDOWN_E_SUCCESS) || !node || (plist_get_node_type(node) != PLIST_UINT)){ if (node) { plist_free(node); } continue; } lockdownd_client_free(lockdown); lockdown = NULL; uint64_t this_ecid = 0; plist_get_uint_val(node, &this_ecid); plist_free(node); if (this_ecid != client->ecid) { continue; } } if (lockdown) { lockdownd_client_free(lockdown); lockdown = NULL; } client->uuid = strdup(devices[j]); *device = dev; break; } idevice_device_list_free(devices); return 0; }
int main(int argc, char *argv[]) { lockdownd_client_t client = NULL; idevice_t phone = NULL; idevice_error_t ret = IDEVICE_E_UNKNOWN_ERROR; int i; int simple = 0; int format = FORMAT_KEY_VALUE; char uuid[41]; char *domain = NULL; char *key = NULL; char *xml_doc = NULL; uint32_t xml_length; plist_t node = NULL; plist_type node_type; uuid[0] = 0; /* parse cmdline args */ for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--debug")) { idevice_set_debug_level(1); continue; } else if (!strcmp(argv[i], "-u") || !strcmp(argv[i], "--uuid")) { i++; if (!argv[i] || (strlen(argv[i]) != 40)) { print_usage(argc, argv); return 0; } strcpy(uuid, argv[i]); continue; } else if (!strcmp(argv[i], "-q") || !strcmp(argv[i], "--domain")) { i++; if (!argv[i] || (strlen(argv[i]) < 4)) { print_usage(argc, argv); return 0; } if (!is_domain_known(argv[i])) { fprintf(stderr, "WARNING: Sending query with unknown domain \"%s\".\n", argv[i]); } domain = strdup(argv[i]); continue; } else if (!strcmp(argv[i], "-k") || !strcmp(argv[i], "--key")) { i++; if (!argv[i] || (strlen(argv[i]) <= 1)) { print_usage(argc, argv); return 0; } key = strdup(argv[i]); continue; } else if (!strcmp(argv[i], "-x") || !strcmp(argv[i], "--xml")) { format = FORMAT_XML; continue; } else if (!strcmp(argv[i], "-s") || !strcmp(argv[i], "--simple")) { simple = 1; continue; } else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) { print_usage(argc, argv); return 0; } else { print_usage(argc, argv); return 0; } } if (uuid[0] != 0) { ret = idevice_new(&phone, uuid); if (ret != IDEVICE_E_SUCCESS) { printf("No device found with uuid %s, is it plugged in?\n", uuid); return -1; } } else { ret = idevice_new(&phone, NULL); if (ret != IDEVICE_E_SUCCESS) { printf("No device found, is it plugged in?\n"); return -1; } } if (LOCKDOWN_E_SUCCESS != (simple ? lockdownd_client_new(phone, &client, "ideviceinfo"): lockdownd_client_new_with_handshake(phone, &client, "ideviceinfo"))) { idevice_free(phone); return -1; } /* run query and output information */ if(lockdownd_get_value(client, domain, key, &node) == LOCKDOWN_E_SUCCESS) { if (node) { switch (format) { case FORMAT_XML: plist_to_xml(node, &xml_doc, &xml_length); printf("%s", xml_doc); free(xml_doc); break; case FORMAT_KEY_VALUE: node_type = plist_get_node_type(node); if (node_type == PLIST_DICT) { plist_dict_to_string(node); } else if (node_type == PLIST_ARRAY) { plist_array_to_string(node); break; } default: if (key != NULL) plist_node_to_string(node); break; } plist_free(node); node = NULL; } } if (domain != NULL) free(domain); lockdownd_client_free(client); idevice_free(phone); return 0; }