add abilitiy for multiple delimitiers and multibyte delimiters to packet length parser

Author: bbeck

packages/parser-packet-length/lib/index.test.ts

@@ -90,4 +90,45 @@ describe('DelimiterParser', () => {
     assert.deepEqual(spy.getCall(1).args[0], Buffer.concat([Buffer.from([0xaa, 0x02, 0x13, 0x00]), Buffer.from('Each and Every One\n')]))
     assert(spy.calledTwice)
   })
+
+  it('works with multiple delimiters', () => {
+    const spy = sinon.spy()
+    const parser = new PacketLengthParser({ delimiter: [0xaa, 0xbb], lengthOffset: 2, packetOverhead: 4, lengthBytes: 2 })
+    parser.on('data', spy)
+    parser.write(Buffer.from('\xbb\x01\x0d'))
+    parser.write(Buffer.from('\x00I love hobits\xaa\x02\x13\x00Each '))
+    parser.write(Buffer.from('and Every One\n'))
+
+    assert.deepEqual(spy.getCall(0).args[0], Buffer.concat([Buffer.from([0xbb, 0x01, 0x0d, 0x00]), Buffer.from('I love hobits')]))
+    assert.deepEqual(spy.getCall(1).args[0], Buffer.concat([Buffer.from([0xaa, 0x02, 0x13, 0x00]), Buffer.from('Each and Every One\n')]))
+    assert(spy.calledTwice)
+  })
+
+  it('works with multibyte delimiters', () => {
+    const spy = sinon.spy()
+    const parser = new PacketLengthParser({ delimiter: [0xababba], delimiterBytes: 3, lengthOffset: 3, packetOverhead: 4, lengthBytes: 1 })
+    parser.on('data', spy)
+    parser.write(Buffer.from([0xab, 0xab, 0xba, 0x0d]))
+    parser.write(Buffer.from('I love hobits'))
+    parser.write(Buffer.from([0xab, 0xab, 0xba, 0x13]))
+    parser.write(Buffer.from('Each and Every One\n'))
+
+    assert.deepEqual(spy.getCall(0).args[0], Buffer.concat([Buffer.from([0xab, 0xab, 0xba, 0x0d]), Buffer.from('I love hobits')]))
+    assert.deepEqual(spy.getCall(1).args[0], Buffer.concat([Buffer.from([0xab, 0xab, 0xba, 0x13]), Buffer.from('Each and Every One\n')]))
+    assert(spy.calledTwice)
+  })
+
+  it('works with multiple multibyte delimiters', () => {
+    const spy = sinon.spy()
+    const parser = new PacketLengthParser({ delimiter: [0xababba, 0xbaddad], delimiterBytes: 3, lengthOffset: 3, packetOverhead: 4, lengthBytes: 1 })
+    parser.on('data', spy)
+    parser.write(Buffer.from([0xab, 0xab, 0xba, 0x0d]))
+    parser.write(Buffer.from('I love hobits'))
+    parser.write(Buffer.from([0xba, 0xdd, 0xad, 0x13]))
+    parser.write(Buffer.from('Each and Every One\n'))
+
+    assert.deepEqual(spy.getCall(0).args[0], Buffer.concat([Buffer.from([0xab, 0xab, 0xba, 0x0d]), Buffer.from('I love hobits')]))
+    assert.deepEqual(spy.getCall(1).args[0], Buffer.concat([Buffer.from([0xba, 0xdd, 0xad, 0x13]), Buffer.from('Each and Every One\n')]))
+    assert(spy.calledTwice)
+  })
 })

packages/parser-packet-length/lib/index.ts

@@ -1,8 +1,10 @@
 import { Transform, TransformCallback, TransformOptions } from 'stream'
 
 export interface PacketLengthOptions extends TransformOptions {
-  /** delimiter to use defaults to 0xaa */
-  delimiter?: number
+  /** delimiter(s) to use defaults to 0xaa */
+  delimiter?: number | number[]
+  /** delimiter length in bytes defaults to 1 */
+  delimiterBytes?: number
   /** overhead of packet (including length, delimiter and any checksum / packet footer) defaults to 2 */
   packetOverhead?: number
   /** number of bytes containing length defaults to 1 */
@@ -29,14 +31,15 @@ export interface PacketLengthOptions extends TransformOptions {
 export class PacketLengthParser extends Transform {
   buffer: Buffer
   start: boolean
-  opts: { delimiter: number, packetOverhead: number, lengthBytes: number, lengthOffset: number, maxLen: number }
+  opts: { delimiter: number[], delimiterBytes: number, packetOverhead: number, lengthBytes: number, lengthOffset: number, maxLen: number }
   constructor(options: PacketLengthOptions = {}) {
     super(options)
 
-    const { delimiter = 0xaa, packetOverhead = 2, lengthBytes = 1, lengthOffset = 1, maxLen = 0xff } = options
+    const { delimiter = [0xaa], delimiterBytes = 1, packetOverhead = 2, lengthBytes = 1, lengthOffset = 1, maxLen = 0xff } = options
 
     this.opts = {
-      delimiter,
+      delimiter: ([] as number[]).concat(delimiter),
+      delimiterBytes,
       packetOverhead,
       lengthBytes,
       lengthOffset,
@@ -51,13 +54,8 @@ export class PacketLengthParser extends Transform {
     for (let ndx = 0; ndx < chunk.length; ndx++) {
       const byte = chunk[ndx]
 
-      if (byte === this.opts.delimiter) {
-        this.start = true
-      }
-
       if (true === this.start) {
         this.buffer = Buffer.concat([this.buffer, Buffer.from([byte])])
-
         if (this.buffer.length >= this.opts.lengthOffset + this.opts.lengthBytes) {
           const len = this.buffer.readUIntLE(this.opts.lengthOffset, this.opts.lengthBytes)
 
@@ -67,6 +65,17 @@ export class PacketLengthParser extends Transform {
             this.start = false
           }
         }
+      } else {
+        this.buffer = Buffer.concat([Buffer.from([byte]), this.buffer])
+        if (this.buffer.length === this.opts.delimiterBytes) {
+          const delimiter = this.buffer.readUIntLE(0, this.opts.delimiterBytes)
+          if (this.opts.delimiter.includes(delimiter)) {
+            this.start = true
+            this.buffer = Buffer.from([...this.buffer].reverse())
+          } else {
+            this.buffer = Buffer.from(this.buffer.subarray(1, this.buffer.length))
+          }
+        }
       }
     }