Rudimentary capabilities support

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

@@ -60,7 +60,7 @@ class IrcClientImpl(private val server: Server, private val profile: Profile) :
             with(socketFactory(server.host, server.port)) {
                 socket = this
                 connect()
-                // TODO: CAP LS
+                sendLine("CAP LS 302")
                 server.password?.let { pass -> sendLine(passwordMessage(pass)) }
                 sendLine(nickMessage(profile.initialNick))
                 // TODO: Send correct host
@@ -81,11 +81,11 @@ class IrcClientImpl(private val server: Server, private val profile: Profile) :
             }
 
             runBlocking {
-                val client = IrcClientImpl(Server("uk.quakenet.org", 6667), Profile("KtIrc", "Kotlin!", "kotlin"))
+                val client = IrcClientImpl(Server("testnet.inspircd.org", 6667), Profile("KtIrc", "Kotlin!", "kotlin"))
                 client.eventHandler = object : EventHandler {
                     override suspend fun processEvent(client: IrcClient, event: IrcEvent) {
                         when (event) {
-                            is ServerWelcome -> client.send(joinMessage("#mdbot"))
+                            is ServerWelcome -> client.send(joinMessage("#ktirc"))
                             is MessageReceived -> if (event.message == "!test") client.send(privmsgMessage(event.target, "Test successful!"))
                         }
                     }

src/main/kotlin/com/dmdirc/ktirc/events/CapabilitiesHandler.kt

@@ -0,0 +1,49 @@
+package com.dmdirc.ktirc.events
+
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.messages.capabilityEndMessage
+import com.dmdirc.ktirc.messages.capabilityRequestMessage
+import com.dmdirc.ktirc.model.CapabilitiesNegotiationState
+import com.dmdirc.ktirc.model.CapabilitiesState
+import com.dmdirc.ktirc.model.Capability
+import com.dmdirc.ktirc.util.logger
+
+class CapabilitiesHandler : EventHandler {
+
+    private val log by logger()
+
+    override suspend fun processEvent(client: IrcClient, event: IrcEvent) {
+        when (event) {
+            is ServerCapabilitiesReceived -> handleCapabilitiesReceived(client.serverState.capabilities, event.capabilities)
+            is ServerCapabilitiesFinished -> handleCapabilitiesFinished(client)
+            is ServerCapabilitiesAcknowledged -> handleCapabilitiesAcknowledged(client, event.capabilities)
+        }
+    }
+
+    private fun handleCapabilitiesReceived(state: CapabilitiesState, capabilities: Map<Capability, String>) {
+        state.advertisedCapabilities.putAll(capabilities)
+    }
+
+    private suspend fun handleCapabilitiesFinished(client: IrcClient) {
+        // TODO: We probably need to split the outgoing REQ lines if there are lots of caps
+        // TODO: For caps with values we'll need to decide which value to use/whether to enable them/etc
+        with (client.serverState.capabilities) {
+            negotiationState = CapabilitiesNegotiationState.AWAITING_ACK
+            advertisedCapabilities.keys.map { it.name }.let {
+                log.info { "Requesting capabilities: ${it.toList()}" }
+                client.send(capabilityRequestMessage(it))
+            }
+        }
+    }
+
+    private suspend fun handleCapabilitiesAcknowledged(client: IrcClient, capabilities: Map<Capability, String>) {
+        // TODO: Check if everything we wanted is enabled
+        with (client.serverState.capabilities) {
+            log.info { "Acknowledged capabilities: ${capabilities.keys.map { it.name }.toList()}" }
+            negotiationState = CapabilitiesNegotiationState.FINISHED
+            enabledCapabilities.putAll(capabilities)
+            client.send(capabilityEndMessage())
+        }
+    }
+
+}

src/main/kotlin/com/dmdirc/ktirc/events/EventHandler.kt

@@ -9,6 +9,7 @@ interface EventHandler {
 }
 
 val eventHandlers = setOf(
+        CapabilitiesHandler(),
         ChannelStateHandler(),
         PingHandler(),
         ServerStateHandler()

src/main/kotlin/com/dmdirc/ktirc/events/Events.kt

@@ -2,6 +2,7 @@
 
 package com.dmdirc.ktirc.events
 
+import com.dmdirc.ktirc.model.Capability
 import com.dmdirc.ktirc.model.ServerFeatureMap
 import com.dmdirc.ktirc.model.User
 
@@ -37,3 +38,12 @@ data class MessageReceived(val user: User, val target: String, val message: Stri
 
 /** Raised when a user quits. */
 data class UserQuit(val user: User, val reason: String = "") : IrcEvent()
+
+/** Raised when available server capabilities are received. More batches may follow. */
+data class ServerCapabilitiesReceived(val capabilities: Map<Capability, String>): IrcEvent()
+
+/** Raised when our requested capabilities are acknowledged. More batches may follow. */
+data class ServerCapabilitiesAcknowledged(val capabilities: Map<Capability, String>): IrcEvent()
+
+/** Raised when the server has finished sending us capabilities. */
+object ServerCapabilitiesFinished : IrcEvent()

src/main/kotlin/com/dmdirc/ktirc/messages/CapabilityProcessor.kt

@@ -0,0 +1,47 @@
+package com.dmdirc.ktirc.messages
+
+import com.dmdirc.ktirc.events.ServerCapabilitiesAcknowledged
+import com.dmdirc.ktirc.events.ServerCapabilitiesFinished
+import com.dmdirc.ktirc.events.ServerCapabilitiesReceived
+import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.capabilities
+import com.dmdirc.ktirc.util.logger
+
+class CapabilityProcessor : MessageProcessor {
+
+    private val log by logger()
+
+    override val commands = arrayOf("CAP")
+
+    override fun process(message: IrcMessage) = when (message.subCommand) {
+        "LS" -> handleList(message.subCommandArguments)
+        "ACK" -> listOf(ServerCapabilitiesAcknowledged(message.params.capabilities))
+        else -> emptyList()
+    }
+
+    private fun handleList(lsParams: List<ByteArray>) = sequence {
+        yield(ServerCapabilitiesReceived(lsParams.capabilities))
+        if (lsParams.size < 2 || String(lsParams[0]) != "*") {
+            yield(ServerCapabilitiesFinished)
+        }
+    }.toList()
+
+    private val IrcMessage.subCommand
+        get() = String(params[1])
+
+    private val IrcMessage.subCommandArguments
+        get() = params.slice(1 until params.size)
+
+    private val List<ByteArray>.capabilities
+        get() = String(last()).split(' ').toCapabilities()
+
+    private fun List<String>.toCapabilities() = sequence {
+        forEach { cap ->
+            val index = cap.indexOf('=')
+            val name = if (index == -1) cap else cap.substring(0 until index)
+            val value = if (index == -1) "" else cap.substring(index + 1)
+            capabilities[name]?.let { yield(Pair(it, value)) } ?: log.info { "Unknown capability: $name (value: $value)" }
+        }
+    }.toMap()
+
+}

src/main/kotlin/com/dmdirc/ktirc/messages/MessageBuilders.kt

@@ -1,5 +1,7 @@
 package com.dmdirc.ktirc.messages
 
+fun capabilityEndMessage() = "CAP END"
+fun capabilityRequestMessage(capabilities: List<String>) = "CAP REQ :${capabilities.joinToString(" ")}"
 fun joinMessage(channel: String) = "JOIN :$channel"
 fun nickMessage(nick: String) = "NICK :$nick"
 fun passwordMessage(password: String) = "PASS :$password"

src/main/kotlin/com/dmdirc/ktirc/messages/MessageProcessor.kt

@@ -18,6 +18,7 @@ interface MessageProcessor {
 }
 
 val messageProcessors = setOf(
+        CapabilityProcessor(),
         ISupportProcessor(),
         JoinProcessor(),
         NamesProcessor(),

src/main/kotlin/com/dmdirc/ktirc/model/CapabilitiesState.kt

@@ -0,0 +1,41 @@
+package com.dmdirc.ktirc.model
+
+class CapabilitiesState {
+
+    var negotiationState: CapabilitiesNegotiationState = CapabilitiesNegotiationState.AWAITING_LIST
+
+    val advertisedCapabilities = HashMap<Capability, String>()
+    val enabledCapabilities = HashMap<Capability, String>()
+
+}
+
+enum class CapabilitiesNegotiationState {
+
+    AWAITING_LIST,
+    AWAITING_ACK,
+    FINISHED
+
+}
+
+sealed class Capability(val name: String) {
+    // Capabilities that enable more information in message tags:
+    object ServerTimeMessageTag : Capability("server-time") // TODO: Parse this and expose time in events
+    object UserAccountMessageTag : Capability("account-tag") // TODO: Add accounts to user info
+
+    // Capabilities that extend existing commands to supply extra information:
+    object HostsInNamesReply : Capability("userhost-in-names") // TODO: Parse these hosts
+    object MultipleUserModePrefixes : Capability("multi-prefix")
+    object AccountAndRealNameInJoinMessages : Capability("extended-join") // TODO: Parse this
+
+    // Capabilities that affect how messages are sent/received:
+    object EchoMessages : Capability("echo-message")
+
+    // Capabilities that notify us of changes to other clients:
+    object AccountChangeMessages : Capability("account-notify")
+    object AwayStateMessages : Capability("away-notify")
+    object HostChangeMessages : Capability("chghost")
+}
+
+val capabilities: Map<String, Capability> by lazy {
+    Capability::class.nestedClasses.map { it.objectInstance as Capability }.associateBy { it.name }
+}

src/main/kotlin/com/dmdirc/ktirc/model/ServerState.kt

@@ -7,6 +7,7 @@ class ServerState(initialNickname: String) {
 
     var localNickname: String = initialNickname
     val features = ServerFeatureMap()
+    val capabilities = CapabilitiesState()
 
 }
 
@@ -38,7 +39,7 @@ data class ModePrefixMapping(val modes: String, val prefixes: String) {
 sealed class ServerFeature<T : Any>(val name: String, val type: KClass<T>, val default: T? = null) {
     object ServerCaseMapping : ServerFeature<CaseMapping>("CASEMAPPING", CaseMapping::class, CaseMapping.Rfc)
     object ModePrefixes : ServerFeature<ModePrefixMapping>("PREFIX", ModePrefixMapping::class, ModePrefixMapping("ov", "@+"))
-    object MaximumChannels : ServerFeature<Int>("CHANLIMIT", Int::class)
+    object MaximumChannels : ServerFeature<Int>("MAXCHANNELS", Int::class) // TODO: CHANLIMIT also exists
     object ChannelModes : ServerFeature<String>("CHANMODES", String::class)
     object MaximumChannelNameLength : ServerFeature<Int>("CHANNELLEN", Int::class, 200)
     object WhoxSupport : ServerFeature<Boolean>("WHOX", Boolean::class, false)

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

@@ -79,6 +79,7 @@ internal class IrcClientImplTest {
             client.connect()
 
             with(inOrder(mockSocket).verify(mockSocket)) {
+                sendLine("CAP LS 302")
                 sendLine("NICK :$NICK")
                 sendLine("USER $USER_NAME localhost $HOST :$REAL_NAME")
             }
@@ -95,6 +96,7 @@ internal class IrcClientImplTest {
             client.connect()
 
             with(inOrder(mockSocket).verify(mockSocket)) {
+                sendLine("CAP LS 302")
                 sendLine("PASS :$PASSWORD")
                 sendLine("NICK :$NICK")
             }

src/test/kotlin/com/dmdirc/ktirc/events/CapabilitiesHandlerTest.kt

@@ -0,0 +1,96 @@
+package com.dmdirc.ktirc.events
+
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.model.CapabilitiesNegotiationState
+import com.dmdirc.ktirc.model.Capability
+import com.dmdirc.ktirc.model.ServerState
+import com.nhaarman.mockitokotlin2.argThat
+import com.nhaarman.mockitokotlin2.doReturn
+import com.nhaarman.mockitokotlin2.mock
+import com.nhaarman.mockitokotlin2.verify
+import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class CapabilitiesHandlerTest {
+
+    private val handler = CapabilitiesHandler()
+    private val serverState = ServerState("")
+    private val ircClient = mock<IrcClient> {
+        on { serverState } doReturn serverState
+    }
+
+    @Test
+    fun `CapabilitiesHandler adds new capabilities to the state`() {
+        runBlocking {
+            handler.processEvent(ircClient, ServerCapabilitiesReceived(hashMapOf(
+                    Capability.EchoMessages to "",
+                    Capability.HostsInNamesReply to "123"
+            )))
+
+            assertEquals(2, serverState.capabilities.advertisedCapabilities.size)
+            assertEquals("", serverState.capabilities.advertisedCapabilities[Capability.EchoMessages])
+            assertEquals("123", serverState.capabilities.advertisedCapabilities[Capability.HostsInNamesReply])
+        }
+    }
+
+    @Test
+    fun `CapabilitiesHandler updates negotiation state when capabilities finished`() {
+        runBlocking {
+            handler.processEvent(ircClient, ServerCapabilitiesFinished)
+
+            assertEquals(CapabilitiesNegotiationState.AWAITING_ACK, serverState.capabilities.negotiationState)
+        }
+    }
+
+    @Test
+    fun `CapabilitiesHandler sends REQ when capabilities received`() {
+        runBlocking {
+            serverState.capabilities.advertisedCapabilities[Capability.EchoMessages] = ""
+            serverState.capabilities.advertisedCapabilities[Capability.AccountChangeMessages] = ""
+
+            handler.processEvent(ircClient, ServerCapabilitiesFinished)
+
+            verify(ircClient).send(argThat { equals("CAP REQ :echo-message account-notify") || equals("CAP REQ :account-notify echo-message") })
+        }
+    }
+
+    @Test
+    fun `CapabilitiesHandler sends END when capabilities acknowledged`() {
+        runBlocking {
+            handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(hashMapOf(
+                    Capability.EchoMessages to "",
+                    Capability.HostsInNamesReply to "123"
+            )))
+
+            verify(ircClient).send("CAP END")
+        }
+    }
+
+    @Test
+    fun `CapabilitiesHandler updates negotiation state when capabilities acknowledged`() {
+        runBlocking {
+            handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(hashMapOf(
+                    Capability.EchoMessages to "",
+                    Capability.HostsInNamesReply to "123"
+            )))
+
+            assertEquals(CapabilitiesNegotiationState.FINISHED, serverState.capabilities.negotiationState)
+        }
+    }
+
+    @Test
+    fun `CapabilitiesHandler stores enabled caps when capabilities acknowledged`() {
+        runBlocking {
+            handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(hashMapOf(
+                    Capability.EchoMessages to "",
+                    Capability.HostsInNamesReply to "123"
+            )))
+
+            assertEquals(2, serverState.capabilities.enabledCapabilities.size)
+            assertEquals("", serverState.capabilities.enabledCapabilities[Capability.EchoMessages])
+            assertEquals("123", serverState.capabilities.enabledCapabilities[Capability.HostsInNamesReply])
+        }
+    }
+
+}

src/test/kotlin/com/dmdirc/ktirc/messages/CapabilityProcessorTest.kt

@@ -0,0 +1,81 @@
+package com.dmdirc.ktirc.messages
+
+import com.dmdirc.ktirc.events.ServerCapabilitiesAcknowledged
+import com.dmdirc.ktirc.events.ServerCapabilitiesFinished
+import com.dmdirc.ktirc.events.ServerCapabilitiesReceived
+import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.Capability
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+
+internal class CapabilityProcessorTest {
+
+    private val processor = CapabilityProcessor()
+
+    @Test
+    fun `CapabilityProcessor does nothing for unknown subcommand`() {
+        val events = processor.process(IrcMessage(null, "the.gibson".toByteArray(), "CAP", listOf("*".toByteArray(), "FOO".toByteArray())))
+
+        assertTrue(events.isEmpty())
+    }
+
+    @Test
+    fun `CapabilityProcessor raises ServerCapabilitiesReceived event with known capabilities`() {
+        val events = processor.process(IrcMessage(null, "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "chghost extended-join invalid").map { it.toByteArray() }))
+
+        val receivedEvent = events.filterIsInstance<ServerCapabilitiesReceived>()[0]
+        assertEquals(2, receivedEvent.capabilities.size)
+        assertTrue(Capability.HostChangeMessages in receivedEvent.capabilities)
+        assertTrue(Capability.AccountAndRealNameInJoinMessages in receivedEvent.capabilities)
+    }
+
+    @Test
+    fun `CapabilityProcessor raises ServerCapabilitiesReceived event with values for capabilities`() {
+        val events = processor.process(IrcMessage(null, "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "chghost=test123 extended-join=abc=def invalid").map { it.toByteArray() }))
+
+        val receivedEvent = events.filterIsInstance<ServerCapabilitiesReceived>()[0]
+        assertEquals(2, receivedEvent.capabilities.size)
+        assertEquals("test123", receivedEvent.capabilities[Capability.HostChangeMessages])
+        assertEquals("abc=def", receivedEvent.capabilities[Capability.AccountAndRealNameInJoinMessages])
+    }
+
+    @Test
+    fun `CapabilityProcessor overwrites earlier values with later ones for identical capabilities`() {
+        val events = processor.process(IrcMessage(null, "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "chghost=test123 chghost chghost=456").map { it.toByteArray() }))
+
+        val receivedEvent = events.filterIsInstance<ServerCapabilitiesReceived>()[0]
+        assertEquals(1, receivedEvent.capabilities.size)
+        assertEquals("456", receivedEvent.capabilities[Capability.HostChangeMessages])
+    }
+
+
+    @Test
+    fun `CapabilityProcessor raises ServerCapabilitiesReceived event with known capabilities for multi-line responses`() {
+        val events = processor.process(IrcMessage(null, "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "*", "chghost extended-join invalid").map { it.toByteArray() }))
+
+        val receivedEvent = events.filterIsInstance<ServerCapabilitiesReceived>()[0]
+        assertEquals(2, receivedEvent.capabilities.size)
+        assertTrue(Capability.HostChangeMessages in receivedEvent.capabilities)
+        assertTrue(Capability.AccountAndRealNameInJoinMessages in receivedEvent.capabilities)
+    }
+
+    @Test
+    fun `CapabilityProcessor raises ServerCapabilitiesFinished event for final LS responses`() {
+        val events = processor.process(IrcMessage(null, "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "chghost extended-join invalid").map { it.toByteArray() }))
+
+        assertEquals(2, events.size)
+        assertTrue(events[1] is ServerCapabilitiesFinished)
+    }
+
+    @Test
+    fun `CapabilityProcessor raises ServerCapabilitiesAcknowledged event`() {
+        val events = processor.process(IrcMessage(null, "the.gibson".toByteArray(), "CAP", listOf("*", "ACK", "chghost=test123 extended-join=abc=def invalid").map { it.toByteArray() }))
+
+        val receivedEvent = events.filterIsInstance<ServerCapabilitiesAcknowledged>()[0]
+        assertEquals(2, receivedEvent.capabilities.size)
+        assertEquals("test123", receivedEvent.capabilities[Capability.HostChangeMessages])
+        assertEquals("abc=def", receivedEvent.capabilities[Capability.AccountAndRealNameInJoinMessages])
+    }
+
+}

src/test/kotlin/com/dmdirc/ktirc/messages/ISupportProcessorTest.kt

@@ -20,7 +20,7 @@ internal class ISupportProcessorTest {
     @Test
     fun `ISupportProcessor handles multiple numeric arguments`() {
         val events = processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
-                listOf("nickname", "CHANLIMIT=123", "CHANNELLEN=456", "are supported blah blah").map { it.toByteArray() }))
+                listOf("nickname", "MAXCHANNELS=123", "CHANNELLEN=456", "are supported blah blah").map { it.toByteArray() }))
 
         assertEquals(123, events[0].serverFeatures[ServerFeature.MaximumChannels])
         assertEquals(456, events[0].serverFeatures[ServerFeature.MaximumChannelNameLength])

src/test/kotlin/com/dmdirc/ktirc/messages/MessageBuildersTest.kt

@@ -1,10 +1,16 @@
 package com.dmdirc.ktirc.messages
 
-import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 
 internal class MessageBuildersTest {
 
+    @Test
+    fun `CapabilityRequestMessage creates CAP REQ message with single argument`() = assertEquals("CAP REQ :a", capabilityRequestMessage(listOf("a")))
+
+    @Test
+    fun `CapabilityRequestMessage creates CAP REQ message with multiple args`() = assertEquals("CAP REQ :a b c", capabilityRequestMessage(listOf("a b c")))
+
     @Test
     fun `JoinMessage creates correct JOIN message`() = assertEquals("JOIN :#Test123", joinMessage("#Test123"))
 
@@ -17,6 +23,9 @@ internal class MessageBuildersTest {
     @Test
     fun `PongMessage creates correct PONG message`() = assertEquals("PONG :abcdef", pongMessage("abcdef".toByteArray()))
 
+    @Test
+    fun `PrivmsgMessage creates correct PRIVMSG message`() = assertEquals("PRIVMSG acidBurn :Hack the planet!", privmsgMessage("acidBurn", "Hack the planet!"))
+
     @Test
     fun `UserMessage creates correct USER message`() = assertEquals("USER AcidBurn localhost gibson :Kate", userMessage("AcidBurn", "localhost", "gibson", "Kate"))
 

src/test/kotlin/com/dmdirc/ktirc/model/CapabilitiesStateTest.kt

@@ -0,0 +1,15 @@
+package com.dmdirc.ktirc.model
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class CapabilitiesStateTest {
+
+    @Test
+    fun `CapabilitiesState defaults negotiation state to awaiting list`() {
+        val capabilitiesState = CapabilitiesState()
+
+        assertEquals(CapabilitiesNegotiationState.AWAITING_LIST, capabilitiesState.negotiationState)
+    }
+
+}