Initial commit
This commit is contained in:
weishaupt
@@ -0,0 +1,288 @@
|
||||
package irc
|
||||
|
||||
import data.ServerConfig
|
||||
import kotlinx.coroutines.*
|
||||
import kotlinx.coroutines.channels.Channel
|
||||
import java.io.BufferedReader
|
||||
import java.io.InputStreamReader
|
||||
import java.io.OutputStreamWriter
|
||||
import java.io.PrintWriter
|
||||
import java.net.Socket
|
||||
import javax.net.ssl.SSLSocket
|
||||
import javax.net.ssl.SSLSocketFactory
|
||||
|
||||
// TEMP DEBUG (see task: closed-channel-doesn't-receive-messages investigation) - remove
|
||||
// once the overnight rejoin issue is confirmed fixed. Prefixed so it's easy to grep out.
|
||||
private fun ircDebug(serverId: String, msg: String) {
|
||||
println("[irc-debug][$serverId] $msg")
|
||||
}
|
||||
|
||||
// Extra buffer after end-of-MOTD (376/422) before actually sending on-connect commands -
|
||||
// see runPostRegistration(). Some networks' services genuinely aren't ready the same
|
||||
// instant MOTD ends; this is cheap insurance on top of that already-real trigger.
|
||||
private const val POST_MOTD_IDENTIFY_DELAY_MS = 1500L
|
||||
|
||||
// on-connect commands are meant to be raw IRC protocol lines (e.g.
|
||||
// "PRIVMSG NickServ :IDENTIFY password"), but the app's own chat window teaches
|
||||
// "/msg NickServ IDENTIFY password" as the correct thing to type (it IS correct there -
|
||||
// ChannelWindow.kt's onSend translates that shorthand before sending) - an easy, natural
|
||||
// mistake to reuse that exact phrasing in the on-connect-commands field, which has no such
|
||||
// translation and just writes the string to the socket byte-for-byte. A real network
|
||||
// confirmed this: the raw line got rejected outright with "421 Unknown command" before
|
||||
// NickServ ever saw it, since IRC servers have no "/msg" command. This makes on-connect
|
||||
// commands tolerant of that shorthand too, so either form works.
|
||||
private fun translateOnConnectCommand(cmd: String): String {
|
||||
val trimmed = cmd.trim()
|
||||
if (!trimmed.startsWith("/msg ", ignoreCase = true)) return cmd
|
||||
val rest = trimmed.substring(5).trim()
|
||||
val spaceIdx = rest.indexOf(' ')
|
||||
if (spaceIdx <= 0) return cmd
|
||||
val target = rest.substring(0, spaceIdx)
|
||||
val message = rest.substring(spaceIdx + 1).trim()
|
||||
if (message.isEmpty()) return cmd
|
||||
return "PRIVMSG $target :$message"
|
||||
}
|
||||
|
||||
/**
|
||||
* Owns one socket to one IRC server. Emits raw parsed lines via onLine.
|
||||
* Handles registration (NICK/USER), and basic auto-reconnect with backoff.
|
||||
*/
|
||||
class IrcConnection(
|
||||
val config: ServerConfig,
|
||||
private val scope: CoroutineScope,
|
||||
private val onLine: (ParsedLine) -> Unit,
|
||||
private val onStatus: (String) -> Unit
|
||||
) {
|
||||
// @Volatile: read from the outbox-consumer coroutine, written from the read-loop
|
||||
// coroutine - without it there's no cross-thread visibility guarantee, so the outbox
|
||||
// consumer could keep observing a stale non-null `writer` from a socket that already
|
||||
// closed (or a stale null after a new one connected), silently mis-routing sends.
|
||||
@Volatile private var socket: Socket? = null
|
||||
@Volatile private var writer: PrintWriter? = null
|
||||
private var readJob: Job? = null
|
||||
private var wantConnected = false
|
||||
private var backoffMillis = 2000L
|
||||
|
||||
// Every channel we're currently in, whether from config.autoJoinChannels or joined
|
||||
// manually mid-session - so a reconnect rejoins everything, not just the original
|
||||
// auto-join list.
|
||||
private val joinedChannels = java.util.concurrent.CopyOnWriteArraySet<String>()
|
||||
|
||||
// Guards runPostRegistration() against running twice for the same connection cycle
|
||||
// (376 and 422 are mutually exclusive per RFC, but this is cheap insurance) - reset
|
||||
// to false at the top of every connect attempt so a reconnect re-arms it.
|
||||
@Volatile private var registeredHandled = false
|
||||
|
||||
// Outgoing lines go through a single serial consumer instead of one
|
||||
// scope.launch(Dispatchers.IO) per send() call. That old approach had two problems:
|
||||
// (1) no ordering guarantee between independently-scheduled coroutines on a thread
|
||||
// pool dispatcher, and (2) if the socket dropped between a send() call being made and
|
||||
// its coroutine actually running, `writer` would already be null and the line was
|
||||
// silently discarded with no trace - which made a dropped JOIN indistinguishable from
|
||||
// one that was never requested. This queue preserves order and gives a single place
|
||||
// to log what actually made it onto the wire vs. what got dropped.
|
||||
private val outbox = Channel<String>(Channel.UNLIMITED)
|
||||
|
||||
init {
|
||||
scope.launch(Dispatchers.IO) {
|
||||
for (raw in outbox) {
|
||||
val w = writer
|
||||
if (w == null) {
|
||||
// Kept (unlike the old per-line CHECKPOINT4 write-confirmation logging,
|
||||
// removed - it fired on every single outbound line and was real
|
||||
// console-I/O overhead under busy-channel volume, per println being
|
||||
// synchronized/blocking) - this specific case should be rare and is
|
||||
// worth knowing about if it ever happens.
|
||||
ircDebug(config.id, "DROPPED (writer is null - not connected): \"$raw\"")
|
||||
} else {
|
||||
w.println(raw)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun connect() {
|
||||
wantConnected = true
|
||||
readJob?.cancel()
|
||||
readJob = scope.launch(Dispatchers.IO) {
|
||||
while (wantConnected && isActive) {
|
||||
var fallbackJob: Job? = null
|
||||
try {
|
||||
onStatus("Connecting to ${config.host}:${config.port}...")
|
||||
ircDebug(config.id, "connecting to ${config.host}:${config.port} (tracked channels: $joinedChannels)")
|
||||
val sock: Socket = if (config.useTls) {
|
||||
val sslSocket = SSLSocketFactory.getDefault().createSocket(config.host, config.port) as SSLSocket
|
||||
val sslParams = sslSocket.sslParameters
|
||||
sslParams.endpointIdentificationAlgorithm = "HTTPS"
|
||||
sslSocket.sslParameters = sslParams
|
||||
sslSocket.startHandshake()
|
||||
sslSocket
|
||||
} else {
|
||||
Socket(config.host, config.port)
|
||||
}
|
||||
socket = sock
|
||||
val out = PrintWriter(OutputStreamWriter(sock.getOutputStream(), Charsets.UTF_8), true)
|
||||
writer = out
|
||||
|
||||
// Used to send "CAP REQ :sasl" here whenever config.saslUser was set, but
|
||||
// there was never any AUTHENTICATE/CAP END follow-through - SASL isn't
|
||||
// actually implemented (there's no UI to even set saslUser/saslPass). Per
|
||||
// the IRCv3 CAP spec, a compliant server MUST hold off sending 001 until
|
||||
// it sees CAP END, so starting a negotiation the client can never finish
|
||||
// risked silently stalling registration forever on strict servers -
|
||||
// meaning 001/376/422 (and therefore the on-connect identify command)
|
||||
// would never fire at all. Removed until SASL is actually implemented
|
||||
// end-to-end.
|
||||
out.println("NICK ${config.nick}")
|
||||
out.println("USER ${config.nick} 0 * :${config.nick}")
|
||||
|
||||
backoffMillis = 2000L
|
||||
onStatus("Connected, registering...")
|
||||
registeredHandled = false
|
||||
// On-connect commands (identify, etc.) used to fire straight off 001 -
|
||||
// technically "registered" but too early on plenty of real networks:
|
||||
// NickServ/services in general aren't guaranteed ready for PRIVMSGs the
|
||||
// instant 001 lands, which is exactly why real clients (mIRC, HexChat,
|
||||
// irssi) fire "perform"/on-connect scripts off end-of-MOTD (376/422)
|
||||
// instead - see runPostRegistration(). This matches that convention, with
|
||||
// an 8s fallback in case a server never sends either (rare, but some
|
||||
// minimal/bouncer-style endpoints omit MOTD numerics entirely).
|
||||
fallbackJob = scope.launch {
|
||||
delay(8000)
|
||||
if (!registeredHandled) {
|
||||
ircDebug(config.id, "no 376/422 within 8s of connecting - running perform+rejoin anyway (fallback)")
|
||||
runPostRegistration()
|
||||
}
|
||||
}
|
||||
|
||||
val reader = BufferedReader(InputStreamReader(sock.getInputStream(), Charsets.UTF_8))
|
||||
while (isActive) {
|
||||
val line = reader.readLine() ?: break
|
||||
handleRawLine(line)
|
||||
}
|
||||
} catch (e: Exception) {
|
||||
onStatus("Connection error: ${e.message}")
|
||||
ircDebug(config.id, "connection dropped: ${e.message} - tracked channels at drop time: $joinedChannels")
|
||||
} finally {
|
||||
fallbackJob?.cancel()
|
||||
closeSocketQuietly()
|
||||
}
|
||||
|
||||
if (wantConnected) {
|
||||
onStatus("Reconnecting in ${backoffMillis / 1000}s...")
|
||||
ircDebug(config.id, "reconnecting in ${backoffMillis}ms")
|
||||
delay(backoffMillis)
|
||||
backoffMillis = (backoffMillis * 2).coerceAtMost(60_000L)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun handleRawLine(line: String) {
|
||||
// Used to log every single raw line here (RECV: "...") - removed. It was the
|
||||
// single highest-volume debug line in the app: one per incoming line, every line,
|
||||
// forever, and println is synchronized/blocking - a real, measurable cost in a
|
||||
// busy channel, not just noise. The specific 001/376/422 confirmations below are
|
||||
// once-per-connect and stay.
|
||||
if (line.startsWith("PING")) {
|
||||
val token = line.substringAfter("PING ")
|
||||
send("PONG $token")
|
||||
return
|
||||
}
|
||||
val parsed = parseIrcLine(line) ?: return
|
||||
|
||||
// CTCP requests arrive as a PRIVMSG wrapped in \x01...\x01. VERSION gets
|
||||
// handled right here so it never shows up in a channel/PM window - real
|
||||
// clients answer these silently too.
|
||||
if (parsed.command == "PRIVMSG") {
|
||||
val text = parsed.params.getOrNull(1)
|
||||
if (text != null && text.startsWith("") && text.endsWith("") && text.length > 1) {
|
||||
val ctcpBody = text.removePrefix("").removeSuffix("")
|
||||
val ctcpCommand = ctcpBody.substringBefore(' ').uppercase()
|
||||
if (ctcpCommand == "VERSION") {
|
||||
val replyTo = nickFromPrefix(parsed.prefix)
|
||||
if (replyTo != null) {
|
||||
send("NOTICE $replyTo :VERSION It's an irc client, fucko!")
|
||||
}
|
||||
return
|
||||
}
|
||||
// Other CTCP types (ACTION, PING, etc.) fall through to onLine as normal -
|
||||
// ACTION in particular still needs to reach ConnectionManager to render as /me.
|
||||
}
|
||||
}
|
||||
|
||||
if (parsed.command == "001") {
|
||||
ircDebug(config.id, "registered (001) - awaiting end-of-MOTD (376/422) before perform+rejoin")
|
||||
}
|
||||
if (parsed.command == "376" || parsed.command == "422") {
|
||||
runPostRegistration()
|
||||
}
|
||||
onLine(parsed)
|
||||
}
|
||||
|
||||
// Runs the on-connect ("perform") commands - NickServ/ChanServ identify, etc. - then
|
||||
// rejoins every channel we were actually in (the configured auto-join list plus
|
||||
// anything joined manually mid-session, so a reconnect doesn't forget those). Fired
|
||||
// off end-of-MOTD rather than bare 001 - see the comment in connect() for why - so
|
||||
// identify commands land once the session is actually settled enough for services to
|
||||
// reliably act on them.
|
||||
private fun runPostRegistration() {
|
||||
if (registeredHandled) return
|
||||
registeredHandled = true
|
||||
// The whole sequence (identify, then rejoin) runs inside this delayed coroutine
|
||||
// rather than just delaying the identify send - keeping both here preserves "run
|
||||
// identify before joining anything that might require it" (rejoin used to run
|
||||
// synchronously right after, which would otherwise now race ahead of a delayed
|
||||
// identify send and reach the wire first). The delay itself is a few extra hundred
|
||||
// ms of insurance on top of an already-real event (376/422) rather than a fixed
|
||||
// guess from connection time - some networks' NickServ genuinely isn't ready to
|
||||
// process a command in the same instant MOTD ends.
|
||||
scope.launch(Dispatchers.IO) {
|
||||
delay(POST_MOTD_IDENTIFY_DELAY_MS)
|
||||
config.onConnectCommands.forEach { cmd ->
|
||||
if (cmd.isNotBlank()) send(translateOnConnectCommand(cmd))
|
||||
}
|
||||
val rejoinList = (config.autoJoinChannels + joinedChannels).distinct()
|
||||
ircDebug(config.id, "post-registration - rejoining: $rejoinList")
|
||||
rejoinList.forEach { ch -> joinChannel(ch) }
|
||||
}
|
||||
}
|
||||
|
||||
fun send(raw: String) {
|
||||
outbox.trySend(raw)
|
||||
}
|
||||
|
||||
fun sendMessage(target: String, text: String) {
|
||||
send("PRIVMSG $target :$text")
|
||||
}
|
||||
|
||||
fun joinChannel(channel: String) {
|
||||
joinedChannels.add(channel)
|
||||
ircDebug(config.id, "joinChannel($channel) - tracked set now: $joinedChannels")
|
||||
send("JOIN $channel")
|
||||
}
|
||||
|
||||
fun partChannel(channel: String, reason: String = "") {
|
||||
joinedChannels.remove(channel)
|
||||
ircDebug(config.id, "partChannel($channel) - tracked set now: $joinedChannels")
|
||||
send("PART $channel :$reason")
|
||||
}
|
||||
fun kick(channel: String, nick: String, reason: String = "") = send("KICK $channel $nick :$reason")
|
||||
fun setMode(channel: String, modeChange: String, nick: String) = send("MODE $channel $modeChange $nick")
|
||||
fun ban(channel: String, mask: String) = send("MODE $channel +b $mask")
|
||||
|
||||
fun disconnect() {
|
||||
wantConnected = false
|
||||
scope.launch(Dispatchers.IO) {
|
||||
try { writer?.println("QUIT :leaving") } catch (_: Exception) {}
|
||||
readJob?.cancel()
|
||||
closeSocketQuietly()
|
||||
}
|
||||
}
|
||||
|
||||
private fun closeSocketQuietly() {
|
||||
try { socket?.close() } catch (_: Exception) {}
|
||||
socket = null
|
||||
writer = null
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user