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;
}
SWIGEXPORT jshort JNICALL Java_org_robovm_libimobiledevice_binding_libimobiledeviceJNI_lockdownd_1query_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) {
jshort jresult = 0 ;
lockdownd_client_t arg1 = (lockdownd_client_t) 0 ;
char **arg2 = (char **) 0 ;
lockdownd_error_t result;
(void)jenv;
(void)jcls;
arg1 = *(lockdownd_client_t *)&jarg1;
arg2 = *(char ***)&jarg2;
result = (lockdownd_error_t)lockdownd_query_type(arg1,arg2);
jresult = (jshort)result;
return jresult;
}
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;
}
LIBIMOBILEDEVICE_API lockdownd_error_t lockdownd_client_new(idevice_t device, lockdownd_client_t *client, const char *label)
{
if (!client)
return LOCKDOWN_E_INVALID_ARG;
static struct lockdownd_service_descriptor service = {
.port = 0xf27e,
.ssl_enabled = 0
};
property_list_service_client_t plistclient = NULL;
if (property_list_service_client_new(device, (lockdownd_service_descriptor_t)&service, &plistclient) != PROPERTY_LIST_SERVICE_E_SUCCESS) {
debug_info("could not connect to lockdownd (device %s)", device->udid);
return LOCKDOWN_E_MUX_ERROR;
}
lockdownd_client_t client_loc = (lockdownd_client_t) malloc(sizeof(struct lockdownd_client_private));
client_loc->parent = plistclient;
client_loc->ssl_enabled = 0;
client_loc->session_id = NULL;
if (idevice_get_udid(device, &client_loc->udid) != IDEVICE_E_SUCCESS) {
debug_info("failed to get device udid.");
}
debug_info("device udid: %s", client_loc->udid);
client_loc->label = label ? strdup(label) : NULL;
*client = client_loc;
return LOCKDOWN_E_SUCCESS;
}
LIBIMOBILEDEVICE_API lockdownd_error_t lockdownd_client_new_with_handshake(idevice_t device, lockdownd_client_t *client, const char *label)
{
if (!client)
return LOCKDOWN_E_INVALID_ARG;
lockdownd_error_t ret = LOCKDOWN_E_SUCCESS;
lockdownd_client_t client_loc = NULL;
char *host_id = NULL;
char *type = NULL;
ret = lockdownd_client_new(device, &client_loc, label);
if (LOCKDOWN_E_SUCCESS != ret) {
debug_info("failed to create lockdownd client.");
return ret;
}
/* perform handshake */
if (LOCKDOWN_E_SUCCESS != lockdownd_query_type(client_loc, &type)) {
debug_info("QueryType failed in the lockdownd client.");
ret = LOCKDOWN_E_NOT_ENOUGH_DATA;
} else {
if (strcmp("com.apple.mobile.lockdown", type)) {
debug_info("Warning QueryType request returned \"%s\".", type);
}
}
if (type)
free(type);
plist_t pair_record = NULL;
userpref_read_pair_record(client_loc->udid, &pair_record);
if (pair_record) {
pair_record_get_host_id(pair_record, &host_id);
}
if (LOCKDOWN_E_SUCCESS == ret && !host_id) {
ret = LOCKDOWN_E_INVALID_CONF;
}
if (LOCKDOWN_E_SUCCESS == ret && !pair_record) {
/* attempt pairing */
ret = lockdownd_pair(client_loc, NULL);
}
plist_free(pair_record);
pair_record = NULL;
/* in any case, we need to validate pairing to receive trusted host status */
ret = lockdownd_validate_pair(client_loc, NULL);
/* if not paired yet, let's do it now */
if (LOCKDOWN_E_INVALID_HOST_ID == ret) {
ret = lockdownd_pair(client_loc, NULL);
if (LOCKDOWN_E_SUCCESS == ret) {
ret = lockdownd_validate_pair(client_loc, NULL);
} else if (LOCKDOWN_E_PAIRING_DIALOG_PENDING == ret) {
debug_info("Device shows the pairing dialog.");
}
}
if (LOCKDOWN_E_SUCCESS == ret) {
if (!host_id) {
userpref_read_pair_record(client_loc->udid, &pair_record);
if (pair_record) {
pair_record_get_host_id(pair_record, &host_id);
plist_free(pair_record);
}
}
ret = lockdownd_start_session(client_loc, host_id, NULL, NULL);
if (LOCKDOWN_E_SUCCESS != ret) {
debug_info("Session opening failed.");
}
if (host_id) {
free(host_id);
host_id = NULL;
}
}
if (LOCKDOWN_E_SUCCESS == ret) {
*client = client_loc;
} else {
lockdownd_client_free(client_loc);
}
return ret;
}
/**
* Returns a new plist from the supplied lockdownd pair record. The caller is
* responsible for freeing the plist.
*
* @param pair_record The pair record to create a plist from.
*
* @return A pair record plist from the device, NULL if pair_record is not set
*/
static plist_t lockdownd_pair_record_to_plist(lockdownd_pair_record_t pair_record)
{
if (!pair_record)
return NULL;
/* setup request plist */
plist_t dict = plist_new_dict();
plist_dict_set_item(dict, "DeviceCertificate", plist_new_data(pair_record->device_certificate, strlen(pair_record->device_certificate)));
plist_dict_set_item(dict, "HostCertificate", plist_new_data(pair_record->host_certificate, strlen(pair_record->host_certificate)));
plist_dict_set_item(dict, "HostID", plist_new_string(pair_record->host_id));
plist_dict_set_item(dict, "RootCertificate", plist_new_data(pair_record->root_certificate, strlen(pair_record->root_certificate)));
plist_dict_set_item(dict, "SystemBUID", plist_new_string(pair_record->system_buid));
return dict;
}
/**
* Generates a pair record plist with required certificates for a specific
* device. If a pairing exists, it is loaded from the computer instead of being
* generated.
*
* @param pair_record_plist Holds the pair record.
*
* @return LOCKDOWN_E_SUCCESS on success
*/
static lockdownd_error_t pair_record_generate(lockdownd_client_t client, plist_t *pair_record)
{
lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
key_data_t public_key = { NULL, 0 };
char* host_id = NULL;
char* system_buid = NULL;
/* retrieve device public key */
ret = lockdownd_get_device_public_key_as_key_data(client, &public_key);
if (ret != LOCKDOWN_E_SUCCESS) {
debug_info("device refused to send public key.");
goto leave;
}
debug_info("device public key follows:\n%.*s", public_key.size, public_key.data);
*pair_record = plist_new_dict();
/* generate keys and certificates into pair record */
userpref_error_t uret = USERPREF_E_SUCCESS;
uret = pair_record_generate_keys_and_certs(*pair_record, public_key);
switch(uret) {
case USERPREF_E_INVALID_ARG:
ret = LOCKDOWN_E_INVALID_ARG;
break;
case USERPREF_E_INVALID_CONF:
ret = LOCKDOWN_E_INVALID_CONF;
break;
case USERPREF_E_SSL_ERROR:
ret = LOCKDOWN_E_SSL_ERROR;
default:
break;
}
/* set SystemBUID */
userpref_read_system_buid(&system_buid);
if (system_buid) {
plist_dict_set_item(*pair_record, USERPREF_SYSTEM_BUID_KEY, plist_new_string(system_buid));
}
/* set HostID */
host_id = generate_uuid();
pair_record_set_host_id(*pair_record, host_id);
leave:
if (host_id)
free(host_id);
if (system_buid)
free(system_buid);
if (public_key.data)
free(public_key.data);
return ret;
}
int main(int argc, char **argv)
{
lockdownd_client_t client = NULL;
idevice_t device = NULL;
idevice_error_t ret = IDEVICE_E_UNKNOWN_ERROR;
lockdownd_error_t lerr;
int result;
char *type = NULL;
char *cmd;
typedef enum {
OP_NONE = 0, OP_PAIR, OP_VALIDATE, OP_UNPAIR, OP_LIST, OP_HOSTID
} op_t;
op_t op = OP_NONE;
parse_opts(argc, argv);
if ((argc - optind) < 1) {
printf("ERROR: You need to specify a COMMAND!\n");
print_usage(argc, argv);
exit(EXIT_FAILURE);
}
cmd = (argv+optind)[0];
if (!strcmp(cmd, "pair")) {
op = OP_PAIR;
} else if (!strcmp(cmd, "validate")) {
op = OP_VALIDATE;
} else if (!strcmp(cmd, "unpair")) {
op = OP_UNPAIR;
} else if (!strcmp(cmd, "list")) {
op = OP_LIST;
} else if (!strcmp(cmd, "hostid")) {
op = OP_HOSTID;
} else {
printf("ERROR: Invalid command '%s' specified\n", cmd);
print_usage(argc, argv);
exit(EXIT_FAILURE);
}
if (op == OP_HOSTID) {
char *hostid = NULL;
userpref_get_host_id(&hostid);
printf("%s\n", hostid);
if (hostid)
free(hostid);
return EXIT_SUCCESS;
}
if (op == OP_LIST) {
unsigned int i;
char **udids = NULL;
unsigned int count = 0;
userpref_get_paired_udids(&udids, &count);
for (i = 0; i < count; i++) {
printf("%s\n", udids[i]);
free(udids[i]);
}
if (udids)
free(udids);
if (udid)
free(udid);
return EXIT_SUCCESS;
}
if (udid) {
ret = idevice_new(&device, udid);
free(udid);
udid = NULL;
if (ret != IDEVICE_E_SUCCESS) {
printf("No device found with udid %s, is it plugged in?\n", udid);
return EXIT_FAILURE;
}
} else {
ret = idevice_new(&device, NULL);
if (ret != IDEVICE_E_SUCCESS) {
printf("No device found, is it plugged in?\n");
return EXIT_FAILURE;
}
}
lerr = lockdownd_client_new(device, &client, "idevicepair");
if (lerr != LOCKDOWN_E_SUCCESS) {
idevice_free(device);
printf("ERROR: lockdownd_client_new failed with error code %d\n", lerr);
return EXIT_FAILURE;
}
result = EXIT_SUCCESS;
lerr = lockdownd_query_type(client, &type);
if (lerr != LOCKDOWN_E_SUCCESS) {
printf("QueryType failed, error code %d\n", lerr);
result = EXIT_FAILURE;
goto leave;
} else {
if (strcmp("com.apple.mobile.lockdown", type)) {
printf("WARNING: QueryType request returned '%s'\n", type);
}
if (type) {
free(type);
}
}
ret = idevice_get_udid(device, &udid);
if (ret != IDEVICE_E_SUCCESS) {
printf("ERROR: Could not get device udid, error code %d\n", ret);
result = EXIT_FAILURE;
goto leave;
}
switch(op) {
default:
case OP_PAIR:
lerr = lockdownd_pair(client, NULL);
if (lerr == LOCKDOWN_E_SUCCESS) {
printf("SUCCESS: Paired with device %s\n", udid);
} else {
result = EXIT_FAILURE;
if (lerr == LOCKDOWN_E_PASSWORD_PROTECTED) {
printf("ERROR: Could not pair with the device because a passcode is set. Please enter the passcode on the device and retry.\n");
} else {
printf("ERROR: Pairing with device %s failed with unhandled error code %d\n", udid, lerr);
}
}
break;
case OP_VALIDATE:
lerr = lockdownd_validate_pair(client, NULL);
if (lerr == LOCKDOWN_E_SUCCESS) {
printf("SUCCESS: Validated pairing with device %s\n", udid);
} else {
result = EXIT_FAILURE;
if (lerr == LOCKDOWN_E_PASSWORD_PROTECTED) {
printf("ERROR: Could not validate with the device because a passcode is set. Please enter the passcode on the device and retry.\n");
} else if (lerr == LOCKDOWN_E_INVALID_HOST_ID) {
printf("ERROR: Device %s is not paired with this host\n", udid);
} else {
printf("ERROR: Pairing failed with unhandled error code %d\n", lerr);
}
}
break;
case OP_UNPAIR:
lerr = lockdownd_unpair(client, NULL);
if (lerr == LOCKDOWN_E_SUCCESS) {
/* also remove local device public key */
userpref_remove_device_public_key(udid);
printf("SUCCESS: Unpaired with device %s\n", udid);
} else {
result = EXIT_FAILURE;
if (lerr == LOCKDOWN_E_INVALID_HOST_ID) {
printf("ERROR: Device %s is not paired with this host\n", udid);
} else {
printf("ERROR: Unpairing with device %s failed with unhandled error code %d\n", udid, lerr);
}
}
break;
}
leave:
lockdownd_client_free(client);
idevice_free(device);
if (udid) {
free(udid);
}
return result;
}
LIBIMOBILEDEVICE_API lockdownd_error_t lockdownd_client_new_with_handshake(idevice_t device, lockdownd_client_t *client, const char *label)
{
if (!client)
return LOCKDOWN_E_INVALID_ARG;
lockdownd_error_t ret = LOCKDOWN_E_SUCCESS;
lockdownd_client_t client_loc = NULL;
plist_t pair_record = NULL;
char *host_id = NULL;
char *type = NULL;
ret = lockdownd_client_new(device, &client_loc, label);
if (LOCKDOWN_E_SUCCESS != ret) {
debug_info("failed to create lockdownd client.");
return ret;
}
/* perform handshake */
if (LOCKDOWN_E_SUCCESS != lockdownd_query_type(client_loc, &type)) {
debug_info("QueryType failed in the lockdownd client.");
ret = LOCKDOWN_E_NOT_ENOUGH_DATA;
} else {
if (strcmp("com.apple.mobile.lockdown", type)) {
debug_info("Warning QueryType request returned \"%s\".", type);
}
}
free(type);
userpref_read_pair_record(client_loc->udid, &pair_record);
if (pair_record) {
pair_record_get_host_id(pair_record, &host_id);
}
if (LOCKDOWN_E_SUCCESS == ret && !host_id) {
ret = LOCKDOWN_E_INVALID_CONF;
}
if (LOCKDOWN_E_SUCCESS == ret && !pair_record) {
/* attempt pairing */
ret = lockdownd_pair(client_loc, NULL);
}
plist_free(pair_record);
pair_record = NULL;
/* in any case, we need to validate pairing to receive trusted host status */
ret = lockdownd_validate_pair(client_loc, NULL);
/* if not paired yet, let's do it now */
if (LOCKDOWN_E_INVALID_HOST_ID == ret) {
free(host_id);
host_id = NULL;
ret = lockdownd_pair(client_loc, NULL);
if (LOCKDOWN_E_SUCCESS == ret) {
ret = lockdownd_validate_pair(client_loc, NULL);
} else if (LOCKDOWN_E_PAIRING_DIALOG_PENDING == ret) {
debug_info("Device shows the pairing dialog.");
}
}
if (LOCKDOWN_E_SUCCESS == ret) {
if (!host_id) {
userpref_read_pair_record(client_loc->udid, &pair_record);
if (pair_record) {
pair_record_get_host_id(pair_record, &host_id);
plist_free(pair_record);
}
}
ret = lockdownd_start_session(client_loc, host_id, NULL, NULL);
if (LOCKDOWN_E_SUCCESS != ret) {
debug_info("Session opening failed.");
}
}
if (LOCKDOWN_E_SUCCESS == ret) {
*client = client_loc;
} else {
lockdownd_client_free(client_loc);
}
free(host_id);
return ret;
}
static void* preflight_worker_handle_device_add(void* userdata)
{
struct device_info *info = (struct device_info*)userdata;
struct idevice_private *_dev = (struct idevice_private*)malloc(sizeof(struct idevice_private));
_dev->udid = strdup(info->serial);
_dev->conn_type = CONNECTION_USBMUXD;
_dev->conn_data = (void*)(long)info->id;
idevice_t dev = (idevice_t)_dev;
lockdownd_client_t lockdown = NULL;
lockdownd_error_t lerr;
plist_t value = NULL;
char* version_str = NULL;
usbmuxd_log(LL_INFO, "%s: Starting preflight on device %s...", __func__, _dev->udid);
retry:
lerr = lockdownd_client_new(dev, &lockdown, "usbmuxd");
if (lerr != LOCKDOWN_E_SUCCESS) {
usbmuxd_log(LL_ERROR, "%s: ERROR: Could not connect to lockdownd on device %s, lockdown error %d", __func__, _dev->udid, lerr);
goto leave;
}
char *type = NULL;
lerr = lockdownd_query_type(lockdown, &type);
if (!type) {
usbmuxd_log(LL_ERROR, "%s: ERROR: Could not get lockdownd type from device %s, lockdown error %d", __func__, _dev->udid, lerr);
goto leave;
}
if (strcmp(type, "com.apple.mobile.lockdown") != 0) {
// make restore mode devices visible
free(type);
usbmuxd_log(LL_INFO, "%s: Finished preflight on device %s", __func__, _dev->udid);
client_device_add(info);
goto leave;
}
free(type);
int is_device_paired = 0;
char *host_id = NULL;
if (config_has_device_record(dev->udid)) {
config_device_record_get_host_id(dev->udid, &host_id);
lerr = lockdownd_start_session(lockdown, host_id, NULL, NULL);
if (host_id)
free(host_id);
if (lerr == LOCKDOWN_E_SUCCESS) {
usbmuxd_log(LL_INFO, "%s: StartSession success for device %s", __func__, _dev->udid);
usbmuxd_log(LL_INFO, "%s: Finished preflight on device %s", __func__, _dev->udid);
client_device_add(info);
goto leave;
}
usbmuxd_log(LL_INFO, "%s: StartSession failed on device %s, lockdown error %d", __func__, _dev->udid, lerr);
} else {
lerr = LOCKDOWN_E_INVALID_HOST_ID;
}
switch (lerr) {
case LOCKDOWN_E_INVALID_HOST_ID:
usbmuxd_log(LL_INFO, "%s: Device %s is not paired with this host.", __func__, _dev->udid);
break;
case LOCKDOWN_E_SSL_ERROR:
usbmuxd_log(LL_ERROR, "%s: The stored pair record for device %s is invalid. Removing.", __func__, _dev->udid);
if (config_remove_device_record(_dev->udid) == 0) {
lockdownd_client_free(lockdown);
lockdown = NULL;
goto retry;
} else {
usbmuxd_log(LL_ERROR, "%s: Could not remove pair record for device %s", __func__, _dev->udid);
}
break;
default:
is_device_paired = 1;
break;
}
lerr = lockdownd_get_value(lockdown, NULL, "ProductVersion", &value);
if (lerr != LOCKDOWN_E_SUCCESS) {
usbmuxd_log(LL_ERROR, "%s: ERROR: Could not get ProductVersion from device %s, lockdown error %d", __func__, _dev->udid, lerr);
goto leave;
}
if (value && plist_get_node_type(value) == PLIST_STRING) {
plist_get_string_val(value, &version_str);
}
if (!version_str) {
usbmuxd_log(LL_ERROR, "%s: Could not get ProductVersion string from device %s handle %d", __func__, _dev->udid, (int)(long)_dev->conn_data);
goto leave;
}
int version_major = strtol(version_str, NULL, 10);
if (version_major >= 7) {
/* iOS 7.0 and later */
usbmuxd_log(LL_INFO, "%s: Found ProductVersion %s device %s", __func__, version_str, _dev->udid);
lockdownd_set_untrusted_host_buid(lockdown);
/* if not paired, trigger the trust dialog to make sure it appears */
if (!is_device_paired) {
if (lockdownd_pair(lockdown, NULL) == LOCKDOWN_E_SUCCESS) {
/* if device is still showing the setup screen it will pair even without trust dialog */
usbmuxd_log(LL_INFO, "%s: Pair success for device %s", __func__, _dev->udid);
usbmuxd_log(LL_INFO, "%s: Finished preflight on device %s", __func__, _dev->udid);
client_device_add(info);
goto leave;
}
}
lockdownd_service_descriptor_t service = NULL;
lerr = lockdownd_start_service(lockdown, "com.apple.mobile.insecure_notification_proxy", &service);
if (lerr != LOCKDOWN_E_SUCCESS) {
usbmuxd_log(LL_ERROR, "%s: ERROR: Could not start insecure_notification_proxy on %s, lockdown error %d", __func__, _dev->udid, lerr);
goto leave;
}
np_client_t np = NULL;
np_client_new(dev, service, &np);
lockdownd_service_descriptor_free(service);
service = NULL;
lockdownd_client_free(lockdown);
lockdown = NULL;
struct cb_data cbdata;
cbdata.dev = dev;
cbdata.np = np;
cbdata.is_device_connected = 1;
np_set_notify_callback(np, np_callback, (void*)&cbdata);
device_set_preflight_cb_data(info->id, (void*)&cbdata);
const char* spec[] = {
"com.apple.mobile.lockdown.request_pair",
"com.apple.mobile.lockdown.request_host_buid",
NULL
};
np_observe_notifications(np, spec);
/* TODO send notification to user's desktop */
usbmuxd_log(LL_INFO, "%s: Waiting for user to trust this computer on device %s", __func__, _dev->udid);
/* make device visible anyways */
client_device_add(info);
while (cbdata.np && cbdata.is_device_connected == 1) {
sleep(1);
}
device_set_preflight_cb_data(info->id, NULL);
usbmuxd_log(LL_INFO, "%s: Finished waiting for notification from device %s, is_device_connected %d", __func__, _dev->udid, cbdata.is_device_connected);
if (cbdata.np) {
np_client_free(cbdata.np);
}
} else {
/* iOS 6.x and earlier */
lerr = lockdownd_pair(lockdown, NULL);
if (lerr != LOCKDOWN_E_SUCCESS) {
if (lerr == LOCKDOWN_E_PASSWORD_PROTECTED) {
usbmuxd_log(LL_INFO, "%s: Device %s is locked with a passcode. Cannot pair.", __func__, _dev->udid);
/* TODO send notification to user's desktop */
} else {
usbmuxd_log(LL_ERROR, "%s: ERROR: Pair failed for device %s, lockdown error %d", __func__, _dev->udid, lerr);
}
usbmuxd_log(LL_INFO, "%s: Finished preflight on device %s", __func__, _dev->udid);
/* make device visible anyways */
client_device_add(info);
goto leave;
}
host_id = NULL;
config_device_record_get_host_id(dev->udid, &host_id);
lerr = lockdownd_start_session(lockdown, host_id, NULL, NULL);
free(host_id);
if (lerr != LOCKDOWN_E_SUCCESS) {
usbmuxd_log(LL_ERROR, "%s: ERROR StartSession failed on device %s, lockdown error %d", __func__, _dev->udid, lerr);
goto leave;
}
lerr = lockdownd_validate_pair(lockdown, NULL);
if (lerr != LOCKDOWN_E_SUCCESS) {
usbmuxd_log(LL_ERROR, "%s: ERROR: ValidatePair failed for device %s, lockdown error %d", __func__, _dev->udid, lerr);
goto leave;
}
usbmuxd_log(LL_INFO, "%s: Finished preflight on device %s", __func__, _dev->udid);
/* emit device added event and thus make device visible to clients */
client_device_add(info);
}
leave:
if (value)
plist_free(value);
if (version_str)
free(version_str);
if (lockdown)
lockdownd_client_free(lockdown);
if (dev)
idevice_free(dev);
free(info);
return NULL;
}
int normal_open_with_timeout(struct idevicerestore_client_t* client) {
int i = 0;
int attempts = 10;
idevice_t device = NULL;
lockdownd_client_t lockdownd = NULL;
idevice_error_t device_error = IDEVICE_E_SUCCESS;
lockdownd_error_t lockdownd_error = LOCKDOWN_E_SUCCESS;
// no context exists so bail
if(client == NULL) {
return -1;
}
// create our normal client if it doesn't yet exist
if(client->normal == NULL) {
client->normal = (struct normal_client_t*) malloc(sizeof(struct normal_client_t));
if(client->normal == NULL) {
error("ERROR: Out of memory\n");
return -1;
}
}
device_error = idevice_event_subscribe(&normal_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 (normal_device_connected == 1) {
break;
}
if (i == attempts) {
error("ERROR: Unable to connect to device in normal mode\n");
return -1;
}
sleep(2);
}
device_error = idevice_new(&device, client->uuid);
if (device_error != IDEVICE_E_SUCCESS) {
return -1;
}
lockdownd_error = lockdownd_client_new(device, &lockdownd, "idevicerestore");
if (lockdownd_error != LOCKDOWN_E_SUCCESS) {
//idevice_event_unsubscribe();
idevice_free(device);
return -1;
}
char* type = NULL;
lockdownd_error = lockdownd_query_type(lockdownd, &type);
if (lockdownd_error != LOCKDOWN_E_SUCCESS) {
lockdownd_client_free(lockdownd);
//idevice_event_unsubscribe();
idevice_free(device);
return -1;
}
client->normal->device = device;
client->normal->client = lockdownd;
return 0;
}
int main(int argc, char **argv)
{
lockdownd_client_t client = NULL;
idevice_t device = NULL;
idevice_error_t ret = IDEVICE_E_UNKNOWN_ERROR;
lockdownd_error_t lerr;
int result;
char *type = NULL;
char *cmd;
typedef enum {
OP_NONE = 0, OP_PAIR, OP_VALIDATE, OP_UNPAIR, OP_LIST, OP_HOSTID, OP_SYSTEMBUID
} op_t;
op_t op = OP_NONE;
parse_opts(argc, argv);
if ((argc - optind) < 1) {
printf("ERROR: You need to specify a COMMAND!\n");
print_usage(argc, argv);
exit(EXIT_FAILURE);
}
cmd = (argv+optind)[0];
if (!strcmp(cmd, "pair")) {
op = OP_PAIR;
} else if (!strcmp(cmd, "validate")) {
op = OP_VALIDATE;
} else if (!strcmp(cmd, "unpair")) {
op = OP_UNPAIR;
} else if (!strcmp(cmd, "list")) {
op = OP_LIST;
} else if (!strcmp(cmd, "hostid")) {
op = OP_HOSTID;
} else if (!strcmp(cmd, "systembuid")) {
op = OP_SYSTEMBUID;
} else {
printf("ERROR: Invalid command '%s' specified\n", cmd);
print_usage(argc, argv);
exit(EXIT_FAILURE);
}
if (op == OP_SYSTEMBUID) {
char *systembuid = NULL;
userpref_read_system_buid(&systembuid);
printf("%s\n", systembuid);
if (systembuid)
free(systembuid);
return EXIT_SUCCESS;
}
if (op == OP_LIST) {
unsigned int i;
char **udids = NULL;
unsigned int count = 0;
userpref_get_paired_udids(&udids, &count);
for (i = 0; i < count; i++) {
printf("%s\n", udids[i]);
free(udids[i]);
}
if (udids)
free(udids);
if (udid)
free(udid);
return EXIT_SUCCESS;
}
if (udid) {
ret = idevice_new(&device, udid);
free(udid);
udid = NULL;
if (ret != IDEVICE_E_SUCCESS) {
printf("No device found with udid %s, is it plugged in?\n", udid);
return EXIT_FAILURE;
}
} else {
ret = idevice_new(&device, NULL);
if (ret != IDEVICE_E_SUCCESS) {
printf("No device found, is it plugged in?\n");
return EXIT_FAILURE;
}
}
ret = idevice_get_udid(device, &udid);
if (ret != IDEVICE_E_SUCCESS) {
printf("ERROR: Could not get device udid, error code %d\n", ret);
result = EXIT_FAILURE;
goto leave;
}
if (op == OP_HOSTID) {
plist_t pair_record = NULL;
char *hostid = NULL;
userpref_read_pair_record(udid, &pair_record);
pair_record_get_host_id(pair_record, &hostid);
printf("%s\n", hostid);
if (hostid)
free(hostid);
if (pair_record)
plist_free(pair_record);
return EXIT_SUCCESS;
}
lerr = lockdownd_client_new(device, &client, "idevicepair");
if (lerr != LOCKDOWN_E_SUCCESS) {
idevice_free(device);
printf("ERROR: Could not connect to lockdownd, error code %d\n", lerr);
return EXIT_FAILURE;
}
result = EXIT_SUCCESS;
lerr = lockdownd_query_type(client, &type);
if (lerr != LOCKDOWN_E_SUCCESS) {
printf("QueryType failed, error code %d\n", lerr);
result = EXIT_FAILURE;
goto leave;
} else {
if (strcmp("com.apple.mobile.lockdown", type)) {
printf("WARNING: QueryType request returned '%s'\n", type);
}
if (type) {
free(type);
}
}
switch(op) {
default:
case OP_PAIR:
lerr = lockdownd_pair(client, NULL);
if (lerr == LOCKDOWN_E_SUCCESS) {
printf("SUCCESS: Paired with device %s\n", udid);
} else {
result = EXIT_FAILURE;
print_error_message(lerr);
}
break;
case OP_VALIDATE:
lerr = lockdownd_validate_pair(client, NULL);
if (lerr == LOCKDOWN_E_SUCCESS) {
printf("SUCCESS: Validated pairing with device %s\n", udid);
} else {
result = EXIT_FAILURE;
print_error_message(lerr);
}
break;
case OP_UNPAIR:
lerr = lockdownd_unpair(client, NULL);
if (lerr == LOCKDOWN_E_SUCCESS) {
printf("SUCCESS: Unpaired with device %s\n", udid);
} else {
result = EXIT_FAILURE;
print_error_message(lerr);
}
break;
}
leave:
lockdownd_client_free(client);
idevice_free(device);
if (udid) {
free(udid);
}
return result;
}
