3 files changed, 226 insertions, 137 deletions

diff --git a/cython/lockdown.pxi b/cython/lockdown.pxi
index 13fe634..7d903d6 100644
--- a/cython/lockdown.pxi
+++ b/cython/lockdown.pxi
@@ -1,27 +1,44 @@
 cdef extern from "libimobiledevice/lockdown.h":
     ctypedef enum lockdownd_error_t:
-        LOCKDOWN_E_SUCCESS = 0
-        LOCKDOWN_E_INVALID_ARG = -1
-        LOCKDOWN_E_INVALID_CONF = -2
-        LOCKDOWN_E_PLIST_ERROR = -3
-        LOCKDOWN_E_PAIRING_FAILED = -4
-        LOCKDOWN_E_SSL_ERROR = -5
-        LOCKDOWN_E_DICT_ERROR = -6
-        LOCKDOWN_E_START_SERVICE_FAILED = -7
-        LOCKDOWN_E_NOT_ENOUGH_DATA = -8
-        LOCKDOWN_E_SET_VALUE_PROHIBITED = -9
-        LOCKDOWN_E_GET_VALUE_PROHIBITED = -10
-        LOCKDOWN_E_REMOVE_VALUE_PROHIBITED = -11
-        LOCKDOWN_E_MUX_ERROR = -12
-        LOCKDOWN_E_ACTIVATION_FAILED = -13
-        LOCKDOWN_E_PASSWORD_PROTECTED = -14
-        LOCKDOWN_E_NO_RUNNING_SESSION = -15
-        LOCKDOWN_E_INVALID_HOST_ID = -16
-        LOCKDOWN_E_INVALID_SERVICE = -17
-        LOCKDOWN_E_INVALID_ACTIVATION_RECORD = -18
-        LOCKDOWN_E_PAIRING_DIALOG_PENDING = -20
-        LOCKDOWN_E_USER_DENIED_PAIRING = -21
-        LOCKDOWN_E_UNKNOWN_ERROR = -256
+        LOCKDOWN_E_SUCCESS
+        LOCKDOWN_E_INVALID_ARG
+        LOCKDOWN_E_INVALID_CONF
+        LOCKDOWN_E_PLIST_ERROR
+        LOCKDOWN_E_PAIRING_FAILED
+        LOCKDOWN_E_SSL_ERROR
+        LOCKDOWN_E_DICT_ERROR
+        LOCKDOWN_E_NOT_ENOUGH_DATA
+        LOCKDOWN_E_SET_VALUE_PROHIBITED
+        LOCKDOWN_E_GET_VALUE_PROHIBITED
+        LOCKDOWN_E_MUX_ERROR
+        LOCKDOWN_E_NO_RUNNING_SESSION
+        LOCKDOWN_E_INVALID_RESPONSE
+        LOCKDOWN_E_MISSING_KEY
+        LOCKDOWN_E_MISSING_VALUE
+        LOCKDOWN_E_GET_PROHIBITED
+        LOCKDOWN_E_SET_PROHIBITED
+        LOCKDOWN_E_REMOVE_PROHIBITED
+        LOCKDOWN_E_IMMUTABLE_VALUE
+        LOCKDOWN_E_PASSWORD_PROTECTED
+        LOCKDOWN_E_USER_DENIED_PAIRING
+        LOCKDOWN_E_PAIRING_DIALOG_RESPONSE_PENDING
+        LOCKDOWN_E_MISSING_HOST_ID
+        LOCKDOWN_E_INVALID_HOST_ID
+        LOCKDOWN_E_SESSION_ACTIVE
+        LOCKDOWN_E_SESSION_INACTIVE
+        LOCKDOWN_E_MISSING_SESSION_ID
+        LOCKDOWN_E_INVALID_SESSION_ID
+        LOCKDOWN_E_MISSING_SERVICE
+        LOCKDOWN_E_INVALID_SERVICE
+        LOCKDOWN_E_SERVICE_LIMIT
+        LOCKDOWN_E_MISSING_PAIR_RECORD
+        LOCKDOWN_E_SAVE_PAIR_RECORD_FAILED
+        LOCKDOWN_E_INVALID_PAIR_RECORD
+        LOCKDOWN_E_INVALID_ACTIVATION_RECORD
+        LOCKDOWN_E_MISSING_ACTIVATION_RECORD
+        LOCKDOWN_E_SERVICE_PROHIBITED
+        LOCKDOWN_E_ESCROW_LOCKED
+        LOCKDOWN_E_UNKNOWN_ERROR
 
     lockdownd_error_t lockdownd_client_new(idevice_t device, lockdownd_client_t *client, char *label)
     lockdownd_error_t lockdownd_client_new_with_handshake(idevice_t device, lockdownd_client_t *client, char *label)
@@ -56,21 +73,36 @@ cdef class LockdownError(BaseError):
             LOCKDOWN_E_PLIST_ERROR: "Property list error",
             LOCKDOWN_E_PAIRING_FAILED: "Pairing failed",
             LOCKDOWN_E_SSL_ERROR: "SSL error",
-            LOCKDOWN_E_DICT_ERROR: "Dict error",
-            LOCKDOWN_E_START_SERVICE_FAILED: "Start service failed",
+            LOCKDOWN_E_DICT_ERROR: "Dictionary error",
             LOCKDOWN_E_NOT_ENOUGH_DATA: "Not enough data",
-            LOCKDOWN_E_SET_VALUE_PROHIBITED: "Set value prohibited",
-            LOCKDOWN_E_GET_VALUE_PROHIBITED: "Get value prohibited",
-            LOCKDOWN_E_REMOVE_VALUE_PROHIBITED: "Remove value prohibited",
-            LOCKDOWN_E_MUX_ERROR: "MUX Error",
-            LOCKDOWN_E_ACTIVATION_FAILED: "Activation failed",
-            LOCKDOWN_E_PASSWORD_PROTECTED: "Password protected",
+            LOCKDOWN_E_MUX_ERROR: "Mux Protocol Error",
             LOCKDOWN_E_NO_RUNNING_SESSION: "No running session",
+            LOCKDOWN_E_INVALID_RESPONSE: "Invalid response",
+            LOCKDOWN_E_MISSING_KEY: "Missing key",
+            LOCKDOWN_E_MISSING_VALUE: "Missing value",
+            LOCKDOWN_E_GET_PROHIBITED: "Get value prohibited",
+            LOCKDOWN_E_SET_PROHIBITED: "Set value prohibited",
+            LOCKDOWN_E_REMOVE_PROHIBITED: "Remove value prohibited",
+            LOCKDOWN_E_IMMUTABLE_VALUE: "Immutable value",
+            LOCKDOWN_E_PASSWORD_PROTECTED: "Password protected",
+            LOCKDOWN_E_USER_DENIED_PAIRING: "User denied pairing",
+            LOCKDOWN_E_PAIRING_DIALOG_RESPONSE_PENDING: "Pairing dialog response pending",
+            LOCKDOWN_E_MISSING_HOST_ID: "Missing host ID",
             LOCKDOWN_E_INVALID_HOST_ID: "Invalid host ID",
+            LOCKDOWN_E_SESSION_ACTIVE: "Session active",
+            LOCKDOWN_E_SESSION_INACTIVE: "Session inactive",
+            LOCKDOWN_E_MISSING_SESSION_ID: "Missing session ID",
+            LOCKDOWN_E_INVALID_SESSION_ID: "Invalid session ID",
+            LOCKDOWN_E_MISSING_SERVICE: "Missing service",
             LOCKDOWN_E_INVALID_SERVICE: "Invalid service",
+            LOCKDOWN_E_SERVICE_LIMIT: "Service limit reached",
+            LOCKDOWN_E_MISSING_PAIR_RECORD: "Missing pair record",
+            LOCKDOWN_E_SAVE_PAIR_RECORD_FAILED: "Saving pair record failed",
+            LOCKDOWN_E_INVALID_PAIR_RECORD: "Invalid pair record",
             LOCKDOWN_E_INVALID_ACTIVATION_RECORD: "Invalid activation record",
-            LOCKDOWN_E_PAIRING_DIALOG_PENDING: "Pairing dialog pending",
-            LOCKDOWN_E_USER_DENIED_PAIRING: "User denied pairing",
+            LOCKDOWN_E_MISSING_ACTIVATION_RECORD: "Missing activation record",
+            LOCKDOWN_E_SERVICE_PROHIBITED: "Service prohibited",
+            LOCKDOWN_E_ESCROW_LOCKED: "Escrow locked",
             LOCKDOWN_E_UNKNOWN_ERROR: "Unknown error"
         }
         BaseError.__init__(self, *args, **kwargs)
diff --git a/include/libimobiledevice/lockdown.h b/include/libimobiledevice/lockdown.h
index 24830ff..4f87235 100644
--- a/include/libimobiledevice/lockdown.h
+++ b/include/libimobiledevice/lockdown.h
@@ -33,29 +33,45 @@ extern "C" {
 
 /** Error Codes */
 typedef enum {
-        LOCKDOWN_E_SUCCESS                   =   0,
-        LOCKDOWN_E_INVALID_ARG               =  -1,
-        LOCKDOWN_E_INVALID_CONF              =  -2,
-        LOCKDOWN_E_PLIST_ERROR               =  -3,
-        LOCKDOWN_E_PAIRING_FAILED            =  -4,
-        LOCKDOWN_E_SSL_ERROR                 =  -5,
-        LOCKDOWN_E_DICT_ERROR                =  -6,
-        LOCKDOWN_E_START_SERVICE_FAILED      =  -7,
-        LOCKDOWN_E_NOT_ENOUGH_DATA           =  -8,
-        LOCKDOWN_E_SET_VALUE_PROHIBITED      =  -9,
-        LOCKDOWN_E_GET_VALUE_PROHIBITED      = -10,
-        LOCKDOWN_E_REMOVE_VALUE_PROHIBITED   = -11,
-        LOCKDOWN_E_MUX_ERROR                 = -12,
-        LOCKDOWN_E_ACTIVATION_FAILED         = -13,
-        LOCKDOWN_E_PASSWORD_PROTECTED        = -14,
-        LOCKDOWN_E_NO_RUNNING_SESSION        = -15,
-        LOCKDOWN_E_INVALID_HOST_ID           = -16,
-        LOCKDOWN_E_INVALID_SERVICE           = -17,
-        LOCKDOWN_E_INVALID_ACTIVATION_RECORD = -18,
-        LOCKDOWN_E_PAIRING_DIALOG_PENDING    = -20,
-        LOCKDOWN_E_USER_DENIED_PAIRING       = -21,
-        LOCKDOWN_E_SERVICE_LIMIT             = -22,
-        LOCKDOWN_E_UNKNOWN_ERROR             = -256
+        /* custom */
+        LOCKDOWN_E_SUCCESS                                 =   0,
+        LOCKDOWN_E_INVALID_ARG                             =  -1,
+        LOCKDOWN_E_INVALID_CONF                            =  -2,
+        LOCKDOWN_E_PLIST_ERROR                             =  -3,
+        LOCKDOWN_E_PAIRING_FAILED                          =  -4,
+        LOCKDOWN_E_SSL_ERROR                               =  -5,
+        LOCKDOWN_E_DICT_ERROR                              =  -6,
+        LOCKDOWN_E_NOT_ENOUGH_DATA                         =  -7,
+        LOCKDOWN_E_MUX_ERROR                               =  -8,
+        LOCKDOWN_E_NO_RUNNING_SESSION                      =  -9,
+        /* native */
+        LOCKDOWN_E_INVALID_RESPONSE                        = -10,
+        LOCKDOWN_E_MISSING_KEY                             = -11,
+        LOCKDOWN_E_MISSING_VALUE                           = -12,
+        LOCKDOWN_E_GET_PROHIBITED                          = -13,
+        LOCKDOWN_E_SET_PROHIBITED                          = -14,
+        LOCKDOWN_E_REMOVE_PROHIBITED                       = -15,
+        LOCKDOWN_E_IMMUTABLE_VALUE                         = -16,
+        LOCKDOWN_E_PASSWORD_PROTECTED                      = -17,
+        LOCKDOWN_E_USER_DENIED_PAIRING                     = -18,
+        LOCKDOWN_E_PAIRING_DIALOG_RESPONSE_PENDING         = -19,
+        LOCKDOWN_E_MISSING_HOST_ID                         = -20,
+        LOCKDOWN_E_INVALID_HOST_ID                         = -21,
+        LOCKDOWN_E_SESSION_ACTIVE                          = -22,
+        LOCKDOWN_E_SESSION_INACTIVE                        = -23,
+        LOCKDOWN_E_MISSING_SESSION_ID                      = -24,
+        LOCKDOWN_E_INVALID_SESSION_ID                      = -25,
+        LOCKDOWN_E_MISSING_SERVICE                         = -26,
+        LOCKDOWN_E_INVALID_SERVICE                         = -27,
+        LOCKDOWN_E_SERVICE_LIMIT                           = -28,
+        LOCKDOWN_E_MISSING_PAIR_RECORD                     = -29,
+        LOCKDOWN_E_SAVE_PAIR_RECORD_FAILED                 = -30,
+        LOCKDOWN_E_INVALID_PAIR_RECORD                     = -31,
+        LOCKDOWN_E_INVALID_ACTIVATION_RECORD               = -32,
+        LOCKDOWN_E_MISSING_ACTIVATION_RECORD               = -33,
+        LOCKDOWN_E_SERVICE_PROHIBITED                      = -34,
+        LOCKDOWN_E_ESCROW_LOCKED                           = -35,
+        LOCKDOWN_E_UNKNOWN_ERROR                           = -256
 } lockdownd_error_t;
 
 typedef struct lockdownd_client_private lockdownd_client_private;
diff --git a/src/lockdown.c b/src/lockdown.c
index 29dde02..12cefa5 100644
--- a/src/lockdown.c
+++ b/src/lockdown.c
@@ -2,7 +2,7 @@
  * lockdown.c
  * com.apple.mobile.lockdownd service implementation.
  *
- * Copyright (c) 2014 Martin Szulecki All Rights Reserved.
+ * Copyright (c) 2009-2015 Martin Szulecki All Rights Reserved.
  * Copyright (c) 2014 Nikias Bassen. All Rights Reserved.
  * Copyright (c) 2010 Bryan Forbes All Rights Reserved.
  * Copyright (c) 2008 Zach C. All Rights Reserved.
@@ -57,8 +57,75 @@
 #define sleep(x) Sleep(x*1000)
 #endif
 
-#define RESULT_SUCCESS 0
-#define RESULT_FAILURE 1
+/**
+ * Convert an error string identifier to a lockdownd_error_t value.
+ * Used internally to get correct error codes from a response.
+ *
+ * @param name The error name to convert.
+ *
+ * @return A matching lockdownd_error_t error code,
+ *     LOCKDOWN_E_UNKNOWN_ERROR otherwise.
+ */
+static lockdownd_error_t lockdownd_strtoerr(const char* name)
+{
+        lockdownd_error_t err = LOCKDOWN_E_UNKNOWN_ERROR;
+
+        if (strcmp(name, "InvalidResponse") == 0) {
+                err = LOCKDOWN_E_INVALID_RESPONSE;
+        } else if (strcmp(name, "MissingKey") == 0) {
+                err = LOCKDOWN_E_MISSING_KEY;
+        } else if (strcmp(name, "MissingValue") == 0) {
+                err = LOCKDOWN_E_MISSING_VALUE;
+        } else if (strcmp(name, "GetProhibited") == 0) {
+                err = LOCKDOWN_E_GET_PROHIBITED;
+        } else if (strcmp(name, "SetProhibited") == 0) {
+                err = LOCKDOWN_E_SET_PROHIBITED;
+        } else if (strcmp(name, "RemoveProhibited") == 0) {
+                err = LOCKDOWN_E_REMOVE_PROHIBITED;
+        } else if (strcmp(name, "ImmutableValue") == 0) {
+                err = LOCKDOWN_E_IMMUTABLE_VALUE;
+        } else if (strcmp(name, "PasswordProtected") == 0) {
+                err = LOCKDOWN_E_PASSWORD_PROTECTED;
+        } else if (strcmp(name, "UserDeniedPairing") == 0) {
+                err = LOCKDOWN_E_USER_DENIED_PAIRING;
+        } else if (strcmp(name, "PairingDialogResponsePending") == 0) {
+                err = LOCKDOWN_E_PAIRING_DIALOG_RESPONSE_PENDING;
+        } else if (strcmp(name, "MissingHostID") == 0) {
+                err = LOCKDOWN_E_MISSING_HOST_ID;
+        } else if (strcmp(name, "InvalidHostID") == 0) {
+                err = LOCKDOWN_E_INVALID_HOST_ID;
+        } else if (strcmp(name, "SessionActive") == 0) {
+                err = LOCKDOWN_E_SESSION_ACTIVE;
+        } else if (strcmp(name, "SessionInactive") == 0) {
+                err = LOCKDOWN_E_SESSION_INACTIVE;
+        } else if (strcmp(name, "MissingSessionID") == 0) {
+                err = LOCKDOWN_E_MISSING_SESSION_ID;
+        } else if (strcmp(name, "InvalidSessionID") == 0) {
+                err = LOCKDOWN_E_INVALID_SESSION_ID;
+        } else if (strcmp(name, "MissingService") == 0) {
+                err = LOCKDOWN_E_MISSING_SERVICE;
+        } else if (strcmp(name, "InvalidService") == 0) {
+                err = LOCKDOWN_E_INVALID_SERVICE;
+        } else if (strcmp(name, "ServiceLimit") == 0) {
+                err = LOCKDOWN_E_SERVICE_LIMIT;
+        } else if (strcmp(name, "MissingPairRecord") == 0) {
+                err = LOCKDOWN_E_MISSING_PAIR_RECORD;
+        } else if (strcmp(name, "SavePairRecordFailed") == 0) {
+                err = LOCKDOWN_E_SAVE_PAIR_RECORD_FAILED;
+        } else if (strcmp(name, "InvalidPairRecord") == 0) {
+                err = LOCKDOWN_E_INVALID_PAIR_RECORD;
+        } else if (strcmp(name, "InvalidActivationRecord") == 0) {
+                err = LOCKDOWN_E_INVALID_ACTIVATION_RECORD;
+        } else if (strcmp(name, "MissingActivationRecord") == 0) {
+                err = LOCKDOWN_E_MISSING_ACTIVATION_RECORD;
+        } else if (strcmp(name, "ServiceProhibited") == 0) {
+                err = LOCKDOWN_E_SERVICE_PROHIBITED;
+        } else if (strcmp(name, "EscrowLocked") == 0) {
+                err = LOCKDOWN_E_ESCROW_LOCKED;
+        }
+
+        return err;
+}
 
 /**
  * Internally used function for checking the result from lockdown's answer
@@ -68,30 +135,34 @@
  * @param query_match Name of the request to match or NULL if no match is
  *        required.
  *
- * @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.
+ * @return LOCKDOWN_E_SUCCESS when the result is 'Success',
+ *         LOCKDOWN_E_UNKNOWN_ERROR when the result is 'Failure',
+ *         or a specific error code if derieved from the result.
  */
-static int lockdown_check_result(plist_t dict, const char *query_match)
+static lockdownd_error_t lockdown_check_result(plist_t dict, const char *query_match)
 {
-        int ret = -1;
+        lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
 
         plist_t query_node = plist_dict_get_item(dict, "Request");
         if (!query_node) {
                 return ret;
         }
+
         if (plist_get_node_type(query_node) != PLIST_STRING) {
                 return ret;
         } else {
                 char *query_value = NULL;
+
                 plist_get_string_val(query_node, &query_value);
                 if (!query_value) {
                         return ret;
                 }
+
                 if (query_match && (strcmp(query_value, query_match) != 0)) {
                         free(query_value);
                         return ret;
                 }
+
                 free(query_value);
         }
 
@@ -103,39 +174,43 @@ static int lockdown_check_result(plist_t dict, const char *query_match)
                 if (err_node) {
                         if (plist_get_node_type(err_node) == PLIST_STRING) {
                                 char *err_value = NULL;
+
                                 plist_get_string_val(err_node, &err_value);
                                 if (err_value) {
                                         debug_info("ERROR: %s", err_value);
+                                        ret = lockdownd_strtoerr(err_value);
                                         free(err_value);
                                 } else {
                                         debug_info("ERROR: unknown error occured");
                                 }
                         }
-                        return RESULT_FAILURE;
+                        return ret;
                 }
-                return RESULT_SUCCESS;
+
+                ret = LOCKDOWN_E_SUCCESS;
+
+                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;
+                                ret = LOCKDOWN_E_SUCCESS;
                         } else if (!strcmp(result_value, "Failure")) {
-                                ret = RESULT_FAILURE;
+                                ret = LOCKDOWN_E_UNKNOWN_ERROR;
                         } else {
                                 debug_info("ERROR: unknown result value '%s'", result_value);
                         }
                 }
+
                 if (result_value)
                         free(result_value);
         }
+
         return ret;
 }
 
@@ -185,10 +260,9 @@ LIBIMOBILEDEVICE_API lockdownd_error_t lockdownd_stop_session(lockdownd_client_t
                 return LOCKDOWN_E_PLIST_ERROR;
         }
 
-        ret = LOCKDOWN_E_UNKNOWN_ERROR;
-        if (lockdown_check_result(dict, "StopSession") == RESULT_SUCCESS) {
+        ret = lockdown_check_result(dict, "StopSession");
+        if (ret == LOCKDOWN_E_SUCCESS) {
                 debug_info("success");
-                ret = LOCKDOWN_E_SUCCESS;
         }
 
         plist_free(dict);
@@ -374,12 +448,11 @@ LIBIMOBILEDEVICE_API lockdownd_error_t lockdownd_get_value(lockdownd_client_t cl
         if (ret != LOCKDOWN_E_SUCCESS)
                 return ret;
 
-        if (lockdown_check_result(dict, "GetValue") == RESULT_SUCCESS) {
+        ret = lockdown_check_result(dict, "GetValue");
+        if (ret == LOCKDOWN_E_SUCCESS) {
                 debug_info("success");
-                ret = LOCKDOWN_E_SUCCESS;
-        } else {
-                ret = LOCKDOWN_E_UNKNOWN_ERROR;
         }
+
         if (ret != LOCKDOWN_E_SUCCESS) {
                 plist_free(dict);
                 return ret;
@@ -430,9 +503,9 @@ LIBIMOBILEDEVICE_API lockdownd_error_t lockdownd_set_value(lockdownd_client_t cl
         if (ret != LOCKDOWN_E_SUCCESS)
                 return ret;
 
-        if (lockdown_check_result(dict, "SetValue") == RESULT_SUCCESS) {
+        ret = lockdown_check_result(dict, "SetValue");
+        if (ret == LOCKDOWN_E_SUCCESS) {
                 debug_info("success");
-                ret = LOCKDOWN_E_SUCCESS;
         }
 
         if (ret != LOCKDOWN_E_SUCCESS) {
@@ -477,9 +550,9 @@ LIBIMOBILEDEVICE_API lockdownd_error_t lockdownd_remove_value(lockdownd_client_t
         if (ret != LOCKDOWN_E_SUCCESS)
                 return ret;
 
-        if (lockdown_check_result(dict, "RemoveValue") == RESULT_SUCCESS) {
+        ret = lockdown_check_result(dict, "RemoveValue");
+        if (ret == LOCKDOWN_E_SUCCESS) {
                 debug_info("success");
-                ret = LOCKDOWN_E_SUCCESS;
         }
 
         if (ret != LOCKDOWN_E_SUCCESS) {
@@ -641,7 +714,7 @@ LIBIMOBILEDEVICE_API lockdownd_error_t lockdownd_client_new_with_handshake(idevi
                 ret = lockdownd_pair(client_loc, NULL);
                 if (LOCKDOWN_E_SUCCESS == ret) {
                         ret = lockdownd_validate_pair(client_loc, NULL);
-                } else if (LOCKDOWN_E_PAIRING_DIALOG_PENDING == ret) {
+                } else if (LOCKDOWN_E_PAIRING_DIALOG_RESPONSE_PENDING == ret) {
                         debug_info("Device shows the pairing dialog.");
                 }
         }
@@ -762,7 +835,7 @@ leave:
 /**
  * Function used internally by lockdownd_pair() and lockdownd_validate_pair()
  *
- * @param client The lockdown client to pair with.
+ * @param client The lockdown client
  * @param pair_record The pair record to use for pairing. If NULL is passed, then
  *    the pair records from the current machine are used. New records will be
  *    generated automatically when pairing is done for the first time.
@@ -863,11 +936,11 @@ static lockdownd_error_t lockdownd_do_pair(lockdownd_client_t client, lockdownd_
         if (strcmp(verb, "Unpair") == 0) {
                 /* workaround for Unpair giving back ValidatePair,
                  * seems to be a bug in the device's fw */
-                if (lockdown_check_result(dict, NULL) != RESULT_SUCCESS) {
+                if (lockdown_check_result(dict, NULL) != LOCKDOWN_E_SUCCESS) {
                         ret = LOCKDOWN_E_PAIRING_FAILED;
                 }
         } else {
-                if (lockdown_check_result(dict, verb) != RESULT_SUCCESS) {
+                if (lockdown_check_result(dict, verb) != LOCKDOWN_E_SUCCESS) {
                         ret = LOCKDOWN_E_PAIRING_FAILED;
                 }
         }
@@ -915,15 +988,7 @@ static lockdownd_error_t lockdownd_do_pair(lockdownd_client_t client, lockdownd_
                         plist_get_string_val(error_node, &value);
                         if (value) {
                                 /* the first pairing fails if the device is password protected */
-                                if (!strcmp(value, "PasswordProtected")) {
-                                        ret = LOCKDOWN_E_PASSWORD_PROTECTED;
-                                } else if (!strcmp(value, "InvalidHostID")) {
-                                        ret = LOCKDOWN_E_INVALID_HOST_ID;
-                                } else if (!strcmp(value, "UserDeniedPairing")) {
-                                        ret = LOCKDOWN_E_USER_DENIED_PAIRING;
-                                } else if (!strcmp(value, "PairingDialogResponsePending")) {
-                                        ret = LOCKDOWN_E_PAIRING_DIALOG_PENDING;
-                                }
+                                ret = lockdownd_strtoerr(value);
                                 free(value);
                         }
 
@@ -982,12 +1047,14 @@ LIBIMOBILEDEVICE_API lockdownd_error_t lockdownd_enter_recovery(lockdownd_client
 
         ret = lockdownd_receive(client, &dict);
 
-        if (lockdown_check_result(dict, "EnterRecovery") == RESULT_SUCCESS) {
+        ret = lockdown_check_result(dict, "EnterRecovery");
+        if (ret == LOCKDOWN_E_SUCCESS) {
                 debug_info("success");
-                ret = LOCKDOWN_E_SUCCESS;
         }
+
         plist_free(dict);
         dict = NULL;
+
         return ret;
 }
 
@@ -1014,10 +1081,11 @@ LIBIMOBILEDEVICE_API lockdownd_error_t lockdownd_goodbye(lockdownd_client_t clie
                 return LOCKDOWN_E_PLIST_ERROR;
         }
 
-        if (lockdown_check_result(dict, "Goodbye") == RESULT_SUCCESS) {
+        ret = lockdown_check_result(dict, "Goodbye");
+        if (ret == LOCKDOWN_E_SUCCESS) {
                 debug_info("success");
-                ret = LOCKDOWN_E_SUCCESS;
         }
+
         plist_free(dict);
         dict = NULL;
 
@@ -1071,17 +1139,8 @@ LIBIMOBILEDEVICE_API lockdownd_error_t lockdownd_start_session(lockdownd_client_
         if (!dict)
                 return LOCKDOWN_E_PLIST_ERROR;
 
-        if (lockdown_check_result(dict, "StartSession") == RESULT_FAILURE) {
-                plist_t error_node = plist_dict_get_item(dict, "Error");
-                if (error_node && PLIST_STRING == plist_get_node_type(error_node)) {
-                        char *error = NULL;
-                        plist_get_string_val(error_node, &error);
-                        if (!strcmp(error, "InvalidHostID")) {
-                                ret = LOCKDOWN_E_INVALID_HOST_ID;
-                        }
-                        free(error);
-                }
-        } else {
+        ret = lockdown_check_result(dict, "StartSession");
+        if (ret == LOCKDOWN_E_SUCCESS) {
                 uint8_t use_ssl = 0;
 
                 plist_t enable_ssl = plist_dict_get_item(dict, "EnableSessionSSL");
@@ -1230,8 +1289,8 @@ static lockdownd_error_t lockdownd_do_start_service(lockdownd_client_t client, c
         if (!dict)
                 return LOCKDOWN_E_PLIST_ERROR;
 
-        ret = LOCKDOWN_E_UNKNOWN_ERROR;
-        if (lockdown_check_result(dict, "StartService") == RESULT_SUCCESS) {
+        ret = lockdown_check_result(dict, "StartService");
+        if (ret == LOCKDOWN_E_SUCCESS) {
                 if (*service == NULL)
                         *service = (lockdownd_service_descriptor_t)malloc(sizeof(struct lockdownd_service_descriptor));
                 (*service)->port = 0;
@@ -1260,24 +1319,18 @@ static lockdownd_error_t lockdownd_do_start_service(lockdownd_client_t client, c
                         (*service)->ssl_enabled = b;
                 }
         } else {
-                ret = LOCKDOWN_E_START_SERVICE_FAILED;
                 plist_t error_node = plist_dict_get_item(dict, "Error");
                 if (error_node && PLIST_STRING == plist_get_node_type(error_node)) {
                         char *error = NULL;
                         plist_get_string_val(error_node, &error);
-                        if (!strcmp(error, "InvalidService")) {
-                                ret = LOCKDOWN_E_INVALID_SERVICE;
-                        } else if (!strcmp(error, "ServiceLimit")) {
-                                ret = LOCKDOWN_E_SERVICE_LIMIT;
-                        } else if (!strcmp(error, "NoRunningSession")) {
-                                ret = LOCKDOWN_E_NO_RUNNING_SESSION;
-                        }
+                        ret = lockdownd_strtoerr(error);
                         free(error);
                 }
         }
 
         plist_free(dict);
         dict = NULL;
+
         return ret;
 }
 
@@ -1319,23 +1372,11 @@ LIBIMOBILEDEVICE_API lockdownd_error_t lockdownd_activate(lockdownd_client_t cli
                 return LOCKDOWN_E_PLIST_ERROR;
         }
 
-        ret = LOCKDOWN_E_ACTIVATION_FAILED;
-        if (lockdown_check_result(dict, "Activate") == RESULT_SUCCESS) {
+        ret = lockdown_check_result(dict, "Activate");
+        if (ret == LOCKDOWN_E_SUCCESS) {
                 debug_info("success");
-                ret = LOCKDOWN_E_SUCCESS;
-                
-        } else {
-                plist_t error_node = plist_dict_get_item(dict, "Error");
-                if (error_node && PLIST_STRING == plist_get_node_type(error_node)) {
-                        char *error = NULL;
-                        plist_get_string_val(error_node, &error);
-                        if (!strcmp(error, "InvalidActivationRecord")) {
-                                ret = LOCKDOWN_E_INVALID_ACTIVATION_RECORD;
-                        }
-                        free(error);
-                }
         }
-        
+
         plist_free(dict);
         dict = NULL;
 
@@ -1366,11 +1407,11 @@ LIBIMOBILEDEVICE_API lockdownd_error_t lockdownd_deactivate(lockdownd_client_t c
                 return LOCKDOWN_E_PLIST_ERROR;
         }
 
-        ret = LOCKDOWN_E_UNKNOWN_ERROR;
-        if (lockdown_check_result(dict, "Deactivate") == RESULT_SUCCESS) {
+        ret = lockdown_check_result(dict, "Deactivate");
+        if (ret == LOCKDOWN_E_SUCCESS) {
                 debug_info("success");
-                ret = LOCKDOWN_E_SUCCESS;
         }
+
         plist_free(dict);
         dict = NULL;