Rework TLS buffers to avoid overflowing.

If we're keeping some bytes in the line buffer waiting for a
CR/LF, the SSLEngine may not have enough room to put a packet's
worth of data in.

Instead of managing a single buffer, keep a channel of them
and emit a complete buffer each read call.

CHANGELOG

 vNEXT (in development)
 
+ * Fixed issue with very long packets not fitting in buffers
+   after TLS decryption.
+
 v1.0.0
 
  * Replaced Ktor dependency with custom socket handling, which fixes

src/main/kotlin/com/dmdirc/ktirc/io/LineBufferedSocket.kt

 import kotlinx.coroutines.channels.SendChannel
 import kotlinx.coroutines.channels.produce
 import kotlinx.coroutines.io.ByteWriteChannel
+import kotlinx.io.core.String
 import java.net.InetSocketAddress
 import java.nio.ByteBuffer
 import java.security.SecureRandom
 
     override val receiveChannel
         get() = produce {
-            val lineBuffer = ByteArray(16384)
-            var nextByteOffset = 0
-            while (socket.isOpen) {
-                var lineStart = 0
-                val bytesRead = socket.read(ByteBuffer.wrap(lineBuffer).apply { position(nextByteOffset) })
-                for (i in nextByteOffset until nextByteOffset + bytesRead) {
-                    if (lineBuffer[i] == CARRIAGE_RETURN || lineBuffer[i] == LINE_FEED) {
-                        if (lineStart < i) {
-                            val line = lineBuffer.sliceArray(lineStart until i)
-                            log.fine { "<<< ${String(line)}" }
-                            send(line)
+            defaultPool.borrow { lineBuffer ->
+                while (socket.isOpen) {
+                    defaultPool.borrow { buffer ->
+                        val bytesRead = socket.read(buffer)
+                        var lastLine = 0
+                        for (i in 0 until bytesRead) {
+                            if (buffer[i] == CARRIAGE_RETURN || buffer[i] == LINE_FEED) {
+                                val length = i - lastLine + lineBuffer.position()
+
+                                if (length > 1) {
+                                    val output = ByteBuffer.allocate(length)
+
+                                    lineBuffer.flip()
+                                    output.put(lineBuffer)
+                                    lineBuffer.clear()
+
+                                    output.put(buffer.array(), lastLine, i - lastLine)
+                                    log.fine { "<<< ${String(output.array())}" }
+                                    send(output.array())
+                                }
+
+                                lastLine = i + 1
+                            }
                         }
-                        lineStart = i + 1
+                        lineBuffer.put(buffer.array(), lastLine, bytesRead - lastLine)
                     }
                 }
-                lineBuffer.copyInto(lineBuffer, 0, lineStart)
-                nextByteOffset += bytesRead - lineStart
             }
         }
 

src/main/kotlin/com/dmdirc/ktirc/io/Sockets.kt

 import kotlin.coroutines.resumeWithException
 
 internal const val BUFFER_SIZE = 32768
-internal const val POOL_SIZE = 16
+internal const val POOL_SIZE = 128
 
 internal val defaultPool = ByteBufferPool()
 

src/main/kotlin/com/dmdirc/ktirc/io/Tls.kt

 package com.dmdirc.ktirc.io
 
+import com.dmdirc.ktirc.util.logger
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.io.ByteChannel
 import kotlinx.coroutines.io.ByteWriteChannel
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
 import java.net.SocketAddress
 import java.nio.ByteBuffer
 import java.security.cert.CertificateException
         private val hostname: String
 ) : Socket {
 
+    private val log by logger()
     private var engine: SSLEngine = sslContext.createSSLEngine()
 
     private var incomingNetBuffer = ByteBuffer.allocate(0)
-    private var outgoingAppBuffer = ByteBuffer.allocate(0)
     private var incomingAppBuffer = ByteBuffer.allocate(0)
-    private val outgoingAppBufferMutex = Mutex(false)
+    private var outgoingAppBuffers = Channel<ByteBuffer>(capacity = Channel.UNLIMITED)
 
     private var writeChannel = ByteChannel(autoFlush = true)
 
         }
 
         incomingNetBuffer = ByteBuffer.allocate(engine.session.packetBufferSize)
-        outgoingAppBuffer = ByteBuffer.allocate(engine.session.applicationBufferSize)
+        outgoingAppBuffers = Channel(capacity = Channel.UNLIMITED)
         incomingAppBuffer = ByteBuffer.allocate(engine.session.applicationBufferSize)
 
         socket.connect(socketAddress)
         }
     }
 
-    override suspend fun read(buffer: ByteBuffer) = outgoingAppBufferMutex.withLock<Int> {
-        outgoingAppBuffer.flip()
-        val bytes = outgoingAppBuffer.limit()
-        buffer.put(outgoingAppBuffer)
-        outgoingAppBuffer.clear()
+    override suspend fun read(buffer: ByteBuffer): Int {
+        val nextBuffer = outgoingAppBuffers.receive()
+        val bytes = nextBuffer.limit()
+        buffer.put(nextBuffer)
+        defaultPool.recycle(nextBuffer)
         return bytes
     }
 
         return result
     }
 
-    private suspend fun unwrap(): SSLEngineResult? {
-        if (incomingNetBuffer.position() == 0) {
+    private suspend fun unwrap(networkRead: Boolean = incomingNetBuffer.position() == 0): SSLEngineResult? {
+        if (networkRead) {
             val bytes = socket.read(incomingNetBuffer.slice())
             if (bytes == -1) {
                 close()
         }
 
         incomingNetBuffer.flip()
-        outgoingAppBufferMutex.withLock {
-            val result = engine.unwrap(incomingNetBuffer, outgoingAppBuffer)
-            incomingNetBuffer.compact()
-            return result
+
+        val buffer = defaultPool.borrow()
+        val result = engine.unwrap(incomingNetBuffer, buffer)
+        incomingNetBuffer.compact()
+        if (buffer.position() > 0) {
+            buffer.flip()
+            outgoingAppBuffers.send(buffer)
+        } else {
+            defaultPool.recycle(buffer)
+        }
+
+        return if (result?.status == SSLEngineResult.Status.BUFFER_UNDERFLOW && !networkRead) {
+            // We didn't do a network read, but SSLEngine is unhappy; force a read.
+            log.finest { "Incoming net buffer underflowed, forcing re-read" }
+            unwrap(true)
+        } else {
+            result
         }
     }
 
     override fun close() {
         socket.close()
+        outgoingAppBuffers.close()
     }
 
     private suspend fun readLoop() {