Prefer IPv6, default to TLS

CHANGELOG

    client certificate.
  * Added NicknameChangeRequired event for the case when a nickname is
    not allowed during connection and *MUST* be changed
+ * BREAKING: Added 'PreferIPv6' behaviour config, defaulting to true.
+   With this configuration KtIrc will try to use IPv6 if the server
+   publishes AAAA records.
+ * BREAKING: Default port is now 6697, TLS is enabled by default
 
 v0.11.0
 
 v0.7.0
 
  * Fixed experimental API warnings when using IrcClient
- * IrcClients are now constructed using a DSL
+ * BREAKING: IrcClients are now constructed using a DSL
    * Users of the library no longer need to care about the implementing class
    * Facilitates adding more options in the future without breaking existing implementations
  * SASL improvements
 
 v0.3.1
 
-  * Added more documentation to public methods/classes
-  * Fixed exception when sending multiple lines at once (e.g. when connecting!)
+ * Added more documentation to public methods/classes
+ * Fixed exception when sending multiple lines at once (e.g. when connecting!)
 
 v0.3.0
 
-  * Simplified how messages are constructed.
-    Instead of: client.send(joinMessage("#channel"))
-    Now use: client.sendJoin("#channel")
-  * Added reply utility to easily send replies to message events
-  * Server state improvements:
-    * Added status field to ServerState
-    * ServerConnected event is emitted as soon as the socket is connected
-    * ServerReady event is emitted after logging in, negotiating, etc
-  * Added extra debugging to show what type of events are being dispatched
-  * Added ChannelQuit event, raised for each channel a user is in when they quit
-  * (Internal) Event handlers can now return more events to emit
+ * Simplified how messages are constructed.
+   Instead of: client.send(joinMessage("#channel"))
+   Now use: client.sendJoin("#channel")
+ * Added reply utility to easily send replies to message events
+ * Server state improvements:
+   * Added status field to ServerState
+   * ServerConnected event is emitted as soon as the socket is connected
+   * ServerReady event is emitted after logging in, negotiating, etc
+ * Added extra debugging to show what type of events are being dispatched
+ * Added ChannelQuit event, raised for each channel a user is in when they quit
+ * (Internal) Event handlers can now return more events to emit
 
 v0.2.1
 
-  * Added documentation and reduced visibility of some internal methods/classes
-  * (Internal) Enabled Travis, Codacy and Coveralls
+ * Added documentation and reduced visibility of some internal methods/classes
+ * (Internal) Enabled Travis, Codacy and Coveralls
 
 v0.2.0
 
-  * Added support for connecting over TLS
-  * Simplified how event handlers are registered
-  * Improved use of coroutines so users don't have to worry about them
-  * (Internal) Upgraded to Gradle 5.1.1
+ * Added support for connecting over TLS
+ * BREAKING: Simplified how event handlers are registered
+ * BREAKING: Improved use of coroutines so users don't have to worry about them
+ * (Internal) Upgraded to Gradle 5.1.1

docs/index.adoc

 wish to connect to:
 
  * `host` - the hostname or IP address of the server *(required)*
- * `port` - the port to connect on _(default: 6667)_
- * `useTls` - whether to use a secure connection or not _(default: false)_
+ * `port` - the port to connect on _(default: 6697)_
+ * `useTls` - whether to use a secure connection or not _(default: true)_
  * `password` - the password to provide to the server _(default: null)_
 
 An alternative more compact syntax is available for configuring server details:
    in a `MessageReceived` event being returned. Servers that support the
    IRCv3 `echo-message` capability will do this automatically; enabling the
    behaviour will make all servers act the same way _(default: false)_
+ * `preferIPv6` - if enabled, KtIrc will prefer to connect over IPv6 if the
+   server publishes AAAA DNS records. If disabled, KtIrc will prefer IPv4.
+   If the server is available exclusively on IPv4 or IPv6 then this option
+   has no effect. _(default: true)_
 
 The behaviour block is optional in its entirety.
 

src/main/kotlin/com/dmdirc/ktirc/Dsl.kt

  * behaviour {
  *     requestModesOnJoin = true
  *     alwaysEchoMessages = true
+ *     preferIPv6 = false
  * }
  *
  * sasl {
 class ServerConfig {
     /** The hostname (or IP address) of the server to connect to. */
     var host: String = ""
-    /** The port to connect on. Defaults to 6667. */
-    var port: Int = 6667
+    /** The port to connect on. Defaults to 6697. */
+    var port: Int = 6697
     /** Whether or not to use TLS (an encrypted connection). */
-    var useTls: Boolean = false
+    var useTls: Boolean = true
     /** The password required to connect to the server, if any. */
     var password: String? = null
 }
 class BehaviourConfig : ClientBehaviour {
     override var requestModesOnJoin = false
     override var alwaysEchoMessages = false
+    override var preferIPv6 = true
 }

src/main/kotlin/com/dmdirc/ktirc/IrcClient.kt

      */
     val alwaysEchoMessages: Boolean
 
+    /**
+     * If enabled, KtIRC will try to connect to IRC servers over IPv6 if they publish the appropriate DNS entries.
+     *
+     * Otherwise, KtIrc will prefer IPv4.
+     */
+    val preferIPv6: Boolean
+
 }
 
 /**

src/main/kotlin/com/dmdirc/ktirc/IrcClientImpl.kt

 import com.dmdirc.ktirc.messages.*
 import com.dmdirc.ktirc.messages.processors.messageProcessors
 import com.dmdirc.ktirc.model.*
+import com.dmdirc.ktirc.util.RemoveIn
 import com.dmdirc.ktirc.util.currentTimeProvider
 import com.dmdirc.ktirc.util.generateLabel
 import com.dmdirc.ktirc.util.logger
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.map
+import java.net.Inet6Address
+import java.net.InetAddress
 import java.time.Duration
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.logging.Level
 /**
  * Concrete implementation of an [IrcClient].
  */
-// TODO: How should alternative nicknames work?
-// TODO: Should IRC Client take a pool of servers and rotate through, or make the caller do that?
 internal class IrcClientImpl(private val config: IrcClientConfig) : ExperimentalIrcClient, CoroutineScope {
 
     private val log by logger()
     override val coroutineContext = GlobalScope.newCoroutineContext(Dispatchers.IO)
 
     @ExperimentalCoroutinesApi
-    internal var socketFactory: (CoroutineScope, String, Int, Boolean) -> LineBufferedSocket = ::LineBufferedSocketImpl
+    internal var socketFactory: (CoroutineScope, String, String, Int, Boolean) -> LineBufferedSocket = ::LineBufferedSocketImpl
+    internal var resolver: (String) -> Collection<ResolveResult> = { host ->
+        InetAddress.getAllByName(host).map { ResolveResult(it.hostAddress, it is Inet6Address) }
+    }
 
     internal var asyncTimeout = Duration.ofSeconds(20)
 
 
     private val connecting = AtomicBoolean(false)
 
+    @Deprecated("Use structured send instead", ReplaceWith("send(command, arguments)"))
+    @RemoveIn("2.0.0")
     override fun send(message: String) {
         socket?.sendChannel?.offer(message.toByteArray()) ?: log.warning { "No send channel for message: $message" }
     }
     override fun connect() {
         check(!connecting.getAndSet(true))
 
+        val ip: String
+        try {
+            ip = resolve(config.server.host)
+        } catch (ex: Exception) {
+            log.log(Level.SEVERE, ex) { "Error resolving ${config.server.host}" }
+            emitEvent(ServerConnectionError(EventMetadata(currentTimeProvider()), ConnectionError.UnresolvableAddress, ex.localizedMessage))
+            reset()
+            return
+        }
+
         @Suppress("EXPERIMENTAL_API_USAGE")
-        with(socketFactory(this, config.server.host, config.server.port, config.server.useTls)) {
+        with(socketFactory(this, config.server.host, ip, config.server.port, config.server.useTls)) {
             socket = this
 
             emitEvent(ServerConnecting(EventMetadata(currentTimeProvider())))
         }
     }
 
+    private fun resolve(host: String): String {
+        val hosts = resolver(host)
+        val preferredHosts = hosts.filter { it.isV6 == behaviour.preferIPv6 }
+        return if (preferredHosts.isNotEmpty()) {
+            preferredHosts.random().ip
+        } else {
+            hosts.random().ip
+        }
+    }
+
     internal fun reset() {
         serverState.reset()
         channelState.clear()
     }
 
 }
+
+internal data class ResolveResult(val ip: String, val isV6: Boolean)

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

  */
 // TODO: Expose advanced TLS options
 @ExperimentalCoroutinesApi
-internal class LineBufferedSocketImpl(coroutineScope: CoroutineScope, private val host: String, private val port: Int, private val tls: Boolean = false) : CoroutineScope, LineBufferedSocket {
+internal class LineBufferedSocketImpl(coroutineScope: CoroutineScope, private val host: String, private val ip: String, private val port: Int, private val tls: Boolean = false) : CoroutineScope, LineBufferedSocket {
 
     companion object {
         const val CARRIAGE_RETURN = '\r'.toByte()
                     socket = TlsSocket(this@LineBufferedSocketImpl, socket, this, host)
                 }
             }
-            socket.connect(InetSocketAddress(host, port))
-            println("connected!")
+            socket.connect(InetSocketAddress(ip, port))
             writeChannel = socket.write
         }
         launch { writeLines() }

src/test/kotlin/com/dmdirc/ktirc/IrcClientImplTest.kt

 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
+import java.net.UnknownHostException
 import java.nio.channels.UnresolvedAddressException
 import java.security.cert.CertificateException
 import java.util.concurrent.atomic.AtomicReference
 
     companion object {
         private const val HOST = "thegibson.com"
+        private const val HOST2 = "irc.thegibson.com"
+        private const val IP = "127.0.13.37"
         private const val PORT = 12345
         private const val NICK = "AcidBurn"
         private const val REAL_NAME = "Kate Libby"
         every { sendChannel } returns sendLineChannel
     }
 
-    private val mockSocketFactory = mockk<(CoroutineScope, String, Int, Boolean) -> LineBufferedSocket> {
-        every { this@mockk.invoke(any(), eq(HOST), eq(PORT), any()) } returns mockSocket
+    private val mockSocketFactory = mockk<(CoroutineScope, String, String, Int, Boolean) -> LineBufferedSocket> {
+        every { this@mockk.invoke(any(), eq(HOST), eq(IP), eq(PORT), any()) } returns mockSocket
+        every { this@mockk.invoke(any(), eq(HOST2), any(), eq(PORT), any()) } returns mockSocket
+    }
+
+    private val mockResolver = mockk<(String) -> Collection<ResolveResult>> {
+        every { this@mockk.invoke(HOST) } returns listOf(ResolveResult(IP, false))
     }
 
     private val mockEventHandler = mockk<(IrcEvent) -> Unit> {
     private val serverConfig = ServerConfig().apply {
         host = HOST
         port = PORT
+        useTls = false
     }
 
     private val normalConfig = IrcClientConfig(serverConfig, profileConfig, BehaviourConfig(), null)
     fun `uses socket factory to create a new socket on connect`() {
         val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
         client.connect()
 
-        verify(timeout = 500) { mockSocketFactory(client, HOST, PORT, false) }
+        verify(timeout = 500) { mockSocketFactory(client, HOST, IP, PORT, false) }
     }
 
     @Test
             useTls = true
         }, profileConfig, BehaviourConfig(), null))
         client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
+        client.connect()
+
+        verify(timeout = 500) { mockSocketFactory(client, HOST, IP, PORT, true) }
+    }
+
+    @Test
+    fun `prefers ipv6 addresses if behaviour is enabled`() {
+        val client = IrcClientImpl(IrcClientConfig(ServerConfig().apply {
+            host = HOST2
+            port = PORT
+        }, profileConfig, BehaviourConfig().apply { preferIPv6 = true }, null))
+
+        every { mockResolver(HOST2) } returns listOf(
+                ResolveResult(IP, false),
+                ResolveResult("::13:37", true),
+                ResolveResult("0.0.0.0", false)
+        )
+
+        client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
+        client.connect()
+
+        verify(timeout = 500) { mockSocketFactory(client, HOST2, "::13:37", PORT, true) }
+    }
+
+    @Test
+    fun `falls back to ipv4 if no ipv6 addresses are available`() {
+        val client = IrcClientImpl(IrcClientConfig(ServerConfig().apply {
+            host = HOST2
+            port = PORT
+        }, profileConfig, BehaviourConfig().apply { preferIPv6 = true }, null))
+
+        every { mockResolver(HOST2) } returns listOf(
+                ResolveResult("0.0.0.0", false)
+        )
+
+        client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
         client.connect()
 
-        verify(timeout = 500) { mockSocketFactory(client, HOST, PORT, true) }
+        verify(timeout = 500) { mockSocketFactory(client, HOST2, "0.0.0.0", PORT, true) }
+    }
+
+    @Test
+    fun `prefers ipv4 addresses if ipv6 behaviour is disabled`() {
+        val client = IrcClientImpl(IrcClientConfig(ServerConfig().apply {
+            host = HOST2
+            port = PORT
+        }, profileConfig, BehaviourConfig().apply { preferIPv6 = false }, null))
+
+        every { mockResolver(HOST2) } returns listOf(
+                ResolveResult("::13:37", true),
+                ResolveResult("::313:37", true),
+                ResolveResult("0.0.0.0", false)
+        )
+
+        client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
+        client.connect()
+
+        verify(timeout = 500) { mockSocketFactory(client, HOST2, "0.0.0.0", PORT, true) }
+    }
+
+    @Test
+    fun `falls back to ipv6 if no ipv4 addresses available`() {
+        val client = IrcClientImpl(IrcClientConfig(ServerConfig().apply {
+            host = HOST2
+            port = PORT
+        }, profileConfig, BehaviourConfig().apply { preferIPv6 = false }, null))
+
+        every { mockResolver(HOST2) } returns listOf(
+                ResolveResult("::13:37", true)
+        )
+
+        client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
+        client.connect()
+
+        verify(timeout = 500) { mockSocketFactory(client, HOST2, "::13:37", PORT, true) }
+    }
+
+    @Test
+    fun `raises error if dns fails`() {
+        val client = IrcClientImpl(IrcClientConfig(ServerConfig().apply {
+            host = HOST2
+        }, profileConfig, BehaviourConfig().apply { preferIPv6 = true }, null))
+
+        every { mockResolver(HOST2) } throws UnknownHostException("oops")
+
+        client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
+        client.onEvent(mockEventHandler)
+        client.connect()
+
+        verify(timeout = 500) {
+            mockEventHandler(match { it is ServerConnectionError && it.error == ConnectionError.UnresolvableAddress })
+        }
     }
 
     @Test
     fun `throws if socket already exists`() {
         val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
         client.connect()
 
         assertThrows<IllegalStateException> {
 
         val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
         client.onEvent(mockEventHandler)
         client.connect()
 
     fun `sends basic connection strings`() = runBlocking {
         val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
         client.connect()
 
         assertEquals("CAP LS 302", String(sendLineChannel.receive()))
             password = PASSWORD
         }, profileConfig, BehaviourConfig(), null))
         client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
         client.connect()
 
         assertEquals("CAP LS 302", String(sendLineChannel.receive()))
     fun `sends events to provided event handler`() {
         val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
         client.onEvent(mockEventHandler)
 
         GlobalScope.launch {
     fun `sends text to socket`() = runBlocking {
         val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
         client.connect()
 
         client.send("testing 123")
     fun `sends structured text to socket`() = runBlocking {
         val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
         client.connect()
 
         client.send("testing", "123", "456")
         val config = IrcClientConfig(serverConfig, profileConfig, BehaviourConfig().apply { alwaysEchoMessages = true }, null)
         val client = IrcClientImpl(config)
         client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
 
         val slot = slot<MessageReceived>()
         val mockkEventHandler = mockk<(IrcEvent) -> Unit>(relaxed = true)
         val config = IrcClientConfig(serverConfig, profileConfig, BehaviourConfig().apply { alwaysEchoMessages = true }, null)
         val client = IrcClientImpl(config)
         client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
         client.serverState.capabilities.enabledCapabilities[Capability.EchoMessages] = ""
         client.connect()
 
         val config = IrcClientConfig(serverConfig, profileConfig, BehaviourConfig().apply { alwaysEchoMessages = false }, null)
         val client = IrcClientImpl(config)
         client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
         client.connect()
 
         client.onEvent(mockEventHandler)
 
         verify(inverse = true) {
             mockEventHandler(ofType<MessageReceived>())
-        }    }
+        }
+    }
 
     @Test
     fun `sends structured text to socket with tags`() = runBlocking {
         val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
         client.connect()
 
         client.send(tagMap(MessageTag.AccountName to "acidB"), "testing", "123", "456")
     fun `asynchronously sends text to socket without label if cap is missing`() = runBlocking {
         val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
+
         client.connect()
 
         client.sendAsync(tagMap(), "testing", arrayOf("123")) { false }
         generateLabel = { "abc123" }
         val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
+
         client.serverState.capabilities.enabledCapabilities[Capability.LabeledResponse] = ""
         client.connect()
 
         generateLabel = { "abc123" }
         val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
+
         client.serverState.capabilities.enabledCapabilities[Capability.LabeledResponse] = ""
         client.connect()
 
     fun `disconnects the socket`() = runBlocking {
         val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
         client.connect()
 
         client.disconnect()
     fun `sends messages in order`() = runBlocking {
         val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
+        client.resolver = mockResolver
         client.connect()
 
         (0..100).forEach { client.send("TEST", "$it") }
         every { mockSocket.connect() } throws UnresolvedAddressException()
         with(IrcClientImpl(normalConfig)) {
             socketFactory = mockSocketFactory
+            resolver = mockResolver
             withTimeout(500) {
                 launch {
                     delay(50)
         every { mockSocket.connect() } throws CertificateException("Boooo")
         with(IrcClientImpl(normalConfig)) {
             socketFactory = mockSocketFactory
+            resolver = mockResolver
             withTimeout(500) {
                 launch {
                     delay(50)

src/test/kotlin/com/dmdirc/ktirc/io/LineBufferedSocketImplTest.kt

     @Test
     fun `KtorLineBufferedSocket can connect to a server`() = runBlocking {
         ServerSocket(12321).use { serverSocket ->
-            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", 12321)
+            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", "localhost", 12321)
             val clientSocketAsync = GlobalScope.async { serverSocket.accept() }
 
             socket.connect()
     @Test
     fun `KtorLineBufferedSocket can send a byte array to a server`() = runBlocking {
         ServerSocket(12321).use { serverSocket ->
-            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", 12321)
+            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", "localhost", 12321)
             val clientBytesAsync = GlobalScope.async {
                 ByteArray(13).apply {
                     serverSocket.accept().getInputStream().read(this)
     @Test
     fun `KtorLineBufferedSocket can send a string to a server over TLS`() = runBlocking {
         tlsServerSocket(12321).use { serverSocket ->
-            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", 12321, true)
+            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", "localhost", 12321, true)
             socket.tlsTrustManager = getTrustingManager()
             val clientBytesAsync = GlobalScope.async {
                 ByteArray(13).apply {
     @Test
     fun `KtorLineBufferedSocket can receive a line of CRLF delimited text`() = runBlocking {
         ServerSocket(12321).use { serverSocket ->
-            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", 12321)
+            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", "localhost", 12321)
             GlobalScope.launch {
                 serverSocket.accept().getOutputStream().write("Hi there\r\n".toByteArray())
             }
     @Test
     fun `KtorLineBufferedSocket can receive a line of LF delimited text`() = runBlocking {
         ServerSocket(12321).use { serverSocket ->
-            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", 12321)
+            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", "localhost", 12321)
             GlobalScope.launch {
                 serverSocket.accept().getOutputStream().write("Hi there\n".toByteArray())
             }
     @Test
     fun `KtorLineBufferedSocket can receive multiple lines of text in one packet`() = runBlocking {
         ServerSocket(12321).use { serverSocket ->
-            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", 12321)
+            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", "localhost", 12321)
             GlobalScope.launch {
                 serverSocket.accept().getOutputStream().write("Hi there\nThis is a test\r".toByteArray())
             }
     @Test
     fun `KtorLineBufferedSocket can receive multiple long lines of text`() = runBlocking {
         ServerSocket(12321).use { serverSocket ->
-            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", 12321)
+            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", "localhost", 12321)
             val line1 = "abcdefghijklmnopqrstuvwxyz".repeat(500)
             val line2 = "1234567890987654321[];'#,.".repeat(500)
             val line3 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".repeat(500)
     @Test
     fun `KtorLineBufferedSocket can receive one line of text over multiple packets`() = runBlocking {
         ServerSocket(12321).use { serverSocket ->
-            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", 12321)
+            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", "localhost", 12321)
             GlobalScope.launch {
                 with(serverSocket.accept().getOutputStream()) {
                     write("Hi".toByteArray())
     @Test
     fun `KtorLineBufferedSocket returns from readLines when socket is closed`() = runBlocking {
         ServerSocket(12321).use { serverSocket ->
-            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", 12321)
+            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", "localhost", 12321)
             GlobalScope.launch {
                 with(serverSocket.accept()) {
                     getOutputStream().write("Hi there\r\n".toByteArray())
     @Test
     fun `KtorLineBufferedSocket disconnects from server`() = runBlocking {
         ServerSocket(12321).use { serverSocket ->
-            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", 12321)
+            val socket = LineBufferedSocketImpl(GlobalScope, "localhost", "localhost", 12321)
             val clientSocketAsync = GlobalScope.async { serverSocket.accept() }
 
             socket.connect()