migrate lockdown.c

2 files changed, 69 insertions, 65 deletions

diff --git a/src/lockdown.c b/src/lockdown.c
index 7cee12e..bc70d53 100644
--- a/src/lockdown.c
+++ b/src/lockdown.c
@@ -74,9 +74,9 @@ char *lockdownd_generate_hostid() {
  *
  * @return The lockdownd client.
  */
-lockdownd_client *new_lockdownd_client(iPhone *phone) {
+iphone_lckd_client_t new_lockdownd_client(iphone_device_t phone) {
 	if (!phone) return NULL;
-	lockdownd_client *control = (lockdownd_client*)malloc(sizeof(lockdownd_client));
+	iphone_lckd_client_t control = (iphone_lckd_client_t)malloc(sizeof(struct iphone_lckd_client_int));
 	control->connection = mux_connect(phone, 0x0a00, 0xf27e);
 	if (!control->connection) {
 		free(control);
@@ -94,15 +94,15 @@ lockdownd_client *new_lockdownd_client(iPhone *phone) {
  *
  * @param control The lockdown client
  */
-void lockdownd_close(lockdownd_client *control) {
-	if (!control) return;
-	if (control->connection) {
-		mux_close_connection(control->connection);
+void iphone_lckd_free_client( iphone_lckd_client_t client ) {
+	if (!client) return;
+	if (client->connection) {
+		mux_close_connection(client->connection);
 	}
-	
-	if (control->ssl_session) gnutls_deinit(*control->ssl_session);
-	free(control->ssl_session);
-	free(control);
+
+	if (client->ssl_session) gnutls_deinit(*control->ssl_session);
+	free(client->ssl_session);
+	free(client);
 }
 
 /** Polls the iPhone for lockdownd data.
@@ -113,18 +113,18 @@ void lockdownd_close(lockdownd_client *control) {
  *
  * @return The number of bytes received
  */
-int lockdownd_recv(lockdownd_client *control, char **dump_data) {
-	if (!control) return 0;
+int iphone_lckd_recv ( iphone_lckd_client_t client, char **dump_data ) {
+	if (!client) return 0;
 	char *receive;
 	uint32 datalen = 0, bytes = 0;
 	
-	if (!control->in_SSL) bytes = mux_recv(control->connection, (char *)&datalen, sizeof(datalen));
-	else bytes = gnutls_record_recv(*control->ssl_session, &datalen, sizeof(datalen));
+	if (!client->in_SSL) bytes = mux_recv(client->connection, (char *)&datalen, sizeof(datalen));
+	else bytes = gnutls_record_recv(*client->ssl_session, &datalen, sizeof(datalen));
 	datalen = ntohl(datalen);
 	
 	receive = (char*)malloc(sizeof(char) * datalen);
-	if (!control->in_SSL) bytes = mux_recv(control->connection, receive, datalen);
-	else bytes = gnutls_record_recv(*control->ssl_session, receive, datalen);
+	if (!client->in_SSL) bytes = mux_recv(client->connection, receive, datalen);
+	else bytes = gnutls_record_recv(*client->ssl_session, receive, datalen);
 	*dump_data = receive;
 	return bytes;
 }
@@ -140,8 +140,8 @@ int lockdownd_recv(lockdownd_client *control, char **dump_data) {
  *
  * @return The number of bytes sent
  */
-int lockdownd_send(lockdownd_client *control, char *raw_data, uint32 length) {
-	if (!control) return 0;
+int iphone_lckd_send ( iphone_lckd_client_t client, char *raw_data, uint32_t length ) {
+	if (!client) return 0;
 	char *real_query;
 	int bytes;
 	
@@ -157,8 +157,8 @@ int lockdownd_send(lockdownd_client *control, char *raw_data, uint32 length) {
 		packet = NULL;
 	}
 	
-	if (!control->in_SSL) bytes = mux_send(control->connection, real_query, ntohl(length)+sizeof(length));
-	else gnutls_record_send(*control->ssl_session, real_query, ntohl(length)+sizeof(length));
+	if (!client->in_SSL) bytes = mux_send(client->connection, real_query, ntohl(length)+sizeof(length));
+	else gnutls_record_send(*client->ssl_session, real_query, ntohl(length)+sizeof(length));
 	if (debug) printf("lockdownd_send(): sent it!\n");
 	free(real_query);
 	return bytes;
@@ -172,7 +172,7 @@ int lockdownd_send(lockdownd_client *control, char *raw_data, uint32 length) {
  *
  * @return 1 on success and 0 on failure.
  */
-int lockdownd_hello(lockdownd_client *control) {
+int lockdownd_hello(iphone_lckd_client_t control) {
 	if (!control) return 0;
 	xmlDocPtr plist = new_plist();
 	xmlNode *dict, *key;
@@ -223,7 +223,7 @@ int lockdownd_hello(lockdownd_client *control) {
  *
  * @return 1 on success and 0 on failure.
  */
-int lockdownd_generic_get_value(lockdownd_client *control, char *req_key, char **value)
+int lockdownd_generic_get_value(iphone_lckd_client_t control, char *req_key, char **value)
 {
 	xmlDocPtr plist = new_plist();
 	xmlNode *dict = NULL;
@@ -284,7 +284,7 @@ int lockdownd_generic_get_value(lockdownd_client *control, char *req_key, char *
  *
  * @return 1 on success and 0 on failure.
  */
-int lockdownd_get_device_uid(lockdownd_client *control, char **uid)
+int lockdownd_get_device_uid(lockdownd_client_t control, char **uid)
 {
 	return lockdownd_generic_get_value(control, "UniqueDeviceID", uid);
 }
@@ -295,7 +295,7 @@ int lockdownd_get_device_uid(lockdownd_client *control, char **uid)
  *
  * @return 1 on success and 0 on failure.
  */
-int lockdownd_get_device_public_key(lockdownd_client *control, char **public_key)
+int lockdownd_get_device_public_key(lockdownd_client_t control, char **public_key)
 {
 	return lockdownd_generic_get_value(control, "DevicePublicKey", public_key);
 }
@@ -307,42 +307,45 @@ int lockdownd_get_device_public_key(lockdownd_client *control, char **public_key
  *
  * @return 1 on success and 0 on failure
  */
-int lockdownd_init(iPhone_t phone, lockdownd_client_t *control)
+int iphone_lckd_new_client ( iphone_device_t device, iphone_lckd_client_t *client )
 {
-	int ret = 0;
+	if (!device || !client || (client && *client) )
+		return IPHONE_E_INVALID_ARG;
+	int ret = IPHONE_E_SUCCESS;
 	char *host_id = NULL;
 
-	if (!phone)
-		return 0;
-
-	lockdownd_client *control_loc = new_lockdownd_client( (iPhone*)phone );
-	if (!lockdownd_hello(control_loc)){
+	iphone_lckd_client_t client_loc = new_lockdownd_client( device );
+	if (!lockdownd_hello(client_loc)){
 		fprintf(stderr, "Hello failed in the lockdownd client.\n");
+		ret = IPHONE_E_NOT_ENOUGH_DATA;
 	}
 
+
 	char *uid = NULL;
-	if(!lockdownd_get_device_uid(control_loc, &uid)){
-		fprintf(stderr, "Device refused to send public key.\n");
+	if(IPHONE_E_SUCCESS == ret && !lockdownd_get_device_uid(control_loc, &uid)){
+		fprintf(stderr, "Device refused to send uid.\n");
+		ret = IPHONE_E_NOT_ENOUGH_DATA;
 	}
 
 	host_id = get_host_id();
+	if (IPHONE_E_SUCCESS == ret && !host_id){
+		fprintf(stderr, "No HostID found, run libiphone-initconf.\n");
+		ret = IPHONE_E_INVALID_CONF;
+	}
 
-	if (!is_device_known(uid))
+	if (IPHONE_E_SUCCESS == ret && !is_device_known(uid))
 		ret = lockdownd_pair_device(*control, uid, host_id);
-	else 
-		ret = 1;
 
 	if (uid) {
 		free(uid);
 		uid = NULL;
 	}
-	
 
-	if (ret && host_id && lockdownd_start_SSL_session(control_loc, host_id)) {
-		ret = 1;
+	if (IPHONE_E_SUCCESS == ret && !lockdownd_start_SSL_session(client_loc, host_id)) {
+		ret = IPHONE_E_SUCCESS;
 	} else {
-		ret = 0;
-		fprintf(stderr, "lockdownd_init: SSL Session opening failed, has libiphone-initconf been run?\n");
+		ret = IPHONE_E_SSL_ERROR;
+		fprintf(stderr, "SSL Session opening failed.\n");
 	}
 
 	if (host_id) {
@@ -350,8 +353,8 @@ int lockdownd_init(iPhone_t phone, lockdownd_client_t *control)
 		host_id = NULL;
 	}
 
-	*control = (lockdownd_client_t)control_loc;
-
+	if (IPHONE_E_SUCCESS == ret)
+		*client = client_loc;
 	return ret;
 }
 
@@ -362,7 +365,7 @@ int lockdownd_init(iPhone_t phone, lockdownd_client_t *control)
  *
  * @return 1 on success and 0 on failure
  */
-int lockdownd_pair_device(lockdownd_client *control, char *uid, char *host_id)
+int lockdownd_pair_device(iphone_lckd_client_t control, char *uid, char *host_id)
 {
 	int ret = 0;
 	xmlDocPtr plist = new_plist();
@@ -596,7 +599,7 @@ int lockdownd_gen_pair_cert(char *public_key_b64, char **device_cert_b64, char *
  *
  * @return 1 on success and 0 on failure
  */
-int lockdownd_start_SSL_session(lockdownd_client *control, const char *HostID) {
+int lockdownd_start_SSL_session(iphone_lckd_client_t control, const char *HostID) {
 	xmlDocPtr plist = new_plist();
 	xmlNode *dict = add_child_to_plist(plist, "dict", "\n", NULL, 0);
 	xmlNode *key;
@@ -714,8 +717,8 @@ int lockdownd_start_SSL_session(lockdownd_client *control, const char *HostID) {
  */
 ssize_t lockdownd_secuwrite(gnutls_transport_ptr_t transport, char *buffer, size_t length) {
 	int bytes = 0;
-	lockdownd_client *control;
-	control = (lockdownd_client*)transport;
+	iphone_lckd_client_t control;
+	control = (iphone_lckd_client_t)transport;
 	if (debug) printf("lockdownd_secuwrite() called\n");
 	if (debug) printf("pre-send\nlength = %zi\n", length);
 	bytes = mux_send(control->connection, buffer, length);
@@ -742,8 +745,8 @@ ssize_t lockdownd_secuwrite(gnutls_transport_ptr_t transport, char *buffer, size
 ssize_t lockdownd_securead(gnutls_transport_ptr_t transport, char *buffer, size_t length) {
 	int bytes = 0, pos_start_fill = 0;
 	char *hackhackhack = NULL; 
-	lockdownd_client *control;
-	control = (lockdownd_client*)transport;
+	iphone_lckd_client_t control;
+	control = (iphone_lckd_client_t)transport;
 	if (debug) printf("lockdownd_securead() called\nlength = %zi\n", length);
 	// Buffering hack! Throw what we've got in our "buffer" into the stream first, then get more.
 	if (control->gtls_buffer_hack_len > 0) {
@@ -812,11 +815,11 @@ 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 lockdownd_start_service(lockdownd_client *control, const char *service) {
-	if (!control) return 0;
+int iphone_lckd_start_service ( iphone_lckd_client_t client, const char *service ) {
+	if (!client) return 0;
 
 	char* host_id = get_host_id();
-	if (host_id && !control->in_SSL && !lockdownd_start_SSL_session(control, host_id)) return 0;
+	if (host_id && !client->in_SSL && !lockdownd_start_SSL_session(client, host_id)) return 0;
 
 	char *XML_query, **dictionary;
 	uint32 length, i = 0, port = 0;
@@ -835,10 +838,10 @@ int lockdownd_start_service(lockdownd_client *control, const char *service) {
 	
 	xmlDocDumpMemory(plist, (xmlChar **)&XML_query, &length);
 	
-	lockdownd_send(control, XML_query, length);
+	lockdownd_send(client, XML_query, length);
 	free(XML_query);
 	
-	length = lockdownd_recv(control, &XML_query);
+	length = lockdownd_recv(client, &XML_query);
 	
 	xmlFreeDoc(plist);
 	
diff --git a/src/lockdown.h b/src/lockdown.h
index 9893e8e..1c83ab3 100644
--- a/src/lockdown.h
+++ b/src/lockdown.h
@@ -32,29 +32,30 @@
 
 
 
-typedef struct lockdownd_client_s {
+struct iphone_lckd_client_int {
 	usbmux_connection *connection;
 	gnutls_session_t *ssl_session;
 	int in_SSL;
 	char *gtls_buffer_hack;
 	int gtls_buffer_hack_len;
-} lockdownd_client;
+};
 
 char *lockdownd_generate_hostid();
 
-lockdownd_client *new_lockdownd_client(iPhone *phone);
-int lockdownd_hello(lockdownd_client *control);
-int lockdownd_get_device_uid(lockdownd_client *control, char **uid);
-int lockdownd_get_device_public_key(lockdownd_client *control, char **public_key);
+iphone_lckd_client_t new_lockdownd_client(iphone_device_t phone);
+int lockdownd_hello(iphone_lckd_client_t control);
+int lockdownd_get_device_uid(iphone_lckd_client_t control, char **uid);
+int lockdownd_get_device_public_key(iphone_lckd_client_t control, char **public_key);
+
 int lockdownd_gen_pair_cert(char *public_key_b64, char **device_cert_b64, char **host_cert_b64, char **root_cert_b64);
-int lockdownd_pair_device(lockdownd_client *control, char *uid, char *host_id);
-int lockdownd_recv(lockdownd_client *control, char **dump_data);
-int lockdownd_send(lockdownd_client *control, char *raw_data, uint32 length);
-void lockdownd_close(lockdownd_client *control);
+int lockdownd_pair_device(iphone_lckd_client_t control, char *public_key, char *host_id);
+int lockdownd_recv(iphone_lckd_client_t control, char **dump_data);
+int lockdownd_send(iphone_lckd_client_t control, char *raw_data, uint32 length);
+void lockdownd_close(iphone_lckd_client_t control);
 
 // SSL functions
 
-int lockdownd_start_SSL_session(lockdownd_client *control, const char *HostID);
+int lockdownd_start_SSL_session(iphone_lckd_client_t control, 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);