Fix bug with consecutive unbounded binary() parses

Author: Ant Skelton

src/types/binary.js

@@ -25,43 +25,46 @@ function binary(name,
 		reverseTransform = value => value,
 	} = {}
 ) {
+	let instanceSize = size;
+
 	function parse(buffer, parseTree, { bigEndian }) {
 		let offset = 0;
+		instanceSize = size;
 
 		// determine size to copy to result buffer
 		if (sizePrefixed) {
 			const { parse: prefixParser } = uint('prefix', { size: sizePrefixLength, bigEndian: sizePrefixBigEndian });
 			const result = prefixParser(buffer, {}, { bigEndian });
 
-			size = result.value;
+			instanceSize = result.value;
 			offset = result.size;
 		}
 		if (sizeField) {
-			size = sizeFieldTransform(parseTree[sizeField]);
+			instanceSize = sizeFieldTransform(parseTree[sizeField]);
 		}
-		if (size === undefined) {
-			size = buffer.length;
+		if (instanceSize === undefined) {
+			instanceSize = buffer.length;
 		}
 
 		// just copy data to result
-		const result = new Buffer(size);
+		const result = new Buffer(instanceSize);
 
-		buffer.copy(result, 0, offset, size + offset);
+		buffer.copy(result, 0, offset, instanceSize + offset);
 
 		// return result
 		return {
 			value: transform(result),
-			size: size + offset,
+			size: instanceSize + offset,
 		};
 	}
 
 	function prepareEncode(object, parseTree, { bigEndian }) {
 		if (size === undefined) {
-			size = object.length;
+			instanceSize = object.length;
 		}
 
 		if (sizeField) {
-			parseTree[sizeField] = sizeFieldReverseTransform(size);
+			parseTree[sizeField] = sizeFieldReverseTransform(instanceSize);
 		}
 	}
 
@@ -74,21 +77,21 @@ function binary(name,
 			const result = prefixEncoder(transformed.length, { bigEndian });
 
 			bufferItems.unshift(result);
-			size = transformed.length + sizePrefixLength;
+			instanceSize = transformed.length + sizePrefixLength;
 		}
-		if (size === undefined) {
-			size = transformed.length;
+		if (instanceSize === undefined) {
+			instanceSize = transformed.length;
 		}
 
 		// build buffer
 		let data = Buffer.concat(bufferItems);
 
-		if (data.length < size) {
+		if (data.length < instanceSize) {
 			// if the buffer was shorter than anticipated, pad with zeroes
-			data = Buffer.concat([data, Buffer.alloc(size - data.length)]);
-		} else if (data.length > size) {
+			data = Buffer.concat([data, Buffer.alloc(instanceSize - data.length)]);
+		} else if (data.length > instanceSize) {
 			// if the buffer was longer just cut it off
-			data = data.slice(0, size);
+			data = data.slice(0, instanceSize);
 		}
 
 		return data;

test/binary.js

@@ -74,3 +74,25 @@ test('bcd_4byte', (t) => {
 
 	t.is(compareTemplate(template(definition), { bcd: null }), true);
 });
+
+test("binary_reuse_with_undefined_size", (t) => {
+	const definition = [binary("bin")];
+	const buffer = Buffer.from("0d0a", "hex");
+	const buffer2 = Buffer.from("0a0b0c0d", "hex");
+	const parsed = parse(definition, buffer);
+	const parsed2 = parse(definition, buffer2);
+	const encoded = encode(definition, parsed);
+	const encoded2 = encode(definition, parsed2);
+
+	t.is(parsed.bin.length, 2);
+	t.is(parsed.bin[0], 0x0d);
+	t.is(parsed.bin[1], 0x0a);
+	t.is(encoded.compare(buffer), 0);
+
+	t.is(parsed2.bin.length, 4);
+	t.is(parsed2.bin[0], 0x0a);
+	t.is(parsed2.bin[1], 0x0b);
+	t.is(parsed2.bin[2], 0x0c);
+	t.is(parsed2.bin[3], 0x0d);
+	t.is(encoded2.compare(buffer2), 0);
+});