Merge commit 'martin-s/martin'

[#46 state:resolved]

1 files changed, 240 insertions, 223 deletions

diff --git a/src/lockdown.c b/src/lockdown.c
index 1a434aa..bc430c9 100644
--- a/src/lockdown.c
+++ b/src/lockdown.c
@@ -19,10 +19,6 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-#include "utils.h"
-#include "iphone.h"
-#include "lockdown.h"
-#include "userpref.h"
 #include <arpa/inet.h>
 #include <errno.h>
 #include <string.h>
@@ -30,9 +26,13 @@
 #include <glib.h>
 #include <libtasn1.h>
 #include <gnutls/x509.h>
-
 #include <plist/plist.h>
 
+#include "lockdown.h"
+#include "iphone.h"
+#include "utils.h"
+#include "userpref.h"
+
 #define RESULT_SUCCESS 0
 #define RESULT_FAILURE 1
 
@@ -126,21 +126,23 @@ static int lockdown_check_result(plist_t dict, const char *query_match)
  * the StopSession Request to the device.
  *
  * @param control The lockdown client
+ *
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-iphone_error_t lockdownd_stop_session(lockdownd_client_t client)
+lockdownd_error_t lockdownd_stop_session(lockdownd_client_t client, const char *session_id)
 {
         if (!client)
-                return IPHONE_E_INVALID_ARG;
+                return LOCKDOWN_E_INVALID_ARG;
 
-        iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+        lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
 
         plist_t dict = plist_new_dict();
         plist_add_sub_key_el(dict, "Request");
         plist_add_sub_string_el(dict, "StopSession");
         plist_add_sub_key_el(dict, "SessionID");
-        plist_add_sub_string_el(dict, client->session_id);
+        plist_add_sub_string_el(dict, session_id);
 
-        log_dbg_msg(DBGMASK_LOCKDOWND, "iphone_lckd_stop_session() called\n");
+        log_dbg_msg(DBGMASK_LOCKDOWND, "%s: called\n", __func__);
 
         ret = lockdownd_send(client, dict);
 
@@ -150,14 +152,14 @@ iphone_error_t lockdownd_stop_session(lockdownd_client_t client)
         ret = lockdownd_recv(client, &dict);
 
         if (!dict) {
-                log_dbg_msg(DBGMASK_LOCKDOWND, "lockdownd_stop_session(): IPHONE_E_PLIST_ERROR\n");
-                return IPHONE_E_PLIST_ERROR;
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: LOCKDOWN_E_PLIST_ERROR\n", __func__);
+                return LOCKDOWN_E_PLIST_ERROR;
         }
 
-        ret = IPHONE_E_UNKNOWN_ERROR;
+        ret = LOCKDOWN_E_UNKNOWN_ERROR;
         if (lockdown_check_result(dict, "StopSession") == RESULT_SUCCESS) {
-                log_dbg_msg(DBGMASK_LOCKDOWND, "lockdownd_stop_session(): success\n");
-                ret = IPHONE_E_SUCCESS;
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: success\n", __func__);
+                ret = LOCKDOWN_E_SUCCESS;
         }
         plist_free(dict);
         dict = NULL;
@@ -171,19 +173,21 @@ iphone_error_t lockdownd_stop_session(lockdownd_client_t client)
  * performing a close notify, which is done by "gnutls_bye".
  *
  * @param client The lockdown client
+ *
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-static iphone_error_t lockdownd_stop_ssl_session(lockdownd_client_t client)
+static lockdownd_error_t lockdownd_stop_ssl_session(lockdownd_client_t client)
 {
         if (!client) {
-                log_dbg_msg(DBGMASK_LOCKDOWND, "lockdownd_stop_ssl_session(): invalid argument!\n");
-                return IPHONE_E_INVALID_ARG;
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: invalid argument!\n", __func__);
+                return LOCKDOWN_E_INVALID_ARG;
         }
-        iphone_error_t ret = IPHONE_E_SUCCESS;
+        lockdownd_error_t ret = LOCKDOWN_E_SUCCESS;
 
         if (client->in_SSL) {
-                log_dbg_msg(DBGMASK_LOCKDOWND, "Stopping SSL Session\n");
-                ret = lockdownd_stop_session(client);
-                log_dbg_msg(DBGMASK_LOCKDOWND, "Sending SSL close notify\n");
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: stopping SSL session\n", __func__);
+                ret = lockdownd_stop_session(client, client->session_id);
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: sending SSL close notify\n", __func__);
                 gnutls_bye(*client->ssl_session, GNUTLS_SHUT_RDWR);
         }
         if (client->ssl_session) {
@@ -198,12 +202,14 @@ static iphone_error_t lockdownd_stop_ssl_session(lockdownd_client_t client)
 /** Closes the lockdownd client and does the necessary housekeeping.
  *
  * @param client The lockdown client
+ *
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-iphone_error_t lockdownd_free_client(lockdownd_client_t client)
+lockdownd_error_t lockdownd_client_free(lockdownd_client_t client)
 {
         if (!client)
-                return IPHONE_E_INVALID_ARG;
-        iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+                return LOCKDOWN_E_INVALID_ARG;
+        lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
 
         lockdownd_stop_ssl_session(client);
 
@@ -224,13 +230,13 @@ iphone_error_t lockdownd_free_client(lockdownd_client_t client)
  * @param control The lockdownd client
  * @param plist The plist to store the received data
  *
- * @return an error code (IPHONE_E_SUCCESS on success)
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-iphone_error_t lockdownd_recv(lockdownd_client_t client, plist_t *plist)
+lockdownd_error_t lockdownd_recv(lockdownd_client_t client, plist_t *plist)
 {
         if (!client || !plist || (plist && *plist))
-                return IPHONE_E_INVALID_ARG;
-        iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+                return LOCKDOWN_E_INVALID_ARG;
+        lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
         char *receive = NULL;
         uint32_t datalen = 0, bytes = 0, received_bytes = 0;
 
@@ -240,10 +246,10 @@ iphone_error_t lockdownd_recv(lockdownd_client_t client, plist_t *plist)
                 ssize_t res = gnutls_record_recv(*client->ssl_session, &datalen, sizeof(datalen));
                 if (res < 0) {
                         log_dbg_msg(DBGMASK_LOCKDOWND, "gnutls_record_recv: Error occured: %s\n", gnutls_strerror(res));
-                        return IPHONE_E_SSL_ERROR;
+                        return LOCKDOWN_E_SSL_ERROR;
                 } else {
                         bytes = res;
-                        ret = IPHONE_E_SUCCESS;
+                        ret = LOCKDOWN_E_SUCCESS;
                 }
         }
         datalen = ntohl(datalen);
@@ -253,40 +259,40 @@ iphone_error_t lockdownd_recv(lockdownd_client_t client, plist_t *plist)
 
         /* fill buffer and request more packets if needed */
         if (!client->in_SSL) {
-                while ((received_bytes < datalen) && (ret == IPHONE_E_SUCCESS)) {
+                while ((received_bytes < datalen) && (ret == LOCKDOWN_E_SUCCESS)) {
                         ret = usbmuxd_recv(client->sfd, receive + received_bytes, datalen - received_bytes, &bytes);
                         received_bytes += bytes;
                 }
         } else {
                 ssize_t res = 0;
-                while ((received_bytes < datalen) && (ret == IPHONE_E_SUCCESS)) {
+                while ((received_bytes < datalen) && (ret == LOCKDOWN_E_SUCCESS)) {
                         res = gnutls_record_recv(*client->ssl_session, receive + received_bytes, datalen - received_bytes);
                         if (res < 0) {
                                 log_dbg_msg(DBGMASK_LOCKDOWND, "gnutls_record_recv: Error occured: %s\n", gnutls_strerror(res));
-                                ret = IPHONE_E_SSL_ERROR;
+                                ret = LOCKDOWN_E_SSL_ERROR;
                         } else {
                                 received_bytes += res;
-                                ret = IPHONE_E_SUCCESS;
+                                ret = LOCKDOWN_E_SUCCESS;
                         }
                 }
         }
 
-        if (ret != IPHONE_E_SUCCESS) {
+        if (ret != LOCKDOWN_E_SUCCESS) {
                 free(receive);
                 return ret;
         }
 
         if ((ssize_t)received_bytes <= 0) {
                 free(receive);
-                return IPHONE_E_NOT_ENOUGH_DATA;
+                return LOCKDOWN_E_NOT_ENOUGH_DATA;
         }
 
-        log_dbg_msg(DBGMASK_LOCKDOWND, "Recv msg :\nsize : %i\nbuffer :\n%s\n", received_bytes, receive);
+        log_dbg_msg(DBGMASK_LOCKDOWND, "%s: received msg size: %i, buffer follows:\n%s", __func__, received_bytes, receive);
         plist_from_xml(receive, received_bytes, plist);
         free(receive);
 
         if (!*plist)
-                ret = IPHONE_E_PLIST_ERROR;
+                ret = LOCKDOWN_E_PLIST_ERROR;
 
         return ret;
 }
@@ -299,27 +305,27 @@ iphone_error_t lockdownd_recv(lockdownd_client_t client, plist_t *plist)
  * @param client The lockdownd client
  * @param plist The plist to send
  *
- * @return an error code (IPHONE_E_SUCCESS on success)
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-iphone_error_t lockdownd_send(lockdownd_client_t client, plist_t plist)
+lockdownd_error_t lockdownd_send(lockdownd_client_t client, plist_t plist)
 {
         if (!client || !plist)
-                return IPHONE_E_INVALID_ARG;
+                return LOCKDOWN_E_INVALID_ARG;
         char *real_query;
         int bytes;
         char *XMLContent = NULL;
         uint32_t length = 0;
-        iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+        lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
 
         plist_to_xml(plist, &XMLContent, &length);
-        log_dbg_msg(DBGMASK_LOCKDOWND, "Send msg :\nsize : %i\nbuffer :\n%s\n", length, XMLContent);
+        log_dbg_msg(DBGMASK_LOCKDOWND, "%s: sending msg size %i, buffer follows:\n%s", __func__, length, XMLContent);
 
         real_query = (char *) malloc(sizeof(char) * (length + 4));
         length = htonl(length);
         memcpy(real_query, &length, sizeof(length));
         memcpy(real_query + 4, XMLContent, ntohl(length));
         free(XMLContent);
-        log_dbg_msg(DBGMASK_LOCKDOWND, "lockdownd_send(): made the query, sending it along\n");
+        log_dbg_msg(DBGMASK_LOCKDOWND, "%s: made the query, sending it along\n", __func__);
 
         if (!client->in_SSL)
                 ret = usbmuxd_send(client->sfd, real_query, ntohl(length) + sizeof(length), (uint32_t*)&bytes);
@@ -327,16 +333,16 @@ iphone_error_t lockdownd_send(lockdownd_client_t client, plist_t plist)
                 ssize_t res = gnutls_record_send(*client->ssl_session, real_query, ntohl(length) + sizeof(length));
                 if (res < 0) {
                         log_dbg_msg(DBGMASK_LOCKDOWND, "gnutls_record_send: Error occured: %s\n", gnutls_strerror(res));
-                        ret = IPHONE_E_SSL_ERROR;
+                        ret = LOCKDOWN_E_SSL_ERROR;
                 } else {
                         bytes = res;
-                        ret = IPHONE_E_SUCCESS;
+                        ret = LOCKDOWN_E_SUCCESS;
                 }
         }
-        if (ret == IPHONE_E_SUCCESS) {
-                log_dbg_msg(DBGMASK_LOCKDOWND, "lockdownd_send(): sent it!\n");
+        if (ret == LOCKDOWN_E_SUCCESS) {
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: sent it!\n", __func__);
         } else {
-                log_dbg_msg(DBGMASK_LOCKDOWND, "lockdownd_send(): sending failed!\n");
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: sending failed!\n", __func__);
         }
         free(real_query);
 
@@ -347,20 +353,20 @@ iphone_error_t lockdownd_send(lockdownd_client_t client, plist_t plist)
  *
  * @param client The lockdownd client
  *
- * @return an error code (IPHONE_E_SUCCESS on success)
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-iphone_error_t lockdownd_query_type(lockdownd_client_t client)
+lockdownd_error_t lockdownd_query_type(lockdownd_client_t client)
 {
         if (!client)
-                return IPHONE_E_INVALID_ARG;
+                return LOCKDOWN_E_INVALID_ARG;
 
-        iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+        lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
 
         plist_t dict = plist_new_dict();
         plist_add_sub_key_el(dict, "Request");
         plist_add_sub_string_el(dict, "QueryType");
 
-        log_dbg_msg(DBGMASK_LOCKDOWND, "lockdownd_query_type() called\n");
+        log_dbg_msg(DBGMASK_LOCKDOWND, "%s: called\n", __func__);
         ret = lockdownd_send(client, dict);
 
         plist_free(dict);
@@ -368,13 +374,13 @@ iphone_error_t lockdownd_query_type(lockdownd_client_t client)
 
         ret = lockdownd_recv(client, &dict);
 
-        if (IPHONE_E_SUCCESS != ret)
+        if (LOCKDOWN_E_SUCCESS != ret)
                 return ret;
 
-        ret = IPHONE_E_UNKNOWN_ERROR;
+        ret = LOCKDOWN_E_UNKNOWN_ERROR;
         if (lockdown_check_result(dict, "QueryType") == RESULT_SUCCESS) {
-                log_dbg_msg(DBGMASK_LOCKDOWND, "lockdownd_query_type(): success\n");
-                ret = IPHONE_E_SUCCESS;
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: success\n", __func__);
+                ret = LOCKDOWN_E_SUCCESS;
         }
         plist_free(dict);
         dict = NULL;
@@ -389,15 +395,15 @@ iphone_error_t lockdownd_query_type(lockdownd_client_t 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 an error code (IPHONE_E_SUCCESS on success)
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-iphone_error_t lockdownd_get_value(lockdownd_client_t client, const char *domain, const char *key, plist_t *value)
+lockdownd_error_t lockdownd_get_value(lockdownd_client_t client, const char *domain, const char *key, plist_t *value)
 {
         if (!client)
-                return IPHONE_E_INVALID_ARG;
+                return LOCKDOWN_E_INVALID_ARG;
 
         plist_t dict = NULL;
-        iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+        lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
 
         /* setup request plist */
         dict = plist_new_dict();
@@ -418,19 +424,19 @@ iphone_error_t lockdownd_get_value(lockdownd_client_t client, const char *domain
         plist_free(dict);
         dict = NULL;
 
-        if (ret != IPHONE_E_SUCCESS)
+        if (ret != LOCKDOWN_E_SUCCESS)
                 return ret;
 
         /* Now get device's answer */
         ret = lockdownd_recv(client, &dict);
-        if (ret != IPHONE_E_SUCCESS)
+        if (ret != LOCKDOWN_E_SUCCESS)
                 return ret;
 
         if (lockdown_check_result(dict, "GetValue") == RESULT_SUCCESS) {
                 log_dbg_msg(DBGMASK_LOCKDOWND, "%s: success\n", __func__);
-                ret = IPHONE_E_SUCCESS;
+                ret = LOCKDOWN_E_SUCCESS;
         }
-        if (ret != IPHONE_E_SUCCESS) {
+        if (ret != LOCKDOWN_E_SUCCESS) {
                 plist_free(dict);
                 return ret;
         }
@@ -445,7 +451,7 @@ iphone_error_t lockdownd_get_value(lockdownd_client_t client, const char *domain
                 plist_get_key_val(value_key_node, &result_key);
 
                 if (!strcmp(result_key, "Value")) {
-                        log_dbg_msg(DBGMASK_LOCKDOWND, "lockdownd_get_value(): has a value\n");
+                        log_dbg_msg(DBGMASK_LOCKDOWND, "%s: has a value\n", __func__);
                         *value = plist_copy(value_value_node);
                 }
                 free(result_key);
@@ -462,15 +468,15 @@ iphone_error_t lockdownd_get_value(lockdownd_client_t client, const char *domain
  * @param key the key name to set the value or NULL to set a value dict plist
  * @param value a plist node of any node type representing the value to set
  *
- * @return an error code (IPHONE_E_SUCCESS on success)
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-iphone_error_t lockdownd_set_value(lockdownd_client_t client, const char *domain, const char *key, plist_t value)
+lockdownd_error_t lockdownd_set_value(lockdownd_client_t client, const char *domain, const char *key, plist_t value)
 {
         if (!client || !value)
-                return IPHONE_E_INVALID_ARG;
+                return LOCKDOWN_E_INVALID_ARG;
 
         plist_t dict = NULL;
-        iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+        lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
 
         /* setup request plist */
         dict = plist_new_dict();
@@ -494,20 +500,20 @@ iphone_error_t lockdownd_set_value(lockdownd_client_t client, const char *domain
         plist_free(dict);
         dict = NULL;
 
-        if (ret != IPHONE_E_SUCCESS)
+        if (ret != LOCKDOWN_E_SUCCESS)
                 return ret;
 
         /* Now get device's answer */
         ret = lockdownd_recv(client, &dict);
-        if (ret != IPHONE_E_SUCCESS)
+        if (ret != LOCKDOWN_E_SUCCESS)
                 return ret;
 
         if (lockdown_check_result(dict, "SetValue") == RESULT_SUCCESS) {
                 log_dbg_msg(DBGMASK_LOCKDOWND, "%s: success\n", __func__);
-                ret = IPHONE_E_SUCCESS;
+                ret = LOCKDOWN_E_SUCCESS;
         }
 
-        if (ret != IPHONE_E_SUCCESS) {
+        if (ret != LOCKDOWN_E_SUCCESS) {
                 plist_free(dict);
                 return ret;
         }
@@ -524,15 +530,15 @@ iphone_error_t lockdownd_set_value(lockdownd_client_t client, const char *domain
  * @param domain the domain to query on or NULL for global domain
  * @param key the key name to remove or NULL remove all keys for the current domain
  *
- * @return an error code (IPHONE_E_SUCCESS on success)
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-iphone_error_t lockdownd_remove_value(lockdownd_client_t client, const char *domain, const char *key)
+lockdownd_error_t lockdownd_remove_value(lockdownd_client_t client, const char *domain, const char *key)
 {
         if (!client)
-                return IPHONE_E_INVALID_ARG;
+                return LOCKDOWN_E_INVALID_ARG;
 
         plist_t dict = NULL;
-        iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+        lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
 
         /* setup request plist */
         dict = plist_new_dict();
@@ -553,20 +559,20 @@ iphone_error_t lockdownd_remove_value(lockdownd_client_t client, const char *dom
         plist_free(dict);
         dict = NULL;
 
-        if (ret != IPHONE_E_SUCCESS)
+        if (ret != LOCKDOWN_E_SUCCESS)
                 return ret;
 
         /* Now get device's answer */
         ret = lockdownd_recv(client, &dict);
-        if (ret != IPHONE_E_SUCCESS)
+        if (ret != LOCKDOWN_E_SUCCESS)
                 return ret;
 
         if (lockdown_check_result(dict, "RemoveValue") == RESULT_SUCCESS) {
                 log_dbg_msg(DBGMASK_LOCKDOWND, "%s: success\n", __func__);
-                ret = IPHONE_E_SUCCESS;
+                ret = LOCKDOWN_E_SUCCESS;
         }
 
-        if (ret != IPHONE_E_SUCCESS) {
+        if (ret != LOCKDOWN_E_SUCCESS) {
                 plist_free(dict);
                 return ret;
         }
@@ -577,18 +583,18 @@ iphone_error_t lockdownd_remove_value(lockdownd_client_t client, const char *dom
 
 /** Asks for the device's unique id. Part of the lockdownd handshake.
  *
- * @return an error code (IPHONE_E_SUCCESS on success)
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-iphone_error_t lockdownd_get_device_uid(lockdownd_client_t client, char **uid)
+lockdownd_error_t lockdownd_get_device_uuid(lockdownd_client_t client, char **uuid)
 {
-        iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+        lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
         plist_t value = NULL;
 
         ret = lockdownd_get_value(client, NULL, "UniqueDeviceID", &value);
-        if (ret != IPHONE_E_SUCCESS) {
+        if (ret != LOCKDOWN_E_SUCCESS) {
                 return ret;
         }
-        plist_get_string_val(value, uid);
+        plist_get_string_val(value, uuid);
 
         plist_free(value);
         value = NULL;
@@ -597,17 +603,17 @@ iphone_error_t lockdownd_get_device_uid(lockdownd_client_t client, char **uid)
 
 /** Askes for the device's public key. Part of the lockdownd handshake.
  *
- * @return an error code (IPHONE_E_SUCCESS on success)
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-iphone_error_t lockdownd_get_device_public_key(lockdownd_client_t client, gnutls_datum_t * public_key)
+lockdownd_error_t lockdownd_get_device_public_key(lockdownd_client_t client, gnutls_datum_t * public_key)
 {
-        iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+        lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
         plist_t value = NULL;
         char *value_value = NULL;
         uint64_t size = 0;
 
         ret = lockdownd_get_value(client, NULL, "DevicePublicKey", &value);
-        if (ret != IPHONE_E_SUCCESS) {
+        if (ret != LOCKDOWN_E_SUCCESS) {
                 return ret;
         }
         plist_get_data_val(value, &value_value, &size);
@@ -625,15 +631,15 @@ iphone_error_t lockdownd_get_device_public_key(lockdownd_client_t client, gnutls
  * @param client The pointer to the location of the new lockdownd_client
  *
  *
- * @return an error code (IPHONE_E_SUCCESS on success)
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-iphone_error_t lockdownd_get_device_name(lockdownd_client_t client, char **device_name)
+lockdownd_error_t lockdownd_get_device_name(lockdownd_client_t client, char **device_name)
 {
-        iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+        lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
         plist_t value = NULL;
 
         ret = lockdownd_get_value(client, NULL, "DeviceName", &value);
-        if (ret != IPHONE_E_SUCCESS) {
+        if (ret != LOCKDOWN_E_SUCCESS) {
                 return ret;
         }
         plist_get_string_val(value, device_name);
@@ -649,19 +655,19 @@ iphone_error_t lockdownd_get_device_name(lockdownd_client_t client, char **devic
  * @param phone The iPhone to create a lockdownd client for
  * @param client The pointer to the location of the new lockdownd_client
  *
- * @return an error code (IPHONE_E_SUCCESS on success)
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-iphone_error_t lockdownd_new_client(iphone_device_t device, lockdownd_client_t *client)
+lockdownd_error_t lockdownd_client_new(iphone_device_t device, lockdownd_client_t *client)
 {
         if (!device || !client || (client && *client))
-                return IPHONE_E_INVALID_ARG;
-        iphone_error_t ret = IPHONE_E_SUCCESS;
+                return LOCKDOWN_E_INVALID_ARG;
+        lockdownd_error_t ret = LOCKDOWN_E_SUCCESS;
         char *host_id = NULL;
 
         int sfd = usbmuxd_connect(device->handle, 0xf27e);
         if (sfd < 0) {
                 log_debug_msg("%s: could not connect to lockdownd (device handle %d)\n", __func__, device->handle);
-                return IPHONE_E_UNKNOWN_ERROR;
+                return LOCKDOWN_E_MUX_ERROR;
         }
 
         lockdownd_client_t client_loc = (lockdownd_client_t) malloc(sizeof(struct lockdownd_client_int));
@@ -669,36 +675,36 @@ iphone_error_t lockdownd_new_client(iphone_device_t device, lockdownd_client_t *
         client_loc->ssl_session = (gnutls_session_t *) malloc(sizeof(gnutls_session_t));
         client_loc->in_SSL = 0;
 
-        if (IPHONE_E_SUCCESS != lockdownd_query_type(client_loc)) {
-                log_debug_msg("QueryType failed in the lockdownd client.\n");
-                ret = IPHONE_E_NOT_ENOUGH_DATA;
+        if (LOCKDOWN_E_SUCCESS != lockdownd_query_type(client_loc)) {
+                log_debug_msg("%s: QueryType failed in the lockdownd client.\n", __func__);
+                ret = LOCKDOWN_E_NOT_ENOUGH_DATA;
         }
 
-        char *uid = NULL;
-        ret = lockdownd_get_device_uid(client_loc, &uid);
-        if (IPHONE_E_SUCCESS != ret) {
-                log_debug_msg("Device refused to send uid.\n");
+        char *uuid = NULL;
+        ret = iphone_device_get_uuid(device, &uuid);
+        if (LOCKDOWN_E_SUCCESS != ret) {
+                log_debug_msg("%s: failed to get device uuid.\n", __func__);
         }
-        log_debug_msg("Device uid: %s\n", uid);
+        log_debug_msg("%s: device uuid: %s\n", __func__, uuid);
 
-        host_id = get_host_id();
-        if (IPHONE_E_SUCCESS == ret && !host_id) {
-                ret = IPHONE_E_INVALID_CONF;
+        userpref_get_host_id(&host_id);
+        if (LOCKDOWN_E_SUCCESS == ret && !host_id) {
+                ret = LOCKDOWN_E_INVALID_CONF;
         }
 
-        if (IPHONE_E_SUCCESS == ret && !is_device_known(uid))
-                ret = lockdownd_pair(client_loc, uid, host_id);
+        if (LOCKDOWN_E_SUCCESS == ret && !userpref_has_device_public_key(uuid))
+                ret = lockdownd_pair(client_loc, uuid, host_id);
 
-        if (uid) {
-                free(uid);
-                uid = NULL;
+        if (uuid) {
+                free(uuid);
+                uuid = NULL;
         }
 
-        if (IPHONE_E_SUCCESS == ret) {
+        if (LOCKDOWN_E_SUCCESS == ret) {
                 ret = lockdownd_start_ssl_session(client_loc, host_id);
-                if (IPHONE_E_SUCCESS != ret) {
-                        ret = IPHONE_E_SSL_ERROR;
-                        log_debug_msg("SSL Session opening failed.\n");
+                if (LOCKDOWN_E_SUCCESS != ret) {
+                        ret = LOCKDOWN_E_SSL_ERROR;
+                        log_debug_msg("%s: SSL Session opening failed.\n", __func__);
                 }
 
                 if (host_id) {
@@ -706,7 +712,7 @@ iphone_error_t lockdownd_new_client(iphone_device_t device, lockdownd_client_t *
                         host_id = NULL;
                 }
 
-                if (IPHONE_E_SUCCESS == ret)
+                if (LOCKDOWN_E_SUCCESS == ret)
                         *client = client_loc;
         }
 
@@ -716,11 +722,11 @@ iphone_error_t lockdownd_new_client(iphone_device_t device, lockdownd_client_t *
 /** Generates the appropriate keys and pairs the device. It's part of the
  *  lockdownd handshake.
  *
- * @return an error code (IPHONE_E_SUCCESS on success)
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-iphone_error_t lockdownd_pair(lockdownd_client_t client, char *uid, char *host_id)
+lockdownd_error_t lockdownd_pair(lockdownd_client_t client, char *uuid, char *host_id)
 {
-        iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+        lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
         plist_t dict = NULL;
         plist_t dict_record = NULL;
 
@@ -730,14 +736,14 @@ iphone_error_t lockdownd_pair(lockdownd_client_t client, char *uid, char *host_i
         gnutls_datum_t public_key = { NULL, 0 };
 
         ret = lockdownd_get_device_public_key(client, &public_key);
-        if (ret != IPHONE_E_SUCCESS) {
-                log_debug_msg("Device refused to send public key.\n");
+        if (ret != LOCKDOWN_E_SUCCESS) {
+                log_debug_msg("%s: device refused to send public key.\n", __func__);
                 return ret;
         }
-        log_debug_msg("device public key :\n %s.\n", public_key.data);
+        log_debug_msg("%s: device public key follows:\n%s\n", __func__, public_key.data);
 
         ret = lockdownd_gen_pair_cert(public_key, &device_cert, &host_cert, &root_cert);
-        if (ret != IPHONE_E_SUCCESS) {
+        if (ret != LOCKDOWN_E_SUCCESS) {
                 free(public_key.data);
                 return ret;
         }
@@ -763,29 +769,28 @@ iphone_error_t lockdownd_pair(lockdownd_client_t client, char *uid, char *host_i
         plist_free(dict);
         dict = NULL;
 
-        if (ret != IPHONE_E_SUCCESS)
+        if (ret != LOCKDOWN_E_SUCCESS)
                 return ret;
 
         /* Now get iPhone's answer */
         ret = lockdownd_recv(client, &dict);
 
-        if (ret != IPHONE_E_SUCCESS)
+        if (ret != LOCKDOWN_E_SUCCESS)
                 return ret;
 
         if (lockdown_check_result(dict, "Pair") == RESULT_SUCCESS) {
-                ret = IPHONE_E_SUCCESS;
+                ret = LOCKDOWN_E_SUCCESS;
         }
         plist_free(dict);
         dict = NULL;
 
         /* store public key in config if pairing succeeded */
-        if (ret == IPHONE_E_SUCCESS) {
-                log_dbg_msg(DBGMASK_LOCKDOWND, "lockdownd_pair: pair success\n");
-                store_device_public_key(uid, public_key);
-                ret = IPHONE_E_SUCCESS;
+        if (ret == LOCKDOWN_E_SUCCESS) {
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: pair success\n", __func__);
+                userpref_set_device_public_key(uuid, public_key);
         } else {
-                log_dbg_msg(DBGMASK_LOCKDOWND, "lockdownd_pair: pair failure\n");
-                ret = IPHONE_E_PAIRING_FAILED;
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: pair failure\n", __func__);
+                ret = LOCKDOWN_E_PAIRING_FAILED;
         }
         free(public_key.data);
         return ret;
@@ -796,20 +801,20 @@ iphone_error_t lockdownd_pair(lockdownd_client_t client, char *uid, char *host_i
  *
  * @param client The lockdown client
  *
- * @return an error code (IPHONE_E_SUCCESS on success)
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-iphone_error_t lockdownd_enter_recovery(lockdownd_client_t client)
+lockdownd_error_t lockdownd_enter_recovery(lockdownd_client_t client)
 {
         if (!client)
-                return IPHONE_E_INVALID_ARG;
+                return LOCKDOWN_E_INVALID_ARG;
 
-        iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+        lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
 
         plist_t dict = plist_new_dict();
         plist_add_sub_key_el(dict, "Request");
         plist_add_sub_string_el(dict, "EnterRecovery");
 
-        log_dbg_msg(DBGMASK_LOCKDOWND, "%s: Telling device to enter recovery mode\n", __func__);
+        log_dbg_msg(DBGMASK_LOCKDOWND, "%s: telling device to enter recovery mode\n", __func__);
 
         ret = lockdownd_send(client, dict);
         plist_free(dict);
@@ -819,7 +824,7 @@ iphone_error_t lockdownd_enter_recovery(lockdownd_client_t client)
 
         if (lockdown_check_result(dict, "EnterRecovery") == RESULT_SUCCESS) {
                 log_dbg_msg(DBGMASK_LOCKDOWND, "%s: success\n", __func__);
-                ret = IPHONE_E_SUCCESS;
+                ret = LOCKDOWN_E_SUCCESS;
         }
         plist_free(dict);
         dict = NULL;
@@ -832,35 +837,34 @@ iphone_error_t lockdownd_enter_recovery(lockdownd_client_t client)
  *
  * @param client The lockdown client
  *
- * @return an error code (IPHONE_E_SUCCESS on success)
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-iphone_error_t lockdownd_goodbye(lockdownd_client_t client)
+lockdownd_error_t lockdownd_goodbye(lockdownd_client_t client)
 {
         if (!client)
-                return IPHONE_E_INVALID_ARG;
+                return LOCKDOWN_E_INVALID_ARG;
 
-        iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+        lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
 
         plist_t dict = plist_new_dict();
         plist_add_sub_key_el(dict, "Request");
         plist_add_sub_string_el(dict, "Goodbye");
 
-        log_dbg_msg(DBGMASK_LOCKDOWND, "lockdownd_goodbye() called\n");
+        log_dbg_msg(DBGMASK_LOCKDOWND, "%s: called\n", __func__);
 
         ret = lockdownd_send(client, dict);
         plist_free(dict);
         dict = NULL;
 
         ret = lockdownd_recv(client, &dict);
-
         if (!dict) {
-                log_dbg_msg(DBGMASK_LOCKDOWND, "lockdownd_goodbye(): IPHONE_E_PLIST_ERROR\n");
-                return IPHONE_E_PLIST_ERROR;
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: did not get goodbye response back\n", __func__);
+                return LOCKDOWN_E_PLIST_ERROR;
         }
 
         if (lockdown_check_result(dict, "Goodbye") == RESULT_SUCCESS) {
-                log_dbg_msg(DBGMASK_LOCKDOWND, "lockdownd_goodbye(): success\n");
-                ret = IPHONE_E_SUCCESS;
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: success\n", __func__);
+                ret = LOCKDOWN_E_SUCCESS;
         }
         plist_free(dict);
         dict = NULL;
@@ -870,14 +874,15 @@ iphone_error_t lockdownd_goodbye(lockdownd_client_t client)
 /** Generates the device certificate from the public key as well as the host
  *  and root certificates.
  *
- * @return an error code (IPHONE_E_SUCCESS on success)
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-iphone_error_t lockdownd_gen_pair_cert(gnutls_datum_t public_key, gnutls_datum_t * odevice_cert,
+lockdownd_error_t lockdownd_gen_pair_cert(gnutls_datum_t public_key, gnutls_datum_t * odevice_cert,
                                                                            gnutls_datum_t * ohost_cert, gnutls_datum_t * oroot_cert)
 {
         if (!public_key.data || !odevice_cert || !ohost_cert || !oroot_cert)
-                return IPHONE_E_INVALID_ARG;
-        iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+                return LOCKDOWN_E_INVALID_ARG;
+        lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
+        userpref_error_t uret = USERPREF_E_UNKNOWN_ERROR;
 
         gnutls_datum_t modulus = { NULL, 0 };
         gnutls_datum_t exponent = { NULL, 0 };
@@ -905,7 +910,7 @@ iphone_error_t lockdownd_gen_pair_cert(gnutls_datum_t public_key, gnutls_datum_t
                                 ret1 = asn1_read_value(asn1_pub_key, "modulus", modulus.data, (int*)&modulus.size);
                                 ret2 = asn1_read_value(asn1_pub_key, "publicExponent", exponent.data, (int*)&exponent.size);
                                 if (ASN1_SUCCESS == ret1 && ASN1_SUCCESS == ret2)
-                                        ret = IPHONE_E_SUCCESS;
+                                        ret = LOCKDOWN_E_SUCCESS;
                         }
                         if (asn1_pub_key)
                                 asn1_delete_structure(&asn1_pub_key);
@@ -915,7 +920,7 @@ iphone_error_t lockdownd_gen_pair_cert(gnutls_datum_t public_key, gnutls_datum_t
         }
 
         /* now generate certifcates */
-        if (IPHONE_E_SUCCESS == ret && 0 != modulus.size && 0 != exponent.size) {
+        if (LOCKDOWN_E_SUCCESS == ret && 0 != modulus.size && 0 != exponent.size) {
 
                 gnutls_global_init();
                 gnutls_datum_t essentially_null = { (unsigned char*)strdup("abababababababab"), strlen("abababababababab") };
@@ -935,10 +940,9 @@ iphone_error_t lockdownd_gen_pair_cert(gnutls_datum_t public_key, gnutls_datum_t
                         gnutls_x509_privkey_init(&root_privkey);
                         gnutls_x509_privkey_init(&host_privkey);
 
-                        ret = get_keys_and_certs(root_privkey, root_cert, host_privkey, host_cert);
-
-                        if (IPHONE_E_SUCCESS == ret) {
+                        uret = userpref_get_keys_and_certs(root_privkey, root_cert, host_privkey, host_cert);
 
+                        if (USERPREF_E_SUCCESS == uret) {
                                 /* generate device certificate */
                                 gnutls_x509_crt_set_key(dev_cert, fake_privkey);
                                 gnutls_x509_crt_set_serial(dev_cert, "\x00", 1);
@@ -948,7 +952,7 @@ iphone_error_t lockdownd_gen_pair_cert(gnutls_datum_t public_key, gnutls_datum_t
                                 gnutls_x509_crt_set_expiration_time(dev_cert, time(NULL) + (60 * 60 * 24 * 365 * 10));
                                 gnutls_x509_crt_sign(dev_cert, root_cert, root_privkey);
 
-                                if (IPHONE_E_SUCCESS == ret) {
+                                if (LOCKDOWN_E_SUCCESS == ret) {
                                         /* if everything went well, export in PEM format */
                                         gnutls_datum_t dev_pem = { NULL, 0 };
                                         gnutls_x509_crt_export(dev_cert, GNUTLS_X509_FMT_PEM, NULL, &dev_pem.size);
@@ -958,7 +962,9 @@ iphone_error_t lockdownd_gen_pair_cert(gnutls_datum_t public_key, gnutls_datum_t
                                         gnutls_datum_t pem_root_cert = { NULL, 0 };
                                         gnutls_datum_t pem_host_cert = { NULL, 0 };
 
-                                        if ( IPHONE_E_SUCCESS ==  get_certs_as_pem(&pem_root_cert, &pem_host_cert) ) {
+                                        uret = userpref_get_certs_as_pem(&pem_root_cert, &pem_host_cert);
+
+                                        if (USERPREF_E_SUCCESS == uret) {
                                                 /* copy buffer for output */
                                                 odevice_cert->data = malloc(dev_pem.size);
                                                 memcpy(odevice_cert->data, dev_pem.data, dev_pem.size);
@@ -977,6 +983,19 @@ iphone_error_t lockdownd_gen_pair_cert(gnutls_datum_t public_key, gnutls_datum_t
                                         }
                                 }
                         }
+
+                        switch(uret) {
+                        case USERPREF_E_INVALID_ARG:
+                                ret = LOCKDOWN_E_INVALID_ARG;
+                                break;
+                        case USERPREF_E_INVALID_CONF:
+                                ret = LOCKDOWN_E_INVALID_CONF;
+                                break;
+                        case USERPREF_E_SSL_ERROR:
+                                ret = LOCKDOWN_E_SSL_ERROR;
+                        default:
+                                break;
+                        }
                 }
         }
 
@@ -993,14 +1012,14 @@ iphone_error_t lockdownd_gen_pair_cert(gnutls_datum_t public_key, gnutls_datum_t
  * @param client The lockdownd client
  * @param HostID The HostID used with this phone
  *
- * @return an error code (IPHONE_E_SUCCESS on success)
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-iphone_error_t lockdownd_start_ssl_session(lockdownd_client_t client, const char *HostID)
+lockdownd_error_t lockdownd_start_ssl_session(lockdownd_client_t client, const char *HostID)
 {
         plist_t dict = NULL;
         uint32_t return_me = 0;
 
-        iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+        lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
         client->session_id[0] = '\0';
 
         /* Setup DevicePublicKey request plist */
@@ -1014,13 +1033,13 @@ iphone_error_t lockdownd_start_ssl_session(lockdownd_client_t client, const char
         plist_free(dict);
         dict = NULL;
 
-        if (ret != IPHONE_E_SUCCESS)
+        if (ret != LOCKDOWN_E_SUCCESS)
                 return ret;
 
         ret = lockdownd_recv(client, &dict);
 
         if (!dict)
-                return IPHONE_E_PLIST_ERROR;
+                return LOCKDOWN_E_PLIST_ERROR;
 
         if (lockdown_check_result(dict, "StartSession") == RESULT_FAILURE) {
                 plist_t error_node = plist_get_dict_el_from_key(dict, "Error");
@@ -1029,12 +1048,14 @@ iphone_error_t lockdownd_start_ssl_session(lockdownd_client_t client, const char
                         plist_get_string_val(error_node, &error);
 
                         if (!strcmp(error, "InvalidHostID")) {
-                                //hostid is unknown. Pair and try again
-                                char *uid = NULL;
-                                char* host_id = get_host_id();
-                                if (IPHONE_E_SUCCESS == lockdownd_get_device_uid(client, &uid) ) {
-                                        if (IPHONE_E_SUCCESS == lockdownd_pair(client, uid, host_id) ) {
-                                                //start session again
+                                /* hostid is unknown. Pair and try again */
+                                char *uuid = NULL;
+                                char *host_id = NULL;
+                                userpref_get_host_id(&host_id);
+
+                                if (LOCKDOWN_E_SUCCESS == lockdownd_get_device_uuid(client, &uuid) ) {
+                                        if (LOCKDOWN_E_SUCCESS == lockdownd_pair(client, uuid, host_id) ) {
+                                                /* start session again */
                                                 plist_free(dict);
                                                 dict = plist_new_dict();
                                                 plist_add_sub_key_el(dict, "HostID");
@@ -1049,20 +1070,20 @@ iphone_error_t lockdownd_start_ssl_session(lockdownd_client_t client, const char
                                                 ret = lockdownd_recv(client, &dict);
                                         }
                                 }
-                                free(uid);
+                                free(uuid);
                                 free(host_id);
                         }
                         free(error);
                 }
         }
 
-        ret = IPHONE_E_SSL_ERROR;
+        ret = LOCKDOWN_E_SSL_ERROR;
         if (lockdown_check_result(dict, "StartSession") == RESULT_SUCCESS) {
                 // Set up GnuTLS...
                 //gnutls_anon_client_credentials_t anoncred;
                 gnutls_certificate_credentials_t xcred;
 
-                log_dbg_msg(DBGMASK_LOCKDOWND, "We started the session OK, now trying GnuTLS\n");
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: started the session OK, now trying GnuTLS\n", __func__);
                 errno = 0;
                 gnutls_global_init();
                 //gnutls_anon_allocate_client_credentials(&anoncred);
@@ -1084,30 +1105,29 @@ iphone_error_t lockdownd_start_ssl_session(lockdownd_client_t client, const char
                 }
                 gnutls_credentials_set(*client->ssl_session, GNUTLS_CRD_CERTIFICATE, xcred);    // this part is killing me.
 
-                log_dbg_msg(DBGMASK_LOCKDOWND, "GnuTLS step 1...\n");
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: GnuTLS step 1...\n", __func__);
                 gnutls_transport_set_ptr(*client->ssl_session, (gnutls_transport_ptr_t) client);
-                log_dbg_msg(DBGMASK_LOCKDOWND, "GnuTLS step 2...\n");
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: GnuTLS step 2...\n", __func__);
                 gnutls_transport_set_push_function(*client->ssl_session, (gnutls_push_func) & lockdownd_secuwrite);
-                log_dbg_msg(DBGMASK_LOCKDOWND, "GnuTLS step 3...\n");
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: GnuTLS step 3...\n", __func__);
                 gnutls_transport_set_pull_function(*client->ssl_session, (gnutls_pull_func) & lockdownd_securead);
-                log_dbg_msg(DBGMASK_LOCKDOWND, "GnuTLS step 4 -- now handshaking...\n");
-
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: GnuTLS step 4 -- now handshaking...\n", __func__);
                 if (errno)
-                        log_dbg_msg(DBGMASK_LOCKDOWND, "WARN: errno says %s before handshake!\n", strerror(errno));
+                        log_dbg_msg(DBGMASK_LOCKDOWND, "%s: WARN: errno says %s before handshake!\n", __func__, strerror(errno));
                 return_me = gnutls_handshake(*client->ssl_session);
-                log_dbg_msg(DBGMASK_LOCKDOWND, "GnuTLS handshake done...\n");
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: GnuTLS handshake done...\n", __func__);
 
                 if (return_me != GNUTLS_E_SUCCESS) {
-                        log_dbg_msg(DBGMASK_LOCKDOWND, "GnuTLS reported something wrong.\n");
+                        log_dbg_msg(DBGMASK_LOCKDOWND, "%s: GnuTLS reported something wrong.\n", __func__);
                         gnutls_perror(return_me);
-                        log_dbg_msg(DBGMASK_LOCKDOWND, "oh.. errno says %s\n", strerror(errno));
-                        return IPHONE_E_SSL_ERROR;
+                        log_dbg_msg(DBGMASK_LOCKDOWND, "%s: oh.. errno says %s\n", __func__, strerror(errno));
+                        return LOCKDOWN_E_SSL_ERROR;
                 } else {
                         client->in_SSL = 1;
-                        ret = IPHONE_E_SUCCESS;
+                        ret = LOCKDOWN_E_SUCCESS;
                 }
         }
-        //store session id
+        /* store session id */
         plist_t session_node = plist_find_node_by_key(dict, "SessionID");
         if (session_node) {
 
@@ -1120,23 +1140,23 @@ iphone_error_t lockdownd_start_ssl_session(lockdownd_client_t client, const char
                         plist_get_string_val(session_node_val, &session_id);
 
                         if (session_node_val_type == PLIST_STRING && session_id) {
-                                // we need to store the session ID for StopSession
+                                /* we need to store the session ID for StopSession */
                                 strcpy(client->session_id, session_id);
-                                log_dbg_msg(DBGMASK_LOCKDOWND, "SessionID: %s\n", client->session_id);
+                                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: SessionID: %s\n", __func__, client->session_id);
                         }
                         if (session_id)
                                 free(session_id);
                 }
         } else
-                log_dbg_msg(DBGMASK_LOCKDOWND, "Failed to get SessionID!\n");
+                log_dbg_msg(DBGMASK_LOCKDOWND, "%s: Failed to get SessionID!\n", __func__);
         plist_free(dict);
         dict = NULL;
 
-        if (ret == IPHONE_E_SUCCESS)
+        if (ret == LOCKDOWN_E_SUCCESS)
                 return ret;
 
-        log_dbg_msg(DBGMASK_LOCKDOWND, "Apparently failed negotiating with lockdownd.\n");
-        return IPHONE_E_SSL_ERROR;
+        log_dbg_msg(DBGMASK_LOCKDOWND, "%s: Apparently failed negotiating with lockdownd.\n", __func__);
+        return LOCKDOWN_E_SSL_ERROR;
 }
 
 /** gnutls callback for writing data to the iPhone.
@@ -1152,12 +1172,10 @@ ssize_t lockdownd_secuwrite(gnutls_transport_ptr_t transport, char *buffer, size
         uint32_t bytes = 0;
         lockdownd_client_t client;
         client = (lockdownd_client_t) transport;
-        log_dbg_msg(DBGMASK_LOCKDOWND, "lockdownd_secuwrite() called\n");
-        log_dbg_msg(DBGMASK_LOCKDOWND, "pre-send\nlength = %zi\n", length);
+        log_dbg_msg(DBGMASK_LOCKDOWND, "%s: called\n", __func__);
+        log_dbg_msg(DBGMASK_LOCKDOWND, "%s: pre-send length = %zi\n", __func__, length);
         usbmuxd_send(client->sfd, buffer, length, &bytes);
-        log_dbg_msg(DBGMASK_LOCKDOWND, "post-send\nsent %i bytes\n", bytes);
-
-        dump_debug_buffer("sslpacketwrite.out", buffer, length);
+        log_dbg_msg(DBGMASK_LOCKDOWND, "%s: post-send sent %i bytes\n", __func__, bytes);
         return bytes;
 }
 
@@ -1179,19 +1197,17 @@ ssize_t lockdownd_securead(gnutls_transport_ptr_t transport, char *buffer, size_
         client = (lockdownd_client_t) transport;
         char *recv_buffer;
 
-        log_debug_msg("lockdownd_securead() called\nlength = %zi\n", length);
-
-        log_debug_msg("pre-read\nclient wants %zi bytes\n", length);
+        log_debug_msg("%s: pre-read client wants %zi bytes\n", __func__, length);
 
         recv_buffer = (char *) malloc(sizeof(char) * this_len);
 
         // repeat until we have the full data or an error occurs.
         do {
-                if ((res = usbmuxd_recv(client->sfd, recv_buffer, this_len, (uint32_t*)&bytes)) != IPHONE_E_SUCCESS) {
+                if ((res = usbmuxd_recv(client->sfd, recv_buffer, this_len, (uint32_t*)&bytes)) != LOCKDOWN_E_SUCCESS) {
                         log_debug_msg("%s: ERROR: usbmux_recv returned %d\n", __func__, res);
                         return res;
                 }
-                log_debug_msg("post-read\nwe got %i bytes\n", bytes);
+                log_debug_msg("%s: post-read we got %i bytes\n", __func__, bytes);
 
                 // increase read count
                 tbytes += bytes;
@@ -1205,7 +1221,7 @@ ssize_t lockdownd_securead(gnutls_transport_ptr_t transport, char *buffer, size_
                 }
 
                 this_len = length - tbytes;
-                log_debug_msg("re-read\ntrying to read missing %i bytes\n", this_len);
+                log_debug_msg("%s: re-read trying to read missing %i bytes\n", __func__, this_len);
         } while (tbytes < length);
 
         if (recv_buffer) {
@@ -1221,22 +1237,23 @@ ssize_t lockdownd_securead(gnutls_transport_ptr_t transport, char *buffer, size_
  * @param service The name of the service to start
  * @param port The port number the service was started on
  
- * @return an error code (IPHONE_E_SUCCESS on success)
+ * @return an error code (LOCKDOWN_E_SUCCESS on success)
  */
-iphone_error_t lockdownd_start_service(lockdownd_client_t client, const char *service, int *port)
+lockdownd_error_t lockdownd_start_service(lockdownd_client_t client, const char *service, int *port)
 {
         if (!client || !service || !port)
-                return IPHONE_E_INVALID_ARG;
+                return LOCKDOWN_E_INVALID_ARG;
 
-        char *host_id = get_host_id();
+        char *host_id = NULL;
+        userpref_get_host_id(&host_id);
         if (!host_id)
-                return IPHONE_E_INVALID_CONF;
+                return LOCKDOWN_E_INVALID_CONF;
         if (!client->in_SSL && !lockdownd_start_ssl_session(client, host_id))
-                return IPHONE_E_SSL_ERROR;
+                return LOCKDOWN_E_SSL_ERROR;
 
         plist_t dict = NULL;
         uint32_t port_loc = 0;
-        iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+        lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
 
         free(host_id);
         host_id = NULL;
@@ -1252,18 +1269,18 @@ iphone_error_t lockdownd_start_service(lockdownd_client_t client, const char *se
         plist_free(dict);
         dict = NULL;
 
-        if (IPHONE_E_SUCCESS != ret)
+        if (LOCKDOWN_E_SUCCESS != ret)
                 return ret;
 
         ret = lockdownd_recv(client, &dict);
 
-        if (IPHONE_E_SUCCESS != ret)
+        if (LOCKDOWN_E_SUCCESS != ret)
                 return ret;
 
         if (!dict)
-                return IPHONE_E_PLIST_ERROR;
+                return LOCKDOWN_E_PLIST_ERROR;
 
-        ret = IPHONE_E_UNKNOWN_ERROR;
+        ret = LOCKDOWN_E_UNKNOWN_ERROR;
         if (lockdown_check_result(dict, "StartService") == RESULT_SUCCESS) {
                 plist_t port_key_node = plist_find_node_by_key(dict, "Port");
                 plist_t port_value_node = plist_get_next_sibling(port_key_node);
@@ -1277,17 +1294,17 @@ iphone_error_t lockdownd_start_service(lockdownd_client_t client, const char *se
                         plist_get_uint_val(port_value_node, &port_value);
                         if (port_key && !strcmp(port_key, "Port")) {
                                 port_loc = port_value;
-                                ret = IPHONE_E_SUCCESS;
+                                ret = LOCKDOWN_E_SUCCESS;
                         }
                         if (port_key)
                                 free(port_key);
 
-                        if (port && ret == IPHONE_E_SUCCESS)
+                        if (port && ret == LOCKDOWN_E_SUCCESS)
                                 *port = port_loc;
                 }
         }
         else
-                ret = IPHONE_E_START_SERVICE_FAILED;
+                ret = LOCKDOWN_E_START_SERVICE_FAILED;
 
         plist_free(dict);
         dict = NULL;