1 files changed, 128 insertions, 162 deletions

diff --git a/src/restore.c b/src/restore.c
index fd23d85..d13a28a 100644
--- a/src/restore.c
+++ b/src/restore.c
@@ -19,17 +19,18 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-#include <arpa/inet.h>
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include <errno.h>
 #include <string.h>
 #include <stdlib.h>
-#include <glib.h>
 #include <plist/plist.h>
 
 #include "property_list_service.h"
 #include "restore.h"
 #include "idevice.h"
-#include "debug.h"
+#include "common/debug.h"
 
 #define RESULT_SUCCESS 0
 #define RESULT_FAILURE 1
@@ -43,7 +44,7 @@
  *
  * @return RESULT_SUCCESS when the result is 'Success',
  *         RESULT_FAILURE when the result is 'Failure',
- *         or a negative value if an error occured during evaluation.
+ *         or a negative value if an error occurred during evaluation.
  */
 static int restored_check_result(plist_t dict)
 {
@@ -87,40 +88,49 @@ 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_insert_item(plist, "Label", plist_new_string(label));
+                        plist_dict_set_item(plist, "Label", plist_new_string(label));
         }
 }
 
-/**
- * Closes the restored client session if one is running and frees up the
- * restored_client struct.
- *
- * @param client The restore client
- *
- * @return RESTORE_E_SUCCESS on success, NP_E_INVALID_ARG when client is NULL
- */
+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;
+}
+
 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);
 
-                if (property_list_service_client_free(client->parent) == PROPERTY_LIST_SERVICE_E_SUCCESS) {
-                        ret = RESTORE_E_SUCCESS;
-                }
+                ret = restored_error(property_list_service_client_free(client->parent));
         }
 
-        if (client->uuid) {
-                free(client->uuid);
+        if (client->udid) {
+                free(client->udid);
         }
         if (client->label) {
                 free(client->label);
         }
-        
+
         if (client->info) {
                 plist_free(client->info);
         }
@@ -129,13 +139,6 @@ restored_error_t restored_client_free(restored_client_t client)
         return ret;
 }
 
-/**
- * Sets the label to send for requests to restored.
- *
- * @param client The restore client
- * @param label The label to set or NULL to disable sending a label
- *
- */
 void restored_client_set_label(restored_client_t client, const char *label)
 {
         if (client) {
@@ -146,71 +149,22 @@ void restored_client_set_label(restored_client_t client, const char *label)
         }
 }
 
-/**
- * Receives a plist from restored.
- *
- * @param client The restored client
- * @param plist The plist to store the received data
- *
- * @return RESTORE_E_SUCCESS on success, NP_E_INVALID_ARG when client or
- *  plist is NULL
- */
 restored_error_t restored_receive(restored_client_t client, plist_t *plist)
 {
         if (!client || !plist || (plist && *plist))
                 return RESTORE_E_INVALID_ARG;
-                
-        restored_error_t ret = RESTORE_E_SUCCESS;
-        property_list_service_error_t err;
-
-        err = property_list_service_receive_plist(client->parent, plist);
-        if (err != PROPERTY_LIST_SERVICE_E_SUCCESS) {
-                ret = RESTORE_E_UNKNOWN_ERROR;
-        }
 
-        if (!*plist)
-                ret = RESTORE_E_PLIST_ERROR;
-
-        return ret;
+        return restored_error(property_list_service_receive_plist(client->parent, plist));
 }
 
-/**
- * Sends a plist to restored.
- *
- * @note This function is low-level and should only be used if you need to send
- *        a new type of message.
- *
- * @param client The restored client
- * @param plist The plist to send
- *
- * @return RESTORE_E_SUCCESS on success, NP_E_INVALID_ARG when client or
- *  plist is NULL
- */
 restored_error_t restored_send(restored_client_t client, plist_t plist)
 {
         if (!client || !plist)
                 return RESTORE_E_INVALID_ARG;
 
-        restored_error_t ret = RESTORE_E_SUCCESS;
-        idevice_error_t err;
-
-        err = property_list_service_send_xml_plist(client->parent, plist);
-        if (err != PROPERTY_LIST_SERVICE_E_SUCCESS) {
-                ret = RESTORE_E_UNKNOWN_ERROR;
-        }
-        return ret;
+        return restored_error(property_list_service_send_xml_plist(client->parent, plist));
 }
 
-/**
- * Query the type of the service daemon. Depending on whether the device is
- * queried in normal mode or restore mode, different types will be returned.
- *
- * @param client The restored client
- * @param type The type returned by the service daemon. Pass NULL to ignore.
- * @param version The restore protocol version. Pass NULL to ignore.
- *
- * @return RESTORE_E_SUCCESS on success, NP_E_INVALID_ARG when client is NULL
- */
 restored_error_t restored_query_type(restored_client_t client, char **type, uint64_t *version)
 {
         if (!client)
@@ -220,7 +174,7 @@ restored_error_t restored_query_type(restored_client_t client, char **type, uint
 
         plist_t dict = plist_new_dict();
         plist_dict_add_label(dict, client->label);
-        plist_dict_insert_item(dict,"Request", plist_new_string("QueryType"));
+        plist_dict_set_item(dict,"Request", plist_new_string("QueryType"));
 
         debug_info("called");
         ret = restored_send(client, dict);
@@ -229,25 +183,25 @@ restored_error_t restored_query_type(restored_client_t client, char **type, uint
         dict = NULL;
 
         ret = restored_receive(client, &dict);
-        
+
         if (RESTORE_E_SUCCESS != ret)
                 return ret;
 
         ret = RESTORE_E_UNKNOWN_ERROR;
-        if (restored_check_result(dict) == RESULT_SUCCESS) {
+        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) {
-                        plist_t type_node = plist_dict_get_item(dict, "Type");
-                        if (type_node && PLIST_STRING == plist_get_node_type(type_node)) {
-                                plist_get_string_val(type_node, type);
-                                debug_info("success with type %s", *type);
-                                ret = RESTORE_E_SUCCESS;
-                        } else {
-                                return RESTORE_E_UNKNOWN_ERROR;
-                        }
+                        *type = typestr;
+                } else {
+                        free(typestr);
                 }
 
                 /* fetch the restore protocol version */
@@ -256,87 +210,121 @@ restored_error_t restored_query_type(restored_client_t client, char **type, uint
                         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);
-                                ret = RESTORE_E_SUCCESS;
                         } 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;
 }
 
-/**
- * Retrieves a value from information plist specified by a key.
- *
- * @param client An initialized restored client.
- * @param key The key name to request or NULL to query for all keys
- * @param value A plist node representing the result value node
- *
- * @return RESTORE_E_SUCCESS on success, NP_E_INVALID_ARG when client is NULL, RESTORE_E_PLIST_ERROR if value for key can't be found
- */
-restored_error_t restored_get_value(restored_client_t client, const char *key, plist_t *value) 
+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;
+}
+
+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;
-                
-        restored_error_t ret = RESTORE_E_SUCCESS;
-        plist_t item = NULL;
-        
+
         if (!key) {
                 *value = plist_copy(client->info);
                 return RESTORE_E_SUCCESS;
-        } else {
-                item = plist_dict_get_item(client->info, key);
         }
-        
-        if (item) {
-                *value = plist_copy(item);
-        } else {
-                ret = RESTORE_E_PLIST_ERROR;
+
+        item = plist_dict_get_item(client->info, key);
+        if (!item) {
+                return RESTORE_E_PLIST_ERROR;
         }
-        
-        return ret;
+
+        *value = plist_copy(item);
+
+        return RESTORE_E_SUCCESS;
 }
 
-/**
- * Creates a new restored client for the device.
- *
- * @param device The device to create a restored client for
- * @param client The pointer to the location of the new restored_client
- * @param label The label to use for communication. Usually the program name.
- *
- * @return RESTORE_E_SUCCESS on success, NP_E_INVALID_ARG when client is NULL
- */
 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;
-        if (property_list_service_client_new(device, 0xf27e, &plistclient) != PROPERTY_LIST_SERVICE_E_SUCCESS) {
-                debug_info("could not connect to restored (device %s)", device->uuid);
-                return RESTORE_E_MUX_ERROR;
+        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->uuid = NULL;
+        client_loc->udid = NULL;
         client_loc->label = NULL;
+        client_loc->info = NULL;
         if (label != NULL)
                 client_loc->label = strdup(label);
 
-        ret = idevice_get_uuid(device, &client_loc->uuid);
-        if (RESTORE_E_SUCCESS != ret) {
-                debug_info("failed to get device uuid.");
+        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 uuid: %s", client_loc->uuid);
+        debug_info("device udid: %s", client_loc->udid);
 
         if (RESTORE_E_SUCCESS == ret) {
                 *client = client_loc;
@@ -347,14 +335,6 @@ restored_error_t restored_client_new(idevice_t device, restored_client_t *client
         return ret;
 }
 
-/**
- * Sends the Goodbye request to restored signaling the end of communication.
- *
- * @param client The restore client
- *
- * @return RESTORE_E_SUCCESS on success, NP_E_INVALID_ARG when client is NULL,
- *  RESTORE_E_PLIST_ERROR if the device did not acknowledge the request
- */
 restored_error_t restored_goodbye(restored_client_t client)
 {
         if (!client)
@@ -364,7 +344,7 @@ restored_error_t restored_goodbye(restored_client_t client)
 
         plist_t dict = plist_new_dict();
         plist_dict_add_label(dict, client->label);
-        plist_dict_insert_item(dict,"Request", plist_new_string("Goodbye"));
+        plist_dict_set_item(dict,"Request", plist_new_string("Goodbye"));
 
         debug_info("called");
 
@@ -387,15 +367,7 @@ restored_error_t restored_goodbye(restored_client_t client)
         return ret;
 }
 
-/**
- * Requests to start a restore and retrieve it's port on success.
- *
- * @param client The restored client
- *
- * @return RESTORE_E_SUCCESS on success, NP_E_INVALID_ARG if a parameter
- *  is NULL, RESTORE_E_START_RESTORE_FAILED if the request fails
- */
-restored_error_t restored_start_restore(restored_client_t client)
+restored_error_t restored_start_restore(restored_client_t client, plist_t options, uint64_t version)
 {
         if (!client)
                 return RESTORE_E_INVALID_ARG;
@@ -405,8 +377,11 @@ restored_error_t restored_start_restore(restored_client_t client)
 
         dict = plist_new_dict();
         plist_dict_add_label(dict, client->label);
-        plist_dict_insert_item(dict,"Request", plist_new_string("StartRestore"));
-        plist_dict_insert_item(dict,"RestoreProtocolVersion", plist_new_uint(2));
+        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);
@@ -416,14 +391,6 @@ restored_error_t restored_start_restore(restored_client_t client)
         return ret;
 }
 
-/**
- * Requests device to reboot.
- *
- * @param client The restored client
- *
- * @return RESTORE_E_SUCCESS on success, NP_E_INVALID_ARG if a parameter
- *  is NULL
- */
 restored_error_t restored_reboot(restored_client_t client)
 {
         if (!client)
@@ -434,7 +401,7 @@ restored_error_t restored_reboot(restored_client_t client)
 
         dict = plist_new_dict();
         plist_dict_add_label(dict, client->label);
-        plist_dict_insert_item(dict,"Request", plist_new_string("Reboot"));
+        plist_dict_set_item(dict,"Request", plist_new_string("Reboot"));
 
         /* send to device */
         ret = restored_send(client, dict);
@@ -455,4 +422,3 @@ restored_error_t restored_reboot(restored_client_t client)
         dict = NULL;
         return ret;
 }
-