blob: 1759f509d443dc71fd6b65be9a9ff13a6d5180be [file] [log] [blame]
/*
* idevicebackup.c
* Command line interface to use the device's backup and restore service
*
* Copyright (c) 2009-2010 Martin Szulecki All Rights Reserved.
* 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
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#define TOOL_NAME "idevicebackup"
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <signal.h>
#if defined(HAVE_OPENSSL)
#include <openssl/sha.h>
#elif defined(HAVE_GNUTLS)
#include <gcrypt.h>
#elif defined(HAVE_MBEDTLS)
#include <mbedtls/sha1.h>
#if MBEDTLS_VERSION_NUMBER < 0x03000000
#define mbedtls_sha1 mbedtls_sha1_ret
#define mbedtls_sha1_starts mbedtls_sha1_starts_ret
#define mbedtls_sha1_update mbedtls_sha1_update_ret
#define mbedtls_sha1_finish mbedtls_sha1_finish_ret
#endif
#else
#error No supported crypto library enabled
#endif
#include <unistd.h>
#include <ctype.h>
#include <time.h>
#include <libimobiledevice/libimobiledevice.h>
#include <libimobiledevice/lockdown.h>
#include <libimobiledevice/mobilebackup.h>
#include <libimobiledevice/notification_proxy.h>
#include <libimobiledevice/afc.h>
#include <libimobiledevice-glue/utils.h>
#define MOBILEBACKUP_SERVICE_NAME "com.apple.mobilebackup"
#define NP_SERVICE_NAME "com.apple.mobile.notification_proxy"
#define LOCK_ATTEMPTS 50
#define LOCK_WAIT 200000
#ifdef WIN32
#include <windows.h>
#define sleep(x) Sleep(x*1000)
#endif
static mobilebackup_client_t mobilebackup = NULL;
static lockdownd_client_t client = NULL;
static idevice_t device = NULL;
static int quit_flag = 0;
enum cmd_mode {
CMD_BACKUP,
CMD_RESTORE,
CMD_LEAVE
};
enum device_link_file_status_t {
DEVICE_LINK_FILE_STATUS_NONE = 0,
DEVICE_LINK_FILE_STATUS_HUNK,
DEVICE_LINK_FILE_STATUS_LAST_HUNK
};
static void sha1_of_data(const char *input, uint32_t size, unsigned char *hash_out)
{
#if defined(HAVE_OPENSSL)
SHA1((const unsigned char*)input, size, hash_out);
#elif defined(HAVE_GNUTLS)
gcry_md_hash_buffer(GCRY_MD_SHA1, hash_out, input, size);
#elif defined(HAVE_MBEDTLS)
mbedtls_sha1((unsigned char*)input, size, hash_out);
#endif
}
static int compare_hash(const unsigned char *hash1, const unsigned char *hash2, int hash_len)
{
int i;
for (i = 0; i < hash_len; i++) {
if (hash1[i] != hash2[i]) {
return 0;
}
}
return 1;
}
static void _sha1_update(void* context, const char* data, size_t len)
{
#if defined(HAVE_OPENSSL)
SHA1_Update(context, data, len);
#elif defined(HAVE_GNUTLS)
gcry_md_write(context, data, len);
#elif defined(HAVE_MBEDTLS)
mbedtls_sha1_update(context, (const unsigned char*)data, len);
#endif
}
static void compute_datahash(const char *path, const char *destpath, uint8_t greylist, const char *domain, const char *appid, const char *version, unsigned char *hash_out)
{
#if defined(HAVE_OPENSSL)
SHA_CTX sha1;
SHA1_Init(&sha1);
void* psha1 = &sha1;
#elif defined(HAVE_GNUTLS)
gcry_md_hd_t hd = NULL;
gcry_md_open(&hd, GCRY_MD_SHA1, 0);
if (!hd) {
printf("ERROR: Could not initialize libgcrypt/SHA1\n");
return;
}
gcry_md_reset(hd);
void* psha1 = hd;
#elif defined(HAVE_MBEDTLS)
mbedtls_sha1_context sha1;
mbedtls_sha1_init(&sha1);
mbedtls_sha1_starts(&sha1);
void* psha1 = &sha1;
#endif
FILE *f = fopen(path, "rb");
if (f) {
unsigned char buf[16384];
size_t len;
while ((len = fread(buf, 1, 16384, f)) > 0) {
_sha1_update(psha1, (const char*)buf, len);
}
fclose(f);
_sha1_update(psha1, destpath, strlen(destpath));
_sha1_update(psha1, ";", 1);
if (greylist == 1) {
_sha1_update(psha1, "true", 4);
} else {
_sha1_update(psha1, "false", 5);
}
_sha1_update(psha1, ";", 1);
if (domain) {
_sha1_update(psha1, domain, strlen(domain));
} else {
_sha1_update(psha1, "(null)", 6);
}
_sha1_update(psha1, ";", 1);
if (appid) {
_sha1_update(psha1, appid, strlen(appid));
} else {
_sha1_update(psha1, "(null)", 6);
}
_sha1_update(psha1, ";", 1);
if (version) {
_sha1_update(psha1, version, strlen(version));
} else {
_sha1_update(psha1, "(null)", 6);
}
#if defined(HAVE_OPENSSL)
SHA1_Final(hash_out, &sha1);
#elif defined(HAVE_GNUTLS)
unsigned char *newhash = gcry_md_read(hd, GCRY_MD_SHA1);
memcpy(hash_out, newhash, 20);
#elif defined(HAVE_MBEDTLS)
mbedtls_sha1_finish(&sha1, hash_out);
#endif
}
#if defined(HAVE_GNUTLS)
gcry_md_close(hd);
#elif defined(HAVE_MBEDTLS)
mbedtls_sha1_free(&sha1);
#endif
}
static void print_hash(const unsigned char *hash, int len)
{
int i;
for (i = 0; i < len; i++) {
printf("%02x", hash[i]);
}
}
static void notify_cb(const char *notification, void *userdata)
{
if (!strcmp(notification, NP_SYNC_CANCEL_REQUEST)) {
printf("User has aborted on-device\n");
quit_flag++;
} else {
printf("unhandled notification '%s' (TODO: implement)\n", notification);
}
}
static plist_t mobilebackup_factory_info_plist_new(const char* udid)
{
/* gather data from lockdown */
plist_t value_node = NULL;
plist_t root_node = NULL;
char *udid_uppercase = NULL;
plist_t ret = plist_new_dict();
/* get basic device information in one go */
lockdownd_get_value(client, NULL, NULL, &root_node);
/* set fields we understand */
value_node = plist_dict_get_item(root_node, "BuildVersion");
plist_dict_set_item(ret, "Build Version", plist_copy(value_node));
value_node = plist_dict_get_item(root_node, "DeviceName");
plist_dict_set_item(ret, "Device Name", plist_copy(value_node));
plist_dict_set_item(ret, "Display Name", plist_copy(value_node));
/* FIXME: How is the GUID generated? */
plist_dict_set_item(ret, "GUID", plist_new_string("---"));
value_node = plist_dict_get_item(root_node, "InternationalMobileEquipmentIdentity");
if (value_node)
plist_dict_set_item(ret, "IMEI", plist_copy(value_node));
plist_dict_set_item(ret, "Last Backup Date", plist_new_date(time(NULL) - MAC_EPOCH, 0));
value_node = plist_dict_get_item(root_node, "ProductType");
plist_dict_set_item(ret, "Product Type", plist_copy(value_node));
value_node = plist_dict_get_item(root_node, "ProductVersion");
plist_dict_set_item(ret, "Product Version", plist_copy(value_node));
value_node = plist_dict_get_item(root_node, "SerialNumber");
plist_dict_set_item(ret, "Serial Number", plist_copy(value_node));
value_node = plist_dict_get_item(root_node, "UniqueDeviceID");
plist_dict_set_item(ret, "Target Identifier", plist_new_string(udid));
/* uppercase */
udid_uppercase = string_toupper((char*)udid);
plist_dict_set_item(ret, "Unique Identifier", plist_new_string(udid_uppercase));
free(udid_uppercase);
/* FIXME: Embed files as <data> nodes */
plist_t files = plist_new_dict();
plist_dict_set_item(ret, "iTunes Files", files);
plist_dict_set_item(ret, "iTunes Version", plist_new_string("9.0.2"));
plist_free(root_node);
return ret;
}
static void mobilebackup_info_update_last_backup_date(plist_t info_plist)
{
plist_t node = NULL;
if (!info_plist)
return;
node = plist_dict_get_item(info_plist, "Last Backup Date");
plist_set_date_val(node, time(NULL) - MAC_EPOCH, 0);
node = NULL;
}
static int plist_strcmp(plist_t node, const char *str)
{
char *buffer = NULL;
int ret = 0;
if (plist_get_node_type(node) != PLIST_STRING)
return ret;
plist_get_string_val(node, &buffer);
ret = strcmp(buffer, str);
free(buffer);
return ret;
}
static char *mobilebackup_build_path(const char *backup_directory, const char *name, const char *extension)
{
char* filename = (char*)malloc(strlen(name)+(extension == NULL ? 0: strlen(extension))+1);
strcpy(filename, name);
if (extension != NULL)
strcat(filename, extension);
char *path = string_build_path(backup_directory, filename, NULL);
free(filename);
return path;
}
static void mobilebackup_write_status(const char *path, int status)
{
struct stat st;
plist_t status_plist = plist_new_dict();
plist_dict_set_item(status_plist, "Backup Success", plist_new_bool(status));
char *file_path = mobilebackup_build_path(path, "Status", ".plist");
if (stat(file_path, &st) == 0)
remove(file_path);
plist_write_to_filename(status_plist, file_path, PLIST_FORMAT_XML);
plist_free(status_plist);
status_plist = NULL;
free(file_path);
}
static int mobilebackup_read_status(const char *path)
{
int ret = -1;
plist_t status_plist = NULL;
char *file_path = mobilebackup_build_path(path, "Status", ".plist");
plist_read_from_filename(&status_plist, file_path);
free(file_path);
if (!status_plist) {
printf("Could not read Status.plist!\n");
return ret;
}
plist_t node = plist_dict_get_item(status_plist, "Backup Success");
if (node && (plist_get_node_type(node) == PLIST_BOOLEAN)) {
uint8_t bval = 0;
plist_get_bool_val(node, &bval);
ret = bval;
} else {
printf("%s: ERROR could not get Backup Success key from Status.plist!\n", __func__);
}
plist_free(status_plist);
return ret;
}
static int mobilebackup_info_is_current_device(plist_t info)
{
plist_t value_node = NULL;
plist_t node = NULL;
plist_t root_node = NULL;
int ret = 0;
if (!info)
return ret;
if (plist_get_node_type(info) != PLIST_DICT)
return ret;
/* get basic device information in one go */
lockdownd_get_value(client, NULL, NULL, &root_node);
/* verify UDID */
value_node = plist_dict_get_item(root_node, "UniqueDeviceID");
node = plist_dict_get_item(info, "Target Identifier");
if(plist_compare_node_value(value_node, node))
ret = 1;
else {
printf("Info.plist: UniqueDeviceID does not match.\n");
}
/* verify SerialNumber */
if (ret == 1) {
value_node = plist_dict_get_item(root_node, "SerialNumber");
node = plist_dict_get_item(info, "Serial Number");
if(plist_compare_node_value(value_node, node))
ret = 1;
else {
printf("Info.plist: SerialNumber does not match.\n");
ret = 0;
}
}
/* verify ProductVersion to prevent using backup with different OS version */
if (ret == 1) {
value_node = plist_dict_get_item(root_node, "ProductVersion");
node = plist_dict_get_item(info, "Product Version");
if(plist_compare_node_value(value_node, node))
ret = 1;
else {
printf("Info.plist: ProductVersion does not match.\n");
ret = 0;
}
}
plist_free(root_node);
root_node = NULL;
value_node = NULL;
node = NULL;
return ret;
}
static int mobilebackup_delete_backup_file_by_hash(const char *backup_directory, const char *hash)
{
int ret = 0;
char *path = mobilebackup_build_path(backup_directory, hash, ".mddata");
printf("Removing \"%s\" ", path);
if (!remove( path ))
ret = 1;
else
ret = 0;
free(path);
if (!ret)
return ret;
path = mobilebackup_build_path(backup_directory, hash, ".mdinfo");
printf("and \"%s\"... ", path);
if (!remove( path ))
ret = 1;
else
ret = 0;
free(path);
return ret;
}
static int mobilebackup_check_file_integrity(const char *backup_directory, const char *hash, plist_t filedata)
{
char *datapath;
char *infopath;
plist_t mdinfo = NULL;
struct stat st;
unsigned char file_hash[20];
datapath = mobilebackup_build_path(backup_directory, hash, ".mddata");
if (stat(datapath, &st) != 0) {
printf("\r\n");
printf("ERROR: '%s.mddata' is missing!\n", hash);
free(datapath);
return 0;
}
infopath = mobilebackup_build_path(backup_directory, hash, ".mdinfo");
plist_read_from_filename(&mdinfo, infopath);
free(infopath);
if (!mdinfo) {
printf("\r\n");
printf("ERROR: '%s.mdinfo' is missing or corrupted!\n", hash);
free(datapath);
return 0;
}
/* sha1 hash verification */
plist_t node = plist_dict_get_item(filedata, "DataHash");
if (!node || (plist_get_node_type(node) != PLIST_DATA)) {
printf("\r\n");
printf("ERROR: Could not get DataHash for file entry '%s'\n", hash);
plist_free(mdinfo);
free(datapath);
return 0;
}
node = plist_dict_get_item(mdinfo, "Metadata");
if (!node && (plist_get_node_type(node) != PLIST_DATA)) {
printf("\r\n");
printf("ERROR: Could not find Metadata in plist '%s.mdinfo'\n", hash);
plist_free(mdinfo);
free(datapath);
return 0;
}
char *meta_bin = NULL;
uint64_t meta_bin_size = 0;
plist_get_data_val(node, &meta_bin, &meta_bin_size);
plist_t metadata = NULL;
if (meta_bin) {
plist_from_bin(meta_bin, (uint32_t)meta_bin_size, &metadata);
}
if (!metadata) {
printf("\r\n");
printf("ERROR: Could not get Metadata from plist '%s.mdinfo'\n", hash);
plist_free(mdinfo);
free(datapath);
return 0;
}
char *version = NULL;
node = plist_dict_get_item(metadata, "Version");
if (node && (plist_get_node_type(node) == PLIST_STRING)) {
plist_get_string_val(node, &version);
}
char *destpath = NULL;
node = plist_dict_get_item(metadata, "Path");
if (node && (plist_get_node_type(node) == PLIST_STRING)) {
plist_get_string_val(node, &destpath);
}
uint8_t greylist = 0;
node = plist_dict_get_item(metadata, "Greylist");
if (node && (plist_get_node_type(node) == PLIST_BOOLEAN)) {
plist_get_bool_val(node, &greylist);
}
char *domain = NULL;
node = plist_dict_get_item(metadata, "Domain");
if (node && (plist_get_node_type(node) == PLIST_STRING)) {
plist_get_string_val(node, &domain);
}
char *fnstr = malloc(strlen(domain) + 1 + strlen(destpath) + 1);
strcpy(fnstr, domain);
strcat(fnstr, "-");
strcat(fnstr, destpath);
unsigned char fnhash[20];
char fnamehash[41];
char *p = fnamehash;
sha1_of_data(fnstr, strlen(fnstr), fnhash);
free(fnstr);
int i;
for ( i = 0; i < 20; i++, p += 2 ) {
snprintf (p, 3, "%02x", (unsigned char)fnhash[i] );
}
if (strcmp(fnamehash, hash)) {
printf("\r\n");
printf("WARNING: filename hash does not match for entry '%s'\n", hash);
}
char *auth_version = NULL;
node = plist_dict_get_item(mdinfo, "AuthVersion");
if (node && (plist_get_node_type(node) == PLIST_STRING)) {
plist_get_string_val(node, &auth_version);
}
if (strcmp(auth_version, "1.0")) {
printf("\r\n");
printf("WARNING: Unknown AuthVersion '%s', DataHash cannot be verified!\n", auth_version);
}
node = plist_dict_get_item(filedata, "DataHash");
if (!node || (plist_get_node_type(node) != PLIST_DATA)) {
printf("\r\n");
printf("WARNING: Could not get DataHash key from file info data for entry '%s'\n", hash);
}
int res = 1;
unsigned char *data_hash = NULL;
uint64_t data_hash_len = 0;
plist_get_data_val(node, (char**)&data_hash, &data_hash_len);
int hash_ok = 0;
if (data_hash && (data_hash_len == 20)) {
compute_datahash(datapath, destpath, greylist, domain, NULL, version, file_hash);
hash_ok = compare_hash(data_hash, file_hash, 20);
} else if (data_hash_len == 0) {
/* no datahash present */
hash_ok = 1;
}
free(domain);
free(version);
free(destpath);
if (!hash_ok) {
printf("\r\n");
printf("ERROR: The hash for '%s.mddata' does not match DataHash entry in Manifest\n", hash);
printf("datahash: ");
print_hash(data_hash, 20);
printf("\nfilehash: ");
print_hash(file_hash, 20);
printf("\n");
res = 0;
}
free(data_hash);
plist_free(mdinfo);
return res;
}
static void do_post_notification(const char *notification)
{
lockdownd_service_descriptor_t service = NULL;
np_client_t np;
if (!client) {
if (lockdownd_client_new_with_handshake(device, &client, TOOL_NAME) != LOCKDOWN_E_SUCCESS) {
return;
}
}
lockdownd_error_t ldret = lockdownd_start_service(client, NP_SERVICE_NAME, &service);
if (ldret == LOCKDOWN_E_SUCCESS) {
np_client_new(device, service, &np);
if (np) {
np_post_notification(np, notification);
np_client_free(np);
}
} else {
printf("Could not start %s: %s\n", NP_SERVICE_NAME, lockdownd_strerror(ldret));
}
if (service) {
lockdownd_service_descriptor_free(service);
service = NULL;
}
}
static void print_progress(double progress)
{
int i = 0;
if (progress < 0)
return;
if (progress > 100)
progress = 100;
printf("\r[");
for(i = 0; i < 50; i++) {
if(i < progress / 2) {
printf("=");
} else {
printf(" ");
}
}
printf("] %3.0f%%", progress);
fflush(stdout);
if (progress == 100)
printf("\n");
}
/**
* signal handler function for cleaning up properly
*/
static void clean_exit(int sig)
{
fprintf(stderr, "Exiting...\n");
quit_flag++;
}
static void print_usage(int argc, char **argv)
{
char *name = NULL;
name = strrchr(argv[0], '/');
printf("Usage: %s [OPTIONS] CMD [DIRECTORY]\n", (name ? name + 1: argv[0]));
printf("\n");
printf("Create or restore backup from the current or specified directory.\n");
printf("\n");
printf("CMD:\n");
printf(" backup\tSaves a device backup into DIRECTORY\n");
printf(" restore\tRestores a device backup from DIRECTORY.\n");
printf("\n");
printf("OPTIONS:\n");
printf(" -u, --udid UDID\ttarget specific device by UDID\n");
printf(" -n, --network\t\tconnect to network device\n");
printf(" -d, --debug\t\tenable communication debugging\n");
printf(" -h, --help\t\tprints usage information\n");
printf(" -v, --version\t\tprints version information\n");
printf("\n");
printf("Homepage: <" PACKAGE_URL ">\n");
printf("Bug Reports: <" PACKAGE_BUGREPORT ">\n");
}
int main(int argc, char *argv[])
{
idevice_error_t ret = IDEVICE_E_UNKNOWN_ERROR;
lockdownd_error_t ldret = LOCKDOWN_E_UNKNOWN_ERROR;
int i;
char* udid = NULL;
int use_network = 0;
lockdownd_service_descriptor_t service = NULL;
int cmd = -1;
int is_full_backup = 0;
char *backup_directory = NULL;
struct stat st;
plist_t node = NULL;
plist_t node_tmp = NULL;
plist_t manifest_plist = NULL;
plist_t info_plist = NULL;
char *buffer = NULL;
char *file_path = NULL;
uint64_t length = 0;
uint64_t backup_total_size = 0;
enum device_link_file_status_t file_status = DEVICE_LINK_FILE_STATUS_NONE;
uint64_t c = 0;
/* we need to exit cleanly on running backups and restores or we cause havok */
signal(SIGINT, clean_exit);
signal(SIGTERM, clean_exit);
#ifndef WIN32
signal(SIGQUIT, clean_exit);
signal(SIGPIPE, SIG_IGN);
#endif
/* 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] || !*argv[i]) {
print_usage(argc, argv);
return 0;
}
udid = strdup(argv[i]);
continue;
}
else if (!strcmp(argv[i], "-n") || !strcmp(argv[i], "--network")) {
use_network = 1;
continue;
}
else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
print_usage(argc, argv);
return 0;
}
else if (!strcmp(argv[i], "-v") || !strcmp(argv[i], "--version")) {
printf("%s %s\n", TOOL_NAME, PACKAGE_VERSION);
return 0;
}
else if (!strcmp(argv[i], "backup")) {
cmd = CMD_BACKUP;
}
else if (!strcmp(argv[i], "restore")) {
cmd = CMD_RESTORE;
}
else if (backup_directory == NULL) {
backup_directory = argv[i];
}
else {
print_usage(argc, argv);
return 0;
}
}
/* verify options */
if (cmd == -1) {
printf("No command specified.\n");
print_usage(argc, argv);
return -1;
}
if (backup_directory == NULL) {
printf("No target backup directory specified.\n");
print_usage(argc, argv);
return -1;
}
/* verify if passed backup directory exists */
if (stat(backup_directory, &st) != 0) {
printf("ERROR: Backup directory \"%s\" does not exist!\n", backup_directory);
return -1;
}
/* restore directory must contain an Info.plist */
char *info_path = mobilebackup_build_path(backup_directory, "Info", ".plist");
if (cmd == CMD_RESTORE) {
if (stat(info_path, &st) != 0) {
free(info_path);
printf("ERROR: Backup directory \"%s\" is invalid. No Info.plist found.\n", backup_directory);
return -1;
}
}
printf("Backup directory is \"%s\"\n", backup_directory);
ret = idevice_new_with_options(&device, udid, (use_network) ? IDEVICE_LOOKUP_NETWORK : IDEVICE_LOOKUP_USBMUX);
if (ret != IDEVICE_E_SUCCESS) {
if (udid) {
printf("No device found with udid %s.\n", udid);
} else {
printf("No device found.\n");
}
return -1;
}
if (LOCKDOWN_E_SUCCESS != (ldret = lockdownd_client_new_with_handshake(device, &client, TOOL_NAME))) {
printf("ERROR: Could not connect to lockdownd, error code %d\n", ldret);
idevice_free(device);
return -1;
}
node = NULL;
lockdownd_get_value(client, NULL, "ProductVersion", &node);
if (node) {
char* str = NULL;
if (plist_get_node_type(node) == PLIST_STRING) {
plist_get_string_val(node, &str);
}
plist_free(node);
node = NULL;
if (str) {
int maj = strtol(str, NULL, 10);
free(str);
if (maj > 3) {
printf("ERROR: This tool is only compatible with iOS 3 or below. For newer iOS versions please use the idevicebackup2 tool.\n");
lockdownd_client_free(client);
idevice_free(device);
return -1;
}
}
}
/* start notification_proxy */
np_client_t np = NULL;
ldret = lockdownd_start_service(client, NP_SERVICE_NAME, &service);
if ((ldret == LOCKDOWN_E_SUCCESS) && service && service->port) {
np_client_new(device, service, &np);
np_set_notify_callback(np, notify_cb, NULL);
const char *noties[5] = {
NP_SYNC_CANCEL_REQUEST,
NP_SYNC_SUSPEND_REQUEST,
NP_SYNC_RESUME_REQUEST,
NP_BACKUP_DOMAIN_CHANGED,
NULL
};
np_observe_notifications(np, noties);
} else {
printf("ERROR: Could not start service %s: %s\n", NP_SERVICE_NAME, lockdownd_strerror(ldret));
}
afc_client_t afc = NULL;
if (cmd == CMD_BACKUP) {
/* start AFC, we need this for the lock file */
service->port = 0;
service->ssl_enabled = 0;
ldret = lockdownd_start_service(client, AFC_SERVICE_NAME, &service);
if ((ldret == LOCKDOWN_E_SUCCESS) && service->port) {
afc_client_new(device, service, &afc);
} else {
printf("ERROR: Could not start service %s: %s\n", AFC_SERVICE_NAME, lockdownd_strerror(ldret));
}
}
if (service) {
lockdownd_service_descriptor_free(service);
service = NULL;
}
/* start mobilebackup service and retrieve port */
ldret = lockdownd_start_service(client, MOBILEBACKUP_SERVICE_NAME, &service);
if ((ldret == LOCKDOWN_E_SUCCESS) && service && service->port) {
printf("Started \"%s\" service on port %d.\n", MOBILEBACKUP_SERVICE_NAME, service->port);
mobilebackup_client_new(device, service, &mobilebackup);
if (service) {
lockdownd_service_descriptor_free(service);
service = NULL;
}
/* check abort conditions */
if (quit_flag > 0) {
printf("Aborting backup. Cancelled by user.\n");
cmd = CMD_LEAVE;
}
/* verify existing Info.plist */
if (stat(info_path, &st) == 0) {
printf("Reading Info.plist from backup.\n");
plist_read_from_filename(&info_plist, info_path);
if (!info_plist) {
printf("Could not read Info.plist\n");
is_full_backup = 1;
}
if (info_plist && (cmd == CMD_BACKUP)) {
if (mobilebackup_info_is_current_device(info_plist)) {
/* update the last backup time within Info.plist */
mobilebackup_info_update_last_backup_date(info_plist);
remove(info_path);
plist_write_to_filename(info_plist, info_path, PLIST_FORMAT_XML);
} else {
printf("Aborting backup. Backup is not compatible with the current device.\n");
cmd = CMD_LEAVE;
}
} else if (info_plist && (cmd == CMD_RESTORE)) {
if (!mobilebackup_info_is_current_device(info_plist)) {
printf("Aborting restore. Backup data is not compatible with the current device.\n");
cmd = CMD_LEAVE;
}
}
} else {
if (cmd == CMD_RESTORE) {
printf("Aborting restore. Info.plist is missing.\n");
cmd = CMD_LEAVE;
} else {
is_full_backup = 1;
}
}
uint64_t lockfile = 0;
if (cmd == CMD_BACKUP) {
do_post_notification(NP_SYNC_WILL_START);
afc_file_open(afc, "/com.apple.itunes.lock_sync", AFC_FOPEN_RW, &lockfile);
}
if (lockfile) {
afc_error_t aerr;
do_post_notification(NP_SYNC_LOCK_REQUEST);
for (i = 0; i < LOCK_ATTEMPTS; i++) {
aerr = afc_file_lock(afc, lockfile, AFC_LOCK_EX);
if (aerr == AFC_E_SUCCESS) {
do_post_notification(NP_SYNC_DID_START);
break;
} else if (aerr == AFC_E_OP_WOULD_BLOCK) {
usleep(LOCK_WAIT);
continue;
} else {
fprintf(stderr, "ERROR: could not lock file! error code: %d\n", aerr);
afc_file_close(afc, lockfile);
lockfile = 0;
cmd = CMD_LEAVE;
}
}
if (i == LOCK_ATTEMPTS) {
fprintf(stderr, "ERROR: timeout while locking for sync\n");
afc_file_close(afc, lockfile);
lockfile = 0;
cmd = CMD_LEAVE;
}
}
mobilebackup_error_t err;
/* Manifest.plist (backup manifest (backup state)) */
char *manifest_path = mobilebackup_build_path(backup_directory, "Manifest", ".plist");
switch(cmd) {
case CMD_BACKUP:
printf("Starting backup...\n");
/* TODO: check domain com.apple.mobile.backup key RequiresEncrypt and WillEncrypt with lockdown */
/* TODO: verify battery on AC enough battery remaining */
/* read the last Manifest.plist */
if (!is_full_backup) {
printf("Reading existing Manifest.\n");
plist_read_from_filename(&manifest_plist, manifest_path);
if (!manifest_plist) {
printf("Could not read Manifest.plist, switching to full backup mode.\n");
is_full_backup = 1;
}
}
/* Info.plist (Device infos, IC-Info.sidb, photos, app_ids, iTunesPrefs) */
/* create new Info.plist on new backups */
if (is_full_backup) {
if (info_plist) {
plist_free(info_plist);
info_plist = NULL;
}
remove(info_path);
printf("Creating Info.plist for new backup.\n");
info_plist = mobilebackup_factory_info_plist_new(udid);
plist_write_to_filename(info_plist, info_path, PLIST_FORMAT_XML);
}
free(info_path);
plist_free(info_plist);
info_plist = NULL;
/* close down the lockdown connection as it is no longer needed */
if (client) {
lockdownd_client_free(client);
client = NULL;
}
/* create Status.plist with failed status for now */
mobilebackup_write_status(backup_directory, 0);
/* request backup from device with manifest from last backup */
printf("Requesting backup from device...\n");
err = mobilebackup_request_backup(mobilebackup, manifest_plist, "/", "1.6");
if (err == MOBILEBACKUP_E_SUCCESS) {
if (is_full_backup)
printf("Full backup mode.\n");
else
printf("Incremental backup mode.\n");
printf("Please wait. Device is preparing backup data...\n");
} else {
if (err == MOBILEBACKUP_E_BAD_VERSION) {
printf("ERROR: Could not start backup process: backup protocol version mismatch!\n");
} else if (err == MOBILEBACKUP_E_REPLY_NOT_OK) {
printf("ERROR: Could not start backup process: device refused to start the backup process.\n");
} else {
printf("ERROR: Could not start backup process: unspecified error occurred\n");
}
break;
}
/* reset backup status */
int backup_ok = 0;
plist_t message = NULL;
/* receive and save DLSendFile files and metadata, ACK each */
uint64_t file_size = 0;
uint64_t file_size_current = 0;
int file_index = 0;
int hunk_index = 0;
uint64_t backup_real_size = 0;
char *file_ext = NULL;
char *filename_mdinfo = NULL;
char *filename_mddata = NULL;
char *filename_source = NULL;
char *format_size = NULL;
int is_manifest = 0;
uint8_t b = 0;
/* process series of DLSendFile messages */
do {
mobilebackup_receive(mobilebackup, &message);
if (!message) {
printf("Device is not ready yet. Going to try again in 2 seconds...\n");
sleep(2);
goto files_out;
}
node = plist_array_get_item(message, 0);
/* get out if we don't get a DLSendFile */
if (plist_strcmp(node, "DLSendFile"))
break;
node_tmp = plist_array_get_item(message, 2);
/* first message hunk contains total backup size */
if ((hunk_index == 0) && (file_index == 0)) {
node = plist_dict_get_item(node_tmp, "BackupTotalSizeKey");
if (node) {
plist_get_uint_val(node, &backup_total_size);
format_size = string_format_size(backup_total_size);
printf("Backup data requires %s on the disk.\n", format_size);
free(format_size);
}
}
/* check DLFileStatusKey (codes: 1 = Hunk, 2 = Last Hunk) */
node = plist_dict_get_item(node_tmp, "DLFileStatusKey");
plist_get_uint_val(node, &c);
file_status = c;
/* get source filename */
node = plist_dict_get_item(node_tmp, "BackupManifestKey");
b = 0;
if (node) {
plist_get_bool_val(node, &b);
}
is_manifest = (b == 1) ? 1 : 0;
if ((hunk_index == 0) && (!is_manifest)) {
/* get source filename */
node = plist_dict_get_item(node_tmp, "DLFileSource");
plist_get_string_val(node, &filename_source);
/* increase received size */
node = plist_dict_get_item(node_tmp, "DLFileAttributesKey");
node = plist_dict_get_item(node, "FileSize");
plist_get_uint_val(node, &file_size);
backup_real_size += file_size;
format_size = string_format_size(backup_real_size);
printf("(%s", format_size);
free(format_size);
format_size = string_format_size(backup_total_size);
printf("/%s): ", format_size);
free(format_size);
format_size = string_format_size(file_size);
printf("Receiving file %s (%s)... \n", filename_source, format_size);
free(format_size);
if (filename_source)
free(filename_source);
}
/* check if we completed a file */
if ((file_status == DEVICE_LINK_FILE_STATUS_LAST_HUNK) && (!is_manifest)) {
/* save <hash>.mdinfo */
node = plist_dict_get_item(node_tmp, "BackupFileInfo");
if (node) {
node = plist_dict_get_item(node_tmp, "DLFileDest");
plist_get_string_val(node, &file_path);
filename_mdinfo = mobilebackup_build_path(backup_directory, file_path, ".mdinfo");
/* remove any existing file */
if (stat(filename_mdinfo, &st) == 0)
remove(filename_mdinfo);
node = plist_dict_get_item(node_tmp, "BackupFileInfo");
plist_write_to_filename(node, filename_mdinfo, PLIST_FORMAT_BINARY);
free(filename_mdinfo);
}
file_index++;
}
/* save <hash>.mddata */
node = plist_dict_get_item(node_tmp, "BackupFileInfo");
if (node_tmp) {
node = plist_dict_get_item(node_tmp, "DLFileDest");
plist_get_string_val(node, &file_path);
filename_mddata = mobilebackup_build_path(backup_directory, file_path, is_manifest ? NULL: ".mddata");
/* if this is the first hunk, remove any existing file */
if ((hunk_index == 0) && (stat(filename_mddata, &st) == 0))
remove(filename_mddata);
/* get file data hunk */
node_tmp = plist_array_get_item(message, 1);
plist_get_data_val(node_tmp, &buffer, &length);
buffer_write_to_filename(filename_mddata, buffer, length);
if (!is_manifest)
file_size_current += length;
/* activate currently sent manifest */
if ((file_status == DEVICE_LINK_FILE_STATUS_LAST_HUNK) && (is_manifest)) {
rename(filename_mddata, manifest_path);
}
free(buffer);
buffer = NULL;
free(filename_mddata);
}
if ((!is_manifest)) {
if (hunk_index == 0 && file_status == DEVICE_LINK_FILE_STATUS_LAST_HUNK) {
print_progress(100);
} else {
if (file_size > 0)
print_progress((double)((file_size_current*100)/file_size));
}
}
hunk_index++;
if (file_ext)
free(file_ext);
if (message)
plist_free(message);
message = NULL;
if (file_status == DEVICE_LINK_FILE_STATUS_LAST_HUNK) {
/* acknowlegdge that we received the file */
mobilebackup_send_backup_file_received(mobilebackup);
/* reset hunk_index */
hunk_index = 0;
if (!is_manifest) {
file_size_current = 0;
file_size = 0;
}
}
files_out:
if (quit_flag > 0) {
/* need to cancel the backup here */
mobilebackup_send_error(mobilebackup, "Cancelling DLSendFile");
/* remove any atomic Manifest.plist.tmp */
if (manifest_path)
free(manifest_path);
manifest_path = mobilebackup_build_path(backup_directory, "Manifest", ".plist.tmp");
if (stat(manifest_path, &st) == 0)
remove(manifest_path);
break;
}
} while (1);
printf("Received %d files from device.\n", file_index);
if (!quit_flag && !plist_strcmp(node, "DLMessageProcessMessage")) {
node_tmp = plist_array_get_item(message, 1);
node = plist_dict_get_item(node_tmp, "BackupMessageTypeKey");
/* check if we received the final "backup finished" message */
if (node && !plist_strcmp(node, "BackupMessageBackupFinished")) {
/* backup finished */
/* process BackupFilesToDeleteKey */
node = plist_dict_get_item(node_tmp, "BackupFilesToDeleteKey");
if (node) {
length = plist_array_get_size(node);
i = 0;
while ((node_tmp = plist_array_get_item(node, i++)) != NULL) {
plist_get_string_val(node_tmp, &file_path);
if (mobilebackup_delete_backup_file_by_hash(backup_directory, file_path)) {
printf("DONE\n");
} else
printf("FAILED\n");
}
}
/* save last valid Manifest.plist */
node_tmp = plist_array_get_item(message, 1);
manifest_plist = plist_dict_get_item(node_tmp, "BackupManifestKey");
if (manifest_plist) {
remove(manifest_path);
printf("Storing Manifest.plist...\n");
plist_write_to_filename(manifest_plist, manifest_path, PLIST_FORMAT_XML);
}
backup_ok = 1;
}
}
if (backup_ok) {
/* Status.plist (Info on how the backup process turned out) */
printf("Backup Successful.\n");
mobilebackup_write_status(backup_directory, 1);
} else {
printf("Backup Failed.\n");
}
break;
case CMD_RESTORE:
/* close down the lockdown connection as it is no longer needed */
if (client) {
lockdownd_client_free(client);
client = NULL;
}
/* TODO: verify battery on AC enough battery remaining */
/* verify if Status.plist says we read from an successful backup */
if (mobilebackup_read_status(backup_directory) <= 0) {
printf("ERROR: Cannot ensure we restore from a successful backup. Aborting.\n");
break;
}
/* now make sure backup integrity is ok! verify all files */
printf("Reading existing Manifest.\n");
plist_read_from_filename(&manifest_plist, manifest_path);
if (!manifest_plist) {
printf("Could not read Manifest.plist. Aborting.\n");
break;
}
printf("Verifying backup integrity, please wait.\n");
char *bin = NULL;
uint64_t binsize = 0;
node = plist_dict_get_item(manifest_plist, "Data");
if (!node || (plist_get_node_type(node) != PLIST_DATA)) {
printf("Could not read Data key from Manifest.plist!\n");
break;
}
plist_get_data_val(node, &bin, &binsize);
plist_t backup_data = NULL;
if (bin) {
char *auth_ver = NULL;
unsigned char *auth_sig = NULL;
uint64_t auth_sig_len = 0;
/* verify AuthSignature */
node = plist_dict_get_item(manifest_plist, "AuthVersion");
plist_get_string_val(node, &auth_ver);
if (auth_ver && (strcmp(auth_ver, "2.0") == 0)) {
node = plist_dict_get_item(manifest_plist, "AuthSignature");
if (node && (plist_get_node_type(node) == PLIST_DATA)) {
plist_get_data_val(node, (char**)&auth_sig, &auth_sig_len);
}
if (auth_sig && (auth_sig_len == 20)) {
/* calculate the sha1, then compare */
unsigned char data_sha1[20];
sha1_of_data(bin, binsize, data_sha1);
if (compare_hash(auth_sig, data_sha1, 20)) {
printf("AuthSignature is valid\n");
} else {
printf("ERROR: AuthSignature is NOT VALID\n");
}
} else {
printf("Could not get AuthSignature from manifest!\n");
}
free(auth_sig);
} else if (auth_ver) {
printf("Unknown AuthVersion '%s', cannot verify AuthSignature\n", auth_ver);
}
plist_from_bin(bin, (uint32_t)binsize, &backup_data);
free(bin);
}
if (!backup_data) {
printf("Could not read plist from Manifest.plist Data key!\n");
break;
}
plist_t files = plist_dict_get_item(backup_data, "Files");
if (files && (plist_get_node_type(files) == PLIST_DICT)) {
plist_dict_iter iter = NULL;
plist_dict_new_iter(files, &iter);
if (iter) {
/* loop over Files entries in Manifest data plist */
char *hash = NULL;
int file_ok = 0;
int total_files = plist_dict_get_size(files);
int cur_file = 1;
node = NULL;
plist_dict_next_item(files, iter, &hash, &node);
while (node) {
printf("Verifying file %d/%d (%d%%) \r", cur_file, total_files, (cur_file*100/total_files));
cur_file++;
/* make sure both .mddata/.mdinfo files are available for each entry */
file_ok = mobilebackup_check_file_integrity(backup_directory, hash, node);
node = NULL;
free(hash);
hash = NULL;
if (!file_ok) {
break;
}
plist_dict_next_item(files, iter, &hash, &node);
}
printf("\n");
free(iter);
if (!file_ok) {
plist_free(backup_data);
break;
}
printf("All backup files appear to be valid\n");
}
}
printf("Requesting restore from device...\n");
/* request restore from device with manifest (BackupMessageRestoreMigrate) */
int restore_flags = MB_RESTORE_NOTIFY_SPRINGBOARD | MB_RESTORE_PRESERVE_SETTINGS | MB_RESTORE_PRESERVE_CAMERA_ROLL;
err = mobilebackup_request_restore(mobilebackup, manifest_plist, restore_flags, "1.6");
if (err != MOBILEBACKUP_E_SUCCESS) {
if (err == MOBILEBACKUP_E_BAD_VERSION) {
printf("ERROR: Could not start restore process: backup protocol version mismatch!\n");
} else if (err == MOBILEBACKUP_E_REPLY_NOT_OK) {
printf("ERROR: Could not start restore process: device refused to start the restore process.\n");
} else {
printf("ERROR: Could not start restore process: unspecified error occurred (%d)\n", err);
}
plist_free(backup_data);
break;
}
printf("Entered restore mode.\n");
int restore_ok = 0;
if (files && (plist_get_node_type(files) == PLIST_DICT)) {
plist_dict_iter iter = NULL;
plist_dict_new_iter(files, &iter);
if (iter) {
/* loop over Files entries in Manifest data plist */
char *hash = NULL;
plist_t file_info = NULL;
char *file_info_path = NULL;
int total_files = plist_dict_get_size(files);
int cur_file = 0;
uint64_t file_offset = 0;
uint8_t is_encrypted = 0;
plist_t tmp_node = NULL;
plist_t file_path_node = NULL;
plist_t send_file_node = NULL;
node = NULL;
plist_dict_next_item(files, iter, &hash, &node);
while (node) {
/* TODO: read mddata/mdinfo files and send to device using DLSendFile */
file_info_path = mobilebackup_build_path(backup_directory, hash, ".mdinfo");
plist_read_from_filename(&file_info, file_info_path);
/* get encryption state */
tmp_node = plist_dict_get_item(file_info, "IsEncrypted");
plist_get_bool_val(tmp_node, &is_encrypted);
tmp_node = NULL;
/* get real file path from metadata */
tmp_node = plist_dict_get_item(file_info, "Metadata");
plist_get_data_val(tmp_node, &buffer, &length);
tmp_node = NULL;
plist_from_bin(buffer, length, &tmp_node);
file_path_node = plist_dict_get_item(tmp_node, "Path");
plist_get_string_val(file_path_node, &file_path);
printf("Restoring file %s %d/%d (%d%%)... ", file_path, cur_file, total_files, (cur_file*100/total_files));
/* add additional device link file information keys */
plist_dict_set_item(file_info, "DLFileAttributesKey", plist_copy(node));
plist_dict_set_item(file_info, "DLFileSource", plist_new_string(file_info_path));
plist_dict_set_item(file_info, "DLFileDest", plist_new_string("/tmp/RestoreFile.plist"));
plist_dict_set_item(file_info, "DLFileIsEncrypted", plist_new_bool(is_encrypted));
plist_dict_set_item(file_info, "DLFileOffsetKey", plist_new_uint(file_offset));
plist_dict_set_item(file_info, "DLFileStatusKey", plist_new_uint(file_status));
/* read data from file */
free(file_info_path);
file_info_path = mobilebackup_build_path(backup_directory, hash, ".mddata");
/* determine file size */
#ifdef WIN32
struct _stati64 fst;
if (_stati64(file_info_path, &fst) != 0)
#else
struct stat fst;
if (stat(file_info_path, &fst) != 0)
#endif
{
printf("ERROR: stat() failed for '%s': %s\n", file_info_path, strerror(errno));
free(file_info_path);
break;
}
length = fst.st_size;
FILE *f = fopen(file_info_path, "rb");
if (!f) {
printf("ERROR: could not open local file '%s': %s\n", file_info_path, strerror(errno));
free(file_info_path);
break;
}
free(file_info_path);
/* send DLSendFile messages */
file_offset = 0;
do {
char buf[8192];
size_t len = fread(buf, 1, sizeof(buf), f);
if ((length-file_offset) <= sizeof(buf))
file_status = DEVICE_LINK_FILE_STATUS_LAST_HUNK;
else
file_status = DEVICE_LINK_FILE_STATUS_HUNK;
plist_dict_remove_item(file_info, "DLFileOffsetKey");
plist_dict_set_item(file_info, "DLFileOffsetKey", plist_new_uint(file_offset));
plist_dict_remove_item(file_info, "DLFileStatusKey");
plist_dict_set_item(file_info, "DLFileStatusKey", plist_new_uint(file_status));
send_file_node = plist_new_array();
plist_array_append_item(send_file_node, plist_new_string("DLSendFile"));
plist_array_append_item(send_file_node, plist_new_data(buf, len));
plist_array_append_item(send_file_node, plist_copy(file_info));
err = mobilebackup_send(mobilebackup, send_file_node);
if (err != MOBILEBACKUP_E_SUCCESS) {
printf("ERROR: Unable to send file hunk due to error %d. Aborting...\n", err);
file_status = DEVICE_LINK_FILE_STATUS_NONE;
}
if (file_status == DEVICE_LINK_FILE_STATUS_LAST_HUNK) {
/* TODO: if all hunks of a file are sent, device must send ack */
err = mobilebackup_receive_restore_file_received(mobilebackup, NULL);
if (err != MOBILEBACKUP_E_SUCCESS) {
printf("ERROR: Did not receive an ack for the sent file due to error %d. Aborting...\n", err);
file_status = DEVICE_LINK_FILE_STATUS_NONE;
}
}
file_offset += len;
if (file_status == DEVICE_LINK_FILE_STATUS_LAST_HUNK)
printf("DONE\n");
plist_free(send_file_node);
if (file_status == DEVICE_LINK_FILE_STATUS_NONE)
break;
} while((file_offset < length));
free(hash);
node = NULL;
hash = NULL;
restore_ok = 1;
if (file_status == DEVICE_LINK_FILE_STATUS_NONE) {
restore_ok = 0;
break;
}
cur_file++;
plist_dict_next_item(files, iter, &hash, &node);
}
free(iter);
printf("Restored %d files on device.\n", cur_file);
}
}
/* TODO: observe notification_proxy id com.apple.mobile.application_installed */
/* TODO: loop over Applications entries in Manifest data plist */
plist_t applications = plist_dict_get_item(backup_data, "Applications");
if (applications && (plist_get_node_type(applications) == PLIST_DICT) && restore_ok) {
plist_dict_iter iter = NULL;
plist_dict_new_iter(applications, &iter);
if (iter) {
/* loop over Application entries in Manifest data plist */
char *hash = NULL;
int total_files = plist_dict_get_size(applications);
int cur_file = 1;
plist_t tmp_node = NULL;
plist_t dict = NULL;
plist_t array = NULL;
node = NULL;
plist_dict_next_item(applications, iter, &hash, &node);
while (node) {
printf("Restoring Application %s %d/%d (%d%%)...", hash, cur_file, total_files, (cur_file*100/total_files));
/* FIXME: receive com.apple.mobile.application_installed notification */
/* send AppInfo entry */
tmp_node = plist_dict_get_item(node, "AppInfo");
dict = plist_new_dict();
plist_dict_set_item(dict, "AppInfo", plist_copy(tmp_node));
plist_dict_set_item(dict, "BackupMessageTypeKey", plist_new_string("BackupMessageRestoreApplicationSent"));
array = plist_new_array();
plist_array_append_item(array, plist_new_string("DLMessageProcessMessage"));
plist_array_append_item(array, dict);
err = mobilebackup_send(mobilebackup, array);
if (err != MOBILEBACKUP_E_SUCCESS) {
printf("ERROR: Unable to restore application %s due to error %d. Aborting...\n", hash, err);
restore_ok = 0;
}
plist_free(array);
array = NULL;
dict = NULL;
/* receive BackupMessageRestoreApplicationReceived from device */
if (restore_ok) {
err = mobilebackup_receive_restore_application_received(mobilebackup, NULL);
if (err != MOBILEBACKUP_E_SUCCESS) {
printf("ERROR: Failed to receive an ack from the device for this application due to error %d. Aborting...\n", err);
restore_ok = 0;
}
}
tmp_node = NULL;
node = NULL;
free(hash);
hash = NULL;
if (restore_ok) {
printf("DONE\n");
cur_file++;
plist_dict_next_item(applications, iter, &hash, &node);
} else
break;
}
free(iter);
if (restore_ok)
printf("All applications restored.\n");
else
printf("Failed to restore applications.\n");
}
}
plist_free(backup_data);
/* signal restore finished message to device; BackupMessageRestoreComplete */
if (restore_ok) {
err = mobilebackup_send_restore_complete(mobilebackup);
if (err != MOBILEBACKUP_E_SUCCESS) {
printf("ERROR: Could not send BackupMessageRestoreComplete, error code %d\n", err);
}
}
if (restore_ok) {
printf("Restore Successful.\n");
} else {
printf("Restore Failed.\n");
}
break;
case CMD_LEAVE:
default:
break;
}
if (lockfile) {
afc_file_lock(afc, lockfile, AFC_LOCK_UN);
afc_file_close(afc, lockfile);
lockfile = 0;
do_post_notification(NP_SYNC_DID_FINISH);
}
if (manifest_path)
free(manifest_path);
} else {
printf("ERROR: Could not start service %s: %s\n", MOBILEBACKUP_SERVICE_NAME, lockdownd_strerror(ldret));
lockdownd_client_free(client);
client = NULL;
}
if (client) {
lockdownd_client_free(client);
client = NULL;
}
if (afc)
afc_client_free(afc);
if (np)
np_client_free(np);
if (mobilebackup)
mobilebackup_client_free(mobilebackup);
idevice_free(device);
if (udid) {
free(udid);
}
return 0;
}