added preflight worker implementation to handle initial device pairing

1 files changed, 271 insertions, 0 deletions

diff --git a/src/preflight.c b/src/preflight.c
new file mode 100644
index 0000000..0041b21
--- /dev/null
+++ b/src/preflight.c
@@ -0,0 +1,271 @@
+/*
+        usbmuxd - iPhone/iPod Touch USB multiplex server daemon
+
+Copyright (C) 2013      Nikias Bassen <nikias@gmx.li>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 or version 3.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <pthread.h>
+
+#include <sys/time.h>
+
+#include <libimobiledevice/libimobiledevice.h>
+#include <libimobiledevice/lockdown.h>
+#include <libimobiledevice/notification_proxy.h>
+
+#include "preflight.h"
+#include "client.h"
+#include "log.h"
+
+#ifdef HAVE_LIBIMOBILEDEVICE
+enum connection_type {
+	CONNECTION_USBMUXD = 1
+};
+
+struct idevice_private {
+	char *udid;
+	enum connection_type conn_type;
+	void *conn_data;
+};
+
+extern void userpref_get_system_buid(char **systembuid);
+
+struct np_cb_data {
+	idevice_t dev;
+	np_client_t np;
+};
+
+static void set_untrusted_host_buid(lockdownd_client_t lockdown)
+{
+	char* system_buid = NULL;
+	userpref_get_system_buid(&system_buid);
+	usbmuxd_log(LL_DEBUG, "%s: Setting UntrustedHostBUID to %s", __func__, system_buid);
+	lockdownd_set_value(lockdown, NULL, "UntrustedHostBUID", plist_new_string(system_buid));
+	free(system_buid);
+}
+
+static void np_callback(const char* notification, void* userdata)
+{
+	struct np_cb_data *cbdata = (struct np_cb_data*)userdata;
+	idevice_t dev = cbdata->dev;
+	struct idevice_private *_dev = (struct idevice_private*)dev;
+
+	lockdownd_client_t lockdown = NULL;
+	lockdownd_error_t lerr;
+
+	if (strlen(notification) == 0) {
+		cbdata->np = NULL;
+		return;
+	}
+
+	if (strcmp(notification, "com.apple.mobile.lockdown.request_pair") == 0) {
+		usbmuxd_log(LL_INFO, "%s: user trusted this computer on device %s, pairing now", __func__, _dev->udid);
+		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);
+			return;
+		}
+
+		lerr = lockdownd_pair(lockdown, NULL);
+		if (lerr != LOCKDOWN_E_SUCCESS) {
+			usbmuxd_log(LL_ERROR, "%s: ERROR: Pair failed for device %s, lockdown error %d", __func__, _dev->udid, lerr);
+			lockdownd_client_free(lockdown);
+			return;
+		}
+		lockdownd_client_free(lockdown);
+		// device will reconnect by itself at this point.
+
+	} else if (strcmp(notification, "com.apple.mobile.lockdown.request_host_buid") == 0) {
+		lerr = lockdownd_client_new(cbdata->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);
+		} else {
+			set_untrusted_host_buid(lockdown);
+			lockdownd_client_free(lockdown);
+		}
+	}
+}
+
+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;
+	lockdownd_error_t lerr;
+
+	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
+		client_device_add(info);
+		goto leave;
+	}
+
+	char *host_id = NULL;
+	userpref_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_INFO, "%s: StartSession success for 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);
+	if (lerr == LOCKDOWN_E_INVALID_HOST_ID) {
+		usbmuxd_log(LL_INFO, "%s: Device %s is not paired with this host.", __func__, _dev->udid);
+	}
+
+	plist_t value = NULL;
+	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;
+	}
+
+	char* version_str = NULL;
+	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 beyond =============
+		usbmuxd_log(LL_INFO, "%s: Found ProductVersion %s device %s", __func__, version_str, _dev->udid);
+
+		set_untrusted_host_buid(lockdown);
+
+		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 np_cb_data cbdata;
+		cbdata.dev = dev;
+		cbdata.np = np;
+ 
+		np_set_notify_callback(np, np_callback, (void*)&cbdata);
+ 
+		const char* spec[] = {
+			"com.apple.mobile.lockdown.request_pair",
+			"com.apple.mobile.lockdown.request_host_buid",
+			NULL
+		}; 
+		np_observe_notifications(np, spec);
+
+		usbmuxd_log(LL_INFO, "%s: Waiting for user to trust this computer on device %s", __func__, _dev->udid);
+		// TODO send notification to user's desktop
+		while (cbdata.np) {
+			sleep(1);
+		}
+
+		if (cbdata.np) {
+			np_client_free(cbdata.np);
+		}
+	} else {
+		// ============== iOS 6.x and below ==============
+		lerr = lockdownd_pair(lockdown, NULL);
+		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
+			goto leave;
+		} else if (lerr != LOCKDOWN_E_SUCCESS) {
+			usbmuxd_log(LL_ERROR, "%s: ERROR: Pair failed for device %s, lockdown error %d", __func__, _dev->udid, lerr);
+			goto leave;
+		}
+
+		host_id = NULL;
+		userpref_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;
+		}
+
+		// make device visible
+		client_device_add(info);
+	}
+
+leave:
+	if (lockdown)
+		lockdownd_client_free(lockdown);
+	if (dev)
+		idevice_free(dev);
+
+	free(info);
+
+	return NULL;
+}
+#endif
+
+void preflight_worker_device_add(struct device_info* info)
+{
+#ifdef HAVE_LIBIMOBILEDEVICE
+	struct device_info *infocopy = (struct device_info*)malloc(sizeof(struct device_info));
+
+	memcpy(infocopy, info, sizeof(struct device_info));
+
+	pthread_t th;
+	pthread_create(&th, NULL, preflight_worker_handle_device_add, infocopy);
+#else
+	client_device_add(info);
+#endif
+}