From 79fcf91cc86574257539fb45b0b6d1a1c64852c5 Mon Sep 17 00:00:00 2001 From: Martin Szulecki Date: Sun, 24 Jan 2010 02:45:22 +0100 Subject: Add service code and a backup tool for mobilebackup support --- src/Makefile.am | 3 +- src/mobilebackup.c | 131 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/mobilebackup.h | 31 +++++++++++++ 3 files changed, 164 insertions(+), 1 deletion(-) create mode 100644 src/mobilebackup.c create mode 100644 src/mobilebackup.h (limited to 'src') diff --git a/src/Makefile.am b/src/Makefile.am index 2e92382..6c29020 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -14,4 +14,5 @@ libiphone_la_SOURCES = iphone.c iphone.h \ notification_proxy.c notification_proxy.h\ installation_proxy.c installation_proxy.h\ sbservices.c sbservices.h\ - mobilesync.c mobilesync.h + mobilesync.c mobilesync.h\ + mobilebackup.c mobilebackup.h diff --git a/src/mobilebackup.c b/src/mobilebackup.c new file mode 100644 index 0000000..5b81c7f --- /dev/null +++ b/src/mobilebackup.c @@ -0,0 +1,131 @@ +/* + * mobilebackup.c + * Contains functions for the built-in MobileBackup client. + * + * Copyright (c) 2009 Martin Szulecki All Rights Reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include +#include +#include +#include + +#include "mobilebackup.h" +#include "device_link_service.h" +#include "debug.h" + +#define MBACKUP_VERSION_INT1 100 +#define MBACKUP_VERSION_INT2 0 + +/** + * Convert an device_link_service_error_t value to an mobilebackup_error_t value. + * Used internally to get correct error codes when using device_link_service stuff. + * + * @param err An device_link_service_error_t error code + * + * @return A matching mobilebackup_error_t error code, + * MOBILEBACKUP_E_UNKNOWN_ERROR otherwise. + */ +static mobilebackup_error_t mobilebackup_error(device_link_service_error_t err) +{ + switch (err) { + case DEVICE_LINK_SERVICE_E_SUCCESS: + return MOBILEBACKUP_E_SUCCESS; + case DEVICE_LINK_SERVICE_E_INVALID_ARG: + return MOBILEBACKUP_E_INVALID_ARG; + case DEVICE_LINK_SERVICE_E_PLIST_ERROR: + return MOBILEBACKUP_E_PLIST_ERROR; + case DEVICE_LINK_SERVICE_E_MUX_ERROR: + return MOBILEBACKUP_E_MUX_ERROR; + case DEVICE_LINK_SERVICE_E_BAD_VERSION: + return MOBILEBACKUP_E_BAD_VERSION; + default: + break; + } + return MOBILEBACKUP_E_UNKNOWN_ERROR; +} + +mobilebackup_error_t mobilebackup_client_new(iphone_device_t device, uint16_t port, + mobilebackup_client_t * client) +{ + if (!device || port == 0 || !client || *client) + return MOBILEBACKUP_E_INVALID_ARG; + + device_link_service_client_t dlclient = NULL; + mobilebackup_error_t ret = mobilebackup_error(device_link_service_client_new(device, port, &dlclient)); + if (ret != MOBILEBACKUP_E_SUCCESS) { + return ret; + } + + mobilebackup_client_t client_loc = (mobilebackup_client_t) malloc(sizeof(struct mobilebackup_client_int)); + client_loc->parent = dlclient; + + /* perform handshake */ + ret = mobilebackup_error(device_link_service_version_exchange(dlclient, MBACKUP_VERSION_INT1, MBACKUP_VERSION_INT2)); + if (ret != MOBILEBACKUP_E_SUCCESS) { + debug_info("version exchange failed, error %d", ret); + mobilebackup_client_free(client_loc); + return ret; + } + + *client = client_loc; + + return ret; +} + +mobilebackup_error_t mobilebackup_client_free(mobilebackup_client_t client) +{ + if (!client) + return MOBILEBACKUP_E_INVALID_ARG; + device_link_service_disconnect(client->parent); + mobilebackup_error_t err = mobilebackup_error(device_link_service_client_free(client->parent)); + free(client); + return err; +} + +/** Polls the iPhone for MobileBackup data. + * + * @param client The MobileBackup client + * @param plist A pointer to the location where the plist should be stored + * + * @return an error code + */ +mobilebackup_error_t mobilebackup_receive(mobilebackup_client_t client, plist_t * plist) +{ + if (!client) + return MOBILEBACKUP_E_INVALID_ARG; + mobilebackup_error_t ret = mobilebackup_error(device_link_service_receive(client->parent, plist)); + return ret; +} + +/** Sends MobileBackup data to the iPhone + * + * @note This function is low-level and should only be used if you need to send + * a new type of message. + * + * @param client The MobileBackup client + * @param plist The location of the plist to send + * + * @return an error code + */ +mobilebackup_error_t mobilebackup_send(mobilebackup_client_t client, plist_t plist) +{ + if (!client || !plist) + return MOBILEBACKUP_E_INVALID_ARG; + return mobilebackup_error(device_link_service_send(client->parent, plist)); +} + diff --git a/src/mobilebackup.h b/src/mobilebackup.h new file mode 100644 index 0000000..04ebc45 --- /dev/null +++ b/src/mobilebackup.h @@ -0,0 +1,31 @@ + /* + * mobilebackup.h + * Definitions for the mobilebackup service + * + * Copyright (c) 2009 Martin Szulecki All Rights Reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#ifndef MOBILEBACKUP_H +#define MOBILEBACKUP_H + +#include "libiphone/mobilebackup.h" +#include "device_link_service.h" + +struct mobilebackup_client_int { + device_link_service_client_t parent; +}; + +#endif -- cgit v1.1-32-gdbae From 4ded564cbc58bd513ece9ff9f8c5a6948759bfb7 Mon Sep 17 00:00:00 2001 From: Martin Szulecki Date: Sun, 24 Jan 2010 02:45:51 +0100 Subject: Remove duplicated dumping of plists in mobilesync --- src/mobilesync.c | 18 ------------------ 1 file changed, 18 deletions(-) (limited to 'src') diff --git a/src/mobilesync.c b/src/mobilesync.c index 3492673..15614b5 100644 --- a/src/mobilesync.c +++ b/src/mobilesync.c @@ -109,16 +109,6 @@ mobilesync_error_t mobilesync_receive(mobilesync_client_t client, plist_t * plis if (!client) return MOBILESYNC_E_INVALID_ARG; mobilesync_error_t ret = mobilesync_error(device_link_service_receive(client->parent, plist)); -#ifndef STRIP_DEBUG_CODE - if (ret != MOBILESYNC_E_SUCCESS) { - return ret; - } - char *XMLContent = NULL; - uint32_t length = 0; - plist_to_xml(*plist, &XMLContent, &length); - debug_info("plist size: %i\nbuffer :\n%s", length, XMLContent); - free(XMLContent); -#endif return ret; } @@ -136,13 +126,5 @@ mobilesync_error_t mobilesync_send(mobilesync_client_t client, plist_t plist) { if (!client || !plist) return MOBILESYNC_E_INVALID_ARG; - -#ifndef STRIP_DEBUG_CODE - char *XMLContent = NULL; - uint32_t length = 0; - plist_to_xml(plist, &XMLContent, &length); - debug_info("plist size: %i\nbuffer :\n%s", length, XMLContent); - free(XMLContent); -#endif return mobilesync_error(device_link_service_send(client->parent, plist)); } -- cgit v1.1-32-gdbae From 9a6fa170d226d1557e89f5e5252d1e0c61158ff5 Mon Sep 17 00:00:00 2001 From: Martin Szulecki Date: Sun, 24 Jan 2010 02:46:38 +0100 Subject: Add function to handle the ProcessMessage in the DeviceLink service --- src/device_link_service.c | 20 ++++++++++++++++++++ src/device_link_service.h | 1 + 2 files changed, 21 insertions(+) (limited to 'src') diff --git a/src/device_link_service.c b/src/device_link_service.c index e1155a5..c791b03 100644 --- a/src/device_link_service.c +++ b/src/device_link_service.c @@ -252,6 +252,26 @@ device_link_service_error_t device_link_service_disconnect(device_link_service_c return err; } +device_link_service_error_t device_link_service_process_message(device_link_service_client_t client, plist_t message) +{ + if (!client || !message) + return DEVICE_LINK_SERVICE_E_INVALID_ARG; + + if (plist_get_node_type(message) != PLIST_DICT) + return DEVICE_LINK_SERVICE_E_INVALID_ARG; + + plist_t array = plist_new_array(); + plist_array_append_item(array, plist_new_string("DLMessageProcessMessage")); + plist_array_append_item(array, message); + + device_link_service_error_t err = DEVICE_LINK_SERVICE_E_SUCCESS; + if (property_list_service_send_binary_plist(client->parent, array) != PROPERTY_LIST_SERVICE_E_SUCCESS) { + err = DEVICE_LINK_SERVICE_E_MUX_ERROR; + } + plist_free(array); + return err; +} + /** * Generic device link service send function. * diff --git a/src/device_link_service.h b/src/device_link_service.h index e14d897..8345d57 100644 --- a/src/device_link_service.h +++ b/src/device_link_service.h @@ -44,6 +44,7 @@ typedef int16_t device_link_service_error_t; device_link_service_error_t device_link_service_client_new(iphone_device_t device, uint16_t port, device_link_service_client_t *client); device_link_service_error_t device_link_service_client_free(device_link_service_client_t client); device_link_service_error_t device_link_service_version_exchange(device_link_service_client_t client, uint64_t version_major, uint64_t version_minor); +device_link_service_error_t device_link_service_process_message(device_link_service_client_t client, plist_t message); device_link_service_error_t device_link_service_disconnect(device_link_service_client_t client); device_link_service_error_t device_link_service_send(device_link_service_client_t client, plist_t plist); device_link_service_error_t device_link_service_receive(device_link_service_client_t client, plist_t *plist); -- cgit v1.1-32-gdbae From a4a5ffb71575ee76c54903d2616f5845721c9af7 Mon Sep 17 00:00:00 2001 From: Nikias Bassen Date: Mon, 25 Jan 2010 02:55:26 +0100 Subject: device_link_service: send version number with VersionsOk message --- src/device_link_service.c | 1 + 1 file changed, 1 insertion(+) (limited to 'src') diff --git a/src/device_link_service.c b/src/device_link_service.c index e1155a5..b7d9ee8 100644 --- a/src/device_link_service.c +++ b/src/device_link_service.c @@ -193,6 +193,7 @@ device_link_service_error_t device_link_service_version_exchange(device_link_ser array = plist_new_array(); plist_array_append_item(array, plist_new_string("DLMessageVersionExchange")); plist_array_append_item(array, plist_new_string("DLVersionsOk")); + plist_array_append_item(array, plist_new_uint(version_major)); if (property_list_service_send_binary_plist(client->parent, array) != PROPERTY_LIST_SERVICE_E_SUCCESS) { debug_info("Error when sending DLVersionsOk"); err = DEVICE_LINK_SERVICE_E_MUX_ERROR; -- cgit v1.1-32-gdbae From bbfd5355b9bb25ece2da83af93ac3cdd01bc41c7 Mon Sep 17 00:00:00 2001 From: Nikias Bassen Date: Mon, 25 Jan 2010 00:24:31 +0100 Subject: New file_relay service implementation. --- src/Makefile.am | 1 + src/file_relay.c | 197 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/file_relay.h | 40 +++++++++++ 3 files changed, 238 insertions(+) create mode 100644 src/file_relay.c create mode 100644 src/file_relay.h (limited to 'src') diff --git a/src/Makefile.am b/src/Makefile.am index 2e92382..f68f579 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -11,6 +11,7 @@ libiphone_la_SOURCES = iphone.c iphone.h \ device_link_service.c device_link_service.h\ lockdown.c lockdown.h\ afc.c afc.h\ + file_relay.c file_relay.h\ notification_proxy.c notification_proxy.h\ installation_proxy.c installation_proxy.h\ sbservices.c sbservices.h\ diff --git a/src/file_relay.c b/src/file_relay.c new file mode 100644 index 0000000..f0e91f7 --- /dev/null +++ b/src/file_relay.c @@ -0,0 +1,197 @@ + /* + * file_relay.c + * file_relay service implementation. + * + * Copyright (c) 2010 Nikias Bassen, All Rights Reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#include +#include +#include "file_relay.h" +#include "property_list_service.h" +#include "debug.h" + +/** + * Creates a new file_relay client. + * + * @param device The device to connect to. + * @param port Port on device to connect to. + * @param client Reference that will point to a newly allocated + * file_relay_client_t upon successful return. + * + * @return FILE_RELAY_E_SUCCESS on success, + * FILE_RELAY_E_INVALID_ARG when one of the parameters is invalid, + * or FILE_RELAY_E_MUX_ERROR when the connection failed. + */ +file_relay_error_t file_relay_client_new(iphone_device_t device, uint16_t port, file_relay_client_t *client) +{ + if (!device || port == 0 || !client || *client) { + return FILE_RELAY_E_INVALID_ARG; + } + + property_list_service_client_t plistclient = NULL; + if (property_list_service_client_new(device, port, &plistclient) != PROPERTY_LIST_SERVICE_E_SUCCESS) { + return FILE_RELAY_E_MUX_ERROR; + } + + /* create client object */ + file_relay_client_t client_loc = (file_relay_client_t) malloc(sizeof(struct file_relay_client_int)); + client_loc->parent = plistclient; + + /* all done, return success */ + *client = client_loc; + return FILE_RELAY_E_SUCCESS; +} + +/** + * Frees a file_relay client. + * + * @param client The file_relay_client_t to free. + * + * @return FILE_RELAY_E_SUCCESS on success, + * FILE_RELAY_E_INVALID_ARG when one of client or client->parent + * is invalid, or FILE_RELAY_E_UNKNOWN_ERROR when the was an error + * freeing the parent property_list_service client. + */ +file_relay_error_t file_relay_client_free(file_relay_client_t client) +{ + if (!client) + return FILE_RELAY_E_INVALID_ARG; + + if (property_list_service_client_free(client->parent) != PROPERTY_LIST_SERVICE_E_SUCCESS) { + return FILE_RELAY_E_UNKNOWN_ERROR; + } + return FILE_RELAY_E_SUCCESS; +} + +/** + * Request data for the given sources. + * + * @param client The connected file_relay client. + * @param sources A NULL-terminated list of sources to retrieve. + * Valid sources are: + * - AppleSupport + * - Network + * - VPN + * - WiFi + * - UserDatabases + * - CrashReporter + * - tmp + * - SystemConfiguration + * @param connection The connection that has to be used for receiving the + * data using iphone_connection_receive(). The connection will be closed + * automatically by the device, but use file_relay_client_free() to clean + * up properly. + * + * @note WARNING: Don't call this function without reading the data afterwards. + * A directory mobile_file_relay.XXXX used for creating the archive will + * remain in the /tmp directory otherwise. + * + * @return FILE_RELAY_E_SUCCESS on succes, FILE_RELAY_E_INVALID_ARG when one or + * more parameters are invalid, FILE_RELAY_E_MUX_ERROR if a communication + * error occurs, FILE_RELAY_E_PLIST_ERROR when the received result is NULL + * or is not a valid plist, FILE_RELAY_E_INVALID_SOURCE if one or more + * sources are invalid, FILE_RELAY_E_STAGING_EMPTY if no data is available + * for the given sources, or FILE_RELAY_E_UNKNOWN_ERROR otherwise. + */ +file_relay_error_t file_relay_request_sources(file_relay_client_t client, const char **sources, iphone_connection_t *connection) +{ + if (!client || !client->parent || !sources || !sources[0]) { + return FILE_RELAY_E_INVALID_ARG; + } + *connection = NULL; + file_relay_error_t err = FILE_RELAY_E_UNKNOWN_ERROR; + /* set up request plist */ + plist_t array = plist_new_array(); + int i = 0; + while (sources[i]) { + plist_array_append_item(array, plist_new_string(sources[i])); + i++; + } + plist_t dict = plist_new_dict(); + plist_dict_insert_item(dict, "Sources", array); + + if (property_list_service_send_xml_plist(client->parent, dict) != PROPERTY_LIST_SERVICE_E_SUCCESS) { + debug_info("ERROR: Could not send request to device!"); + err = FILE_RELAY_E_MUX_ERROR; + goto leave; + } + plist_free(dict); + + dict = NULL; + if (property_list_service_receive_plist_with_timeout(client->parent, &dict, 60000) != PROPERTY_LIST_SERVICE_E_SUCCESS) { + debug_info("ERROR: Could not receive answer from device!"); + err = FILE_RELAY_E_MUX_ERROR; + goto leave; + } + + if (!dict) { + debug_info("ERROR: Did not receive any plist!"); + err = FILE_RELAY_E_PLIST_ERROR; + goto leave; + } + + plist_t error = plist_dict_get_item(dict, "Error"); + if (error) { + char *errmsg = NULL; + plist_get_string_val(error, &errmsg); + if (errmsg) { + if (!strcmp(errmsg, "InvalidSource")) { + debug_info("ERROR: One or more given sources are invalid!"); + err = FILE_RELAY_E_INVALID_SOURCE; + } else if (!strcmp(errmsg, "StagingEmpty")) { + debug_info("ERROR: StagingEmpty - No data available!"); + err = FILE_RELAY_E_STAGING_EMPTY; + } else { + debug_info("ERROR: Unknown error '%s'", errmsg); + } + free(errmsg); + } else { + debug_info("ERROR: Could not get error message!"); + } + goto leave; + } + + plist_t status = plist_dict_get_item(dict, "Status"); + if (!status) { + debug_info("ERROR: Unexpected plist received!"); + debug_plist(dict); + err = FILE_RELAY_E_PLIST_ERROR; + goto leave; + } + + char *ack = NULL; + plist_get_string_val(status, &ack); + if (!ack) { + debug_info("ERROR: Could not get 'Acknowledged' string!"); + goto leave; + } + + if (strcmp(ack, "Acknowledged")) { + debug_info("ERROR: Did not receive 'Acknowledged' but '%s'", ack); + goto leave; + } + free(ack); + err = FILE_RELAY_E_SUCCESS; + + *connection = client->parent->connection; + +leave: + if (dict) { + plist_free(dict); + } + return err; +} diff --git a/src/file_relay.h b/src/file_relay.h new file mode 100644 index 0000000..9b2488c --- /dev/null +++ b/src/file_relay.h @@ -0,0 +1,40 @@ + /* + * file_relay.h + * Definitions for the file_relay service + * + * Copyright (c) 2010 Nikias Bassen, All Rights Reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#ifndef FILE_RELAY_H +#define FILE_RELAY_H + +#include "libiphone/file_relay.h" +#include "property_list_service.h" + +/* Error Codes */ +#define FILE_RELAY_E_SUCCESS 0 +#define FILE_RELAY_E_INVALID_ARG -1 +#define FILE_RELAY_E_PLIST_ERROR -2 +#define FILE_RELAY_E_MUX_ERROR -3 + +#define FILE_RELAY_E_UNKNOWN_ERROR -256 + + +struct file_relay_client_int { + property_list_service_client_t parent; +}; + +#endif -- cgit v1.1-32-gdbae From 90af94845ba841c693e80ac0eec317130c1c416e Mon Sep 17 00:00:00 2001 From: Martin Szulecki Date: Mon, 25 Jan 2010 23:36:24 +0100 Subject: Auto-pair devices within lockdownd_client_new_with_handshake() This brings back the automatic pairing feature if not yet paired. --- src/lockdown.c | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) (limited to 'src') diff --git a/src/lockdown.c b/src/lockdown.c index 792dd33..108b558 100644 --- a/src/lockdown.c +++ b/src/lockdown.c @@ -661,6 +661,14 @@ lockdownd_error_t lockdownd_client_new_with_handshake(iphone_device_t device, lo /* 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); + } + } + if (LOCKDOWN_E_SUCCESS == ret) { ret = lockdownd_start_session(client_loc, host_id, NULL, NULL); if (LOCKDOWN_E_SUCCESS != ret) { @@ -825,11 +833,16 @@ static lockdownd_error_t lockdownd_do_pair(lockdownd_client_t client, lockdownd_ if (error_node) { char *value = NULL; plist_get_string_val(error_node, &value); - /* the first pairing fails if the device is password protected */ - if (value && !strcmp(value, "PasswordProtected")) { - ret = LOCKDOWN_E_PASSWORD_PROTECTED; + if (value) { + /* the first pairing fails if the device is password protected */ + if (!strcmp(value, "PasswordProtected")) { + ret = LOCKDOWN_E_PASSWORD_PROTECTED; + } else if (!strcmp(value, "InvalidHostID")) { + ret = LOCKDOWN_E_INVALID_HOST_ID; + } free(value); } + plist_free(error_node); error_node = NULL; } -- cgit v1.1-32-gdbae