blob: 41bfb9dcc05a9216a03a4e6b82d34a9f244e3964 [file] [log] [blame]
/*
* restore.c
* com.apple.mobile.restored service implementation.
*
* Copyright (c) 2010 Joshua Hill. 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
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <plist/plist.h>
#include "property_list_service.h"
#include "restore.h"
#include "idevice.h"
#include "common/debug.h"
#define RESULT_SUCCESS 0
#define RESULT_FAILURE 1
/**
* Internally used function for checking the result from restore's answer
* plist to a previously sent request.
*
* @param dict The plist to evaluate.
* @param query_match Name of the request to match.
*
* @return RESULT_SUCCESS when the result is 'Success',
* RESULT_FAILURE when the result is 'Failure',
* or a negative value if an error occurred during evaluation.
*/
static int restored_check_result(plist_t dict)
{
int ret = -1;
plist_t result_node = plist_dict_get_item(dict, "Result");
if (!result_node) {
return ret;
}
plist_type result_type = plist_get_node_type(result_node);
if (result_type == PLIST_STRING) {
char *result_value = NULL;
plist_get_string_val(result_node, &result_value);
if (result_value) {
if (!strcmp(result_value, "Success")) {
ret = RESULT_SUCCESS;
} else if (!strcmp(result_value, "Failure")) {
ret = RESULT_FAILURE;
} else {
debug_info("ERROR: unknown result value '%s'", result_value);
}
}
if (result_value)
free(result_value);
}
return ret;
}
/**
* Adds a label key with the passed value to a plist dict node.
*
* @param plist The plist to add the key to
* @param label The value for the label key
*
*/
static void plist_dict_add_label(plist_t plist, const char *label)
{
if (plist && label) {
if (plist_get_node_type(plist) == PLIST_DICT)
plist_dict_set_item(plist, "Label", plist_new_string(label));
}
}
static restored_error_t restored_error(property_list_service_error_t err)
{
switch (err) {
case PROPERTY_LIST_SERVICE_E_SUCCESS:
return RESTORE_E_SUCCESS;
case PROPERTY_LIST_SERVICE_E_INVALID_ARG:
return RESTORE_E_INVALID_ARG;
case PROPERTY_LIST_SERVICE_E_PLIST_ERROR:
return RESTORE_E_PLIST_ERROR;
case PROPERTY_LIST_SERVICE_E_MUX_ERROR:
return RESTORE_E_MUX_ERROR;
case PROPERTY_LIST_SERVICE_E_RECEIVE_TIMEOUT:
return RESTORE_E_RECEIVE_TIMEOUT;
default:
break;
}
return RESTORE_E_UNKNOWN_ERROR;
}
LIBIMOBILEDEVICE_API restored_error_t restored_client_free(restored_client_t client)
{
if (!client)
return RESTORE_E_INVALID_ARG;
restored_error_t ret = RESTORE_E_UNKNOWN_ERROR;
if (client->parent) {
restored_goodbye(client);
ret = restored_error(property_list_service_client_free(client->parent));
}
if (client->udid) {
free(client->udid);
}
if (client->label) {
free(client->label);
}
if (client->info) {
plist_free(client->info);
}
free(client);
return ret;
}
LIBIMOBILEDEVICE_API void restored_client_set_label(restored_client_t client, const char *label)
{
if (client) {
if (client->label)
free(client->label);
client->label = (label != NULL) ? strdup(label): NULL;
}
}
LIBIMOBILEDEVICE_API restored_error_t restored_receive(restored_client_t client, plist_t *plist)
{
if (!client || !plist || (plist && *plist))
return RESTORE_E_INVALID_ARG;
return restored_error(property_list_service_receive_plist(client->parent, plist));
}
LIBIMOBILEDEVICE_API restored_error_t restored_send(restored_client_t client, plist_t plist)
{
if (!client || !plist)
return RESTORE_E_INVALID_ARG;
return restored_error(property_list_service_send_xml_plist(client->parent, plist));
}
LIBIMOBILEDEVICE_API restored_error_t restored_query_type(restored_client_t client, char **type, uint64_t *version)
{
if (!client)
return RESTORE_E_INVALID_ARG;
restored_error_t ret = RESTORE_E_UNKNOWN_ERROR;
plist_t dict = plist_new_dict();
plist_dict_add_label(dict, client->label);
plist_dict_set_item(dict,"Request", plist_new_string("QueryType"));
debug_info("called");
ret = restored_send(client, dict);
plist_free(dict);
dict = NULL;
ret = restored_receive(client, &dict);
if (RESTORE_E_SUCCESS != ret)
return ret;
ret = RESTORE_E_UNKNOWN_ERROR;
plist_t type_node = plist_dict_get_item(dict, "Type");
if (type_node && (plist_get_node_type(type_node) == PLIST_STRING)) {
char* typestr = NULL;
/* save our device information info */
client->info = dict;
plist_get_string_val(type_node, &typestr);
debug_info("success with type %s", typestr);
/* return the type if requested */
if (type) {
*type = typestr;
} else {
free(typestr);
}
/* fetch the restore protocol version */
if (version) {
plist_t version_node = plist_dict_get_item(dict, "RestoreProtocolVersion");
if (version_node && PLIST_UINT == plist_get_node_type(version_node)) {
plist_get_uint_val(version_node, version);
debug_info("restored protocol version %llu", *version);
} else {
return RESTORE_E_UNKNOWN_ERROR;
}
}
ret = RESTORE_E_SUCCESS;
} else {
debug_info("hmm. QueryType response does not contain a type?!");
debug_plist(dict);
plist_free(dict);
}
return ret;
}
LIBIMOBILEDEVICE_API restored_error_t restored_query_value(restored_client_t client, const char *key, plist_t *value)
{
if (!client || !key)
return RESTORE_E_INVALID_ARG;
plist_t dict = NULL;
restored_error_t ret = RESTORE_E_UNKNOWN_ERROR;
/* setup request plist */
dict = plist_new_dict();
plist_dict_add_label(dict, client->label);
if (key) {
plist_dict_set_item(dict,"QueryKey", plist_new_string(key));
}
plist_dict_set_item(dict,"Request", plist_new_string("QueryValue"));
/* send to device */
ret = restored_send(client, dict);
plist_free(dict);
dict = NULL;
if (ret != RESTORE_E_SUCCESS)
return ret;
/* Now get device's answer */
ret = restored_receive(client, &dict);
if (ret != RESTORE_E_SUCCESS)
return ret;
plist_t value_node = plist_dict_get_item(dict, key);
if (value_node) {
debug_info("has a value");
*value = plist_copy(value_node);
} else {
ret = RESTORE_E_PLIST_ERROR;
}
plist_free(dict);
return ret;
}
LIBIMOBILEDEVICE_API restored_error_t restored_get_value(restored_client_t client, const char *key, plist_t *value)
{
plist_t item;
if (!client || !value || (value && *value))
return RESTORE_E_INVALID_ARG;
if (!client->info)
return RESTORE_E_NOT_ENOUGH_DATA;
if (!key) {
*value = plist_copy(client->info);
return RESTORE_E_SUCCESS;
}
item = plist_dict_get_item(client->info, key);
if (!item) {
return RESTORE_E_PLIST_ERROR;
}
*value = plist_copy(item);
return RESTORE_E_SUCCESS;
}
LIBIMOBILEDEVICE_API restored_error_t restored_client_new(idevice_t device, restored_client_t *client, const char *label)
{
if (!client)
return RESTORE_E_INVALID_ARG;
restored_error_t ret = RESTORE_E_SUCCESS;
idevice_error_t idev_ret;
static struct lockdownd_service_descriptor service = {
.port = 0xf27e,
.ssl_enabled = 0
};
property_list_service_client_t plistclient = NULL;
ret = restored_error(property_list_service_client_new(device, (lockdownd_service_descriptor_t)&service, &plistclient));
if (ret != RESTORE_E_SUCCESS) {
debug_info("could not connect to restored (device %s)", device->udid);
return ret;
}
restored_client_t client_loc = (restored_client_t) malloc(sizeof(struct restored_client_private));
client_loc->parent = plistclient;
client_loc->udid = NULL;
client_loc->label = NULL;
client_loc->info = NULL;
if (label != NULL)
client_loc->label = strdup(label);
idev_ret = idevice_get_udid(device, &client_loc->udid);
if (IDEVICE_E_SUCCESS != idev_ret) {
debug_info("failed to get device udid.");
ret = RESTORE_E_UNKNOWN_ERROR;
}
debug_info("device udid: %s", client_loc->udid);
if (RESTORE_E_SUCCESS == ret) {
*client = client_loc;
} else {
restored_client_free(client_loc);
}
return ret;
}
LIBIMOBILEDEVICE_API restored_error_t restored_goodbye(restored_client_t client)
{
if (!client)
return RESTORE_E_INVALID_ARG;
restored_error_t ret = RESTORE_E_UNKNOWN_ERROR;
plist_t dict = plist_new_dict();
plist_dict_add_label(dict, client->label);
plist_dict_set_item(dict,"Request", plist_new_string("Goodbye"));
debug_info("called");
ret = restored_send(client, dict);
plist_free(dict);
dict = NULL;
ret = restored_receive(client, &dict);
if (!dict) {
debug_info("did not get goodbye response back");
return RESTORE_E_PLIST_ERROR;
}
if (restored_check_result(dict) == RESULT_SUCCESS) {
debug_info("success");
ret = RESTORE_E_SUCCESS;
}
plist_free(dict);
dict = NULL;
return ret;
}
LIBIMOBILEDEVICE_API restored_error_t restored_start_restore(restored_client_t client, plist_t options, uint64_t version)
{
if (!client)
return RESTORE_E_INVALID_ARG;
plist_t dict = NULL;
restored_error_t ret = RESTORE_E_UNKNOWN_ERROR;
dict = plist_new_dict();
plist_dict_add_label(dict, client->label);
plist_dict_set_item(dict,"Request", plist_new_string("StartRestore"));
if (options) {
plist_dict_set_item(dict, "RestoreOptions", plist_copy(options));
}
plist_dict_set_item(dict,"RestoreProtocolVersion", plist_new_uint(version));
/* send to device */
ret = restored_send(client, dict);
plist_free(dict);
dict = NULL;
return ret;
}
LIBIMOBILEDEVICE_API restored_error_t restored_reboot(restored_client_t client)
{
if (!client)
return RESTORE_E_INVALID_ARG;
plist_t dict = NULL;
restored_error_t ret = RESTORE_E_UNKNOWN_ERROR;
dict = plist_new_dict();
plist_dict_add_label(dict, client->label);
plist_dict_set_item(dict,"Request", plist_new_string("Reboot"));
/* send to device */
ret = restored_send(client, dict);
plist_free(dict);
dict = NULL;
if (RESTORE_E_SUCCESS != ret)
return ret;
ret = restored_receive(client, &dict);
if (RESTORE_E_SUCCESS != ret)
return ret;
if (!dict)
return RESTORE_E_PLIST_ERROR;
plist_free(dict);
dict = NULL;
return ret;
}