// InspIRCd spanning-tree link protocol. Handshake + UID + PING mirror the // sequence in Network-Links (protocols/inspircd.py); mode/burst details get // firmed up against a live insp4 uplink. use fedserv_api::{NetAction, NetEvent, Protocol}; use std::time::{SystemTime, UNIX_EPOCH}; pub struct InspIrcd { sid: String, name: String, password: String, protocol: u32, ts: u64, } impl InspIrcd { pub fn new(name: String, sid: String, password: String, protocol: u32, ts: u64) -> Self { Self { sid, name, password, protocol, ts } } fn from_us(&self, cmd: String) -> String { format!(":{} {}", self.sid, cmd) } } impl Protocol for InspIrcd { fn handshake(&mut self) -> Vec { vec![ format!("CAPAB START {}", self.protocol), format!("CAPAB CAPABILITIES :PROTOCOL={}", self.protocol), "CAPAB END".to_string(), format!("SERVER {} {} {} :{}", self.name, self.password, self.sid, "Federated Services"), ] } fn parse(&mut self, line: &str) -> Vec { // Strip an optional IRCv3 message-tag prefix (@k=v;… ) — insp tags PRIVMSGs // with time/msgid, and it sits before the :source. let line = match line.strip_prefix('@') { Some(rest) => rest.splitn(2, ' ').nth(1).unwrap_or(""), None => line, }; let (source, rest) = match line.strip_prefix(':') { Some(s) => { let mut it = s.splitn(2, ' '); (Some(it.next().unwrap_or("").to_string()), it.next().unwrap_or("")) } None => (None, line), }; let mut tokens = rest.split(' '); let cmd = match tokens.next() { Some(c) => c, None => return vec![], }; match cmd.to_ascii_uppercase().as_str() { "SERVER" => vec![NetEvent::Registered], "ENDBURST" => vec![NetEvent::EndBurst], "PING" => { let token = tokens .next() .unwrap_or("") .trim_start_matches(':') .to_string(); vec![NetEvent::Ping { token, from: source }] } "PRIVMSG" => { let to = tokens.next().unwrap_or("").to_string(); vec![NetEvent::Privmsg { from: source.unwrap_or_default(), to, text: trailing(rest), }] } // UID … — track who's online so services can // resolve a sender's current nick. // UID … — take the // displayed host for ban masks. "UID" => { let a: Vec<&str> = tokens.collect(); match (a.first(), a.get(2)) { (Some(uid), Some(nick)) => { let host = a.get(4).unwrap_or(&"").to_string(); vec![NetEvent::UserConnect { uid: uid.to_string(), nick: nick.to_string(), host }] } _ => vec![], } } // : NICK — keep the sender's current nick // fresh, so nick-based commands (IDENTIFY/REGISTER) act on who they // are now, not their nick at burst time (e.g. after a guest rename). "NICK" => match (source, tokens.next()) { (Some(uid), Some(nick)) if !nick.is_empty() => { vec![NetEvent::NickChange { uid, nick: nick.to_string() }] } _ => vec![], }, // FJOIN [params] : — channel create/burst. // Each member is ","; surface a Join for each. "FJOIN" => { // Mode section is everything before the " :" trailing. let head: Vec<&str> = rest.split(" :").next().unwrap_or(rest).split_whitespace().collect(); let chan = head.get(1).copied().unwrap_or(""); if chan.is_empty() { vec![] } else { let mut out = vec![NetEvent::ChannelCreate { channel: chan.to_string() }]; if let Some(modes) = head.get(3) { if let Some(key) = scan_key(modes, head.get(4..).unwrap_or(&[])) { out.push(NetEvent::ChannelKey { channel: chan.to_string(), key }); } } // Members are ",[:]"; the prefixes are the // status mode letters, so 'o' means they join opped. for m in trailing(rest).split_whitespace() { if let Some((prefix, member)) = m.split_once(',') { let uid = member.split(':').next().unwrap_or(""); if !uid.is_empty() { out.push(NetEvent::Join { uid: uid.to_string(), channel: chan.to_string(), op: prefix.contains('o') }); if prefix.contains('v') { out.push(NetEvent::ChannelVoice { channel: chan.to_string(), uid: uid.to_string(), voice: true }); } } } } out } } // : IJOIN — a single user joining an existing channel (not opped). "IJOIN" => match (source.as_deref(), tokens.next()) { (Some(uid), Some(chan)) if chan.starts_with('#') => { vec![NetEvent::Join { uid: uid.to_string(), channel: chan.to_string(), op: false }] } _ => vec![], }, // : PART [:reason] — a user leaving a channel. "PART" => match (source.as_deref(), tokens.next()) { (Some(uid), Some(chan)) if chan.starts_with('#') => { vec![NetEvent::Part { uid: uid.to_string(), channel: chan.to_string() }] } _ => vec![], }, // : KICK : — a user removed from a channel. "KICK" => { let chan = tokens.next().unwrap_or(""); match tokens.next() { Some(uid) if chan.starts_with('#') => { vec![NetEvent::Part { uid: uid.to_string(), channel: chan.to_string() }] } _ => vec![], } } // : FMODE [params] — a channel mode change. // Skip changes we made ourselves so enforcement can't loop. "FMODE" => { let a: Vec<&str> = tokens.collect(); match (source.as_deref(), a.first(), a.get(2)) { // Our own uids (server SID + pseudoclients) share our SID prefix. (Some(src), Some(chan), Some(modes)) if !src.starts_with(self.sid.as_str()) && chan.starts_with('#') => { let params = a.get(3..).unwrap_or(&[]); let mut out = vec![NetEvent::ChannelModeChange { channel: chan.to_string(), modes: modes.to_string() }]; if let Some(key) = scan_key(modes, params) { out.push(NetEvent::ChannelKey { channel: chan.to_string(), key }); } for (op, uid) in scan_status(modes, params, 'o') { out.push(NetEvent::ChannelOp { channel: chan.to_string(), uid, op }); } for (voice, uid) in scan_status(modes, params, 'v') { out.push(NetEvent::ChannelVoice { channel: chan.to_string(), uid, voice }); } out } _ => vec![], } } // : FTOPIC [setby] : — a topic // change. Skip changes we made ourselves so enforcement can't loop. "FTOPIC" => { let a: Vec<&str> = tokens.collect(); match (source.as_deref(), a.first()) { (Some(src), Some(chan)) if !src.starts_with(self.sid.as_str()) && chan.starts_with('#') => { vec![NetEvent::TopicChange { channel: chan.to_string(), setter: src.to_string(), topic: trailing(rest) }] } _ => vec![], } } "QUIT" => vec![NetEvent::Quit { uid: source.unwrap_or_default() }], // account-registration relay from an ircd: // ACCTREGISTER : "ACCTREGISTER" => { let a: Vec<&str> = tokens.by_ref().take(5).collect(); if a.len() == 5 { vec![NetEvent::AccountRequest { reqid: a[0].to_string(), origin: a[1].to_string(), kind: a[2].to_string(), account: a[3].to_string(), p2: a[4].to_string(), p3: trailing(rest), }] } else { vec![] } } // ENCAP … — we only care about relayed SASL: // ENCAP SASL [data…] "ENCAP" => { let _target = tokens.next(); match tokens.next().map(|s| s.to_ascii_uppercase()).as_deref() { Some("SASL") => { let p: Vec<&str> = tokens.collect(); if p.len() >= 3 { vec![NetEvent::Sasl { client: p[0].to_string(), agent: p[1].to_string(), mode: p[2].to_string(), data: p[3..].iter().map(|s| s.to_string()).collect(), }] } else { vec![] } } _ => vec![NetEvent::Unknown { line: line.to_string() }], } } _ => vec![NetEvent::Unknown { line: line.to_string() }], } } fn serialize(&mut self, action: &NetAction) -> Vec { match action { NetAction::Burst => vec![self.from_us(format!("BURST {}", self.ts))], NetAction::EndBurst => vec![self.from_us("ENDBURST".to_string())], NetAction::Pong { token, from } => { let dest = from.clone().unwrap_or_else(|| self.sid.clone()); vec![self.from_us(format!("PONG {} {}", dest, token))] } // insp4 UID: uuid nickts nick realhost disphost realuser dispuser ip signonts +modes :gecos // (both a real AND a displayed user field — see m_spanningtree/uid.cpp Builder). NetAction::IntroduceUser { uid, nick, ident, host, gecos } => vec![self.from_us(format!( "UID {uid} {ts} {nick} {host} {host} {ident} {ident} 0.0.0.0 {ts} +i :{gecos}", uid = uid, ts = self.ts, nick = nick, host = host, ident = ident, gecos = gecos ))], NetAction::Privmsg { from, to, text } => { vec![format!(":{} PRIVMSG {} :{}", from, to, text)] } NetAction::Notice { from, to, text } => { vec![format!(":{} NOTICE {} :{}", from, to, text)] } // ACCTREGRESULT : NetAction::AccountResponse { reqid, kind, account, status, code, message } => { vec![self.from_us(format!( "ACCTREGRESULT {} {} {} {} {} :{}", reqid, kind, account, status, code, message ))] } // ENCAP * SASL [data…] NetAction::Sasl { agent, client, mode, data } => { let mut line = format!("ENCAP * SASL {} {} {}", agent, client, mode); for d in data { line.push(' '); line.push_str(d); } vec![self.from_us(line)] } // METADATA : — "*" is server-global metadata. NetAction::Metadata { target, key, value } => { vec![self.from_us(format!("METADATA {} {} :{}", target, key, value))] } // SVSNICK — the new nick takes the current // time as its TS so it wins any collision resolution. NetAction::QuitUser { uid, reason } => vec![format!(":{} QUIT :{}", uid, reason)], NetAction::ServiceJoin { uid, channel } => vec![format!(":{} IJOIN {}", uid, channel)], NetAction::ServicePart { uid, channel } => vec![format!(":{} PART {}", uid, channel)], // ENCAP the target's server: CHGHOST , to set a vhost. NetAction::SetHost { uid, host } => { let target = uid.get(..3).unwrap_or(uid.as_str()); vec![self.from_us(format!("ENCAP {} CHGHOST {} {}", target, uid, host))] } NetAction::SetIdent { uid, ident } => { let target = uid.get(..3).unwrap_or(uid.as_str()); vec![self.from_us(format!("ENCAP {} CHGIDENT {} {}", target, uid, ident))] } NetAction::ForceNick { uid, nick } => { let now = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(self.ts); vec![self.from_us(format!("SVSNICK {} {} {}", uid, nick, now))] } // SVSJOIN [key]: force a user into a channel, sourced from // the services server. Used to apply an account's auto-join list. NetAction::ForceJoin { uid, channel, key } => { if key.is_empty() { vec![self.from_us(format!("SVSJOIN {} {}", uid, channel))] } else { vec![self.from_us(format!("SVSJOIN {} {} {}", uid, channel, key))] } } // FMODE . The ircd drops an FMODE whose TS is newer // than the channel's, so we send TS 1 to guarantee it applies. Sourced // from the given pseudoclient (e.g. ChanServ) so users see who set it, // or from the services server when `from` is empty. NetAction::ChannelMode { from, channel, modes } => { let cmd = format!("FMODE {} 1 {}", channel, modes); if from.is_empty() { vec![self.from_us(cmd)] } else { vec![format!(":{} {}", from, cmd)] } } NetAction::Kick { from, channel, uid, reason } => { vec![format!(":{} KICK {} {} :{}", from, channel, uid, reason)] } // FTOPIC :. TS 1 so the ircd // always accepts it; sourced from the given pseudoclient. NetAction::Topic { from, channel, topic } => { let now = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(self.ts); vec![format!(":{} FTOPIC {} 1 {} {} :{}", from, channel, now, from, topic)] } // INVITE . Expiry 0 = no expiry. NetAction::Invite { from, uid, channel } => { vec![format!(":{} INVITE {} {} 1 0", from, uid, channel)] } NetAction::Raw(s) => vec![s.clone()], // Internal: the link layer handles these before serialization. NetAction::DeferRegister { .. } | NetAction::DeferPassword { .. } | NetAction::SendEmail { .. } => vec![], } } fn sid(&self) -> &str { &self.sid } } // Whether a channel mode consumes a parameter, for standard InspIRCd chanmodes. // List and prefix modes take one on both set and unset; the key takes one on // both; the rest that take one do so only on set. fn takes_param(m: char, adding: bool) -> bool { match m { 'b' | 'e' | 'I' | 'q' | 'a' | 'o' | 'h' | 'v' | 'k' => true, 'l' | 'L' | 'f' | 'j' | 'J' | 'F' | 'H' => adding, _ => false, } } // Walk a mode change and its params for a key (+k/-k). Returns Some(Some(key)) // when a key is set, Some(None) when cleared, None when `k` isn't in the change. fn scan_key(modes: &str, params: &[&str]) -> Option> { let mut adding = true; let mut pi = 0; let mut result = None; for m in modes.chars() { match m { '+' => adding = true, '-' => adding = false, 'k' => { result = Some(if adding { params.get(pi).map(|s| s.to_string()) } else { None }); pi += 1; } c if takes_param(c, adding) => pi += 1, _ => {} } } result } // Walk a mode change and its params for grants/revokes of one status mode // (`want`, e.g. 'o' or 'v'). Returns (is_set, uid) per match, using the same // param cursor as scan_key. fn scan_status(modes: &str, params: &[&str], want: char) -> Vec<(bool, String)> { let mut adding = true; let mut pi = 0; let mut out = Vec::new(); for m in modes.chars() { match m { '+' => adding = true, '-' => adding = false, c if c == want => { if let Some(p) = params.get(pi) { out.push((adding, p.to_string())); } pi += 1; } c if takes_param(c, adding) => pi += 1, _ => {} } } out } // The IRC "trailing" argument: everything after the first " :", else the last word. fn trailing(rest: &str) -> String { match rest.find(" :") { Some(i) => rest[i + 2..].to_string(), None => rest.rsplit(' ').next().unwrap_or("").to_string(), } } #[cfg(test)] mod tests { use super::*; fn proto() -> InspIrcd { InspIrcd::new("services.test".into(), "42S".into(), "pw".into(), 1206, 1) } // A remote nick change must surface as a NickChange for the source uid, or // nick-based commands act on a stale nick. #[test] fn parses_nick_change() { let ev = proto().parse(":0IRAAAAAB NICK newnick 1783833000"); assert!( matches!(ev.as_slice(), [NetEvent::NickChange { uid, nick }] if uid == "0IRAAAAAB" && nick == "newnick"), "{ev:?}" ); } // A UID burst introduces the user under their current nick. #[test] fn parses_uid_burst() { let ev = proto().parse(":0IR UID 0IRAAAAAB 1783833000 alice host host user user 0.0.0.0 1783833000 +i :real"); assert!( matches!(ev.as_slice(), [NetEvent::UserConnect { uid, nick, .. }] if uid == "0IRAAAAAB" && nick == "alice"), "{ev:?}" ); } // FJOIN (channel create/burst) surfaces as ChannelCreate for the channel, and // the member's uid is taken without its :membid suffix. #[test] fn parses_fjoin_as_channel_create() { let ev = proto().parse(":0IR FJOIN #chan 1783845132 +tn :o,0IRAAAAAB:0"); assert!(matches!(ev.first(), Some(NetEvent::ChannelCreate { channel }) if channel == "#chan"), "{ev:?}"); assert!(ev.iter().any(|e| matches!(e, NetEvent::Join { uid, .. } if uid == "0IRAAAAAB")), "{ev:?}"); } // A peer FMODE surfaces as a mode change; our own (sid 42S) is filtered out. #[test] fn parses_fmode_and_filters_own() { let ev = proto().parse(":0IRAAAAAB FMODE #chan 1783845132 +m"); assert!( matches!(ev.as_slice(), [NetEvent::ChannelModeChange { channel, modes }] if channel == "#chan" && modes == "+m"), "{ev:?}" ); let ev = proto().parse(":42S FMODE #chan 1783845132 -m"); assert!(!ev.iter().any(|e| matches!(e, NetEvent::ChannelModeChange { .. })), "own change filtered: {ev:?}"); } // FMODE and an FJOIN prefix both surface voice status changes. #[test] fn parses_voice_status() { // +o then +v with two params: op for the first uid, voice for the second. let ev = proto().parse(":0IRAAAAAB FMODE #chan 1783845132 +ov 0IRAAAAAB 0IRAAAAAC"); assert!(ev.iter().any(|e| matches!(e, NetEvent::ChannelOp { uid, op: true, .. } if uid == "0IRAAAAAB")), "op: {ev:?}"); assert!(ev.iter().any(|e| matches!(e, NetEvent::ChannelVoice { uid, voice: true, .. } if uid == "0IRAAAAAC")), "voice: {ev:?}"); // A -v revokes voice. let ev = proto().parse(":0IRAAAAAB FMODE #chan 1783845132 -v 0IRAAAAAC"); assert!(ev.iter().any(|e| matches!(e, NetEvent::ChannelVoice { uid, voice: false, .. } if uid == "0IRAAAAAC")), "devoice: {ev:?}"); // A +v join prefix surfaces a voice event alongside the Join. let ev = proto().parse(":0IR FJOIN #chan 1783845132 +tn :v,0IRAAAAAD"); assert!(ev.iter().any(|e| matches!(e, NetEvent::ChannelVoice { uid, voice: true, .. } if uid == "0IRAAAAAD")), "join voice: {ev:?}"); } // A vhost is set by ENCAP'ing the target's own server with CHGHOST / CHGIDENT. #[test] fn serializes_set_host() { let lines = proto().serialize(&NetAction::SetHost { uid: "0IRAAAAAB".into(), host: "cool.example".into() }); assert_eq!(lines, vec![":42S ENCAP 0IR CHGHOST 0IRAAAAAB cool.example".to_string()]); let lines = proto().serialize(&NetAction::SetIdent { uid: "0IRAAAAAB".into(), ident: "cool".into() }); assert_eq!(lines, vec![":42S ENCAP 0IR CHGIDENT 0IRAAAAAB cool".to_string()]); } #[test] fn parses_ftopic_and_filters_own() { let ev = proto().parse(":0IRAAAAAB FTOPIC #chan 1783845132 1783845140 :Welcome all"); assert!( matches!(ev.as_slice(), [NetEvent::TopicChange { channel, setter, topic }] if channel == "#chan" && setter == "0IRAAAAAB" && topic == "Welcome all"), "{ev:?}" ); // The burst/RESYNC form carries a setby field before the topic. let ev = proto().parse(":0IRAAAAAB FTOPIC #chan 1783845132 1783845140 someone!u@h :Hi there"); assert!(matches!(ev.as_slice(), [NetEvent::TopicChange { topic, .. }] if topic == "Hi there"), "{ev:?}"); // Our own topic changes are filtered so enforcement can't loop. let ev = proto().parse(":42S FTOPIC #chan 1 1 :nope"); assert!(!ev.iter().any(|e| matches!(e, NetEvent::TopicChange { .. })), "own change filtered: {ev:?}"); } // FJOIN members and IJOIN both surface as Join events. #[test] fn parses_joins() { let ev = proto().parse(":0IR FJOIN #chan 1783845132 +nt :o,0IRAAAAAB ,0IRAAAAAC"); assert!(matches!(ev.first(), Some(NetEvent::ChannelCreate { channel }) if channel == "#chan")); let joins: Vec<&str> = ev.iter().filter_map(|e| match e { NetEvent::Join { uid, .. } => Some(uid.as_str()), _ => None, }).collect(); assert_eq!(joins, ["0IRAAAAAB", "0IRAAAAAC"]); let ev = proto().parse(":0IRAAAAAD IJOIN #chan"); assert!(matches!(ev.as_slice(), [NetEvent::Join { uid, channel, op: false }] if uid == "0IRAAAAAD" && channel == "#chan"), "{ev:?}"); } }