make all functions return an error code.

1 files changed, 52 insertions, 32 deletions

diff --git a/src/lockdown.c b/src/lockdown.c
index 179b0a9..a22b896 100644
--- a/src/lockdown.c
+++ b/src/lockdown.c
@@ -94,15 +94,18 @@ iphone_lckd_client_t new_lockdownd_client(iphone_device_t phone) {
  *
  * @param control The lockdown client
  */
-void iphone_lckd_free_client( iphone_lckd_client_t client ) {
-	if (!client) return;
+iphone_error_t iphone_lckd_free_client( iphone_lckd_client_t client ) {
+	if (!client) return IPHONE_E_INVALID_ARG;
+	iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+
 	if (client->connection) {
-		iphone_mux_free_client(client->connection);
+		ret = iphone_mux_free_client(client->connection);
 	}
 
 	if (client->ssl_session) gnutls_deinit(*client->ssl_session);
 	free(client->ssl_session);
 	free(client);
+	return ret;
 }
 
 /** Polls the iPhone for lockdownd data.
@@ -113,20 +116,28 @@ void iphone_lckd_free_client( iphone_lckd_client_t client ) {
  *
  * @return The number of bytes received
  */
-int iphone_lckd_recv ( iphone_lckd_client_t client, char **dump_data ) {
-	if (!client) return 0;
+iphone_error_t iphone_lckd_recv ( iphone_lckd_client_t client, char **dump_data, uint32_t *recv_bytes ) {
+	if (!client || dump_data || !recv_bytes) return IPHONE_E_INVALID_ARG;
+	iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
 	char *receive;
 	uint32 datalen = 0, bytes = 0;
 	
-	if (!client->in_SSL) bytes = iphone_mux_recv(client->connection, (char *)&datalen, sizeof(datalen));
-	else bytes = gnutls_record_recv(*client->ssl_session, &datalen, sizeof(datalen));
+	if (!client->in_SSL) ret = iphone_mux_recv(client->connection, (char *)&datalen, sizeof(datalen), &bytes);
+	else {
+		bytes = gnutls_record_recv(*client->ssl_session, &datalen, sizeof(datalen));
+		if (bytes > 0) ret = IPHONE_E_SUCCESS;
+	}
 	datalen = ntohl(datalen);
 	
 	receive = (char*)malloc(sizeof(char) * datalen);
-	if (!client->in_SSL) bytes = iphone_mux_recv(client->connection, receive, datalen);
-	else bytes = gnutls_record_recv(*client->ssl_session, receive, datalen);
+	if (!client->in_SSL) ret = iphone_mux_recv(client->connection, receive, datalen, &bytes);
+	else {
+		bytes = gnutls_record_recv(*client->ssl_session, receive, datalen);
+		if (bytes > 0) ret = IPHONE_E_SUCCESS;
+	}
 	*dump_data = receive;
-	return bytes;
+	*recv_bytes = bytes;
+	return ret;
 }
 
 /** Sends lockdownd data to the iPhone
@@ -140,11 +151,12 @@ int iphone_lckd_recv ( iphone_lckd_client_t client, char **dump_data ) {
  *
  * @return The number of bytes sent
  */
-int iphone_lckd_send ( iphone_lckd_client_t client, char *raw_data, uint32_t length ) {
-	if (!client) return 0;
+iphone_error_t iphone_lckd_send ( iphone_lckd_client_t client, char *raw_data, uint32_t length, uint32_t *sent_bytes ) {
+	if (!client || !raw_data || length == 0 || !sent_bytes) return IPHONE_E_INVALID_ARG;
 	char *real_query;
 	int bytes;
-	
+	iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
+
 	real_query = (char*)malloc(sizeof(char) * (length+4));
 	length = htonl(length);
 	memcpy(real_query, &length, sizeof(length));
@@ -157,11 +169,15 @@ int iphone_lckd_send ( iphone_lckd_client_t client, char *raw_data, uint32_t len
 		packet = NULL;
 	}
 	
-	if (!client->in_SSL) bytes = iphone_mux_send(client->connection, real_query, ntohl(length)+sizeof(length));
-	else gnutls_record_send(*client->ssl_session, real_query, ntohl(length)+sizeof(length));
+	if (!client->in_SSL) ret = iphone_mux_send(client->connection, real_query, ntohl(length)+sizeof(length), &bytes);
+	else {
+		gnutls_record_send(*client->ssl_session, real_query, ntohl(length)+sizeof(length));
+		ret = IPHONE_E_SUCCESS;
+	}
 	if (debug) printf("lockdownd_send(): sent it!\n");
 	free(real_query);
-	return bytes;
+	*sent_bytes = bytes;
+	return ret;
 }
 
 /** Initiates the handshake for the lockdown session. Part of the lockdownd handshake.
@@ -307,11 +323,11 @@ int lockdownd_get_device_public_key(iphone_lckd_client_t control, char **public_
  *
  * @return 1 on success and 0 on failure
  */
-int iphone_lckd_new_client ( iphone_device_t device, iphone_lckd_client_t *client )
+iphone_error_t iphone_lckd_new_client ( iphone_device_t device, iphone_lckd_client_t *client )
 {
 	if (!device || !client || (client && *client) )
 		return IPHONE_E_INVALID_ARG;
-	int ret = IPHONE_E_SUCCESS;
+	iphone_error_t ret = IPHONE_E_SUCCESS;
 	char *host_id = NULL;
 
 	iphone_lckd_client_t client_loc = new_lockdownd_client( device );
@@ -815,14 +831,15 @@ ssize_t lockdownd_securead(gnutls_transport_ptr_t transport, char *buffer, size_
  *
  * @return The port number the service was started on or 0 on failure.
  */
-int iphone_lckd_start_service ( iphone_lckd_client_t client, const char *service ) {
-	if (!client) return 0;
+iphone_error_t iphone_lckd_start_service ( iphone_lckd_client_t client, const char *service, int *port ) {
+	if (!client || !service || !port) return IPHONE_E_INVALID_ARG;
 
 	char* host_id = get_host_id();
-	if (host_id && !client->in_SSL && !lockdownd_start_SSL_session(client, host_id)) return 0;
+	if (!host_id) return IPHONE_E_INVALID_CONF;
+	if (!client->in_SSL && !lockdownd_start_SSL_session(client, host_id)) return IPHONE_E_SSL_ERROR;
 
 	char *XML_query, **dictionary;
-	uint32 length, i = 0, port = 0;
+	uint32 length, i = 0, port_loc = 0;
 	uint8 result = 0;
 
 	free(host_id);
@@ -832,9 +849,9 @@ int iphone_lckd_start_service ( iphone_lckd_client_t client, const char *service
 	xmlNode *dict = add_child_to_plist(plist, "dict", "\n", NULL, 0);
 	xmlNode *key;
 	key = add_key_str_dict_element(plist, dict, "Request", "StartService", 1);
-	if (!key) { xmlFreeDoc(plist); return 0; }
+	if (!key) { xmlFreeDoc(plist); return IPHONE_E_UNKNOWN_ERROR; }
 	key = add_key_str_dict_element(plist, dict, "Service", service, 1);
-	if (!key) { xmlFreeDoc(plist); return 0; }
+	if (!key) { xmlFreeDoc(plist); return IPHONE_E_UNKNOWN_ERROR; }
 	
 	xmlDocDumpMemory(plist, (xmlChar **)&XML_query, &length);
 	
@@ -845,24 +862,24 @@ int iphone_lckd_start_service ( iphone_lckd_client_t client, const char *service
 	
 	xmlFreeDoc(plist);
 	
-	if (length <= 0) return 0;
+	if (length <= 0) return IPHONE_E_NOT_ENOUGH_DATA;
 	else {
 		plist = xmlReadMemory(XML_query, length, NULL, NULL, 0);
-		if (!plist) return 0;
+		if (!plist) return IPHONE_E_UNKNOWN_ERROR;
 		dict = xmlDocGetRootElement(plist);
-		if (!dict) return 0;
+		if (!dict) return IPHONE_E_UNKNOWN_ERROR;
 		for (dict = dict->children; dict; dict = dict->next) {
 			if (!xmlStrcmp(dict->name, "dict")) break;
 		}
 		
-		if (!dict) return 0;
+		if (!dict) return IPHONE_E_UNKNOWN_ERROR;
 		dictionary = read_dict_element_strings(dict);
 		
 		for (i = 0; dictionary[i]; i+=2) {
 			if (debug) printf("lockdownd_start_service() dictionary %s: %s\n", dictionary[i], dictionary[i+1]);
 			
 			if (!xmlStrcmp(dictionary[i], "Port")) {
-				port = atoi(dictionary[i+1]);
+				port_loc = atoi(dictionary[i+1]);
 				if (debug) printf("lockdownd_start_service() atoi'd port: %i\n", port);
 			}
 			
@@ -882,9 +899,12 @@ int iphone_lckd_start_service ( iphone_lckd_client_t client, const char *service
 		free(XML_query);
 		xmlFreeDoc(plist);
 		free_dictionary(dictionary);
-		if (port && result) return port;
-		else return 0;
+		if (port && result) {
+			*port = port_loc;
+			return IPHONE_E_SUCCESS;
+		}
+		else return IPHONE_E_UNKNOWN_ERROR;
 	}
 	
-	return 0;
+	return IPHONE_E_UNKNOWN_ERROR;
 }