From f5e9d76ebd74999512ab73f44fabba86879b1c1f Mon Sep 17 00:00:00 2001 From: Martin Szulecki Date: Sat, 25 Jul 2009 02:40:25 +0200 Subject: Update lockdown API and introduce new error codes --- dev/afccheck.c | 9 +- dev/iphone_id.c | 6 +- dev/iphoneinfo.c | 6 +- dev/lckdclient.c | 15 ++- dev/main.c | 6 +- dev/msyncclient.c | 4 +- dev/syslog_relay.c | 6 +- include/libiphone/libiphone.h | 10 +- include/libiphone/lockdown.h | 51 ++++--- src/lockdown.c | 305 +++++++++++++++++++++--------------------- src/lockdown.h | 10 +- 11 files changed, 226 insertions(+), 202 deletions(-) diff --git a/dev/afccheck.c b/dev/afccheck.c index 0525417..370742b 100644 --- a/dev/afccheck.c +++ b/dev/afccheck.c @@ -104,13 +104,13 @@ int main(int argc, char *argv[]) return 1; } - if (IPHONE_E_SUCCESS != lockdownd_new_client(phone, &client)) { + if (LOCKDOWN_E_SUCCESS != lockdownd_client_new(phone, &client)) { iphone_free_device(phone); return 1; } - if (IPHONE_E_SUCCESS == lockdownd_start_service(client, "com.apple.afc", &port) && !port) { - lockdownd_free_client(client); + if (LOCKDOWN_E_SUCCESS == lockdownd_start_service(client, "com.apple.afc", &port) && !port) { + lockdownd_client_free(client); iphone_free_device(phone); fprintf(stderr, "Something went wrong when starting AFC."); return 1; @@ -136,8 +136,7 @@ int main(int argc, char *argv[]) g_thread_join(threads[i]); } - - lockdownd_free_client(client); + lockdownd_client_free(client); iphone_free_device(phone); return 0; diff --git a/dev/iphone_id.c b/dev/iphone_id.c index dde15bc..1b8f8a1 100644 --- a/dev/iphone_id.c +++ b/dev/iphone_id.c @@ -68,18 +68,18 @@ int main(int argc, char **argv) return -2; } - if (IPHONE_E_SUCCESS != lockdownd_new_client(phone, &client)) { + if (LOCKDOWN_E_SUCCESS != lockdownd_client_new(phone, &client)) { iphone_free_device(phone); fprintf(stderr, "ERROR: Connecting to device failed!\n"); return -2; } - if ((IPHONE_E_SUCCESS != lockdownd_get_device_name(client, &devname)) || !devname) { + if ((LOCKDOWN_E_SUCCESS != lockdownd_get_device_name(client, &devname)) || !devname) { fprintf(stderr, "ERROR: Could not get device name!\n"); ret = -2; } - lockdownd_free_client(client); + lockdownd_client_free(client); iphone_free_device(phone); if (ret == 0) { diff --git a/dev/iphoneinfo.c b/dev/iphoneinfo.c index 02b62d5..52d7c8a 100644 --- a/dev/iphoneinfo.c +++ b/dev/iphoneinfo.c @@ -136,13 +136,13 @@ int main(int argc, char *argv[]) } } - if (IPHONE_E_SUCCESS != lockdownd_new_client(phone, &client)) { + if (LOCKDOWN_E_SUCCESS != lockdownd_client_new(phone, &client)) { iphone_free_device(phone); return -1; } /* run query and output information */ - if(lockdownd_get_value(client, domain, key, &node) == IPHONE_E_SUCCESS) + if(lockdownd_get_value(client, domain, key, &node) == LOCKDOWN_E_SUCCESS) { if (plist_get_node_type(node) == PLIST_DICT) { if (plist_get_first_child(node)) @@ -169,7 +169,7 @@ int main(int argc, char *argv[]) if (domain != NULL) free(domain); - lockdownd_free_client(client); + lockdownd_client_free(client); iphone_free_device(phone); return 0; diff --git a/dev/lckdclient.c b/dev/lckdclient.c index 9518a6e..4dcb0b4 100644 --- a/dev/lckdclient.c +++ b/dev/lckdclient.c @@ -48,7 +48,7 @@ int main(int argc, char *argv[]) if (uuid) free(uuid); - if (IPHONE_E_SUCCESS != lockdownd_new_client(phone, &client)) { + if (LOCKDOWN_E_SUCCESS != lockdownd_client_new(phone, &client)) { iphone_free_device(phone); return -1; } @@ -76,7 +76,7 @@ int main(int argc, char *argv[]) if (!strcmp(*args, "get") && len >= 2) { plist_t value = NULL; - if (IPHONE_E_SUCCESS == lockdownd_get_value(client, len == 3 ? *(args + 1):NULL, len == 3 ? *(args + 2):*(args + 1), &value)) + if (LOCKDOWN_E_SUCCESS == lockdownd_get_value(client, len == 3 ? *(args + 1):NULL, len == 3 ? *(args + 2):*(args + 1), &value)) { char *xml = NULL; uint32_t length; @@ -93,8 +93,13 @@ int main(int argc, char *argv[]) if (!strcmp(*args, "start") && len == 2) { int port = 0; - lockdownd_start_service(client, *(args + 1), &port); - printf("%i\n", port); + if(LOCKDOWN_E_SUCCESS == lockdownd_start_service(client, *(args + 1), &port)) { + printf("started service %s on port %i\n", *(args + 1), port); + } + else + { + printf("failed to start service %s on device.\n", *(args + 1)); + } } } g_strfreev(args); @@ -103,7 +108,7 @@ int main(int argc, char *argv[]) cmd = NULL; } clear_history(); - lockdownd_free_client(client); + lockdownd_client_free(client); iphone_free_device(phone); return 0; diff --git a/dev/main.c b/dev/main.c index 33c60f9..69b0b80 100644 --- a/dev/main.c +++ b/dev/main.c @@ -87,14 +87,14 @@ int main(int argc, char *argv[]) if (uuid) free(uuid); - if (IPHONE_E_SUCCESS != lockdownd_new_client(phone, &client)) { + if (LOCKDOWN_E_SUCCESS != lockdownd_client_new(phone, &client)) { iphone_free_device(phone); printf("Exiting.\n"); return -1; } char *nnn = NULL; - if (IPHONE_E_SUCCESS == lockdownd_get_device_name(client, &nnn)) { + if (LOCKDOWN_E_SUCCESS == lockdownd_get_device_name(client, &nnn)) { printf("DeviceName : %s\n", nnn); free(nnn); } @@ -248,7 +248,7 @@ int main(int argc, char *argv[]) printf("All done.\n"); - lockdownd_free_client(client); + lockdownd_client_free(client); iphone_free_device(phone); return 0; diff --git a/dev/msyncclient.c b/dev/msyncclient.c index 7651002..6ab7c79 100644 --- a/dev/msyncclient.c +++ b/dev/msyncclient.c @@ -141,7 +141,7 @@ int main(int argc, char *argv[]) return -1; } - if (IPHONE_E_SUCCESS != lockdownd_new_client(phone, &client)) { + if (LOCKDOWN_E_SUCCESS != lockdownd_client_new(phone, &client)) { iphone_free_device(phone); return -1; } @@ -161,7 +161,7 @@ int main(int argc, char *argv[]) printf("All done.\n"); - lockdownd_free_client(client); + lockdownd_client_free(client); iphone_free_device(phone); return 0; diff --git a/dev/syslog_relay.c b/dev/syslog_relay.c index 09be6b8..0c41c94 100644 --- a/dev/syslog_relay.c +++ b/dev/syslog_relay.c @@ -100,15 +100,15 @@ int main(int argc, char *argv[]) } } - if (IPHONE_E_SUCCESS != lockdownd_new_client(phone, &client)) { + if (LOCKDOWN_E_SUCCESS != lockdownd_client_new(phone, &client)) { iphone_free_device(phone); return -1; } /* start syslog_relay service and retrieve port */ ret = lockdownd_start_service(client, "com.apple.syslog_relay", &port); - if ((ret == IPHONE_E_SUCCESS) && port) { - lockdownd_free_client(client); + if ((ret == LOCKDOWN_E_SUCCESS) && port) { + lockdownd_client_free(client); /* connect to socket relay messages */ diff --git a/include/libiphone/libiphone.h b/include/libiphone/libiphone.h index 9764a7e..895e809 100644 --- a/include/libiphone/libiphone.h +++ b/include/libiphone/libiphone.h @@ -32,7 +32,7 @@ extern "C" { #include #include -//general errors +/* Error Codes */ #define IPHONE_E_SUCCESS 0 #define IPHONE_E_INVALID_ARG -1 #define IPHONE_E_UNKNOWN_ERROR -2 @@ -41,14 +41,6 @@ extern "C" { #define IPHONE_E_NOT_ENOUGH_DATA -5 #define IPHONE_E_BAD_HEADER -6 -//lockdownd specific error -#define IPHONE_E_INVALID_CONF -7 -#define IPHONE_E_PAIRING_FAILED -8 -#define IPHONE_E_SSL_ERROR -9 -#define IPHONE_E_PLIST_ERROR -10 -#define IPHONE_E_DICT_ERROR -11 -#define IPHONE_E_START_SERVICE_FAILED -12 - //afc specific error #define IPHONE_E_AFC_ERROR -13 diff --git a/include/libiphone/lockdown.h b/include/libiphone/lockdown.h index 20ccf77..55c0cb7 100644 --- a/include/libiphone/lockdown.h +++ b/include/libiphone/lockdown.h @@ -27,25 +27,44 @@ extern "C" { #include +/* Error Codes */ +#define LOCKDOWN_E_SUCCESS 0 +#define LOCKDOWN_E_INVALID_ARG -1 +#define LOCKDOWN_E_INVALID_CONF -2 +#define LOCKDOWN_E_PLIST_ERROR -3 +#define LOCKDOWN_E_PAIRING_FAILED -4 +#define LOCKDOWN_E_SSL_ERROR -5 +#define LOCKDOWN_E_DICT_ERROR -6 +#define LOCKDOWN_E_START_SERVICE_FAILED -7 +#define LOCKDOWN_E_NOT_ENOUGH_DATA -8 +#define LOCKDOWN_E_SET_VALUE_PROHIBITED -9 +#define LOCKDOWN_E_GET_VALUE_PROHIBITED -10 +#define LOCKDOWN_E_REMOVE_VALUE_PROHIBITED -11 +#define LOCKDOWN_E_MUX_ERROR -12 + +#define LOCKDOWN_E_UNKNOWN_ERROR -256 + +typedef int16_t lockdownd_error_t; + struct lockdownd_client_int; typedef struct lockdownd_client_int *lockdownd_client_t; -//lockdownd related functions -iphone_error_t lockdownd_new_client (iphone_device_t device, lockdownd_client_t *client); -iphone_error_t lockdownd_free_client(lockdownd_client_t client); -iphone_error_t lockdownd_query_type(lockdownd_client_t client); -iphone_error_t lockdownd_get_value(lockdownd_client_t client, const char *domain, const char *key, plist_t *value); -iphone_error_t lockdownd_set_value(lockdownd_client_t client, const char *domain, const char *key, plist_t value); -iphone_error_t lockdownd_remove_value(lockdownd_client_t client, const char *domain, const char *key); -iphone_error_t lockdownd_start_service (lockdownd_client_t client, const char *service, int *port); -iphone_error_t lockdownd_stop_session(lockdownd_client_t client); -iphone_error_t lockdownd_send (lockdownd_client_t client, plist_t plist); -iphone_error_t lockdownd_recv (lockdownd_client_t client, plist_t *plist); -iphone_error_t lockdownd_pair(lockdownd_client_t client, char *uid, char *host_id); -iphone_error_t lockdownd_get_device_uid (lockdownd_client_t control, char **uid); -iphone_error_t lockdownd_get_device_name (lockdownd_client_t client, char **device_name); -iphone_error_t lockdownd_enter_recovery(lockdownd_client_t client); -iphone_error_t lockdownd_goodbye(lockdownd_client_t client); +/* Interface */ +lockdownd_error_t lockdownd_client_new(iphone_device_t device, lockdownd_client_t *client); +lockdownd_error_t lockdownd_client_free(lockdownd_client_t client); +lockdownd_error_t lockdownd_query_type(lockdownd_client_t client); +lockdownd_error_t lockdownd_get_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); +lockdownd_error_t lockdownd_remove_value(lockdownd_client_t client, const char *domain, const char *key); +lockdownd_error_t lockdownd_start_service(lockdownd_client_t client, const char *service, int *port); +lockdownd_error_t lockdownd_stop_session(lockdownd_client_t client); +lockdownd_error_t lockdownd_send(lockdownd_client_t client, plist_t plist); +lockdownd_error_t lockdownd_recv(lockdownd_client_t client, plist_t *plist); +lockdownd_error_t lockdownd_pair(lockdownd_client_t client, char *uuid, char *host_id); +lockdownd_error_t lockdownd_get_device_uuid(lockdownd_client_t control, char **uuid); +lockdownd_error_t lockdownd_get_device_name(lockdownd_client_t client, char **device_name); +lockdownd_error_t lockdownd_enter_recovery(lockdownd_client_t client); +lockdownd_error_t lockdownd_goodbye(lockdownd_client_t client); #ifdef __cplusplus } diff --git a/src/lockdown.c b/src/lockdown.c index 757a94a..29e5046 100644 --- a/src/lockdown.c +++ b/src/lockdown.c @@ -126,13 +126,15 @@ 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) { 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"); @@ -151,13 +153,13 @@ iphone_error_t lockdownd_stop_session(lockdownd_client_t client) if (!dict) { log_dbg_msg(DBGMASK_LOCKDOWND, "%s: LOCKDOWN_E_PLIST_ERROR\n", __func__); - 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, "StopSession") == RESULT_SUCCESS) { log_dbg_msg(DBGMASK_LOCKDOWND, "%s: success\n", __func__); - ret = IPHONE_E_SUCCESS; + ret = LOCKDOWN_E_SUCCESS; } plist_free(dict); dict = NULL; @@ -171,14 +173,16 @@ 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, "%s: invalid argument!\n", __func__); - return IPHONE_E_INVALID_ARG; + 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, "%s: stopping SSL session\n", __func__); @@ -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,32 +259,32 @@ 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, "%s: received msg size: %i, buffer follows:\n%s", __func__, received_bytes, receive); @@ -286,7 +292,7 @@ iphone_error_t lockdownd_recv(lockdownd_client_t client, plist_t *plist) free(receive); if (!*plist) - ret = IPHONE_E_PLIST_ERROR; + ret = LOCKDOWN_E_PLIST_ERROR; return ret; } @@ -299,17 +305,17 @@ 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, "%s: sending msg size %i, buffer follows:\n%s", __func__, length, XMLContent); @@ -327,13 +333,13 @@ 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) { + if (ret == LOCKDOWN_E_SUCCESS) { log_dbg_msg(DBGMASK_LOCKDOWND, "%s: sent it!\n", __func__); } else { log_dbg_msg(DBGMASK_LOCKDOWND, "%s: sending failed!\n", __func__); @@ -347,14 +353,14 @@ 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"); @@ -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, "%s: success\n", __func__); - ret = IPHONE_E_SUCCESS; + 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; } @@ -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,23 +675,24 @@ 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 (LOCKDOWN_E_SUCCESS != lockdownd_query_type(client_loc)) { log_debug_msg("%s: QueryType failed in the lockdownd client.\n", __func__); - ret = IPHONE_E_NOT_ENOUGH_DATA; + ret = LOCKDOWN_E_NOT_ENOUGH_DATA; } char *uuid = NULL; ret = iphone_device_get_uuid(device, &uuid); - if (IPHONE_E_SUCCESS != ret) { + if (LOCKDOWN_E_SUCCESS != ret) { log_debug_msg("%s: failed to get device uuid.\n", __func__); } log_debug_msg("%s: device uuid: %s\n", __func__, uuid); userpref_get_host_id(&host_id); - if (IPHONE_E_SUCCESS == ret && !host_id) { - ret = IPHONE_E_INVALID_CONF; + if (LOCKDOWN_E_SUCCESS == ret && !host_id) { + ret = LOCKDOWN_E_INVALID_CONF; } - if (IPHONE_E_SUCCESS == ret && !userpref_has_device_public_key(uuid)) + if (LOCKDOWN_E_SUCCESS == ret && !userpref_has_device_public_key(uuid)) ret = lockdownd_pair(client_loc, uuid, host_id); if (uuid) { @@ -693,10 +700,10 @@ iphone_error_t lockdownd_new_client(iphone_device_t device, lockdownd_client_t * 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; + if (LOCKDOWN_E_SUCCESS != ret) { + ret = LOCKDOWN_E_SSL_ERROR; log_debug_msg("%s: SSL Session opening failed.\n", __func__); } @@ -705,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; } @@ -715,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; @@ -729,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) { + if (ret != LOCKDOWN_E_SUCCESS) { log_debug_msg("%s: device refused to send public key.\n", __func__); return ret; } 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; } @@ -762,28 +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) { + 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, "%s: pair failure\n", __func__); - ret = IPHONE_E_PAIRING_FAILED; + ret = LOCKDOWN_E_PAIRING_FAILED; } free(public_key.data); return ret; @@ -794,14 +801,14 @@ 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"); @@ -817,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; @@ -830,14 +837,14 @@ 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"); @@ -852,12 +859,12 @@ iphone_error_t lockdownd_goodbye(lockdownd_client_t client) ret = lockdownd_recv(client, &dict); if (!dict) { log_dbg_msg(DBGMASK_LOCKDOWND, "%s: did not get goodbye response back\n", __func__); - return IPHONE_E_PLIST_ERROR; + return LOCKDOWN_E_PLIST_ERROR; } if (lockdown_check_result(dict, "Goodbye") == RESULT_SUCCESS) { log_dbg_msg(DBGMASK_LOCKDOWND, "%s: success\n", __func__); - ret = IPHONE_E_SUCCESS; + ret = LOCKDOWN_E_SUCCESS; } plist_free(dict); dict = NULL; @@ -867,14 +874,14 @@ 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 }; @@ -903,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); @@ -913,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") }; @@ -945,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); @@ -979,13 +986,13 @@ iphone_error_t lockdownd_gen_pair_cert(gnutls_datum_t public_key, gnutls_datum_t switch(uret) { case USERPREF_E_INVALID_ARG: - ret = IPHONE_E_INVALID_ARG; + ret = LOCKDOWN_E_INVALID_ARG; break; case USERPREF_E_INVALID_CONF: - ret = IPHONE_E_INVALID_CONF; + ret = LOCKDOWN_E_INVALID_CONF; break; case USERPREF_E_SSL_ERROR: - ret = IPHONE_E_SSL_ERROR; + ret = LOCKDOWN_E_SSL_ERROR; default: break; } @@ -1005,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 */ @@ -1026,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"); @@ -1046,8 +1053,8 @@ iphone_error_t lockdownd_start_ssl_session(lockdownd_client_t client, const char char *host_id = NULL; userpref_get_host_id(&host_id); - if (IPHONE_E_SUCCESS == lockdownd_get_device_uuid(client, &uuid) ) { - if (IPHONE_E_SUCCESS == lockdownd_pair(client, uuid, 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(); @@ -1070,7 +1077,7 @@ iphone_error_t lockdownd_start_ssl_session(lockdownd_client_t client, const char } } - 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; @@ -1114,13 +1121,13 @@ iphone_error_t lockdownd_start_ssl_session(lockdownd_client_t client, const char log_dbg_msg(DBGMASK_LOCKDOWND, "%s: GnuTLS reported something wrong.\n", __func__); gnutls_perror(return_me); log_dbg_msg(DBGMASK_LOCKDOWND, "%s: oh.. errno says %s\n", __func__, strerror(errno)); - return IPHONE_E_SSL_ERROR; + 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) { @@ -1133,7 +1140,7 @@ 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, "%s: SessionID: %s\n", __func__, client->session_id); } @@ -1145,11 +1152,11 @@ 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; log_dbg_msg(DBGMASK_LOCKDOWND, "%s: Apparently failed negotiating with lockdownd.\n", __func__); - return IPHONE_E_SSL_ERROR; + return LOCKDOWN_E_SSL_ERROR; } /** gnutls callback for writing data to the iPhone. @@ -1196,7 +1203,7 @@ ssize_t lockdownd_securead(gnutls_transport_ptr_t transport, char *buffer, size_ // 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; } @@ -1230,23 +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 = 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; @@ -1262,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); @@ -1287,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; diff --git a/src/lockdown.h b/src/lockdown.h index 185d27a..1e193f6 100644 --- a/src/lockdown.h +++ b/src/lockdown.h @@ -24,6 +24,7 @@ #include #include + #include "libiphone/lockdown.h" struct lockdownd_client_int { @@ -33,13 +34,14 @@ struct lockdownd_client_int { char session_id[40]; }; -iphone_error_t lockdownd_get_device_public_key(lockdownd_client_t client, gnutls_datum_t * public_key); -iphone_error_t lockdownd_gen_pair_cert(gnutls_datum_t public_key, gnutls_datum_t * device_cert, +lockdownd_error_t lockdownd_get_device_public_key(lockdownd_client_t client, gnutls_datum_t * public_key); +lockdownd_error_t lockdownd_gen_pair_cert(gnutls_datum_t public_key, gnutls_datum_t * device_cert, gnutls_datum_t * host_cert, gnutls_datum_t * root_cert); -// SSL functions -iphone_error_t lockdownd_start_ssl_session(lockdownd_client_t client, const char *HostID); +/* SSL functions */ +lockdownd_error_t lockdownd_start_ssl_session(lockdownd_client_t client, const char *HostID); ssize_t lockdownd_securead(gnutls_transport_ptr_t transport, char *buffer, size_t length); ssize_t lockdownd_secuwrite(gnutls_transport_ptr_t transport, char *buffer, size_t length); + #endif -- cgit v1.1-32-gdbae