Add heuristic for reclaiming buffer space.

Sources/NIOSSH/SSHPacketParser.swift

@@ -26,6 +26,11 @@ struct SSHPacketParser {
     private var buffer: ByteBuffer
     private var state: State
 
+    /// Testing only: the number of bytes we can discard from this buffer.
+    internal var _discardableBytes: Int {
+        self.buffer.readerIndex
+    }
+
     init(allocator: ByteBufferAllocator) {
         self.buffer = allocator.buffer(capacity: 0)
         self.state = .initialized
@@ -51,6 +56,10 @@ struct SSHPacketParser {
         // This parser has a slightly strange strategy: we leave the packet length field in the buffer until we're done.
         // This is necessary because some transport protection schemes need the length field for MACing purposes, and can
         // benefit from us maintaining the state instead of having to do it themselves.
+        defer {
+            self.reclaimBytes()
+        }
+
         switch self.state {
         case .initialized:
             if let version = try self.readVersion() {
@@ -94,6 +103,12 @@ struct SSHPacketParser {
         }
     }
 
+    private mutating func reclaimBytes() {
+        if self.buffer.readerIndex > 1024, self.buffer.readerIndex > (self.buffer.readableBytes / 2) {
+            self.buffer.discardReadBytes()
+        }
+    }
+
     private mutating func readVersion() throws -> String? {
         // Looking for a string ending with \r\n
         let slice = self.buffer.readableBytesView

Tests/NIOSSHTests/SSHPacketParserTests.swift

@@ -117,6 +117,31 @@ final class SSHPacketParserTests: XCTestCase {
             XCTFail("Expecting .serviceRequest")
         }
     }
+
+    func testWeReclaimStorage() throws {
+        var parser = SSHPacketParser(allocator: ByteBufferAllocator())
+        self.feedVersion(to: &parser)
+        XCTAssertNoThrow(try parser.nextPacket())
+
+        let part = ByteBuffer.of(bytes: [0, 0, 0, 28, 10, 5, 0, 0, 0, 12, 115, 115, 104, 45, 117, 115, 101, 114, 97, 117, 116, 104, 42, 111, 216, 12, 226, 248, 144, 175, 157, 207])
+
+        let neededParts = 2048 / part.readableBytes
+
+        for _ in 0 ..< neededParts {
+            var partCopy = part
+            parser.append(bytes: &partCopy)
+        }
+
+        // The version field is in the buffer, and we can't really prevent it being there.
+        let startingOffset = parser._discardableBytes
+        for i in 0 ..< (neededParts / 2) {
+            XCTAssertEqual(parser._discardableBytes, (i * part.readableBytes) + startingOffset)
+            XCTAssertNoThrow(try parser.nextPacket())
+        }
+
+        // Now we should have cleared up.
+        XCTAssertEqual(parser._discardableBytes, 0)
+    }
 }
 
 extension ByteBuffer {