afc: refactor afc_dispatch_packet and improve afc_file_write performance

1 files changed, 109 insertions, 252 deletions

diff --git a/src/afc.c b/src/afc.c
index bdfa30e..1eff9ac 100644
--- a/src/afc.c
+++ b/src/afc.c
@@ -173,20 +173,17 @@ afc_error_t afc_client_free(afc_client_t client)
  * Dispatches an AFC packet over a client.
  * 
  * @param client The client to send data through.
- * @param data The data to send.
- * @param length The length to send.
- * @param bytes_sent The number of bytes actually sent.
+ * @param operation The operation to perform.
+ * @param data The data to send together with the header.
+ * @param data_length The length of the data to send with the header.
+ * @param payload The data to send after the header has been sent.
+ * @param payload_length The length of data to send after the header.
+ * @param bytes_sent The total number of bytes actually sent.
  *
  * @return AFC_E_SUCCESS on success or an AFC_E_* error value.
- * 
- * @warning set client->afc_packet->this_length and
- *          client->afc_packet->entire_length to 0 before calling this.  The
- *          reason is that if you set them to different values, it indicates
- *          you want to send the data as two packets.
  */
-static afc_error_t afc_dispatch_packet(afc_client_t client, const char *data, uint32_t length, uint32_t *bytes_sent)
+static afc_error_t afc_dispatch_packet(afc_client_t client, uint64_t operation, const char *data, uint32_t data_length, const char* payload, uint32_t payload_length, uint32_t *bytes_sent)
 {
-	uint32_t offset = 0;
 	uint32_t sent = 0;
 
 	if (!client || !client->parent || !client->afc_packet)
@@ -194,117 +191,89 @@ static afc_error_t afc_dispatch_packet(afc_client_t client, const char *data, ui
 
 	*bytes_sent = 0;
 
-	if (!data || !length)
-		length = 0;
+	if (!data || !data_length)
+		data_length = 0;
+	if (!payload || !payload_length)
+		payload_length = 0;
 
 	client->afc_packet->packet_num++;
-	if (!client->afc_packet->entire_length) {
-		client->afc_packet->entire_length = (length) ? sizeof(AFCPacket) + length : sizeof(AFCPacket);
-		client->afc_packet->this_length = client->afc_packet->entire_length;
-	}
-	if (!client->afc_packet->this_length) {
-		client->afc_packet->this_length = sizeof(AFCPacket);
-	}
-	/* We want to send two segments; buffer+sizeof(AFCPacket) to this_length
-	   is the parameters and everything beyond that is the next packet.
-	   (for writing) */
-	if (client->afc_packet->this_length != client->afc_packet->entire_length) {
-		offset = client->afc_packet->this_length - sizeof(AFCPacket);
-
-		debug_info("Offset: %i", offset);
-		if ((length) < (client->afc_packet->entire_length - client->afc_packet->this_length)) {
-			debug_info("Length did not resemble what it was supposed to based on packet");
-			debug_info("length minus offset: %i", length - offset);
-			debug_info("rest of packet: %i", client->afc_packet->entire_length - client->afc_packet->this_length);
-			return AFC_E_INTERNAL_ERROR;
-		}
+	client->afc_packet->operation = operation;
+	client->afc_packet->entire_length = sizeof(AFCPacket) + data_length + payload_length;
+	client->afc_packet->this_length = sizeof(AFCPacket) + data_length;
 
-		/* send AFC packet header */
-		AFCPacket_to_LE(client->afc_packet);
-		sent = 0;
-		service_send(client->parent, (void*)client->afc_packet, sizeof(AFCPacket), &sent);
-		AFCPacket_from_LE(client->afc_packet);
-		if (sent == 0) {
-			/* FIXME: should this be handled as success?! */
-			return AFC_E_SUCCESS;
-		}
-		*bytes_sent += sent;
-
-		/* send AFC packet data */
-		sent = 0;
-		service_send(client->parent, data, offset, &sent);
-		if (sent == 0) {
-			return AFC_E_SUCCESS;
-		}
-		*bytes_sent += sent;
+	debug_info("packet length = %i", client->afc_packet->this_length);
 
-		debug_info("sent the first now go with the second");
-		debug_info("Length: %i", length - offset);
-		debug_info("Buffer: ");
-		debug_buffer(data + offset, length - offset);
+	debug_buffer((char*)client->afc_packet, sizeof(AFCPacket));
 
-		sent = 0;
-		service_send(client->parent, data + offset, length - offset, &sent);
-
-		*bytes_sent = sent;
+	/* send AFC packet header */
+	AFCPacket_to_LE(client->afc_packet);
+	sent = 0;
+	service_send(client->parent, (void*)client->afc_packet, sizeof(AFCPacket), &sent);
+	AFCPacket_from_LE(client->afc_packet);
+	*bytes_sent += sent;
+	if (sent < sizeof(AFCPacket)) {
 		return AFC_E_SUCCESS;
-	} else {
-		debug_info("doin things the old way");
-		debug_info("packet length = %i", client->afc_packet->this_length);
+	}
 
-		debug_buffer((char*)client->afc_packet, sizeof(AFCPacket));
+	/* send AFC packet data (if there's data to send) */
+	sent = 0;
+	if (data_length > 0) {
+		debug_info("packet data follows");
+		debug_buffer(data, data_length);
+		service_send(client->parent, data, data_length, &sent);
+	}
+	*bytes_sent += sent;
+	if (sent < data_length) {
+		return AFC_E_SUCCESS;
+	}
 
-		/* send AFC packet header */
-		AFCPacket_to_LE(client->afc_packet);
-		sent = 0;
-		service_send(client->parent, (void*)client->afc_packet, sizeof(AFCPacket), &sent);
-		AFCPacket_from_LE(client->afc_packet);
-		if (sent == 0) {
-			return AFC_E_SUCCESS;
-		}
-		*bytes_sent += sent;
-		/* send AFC packet data (if there's data to send) */
-		if (length > 0) {
-			debug_info("packet data follows");
-
-			debug_buffer(data, length);
-			service_send(client->parent, data, length, &sent);
-			*bytes_sent += sent;
-		}
+	sent = 0;
+	if (payload_length > 0) {
+		debug_info("packet payload follows");
+		debug_buffer(payload, payload_length);
+		service_send(client->parent, payload, payload_length, &sent);
+	}
+	*bytes_sent += sent;
+	if (sent < payload_length) {
 		return AFC_E_SUCCESS;
 	}
-	return AFC_E_INTERNAL_ERROR;
+
+	return AFC_E_SUCCESS;
 }
 
 /**
  * Receives data through an AFC client and sets a variable to the received data.
  * 
  * @param client The client to receive data on.
- * @param dump_here The char* to point to the newly-received data.
+ * @param bytes The char* to point to the newly-received data.
  * @param bytes_recv How much data was received.
  * 
  * @return AFC_E_SUCCESS on success or an AFC_E_* error value.
  */
-static afc_error_t afc_receive_data(afc_client_t client, char **dump_here, uint32_t *bytes_recv)
+static afc_error_t afc_receive_data(afc_client_t client, char **bytes, uint32_t *bytes_recv)
 {
 	AFCPacket header;
 	uint32_t entire_len = 0;
 	uint32_t this_len = 0;
 	uint32_t current_count = 0;
 	uint64_t param1 = -1;
+	char* dump_here = NULL;
 
-	*bytes_recv = 0;
+	if (bytes_recv) {
+		*bytes_recv = 0;
+	}
+	if (bytes) {
+		*bytes = NULL;
+	}
 
 	/* first, read the AFC header */
 	service_receive(client->parent, (char*)&header, sizeof(AFCPacket), bytes_recv);
 	AFCPacket_from_LE(&header);
 	if (*bytes_recv == 0) {
 		debug_info("Just didn't get enough.");
-		*dump_here = NULL;
 		return AFC_E_MUX_ERROR;
 	} else if (*bytes_recv < sizeof(AFCPacket)) {
 		debug_info("Did not even get the AFCPacket header");
-		*dump_here = NULL;
 		return AFC_E_MUX_ERROR;
 	}
 
@@ -317,19 +286,16 @@ static afc_error_t afc_receive_data(afc_client_t client, char **dump_here, uint3
 	if (header.packet_num != client->afc_packet->packet_num) {
 		/* otherwise print a warning but do not abort */
 		debug_info("ERROR: Unexpected packet number (%lld != %lld) aborting.", header.packet_num, client->afc_packet->packet_num);
-		*dump_here = NULL;
 		return AFC_E_OP_HEADER_INVALID;
 	}
 
 	/* then, read the attached packet */
 	if (header.this_length < sizeof(AFCPacket)) {
 		debug_info("Invalid AFCPacket header received!");
-		*dump_here = NULL;
 		return AFC_E_OP_HEADER_INVALID;
 	} else if ((header.this_length == header.entire_length)
 			&& header.entire_length == sizeof(AFCPacket)) {
 		debug_info("Empty AFCPacket received!");
-		*dump_here = NULL;
 		*bytes_recv = 0;
 		if (header.operation == AFC_OP_DATA) {
 			return AFC_E_SUCCESS;
@@ -348,17 +314,15 @@ static afc_error_t afc_receive_data(afc_client_t client, char **dump_here, uint3
 		fprintf(stderr, "%s: entire_len is larger than MAXIMUM_PACKET_SIZE, (%d > %d)!", __func__, entire_len, MAXIMUM_PACKET_SIZE);
 	}
 
-	*dump_here = (char*)malloc(entire_len);
+	dump_here = (char*)malloc(entire_len);
 	if (this_len > 0) {
-		service_receive(client->parent, *dump_here, this_len, bytes_recv);
+		service_receive(client->parent, dump_here, this_len, bytes_recv);
 		if (*bytes_recv <= 0) {
-			free(*dump_here);
-			*dump_here = NULL;
+			free(dump_here);
 			debug_info("Did not get packet contents!");
 			return AFC_E_NOT_ENOUGH_DATA;
 		} else if (*bytes_recv < this_len) {
-			free(*dump_here);
-			*dump_here = NULL;
+			free(dump_here);
 			debug_info("Could not receive this_len=%d bytes", this_len);
 			return AFC_E_NOT_ENOUGH_DATA;
 		}
@@ -368,7 +332,7 @@ static afc_error_t afc_receive_data(afc_client_t client, char **dump_here, uint3
 
 	if (entire_len > this_len) {
 		while (current_count < entire_len) {
-			service_receive(client->parent, (*dump_here)+current_count, entire_len - current_count, bytes_recv);
+			service_receive(client->parent, dump_here+current_count, entire_len - current_count, bytes_recv);
 			if (*bytes_recv <= 0) {
 				debug_info("Error receiving data (recv returned %d)", *bytes_recv);
 				break;
@@ -381,12 +345,12 @@ static afc_error_t afc_receive_data(afc_client_t client, char **dump_here, uint3
 	}
 
 	if (current_count >= sizeof(uint64_t)) {
-		param1 = le64toh(*(uint64_t*)(*dump_here));
+		param1 = le64toh(*(uint64_t*)(dump_here));
 	}
 
 	debug_info("packet data size = %i", current_count);
 	debug_info("packet data follows");
-	debug_buffer(*dump_here, current_count);
+	debug_buffer(dump_here, current_count);
 
 	/* check operation types */
 	if (header.operation == AFC_OP_STATUS) {
@@ -396,8 +360,7 @@ static afc_error_t afc_receive_data(afc_client_t client, char **dump_here, uint3
 		if (param1 != AFC_E_SUCCESS) {
 			/* error status */
 			/* free buffer */
-			free(*dump_here);
-			*dump_here = NULL;
+			free(dump_here);
 			return (afc_error_t)param1;
 		}
 	} else if (header.operation == AFC_OP_DATA) {
@@ -411,8 +374,7 @@ static afc_error_t afc_receive_data(afc_client_t client, char **dump_here, uint3
 		debug_info("got a tell response, position=%lld", param1);
 	} else {
 		/* unknown operation code received */
-		free(*dump_here);
-		*dump_here = NULL;
+		free(dump_here);
 		*bytes_recv = 0;
 
 		debug_info("WARNING: Unknown operation code received 0x%llx param1=%lld", header.operation, param1);
@@ -423,6 +385,12 @@ static afc_error_t afc_receive_data(afc_client_t client, char **dump_here, uint3
 		return AFC_E_OP_NOT_SUPPORTED;
 	}
 
+	if (bytes) {
+		*bytes = dump_here;
+	} else {
+		free(dump_here);
+	}
+
 	*bytes_recv = current_count;
 	return AFC_E_SUCCESS;
 }
@@ -493,10 +461,7 @@ afc_error_t afc_read_directory(afc_client_t client, const char *dir, char ***lis
 	afc_lock(client);
 
 	/* Send the command */
-	client->afc_packet->operation = AFC_OP_READ_DIR;
-	client->afc_packet->entire_length = 0;
-	client->afc_packet->this_length = 0;
-	ret = afc_dispatch_packet(client, dir, strlen(dir)+1, &bytes);
+	ret = afc_dispatch_packet(client, AFC_OP_READ_DIR, dir, strlen(dir)+1, NULL, 0, &bytes);
 	if (ret != AFC_E_SUCCESS) {
 		afc_unlock(client);
 		return AFC_E_NOT_ENOUGH_DATA;
@@ -504,6 +469,8 @@ afc_error_t afc_read_directory(afc_client_t client, const char *dir, char ***lis
 	/* Receive the data */
 	ret = afc_receive_data(client, &data, &bytes);
 	if (ret != AFC_E_SUCCESS) {
+		if (data)
+			free(data);
 		afc_unlock(client);
 		return ret;
 	}
@@ -541,9 +508,7 @@ afc_error_t afc_get_device_info(afc_client_t client, char ***infos)
 	afc_lock(client);
 
 	/* Send the command */
-	client->afc_packet->operation = AFC_OP_GET_DEVINFO;
-	client->afc_packet->entire_length = client->afc_packet->this_length = 0;
-	ret = afc_dispatch_packet(client, NULL, 0, &bytes);
+	ret = afc_dispatch_packet(client, AFC_OP_GET_DEVINFO, NULL, 0, NULL, 0, &bytes);
 	if (ret != AFC_E_SUCCESS) {
 		afc_unlock(client);
 		return AFC_E_NOT_ENOUGH_DATA;
@@ -551,6 +516,8 @@ afc_error_t afc_get_device_info(afc_client_t client, char ***infos)
 	/* Receive the data */
 	ret = afc_receive_data(client, &data, &bytes);
 	if (ret != AFC_E_SUCCESS) {
+		if (data)
+			free(data);
 		afc_unlock(client);
 		return ret;
 	}
@@ -614,7 +581,6 @@ afc_error_t afc_get_device_info_key(afc_client_t client, const char *key, char *
  */
 afc_error_t afc_remove_path(afc_client_t client, const char *path)
 {
-	char *response = NULL;
 	uint32_t bytes = 0;
 	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
 
@@ -624,17 +590,13 @@ afc_error_t afc_remove_path(afc_client_t client, const char *path)
 	afc_lock(client);
 
 	/* Send command */
-	client->afc_packet->this_length = client->afc_packet->entire_length = 0;
-	client->afc_packet->operation = AFC_OP_REMOVE_PATH;
-	ret = afc_dispatch_packet(client, path, strlen(path)+1, &bytes);
+	ret = afc_dispatch_packet(client, AFC_OP_REMOVE_PATH, path, strlen(path)+1, NULL, 0, &bytes);
 	if (ret != AFC_E_SUCCESS) {
 		afc_unlock(client);
 		return AFC_E_NOT_ENOUGH_DATA;
 	}
 	/* Receive response */
-	ret = afc_receive_data(client, &response, &bytes);
-	if (response)
-		free(response);
+	ret = afc_receive_data(client, NULL, &bytes);
 
 	/* special case; unknown error actually means directory not empty */
 	if (ret == AFC_E_UNKNOWN_ERROR)
@@ -656,7 +618,6 @@ afc_error_t afc_remove_path(afc_client_t client, const char *path)
  */
 afc_error_t afc_rename_path(afc_client_t client, const char *from, const char *to)
 {
-	char *response = NULL;
 	char *send = (char *) malloc(sizeof(char) * (strlen(from) + strlen(to) + 1 + sizeof(uint32_t)));
 	uint32_t bytes = 0;
 	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
@@ -669,18 +630,15 @@ afc_error_t afc_rename_path(afc_client_t client, const char *from, const char *t
 	/* Send command */
 	memcpy(send, from, strlen(from) + 1);
 	memcpy(send + strlen(from) + 1, to, strlen(to) + 1);
-	client->afc_packet->entire_length = client->afc_packet->this_length = 0;
-	client->afc_packet->operation = AFC_OP_RENAME_PATH;
-	ret = afc_dispatch_packet(client, send, strlen(to)+1 + strlen(from)+1, &bytes);
+	ret = afc_dispatch_packet(client, AFC_OP_RENAME_PATH, send, strlen(to)+1 + strlen(from)+1, NULL, 0, &bytes);
 	free(send);
+
 	if (ret != AFC_E_SUCCESS) {
 		afc_unlock(client);
 		return AFC_E_NOT_ENOUGH_DATA;
 	}
 	/* Receive response */
-	ret = afc_receive_data(client, &response, &bytes);
-	if (response)
-		free(response);
+	ret = afc_receive_data(client, NULL, &bytes);
 
 	afc_unlock(client);
 
@@ -699,7 +657,6 @@ afc_error_t afc_rename_path(afc_client_t client, const char *from, const char *t
 afc_error_t afc_make_directory(afc_client_t client, const char *dir)
 {
 	uint32_t bytes = 0;
-	char *response = NULL;
 	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
 
 	if (!client)
@@ -708,17 +665,13 @@ afc_error_t afc_make_directory(afc_client_t client, const char *dir)
 	afc_lock(client);
 
 	/* Send command */
-	client->afc_packet->operation = AFC_OP_MAKE_DIR;
-	client->afc_packet->this_length = client->afc_packet->entire_length = 0;
-	ret = afc_dispatch_packet(client, dir, strlen(dir)+1, &bytes);
+	ret = afc_dispatch_packet(client, AFC_OP_MAKE_DIR, dir, strlen(dir)+1, NULL, 0, &bytes);
 	if (ret != AFC_E_SUCCESS) {
 		afc_unlock(client);
 		return AFC_E_NOT_ENOUGH_DATA;
 	}
 	/* Receive response */
-	ret = afc_receive_data(client, &response, &bytes);
-	if (response)
-		free(response);
+	ret = afc_receive_data(client, NULL, &bytes);
 
 	afc_unlock(client);
 
@@ -748,9 +701,7 @@ afc_error_t afc_get_file_info(afc_client_t client, const char *path, char ***inf
 	afc_lock(client);
 
 	/* Send command */
-	client->afc_packet->operation = AFC_OP_GET_FILE_INFO;
-	client->afc_packet->entire_length = client->afc_packet->this_length = 0;
-	ret = afc_dispatch_packet(client, path, strlen(path)+1, &bytes);
+	ret = afc_dispatch_packet(client, AFC_OP_GET_FILE_INFO, path, strlen(path)+1, NULL, 0, &bytes);
 	if (ret != AFC_E_SUCCESS) {
 		afc_unlock(client);
 		return AFC_E_NOT_ENOUGH_DATA;
@@ -781,7 +732,7 @@ afc_error_t afc_get_file_info(afc_client_t client, const char *path, char ***inf
  * 
  * @return AFC_E_SUCCESS on success or an AFC_E_* error value.
  */
-afc_error_t
+idevice_error_t
 afc_file_open(afc_client_t client, const char *filename,
 					 afc_file_mode_t file_mode, uint64_t *handle)
 {
@@ -802,9 +753,7 @@ afc_file_open(afc_client_t client, const char *filename,
 	memcpy(data, &file_mode_loc, 8);
 	memcpy(data + 8, filename, strlen(filename));
 	data[8 + strlen(filename)] = '\0';
-	client->afc_packet->operation = AFC_OP_FILE_OPEN;
-	client->afc_packet->entire_length = client->afc_packet->this_length = 0;
-	ret = afc_dispatch_packet(client, data, 8 + strlen(filename) + 1, &bytes);
+	ret = afc_dispatch_packet(client, AFC_OP_FILE_OPEN, data, 8 + strlen(filename) + 1, NULL, 0, &bytes);
 	free(data);
 
 	if (ret != AFC_E_SUCCESS) {
@@ -841,7 +790,7 @@ afc_file_open(afc_client_t client, const char *filename,
  *
  * @return AFC_E_SUCCESS on success or an AFC_E_* error value.
  */
-afc_error_t
+idevice_error_t
 afc_file_read(afc_client_t client, uint64_t handle, char *data, uint32_t length, uint32_t *bytes_read)
 {
 	char *input = NULL;
@@ -864,9 +813,7 @@ afc_file_read(afc_client_t client, uint64_t handle, char *data, uint32_t length,
 		AFCFilePacket *packet = (AFCFilePacket *) malloc(sizeof(AFCFilePacket));
 		packet->filehandle = handle;
 		packet->size = htole64(((length - current_count) < MAXIMUM_READ_SIZE) ? (length - current_count) : MAXIMUM_READ_SIZE);
-		client->afc_packet->operation = AFC_OP_READ;
-		client->afc_packet->entire_length = client->afc_packet->this_length = 0;
-		ret = afc_dispatch_packet(client, (char *) packet, sizeof(AFCFilePacket), &bytes_loc);
+		ret = afc_dispatch_packet(client, AFC_OP_READ, (const char*)packet, sizeof(AFCFilePacket), NULL, 0, &bytes_loc);
 		free(packet);
 
 		if (ret != AFC_E_SUCCESS) {
@@ -915,15 +862,11 @@ afc_file_read(afc_client_t client, uint64_t handle, char *data, uint32_t length,
  * 
  * @return AFC_E_SUCCESS on success or an AFC_E_* error value.
  */
-afc_error_t
+idevice_error_t
 afc_file_write(afc_client_t client, uint64_t handle, const char *data, uint32_t length, uint32_t *bytes_written)
 {
-	char *acknowledgement = NULL;
-	const uint32_t MAXIMUM_WRITE_SIZE = 1 << 15;
-	uint32_t current_count = 0, i = 0;
-	uint32_t segments = (length / MAXIMUM_WRITE_SIZE);
+	uint32_t current_count = 0;
 	uint32_t bytes_loc = 0;
-	char *out_buffer = NULL;
 	afc_error_t ret = AFC_E_SUCCESS;
 
 	if (!client || !client->afc_packet || !client->parent || !bytes_written || (handle == 0))
@@ -933,53 +876,9 @@ afc_file_write(afc_client_t client, uint64_t handle, const char *data, uint32_t
 
 	debug_info("Write length: %i", length);
 
-	/* Divide the file into segments. */
-	for (i = 0; i < segments; i++) {
-		/* Send the segment */
-		client->afc_packet->this_length = sizeof(AFCPacket) + 8;
-		client->afc_packet->entire_length = client->afc_packet->this_length + MAXIMUM_WRITE_SIZE;
-		client->afc_packet->operation = AFC_OP_WRITE;
-		out_buffer = (char *) malloc(sizeof(char) * client->afc_packet->entire_length - sizeof(AFCPacket));
-		memcpy(out_buffer, (char *)&handle, sizeof(uint64_t));
-		memcpy(out_buffer + 8, data + current_count, MAXIMUM_WRITE_SIZE);
-		ret = afc_dispatch_packet(client, out_buffer, MAXIMUM_WRITE_SIZE + 8, &bytes_loc);
-		if (ret != AFC_E_SUCCESS) {
-			afc_unlock(client);
-			return AFC_E_NOT_ENOUGH_DATA;
-		}
-		free(out_buffer);
-		out_buffer = NULL;
+	ret = afc_dispatch_packet(client, AFC_OP_WRITE, (const char*)&handle, 8, data, length, &bytes_loc);
 
-		current_count += bytes_loc;
-		ret = afc_receive_data(client, &acknowledgement, &bytes_loc);
-		if (ret != AFC_E_SUCCESS) {
-			afc_unlock(client);
-			return ret;
-		} else {
-			free(acknowledgement);
-		}
-	}
-
-	/* By this point, we should be at the end. i.e. the last segment that didn't
-	   get sent in the for loop. This length is fine because it's always
-	   sizeof(AFCPacket) + 8, but to be sure we do it again */
-	if (current_count == length) {
-		afc_unlock(client);
-		*bytes_written = current_count;
-		return ret;
-	}
-
-	client->afc_packet->this_length = sizeof(AFCPacket) + 8;
-	client->afc_packet->entire_length = client->afc_packet->this_length + (length - current_count);
-	client->afc_packet->operation = AFC_OP_WRITE;
-	out_buffer = (char *) malloc(sizeof(char) * client->afc_packet->entire_length - sizeof(AFCPacket));
-	memcpy(out_buffer, (char *) &handle, sizeof(uint64_t));
-	memcpy(out_buffer + 8, data + current_count, (length - current_count));
-	ret = afc_dispatch_packet(client, out_buffer, (length - current_count) + 8, &bytes_loc);
-	free(out_buffer);
-	out_buffer = NULL;
-
-	current_count += bytes_loc;
+	current_count += bytes_loc - (sizeof(AFCPacket) + 8);
 
 	if (ret != AFC_E_SUCCESS) {
 		afc_unlock(client);
@@ -987,12 +886,10 @@ afc_file_write(afc_client_t client, uint64_t handle, const char *data, uint32_t
 		return AFC_E_SUCCESS;
 	}
 
-	ret = afc_receive_data(client, &acknowledgement, &bytes_loc);
+	ret = afc_receive_data(client, NULL, &bytes_loc);
 	afc_unlock(client);
 	if (ret != AFC_E_SUCCESS) {
 		debug_info("uh oh?");
-	} else {
-		free(acknowledgement);
 	}
 	*bytes_written = current_count;
 	return ret;
@@ -1006,7 +903,6 @@ afc_file_write(afc_client_t client, uint64_t handle, const char *data, uint32_t
  */
 afc_error_t afc_file_close(afc_client_t client, uint64_t handle)
 {
-	char *buffer = malloc(sizeof(char) * 8);
 	uint32_t bytes = 0;
 	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
 
@@ -1018,12 +914,7 @@ afc_error_t afc_file_close(afc_client_t client, uint64_t handle)
 	debug_info("File handle %i", handle);
 
 	/* Send command */
-	memcpy(buffer, &handle, sizeof(uint64_t));
-	client->afc_packet->operation = AFC_OP_FILE_CLOSE;
-	client->afc_packet->entire_length = client->afc_packet->this_length = 0;
-	ret = afc_dispatch_packet(client, buffer, 8, &bytes);
-	free(buffer);
-	buffer = NULL;
+	ret = afc_dispatch_packet(client, AFC_OP_FILE_CLOSE, (const char*)&handle, 8, NULL, 0, &bytes);
 
 	if (ret != AFC_E_SUCCESS) {
 		afc_unlock(client);
@@ -1031,9 +922,7 @@ afc_error_t afc_file_close(afc_client_t client, uint64_t handle)
 	}
 
 	/* Receive the response */
-	ret = afc_receive_data(client, &buffer, &bytes);
-	if (buffer)
-		free(buffer);
+	ret = afc_receive_data(client, NULL, &bytes);
 
 	afc_unlock(client);
 
@@ -1070,9 +959,7 @@ afc_error_t afc_file_lock(afc_client_t client, uint64_t handle, afc_lock_op_t op
 	memcpy(buffer, &handle, sizeof(uint64_t));
 	memcpy(buffer + 8, &op, 8);
 
-	client->afc_packet->operation = AFC_OP_FILE_LOCK;
-	client->afc_packet->entire_length = client->afc_packet->this_length = 0;
-	ret = afc_dispatch_packet(client, buffer, 16, &bytes);
+	ret = afc_dispatch_packet(client, AFC_OP_FILE_LOCK, buffer, 16, NULL, 0, &bytes);
 	free(buffer);
 	buffer = NULL;
 
@@ -1082,11 +969,8 @@ afc_error_t afc_file_lock(afc_client_t client, uint64_t handle, afc_lock_op_t op
 		return AFC_E_UNKNOWN_ERROR;
 	}
 	/* Receive the response */
-	ret = afc_receive_data(client, &buffer, &bytes);
-	if (buffer) {
-		debug_buffer(buffer, bytes);
-		free(buffer);
-	}
+	ret = afc_receive_data(client, NULL, &bytes);
+
 	afc_unlock(client);
 
 	return ret;
@@ -1119,9 +1003,7 @@ afc_error_t afc_file_seek(afc_client_t client, uint64_t handle, int64_t offset,
 	memcpy(buffer, &handle, sizeof(uint64_t));	/* handle */
 	memcpy(buffer + 8, &whence_loc, sizeof(uint64_t));	/* fromwhere */
 	memcpy(buffer + 16, &offset_loc, sizeof(uint64_t));	/* offset */
-	client->afc_packet->operation = AFC_OP_FILE_SEEK;
-	client->afc_packet->this_length = client->afc_packet->entire_length = 0;
-	ret = afc_dispatch_packet(client, buffer, 24, &bytes);
+	ret = afc_dispatch_packet(client, AFC_OP_FILE_SEEK, buffer, 24, NULL, 0, &bytes);
 	free(buffer);
 	buffer = NULL;
 
@@ -1130,9 +1012,7 @@ afc_error_t afc_file_seek(afc_client_t client, uint64_t handle, int64_t offset,
 		return AFC_E_NOT_ENOUGH_DATA;
 	}
 	/* Receive response */
-	ret = afc_receive_data(client, &buffer, &bytes);
-	if (buffer)
-		free(buffer);
+	ret = afc_receive_data(client, NULL, &bytes);
 
 	afc_unlock(client);
 
@@ -1160,12 +1040,7 @@ afc_error_t afc_file_tell(afc_client_t client, uint64_t handle, uint64_t *positi
 	afc_lock(client);
 
 	/* Send the command */
-	memcpy(buffer, &handle, sizeof(uint64_t));	/* handle */
-	client->afc_packet->operation = AFC_OP_FILE_TELL;
-	client->afc_packet->this_length = client->afc_packet->entire_length = 0;
-	ret = afc_dispatch_packet(client, buffer, 8, &bytes);
-	free(buffer);
-	buffer = NULL;
+	ret = afc_dispatch_packet(client, AFC_OP_FILE_TELL, (const char*)&handle, 8, NULL, 0, &bytes);
 
 	if (ret != AFC_E_SUCCESS) {
 		afc_unlock(client);
@@ -1214,9 +1089,7 @@ afc_error_t afc_file_truncate(afc_client_t client, uint64_t handle, uint64_t new
 	/* Send command */
 	memcpy(buffer, &handle, sizeof(uint64_t));	/* handle */
 	memcpy(buffer + 8, &newsize_loc, sizeof(uint64_t));	/* newsize */
-	client->afc_packet->operation = AFC_OP_FILE_SET_SIZE;
-	client->afc_packet->this_length = client->afc_packet->entire_length = 0;
-	ret = afc_dispatch_packet(client, buffer, 16, &bytes);
+	ret = afc_dispatch_packet(client, AFC_OP_FILE_SET_SIZE, buffer, 16, NULL, 0, &bytes);
 	free(buffer);
 	buffer = NULL;
 
@@ -1225,9 +1098,7 @@ afc_error_t afc_file_truncate(afc_client_t client, uint64_t handle, uint64_t new
 		return AFC_E_NOT_ENOUGH_DATA;
 	}
 	/* Receive response */
-	ret = afc_receive_data(client, &buffer, &bytes);
-	if (buffer)
-		free(buffer);
+	ret = afc_receive_data(client, NULL, &bytes);
 
 	afc_unlock(client);
 
@@ -1245,7 +1116,6 @@ afc_error_t afc_file_truncate(afc_client_t client, uint64_t handle, uint64_t new
  */
 afc_error_t afc_truncate(afc_client_t client, const char *path, uint64_t newsize)
 {
-	char *response = NULL;
 	char *send = (char *) malloc(sizeof(char) * (strlen(path) + 1 + 8));
 	uint32_t bytes = 0;
 	uint64_t size_requested = htole64(newsize);
@@ -1259,18 +1129,15 @@ afc_error_t afc_truncate(afc_client_t client, const char *path, uint64_t newsize
 	/* Send command */
 	memcpy(send, &size_requested, 8);
 	memcpy(send + 8, path, strlen(path) + 1);
-	client->afc_packet->entire_length = client->afc_packet->this_length = 0;
-	client->afc_packet->operation = AFC_OP_TRUNCATE;
-	ret = afc_dispatch_packet(client, send, 8 + strlen(path) + 1, &bytes);
+	ret = afc_dispatch_packet(client, AFC_OP_TRUNCATE, send, 8 + strlen(path) + 1, NULL, 0, &bytes);
 	free(send);
+
 	if (ret != AFC_E_SUCCESS) {
 		afc_unlock(client);
 		return AFC_E_NOT_ENOUGH_DATA;
 	}
 	/* Receive response */
-	ret = afc_receive_data(client, &response, &bytes);
-	if (response)
-		free(response);
+	ret = afc_receive_data(client, NULL, &bytes);
 
 	afc_unlock(client);
 
@@ -1289,7 +1156,6 @@ afc_error_t afc_truncate(afc_client_t client, const char *path, uint64_t newsize
  */
 afc_error_t afc_make_link(afc_client_t client, afc_link_type_t linktype, const char *target, const char *linkname)
 {
-	char *response = NULL;
 	char *send = (char *) malloc(sizeof(char) * (strlen(target)+1 + strlen(linkname)+1 + 8));
 	uint32_t bytes = 0;
 	uint64_t type = htole64(linktype);
@@ -1308,18 +1174,14 @@ afc_error_t afc_make_link(afc_client_t client, afc_link_type_t linktype, const c
 	memcpy(send, &type, 8);
 	memcpy(send + 8, target, strlen(target) + 1);
 	memcpy(send + 8 + strlen(target) + 1, linkname, strlen(linkname) + 1);
-	client->afc_packet->entire_length = client->afc_packet->this_length = 0;
-	client->afc_packet->operation = AFC_OP_MAKE_LINK;
-	ret = afc_dispatch_packet(client, send, 8 + strlen(linkname) + 1 + strlen(target) + 1, &bytes);
+	ret = afc_dispatch_packet(client, AFC_OP_MAKE_LINK, send, 8 + strlen(linkname) + 1 + strlen(target) + 1, NULL, 0, &bytes);
 	free(send);
 	if (ret != AFC_E_SUCCESS) {
 		afc_unlock(client);
 		return AFC_E_NOT_ENOUGH_DATA;
 	}
 	/* Receive response */
-	ret = afc_receive_data(client, &response, &bytes);
-	if (response)
-		free(response);
+	ret = afc_receive_data(client, NULL, &bytes);
 
 	afc_unlock(client);
 
@@ -1337,7 +1199,6 @@ afc_error_t afc_make_link(afc_client_t client, afc_link_type_t linktype, const c
  */
 afc_error_t afc_set_file_time(afc_client_t client, const char *path, uint64_t mtime)
 {
-	char *response = NULL;
 	char *send = (char *) malloc(sizeof(char) * (strlen(path) + 1 + 8));
 	uint32_t bytes = 0;
 	uint64_t mtime_loc = htole64(mtime);
@@ -1351,18 +1212,14 @@ afc_error_t afc_set_file_time(afc_client_t client, const char *path, uint64_t mt
 	/* Send command */
 	memcpy(send, &mtime_loc, 8);
 	memcpy(send + 8, path, strlen(path) + 1);
-	client->afc_packet->entire_length = client->afc_packet->this_length = 0;
-	client->afc_packet->operation = AFC_OP_SET_FILE_TIME;
-	ret = afc_dispatch_packet(client, send, 8 + strlen(path) + 1, &bytes);
+	ret = afc_dispatch_packet(client, AFC_OP_SET_FILE_TIME, send, 8 + strlen(path) + 1, NULL, 0, &bytes);
 	free(send);
 	if (ret != AFC_E_SUCCESS) {
 		afc_unlock(client);
 		return AFC_E_NOT_ENOUGH_DATA;
 	}
 	/* Receive response */
-	ret = afc_receive_data(client, &response, &bytes);
-	if (response)
-		free(response);
+	ret = afc_receive_data(client, NULL, &bytes);
 
 	afc_unlock(client);