Fix issue with requests processed too fast

Some requests would fall across two netty messages. These were not handled correctly, and would result in a timeout in iOS.

Author: andylintner

src/main/java/com/beowulfe/hap/impl/connections/LengthPrefixedByteArrayProcessor.java

@@ -4,56 +4,76 @@
 import java.util.Collection;
 import java.util.LinkedList;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 class LengthPrefixedByteArrayProcessor {
 
 	private final ByteArrayOutputStream buffer = new ByteArrayOutputStream();
 	private Byte firstLengthByteBuffer; //Only used if we've received a single byte at the start of a message
 	private int targetLength = 0;
+	
+	private final static Logger LOGGER = LoggerFactory.getLogger(LengthPrefixedByteArrayProcessor.class);
 
 	public synchronized Collection<byte[]> handle(byte[] data) {
 		Collection<byte[]> results = new LinkedList<>();
 		int pos = 0;
+		LOGGER.trace("Received message of length {}. Existing buffer is {}", data.length, buffer.size());
 		if (buffer.size() == 0) {
 			while(data.length - pos > 18) {
 				int targetLength = (data[0] & 0xFF) + (data[1] & 0xFF) * 256 + 16 + 2;
+				LOGGER.trace("Attempting to read message of length {}", targetLength);
 				if (data.length >= pos + targetLength) {
 					byte[] b = new byte[targetLength - 2];
 					System.arraycopy(data, pos+2, b, 0, targetLength-2);
 					results.add(b);
+					LOGGER.trace("Read complete message");
 					pos = pos + targetLength;
 				} else {
+					LOGGER.trace("Not enough data available");
 					break;
 				}
 			}
 		}
 		if (data.length > pos) {
+			LOGGER.trace("Remaining data available");
 			step(data, pos, results);
 		}
+		LOGGER.trace("Returning {} results", results.size());
 		return results;
 	}
 
 	private void step(byte[] data, int pos, Collection<byte[]> results) {
-		if (buffer.size() == 0 && data.length == 1 + pos) {
+		LOGGER.trace("Performing step operation on buffer of length {} with pos {}", data.length, pos);
+		if (targetLength == 0 && data.length == 1 + pos) {
 			firstLengthByteBuffer = data[pos];
+			LOGGER.trace("Received a single byte message, storing byte {} for later", firstLengthByteBuffer);
 			return;
 		}
-		if (buffer.size() == 0) {
+		if (targetLength == 0) {
 			if (firstLengthByteBuffer != null) {
-				targetLength = firstLengthByteBuffer + data[pos] * 256 + 16;
+				targetLength = (firstLengthByteBuffer & 0xFF) + (data[pos] & 0xFF) * 256 + 16;
 				pos += 1;
+				LOGGER.trace("Received the second byte after storing the first byte. New length is {}", targetLength);
 			} else {
-				targetLength = data[pos] + data[pos+1] * 256 + 16;
+				targetLength = (data[pos] & 0xFF) + (data[pos+1] & 0xFF) * 256 + 16;
 				pos += 2;
+				LOGGER.trace("targetLength is {}", targetLength);
 			}
 		}
 		int toWrite = targetLength - buffer.size();
-		if (toWrite > data.length - pos) {
+		if (toWrite <= data.length - pos) {
 			//We have a complete message
+			LOGGER.trace("Received a complete message");
 			buffer.write(data, pos, toWrite);
 			results.add(buffer.toByteArray());
 			buffer.reset();
-			step(data, pos + toWrite, results);
+			targetLength=0;
+			if (pos + toWrite > data.length) {
+				step(data, pos + toWrite, results);
+			}
 		} else {
+			LOGGER.trace("Storing {} bytes in buffer until we receive the complete {}", data.length-pos, targetLength);
 			buffer.write(data, pos, data.length - pos);
 		}
 	}