315 lines
11 KiB
Rust
315 lines
11 KiB
Rust
//! The core: owns the [`Server`] state, the command table and the module list,
|
|
//! and turns a stream of [`Event`]s into IRC. Everything here runs on one
|
|
//! thread, so no state is ever locked.
|
|
|
|
use std::collections::HashMap;
|
|
use std::net::{SocketAddr, TcpStream};
|
|
use std::sync::mpsc::{Receiver, Sender};
|
|
|
|
use crate::command::Command;
|
|
use crate::config::Config;
|
|
use crate::coremods::command_table;
|
|
use crate::message;
|
|
use crate::module::{Hook, ModResult, Module};
|
|
use crate::numeric::{ERR_NEEDMOREPARAMS, ERR_NOTREGISTERED, ERR_UNKNOWNCOMMAND};
|
|
use crate::server::Server;
|
|
use crate::socketengine::OutSink;
|
|
use crate::Uid;
|
|
|
|
/// What the I/O threads hand to the core.
|
|
pub enum Event {
|
|
Connect {
|
|
uid: Uid,
|
|
addr: SocketAddr,
|
|
out: OutSink,
|
|
sock: Option<TcpStream>,
|
|
secure: bool,
|
|
link: bool, // a server-to-server connection, not a client
|
|
outbound: bool, // (link) we dialed them
|
|
},
|
|
Line {
|
|
uid: Uid,
|
|
line: String,
|
|
},
|
|
Disconnect {
|
|
uid: Uid,
|
|
},
|
|
/// A client's connect-time DNS work finished: the reverse-DNS hostname
|
|
/// (`None` = none confirmed) and the DNSBL outcome.
|
|
ResolvedHost {
|
|
uid: Uid,
|
|
host: Option<String>,
|
|
dnsbl: crate::modules::dnsbl::Outcome,
|
|
},
|
|
/// Background timer tick — drives ping/idle timeouts.
|
|
Tick,
|
|
}
|
|
|
|
pub struct Ircd {
|
|
server: Server,
|
|
commands: HashMap<&'static str, Box<dyn Command>>,
|
|
modules: Vec<Box<dyn Module>>,
|
|
}
|
|
|
|
impl Ircd {
|
|
pub fn new(cfg: Config, event_tx: Sender<Event>) -> Ircd {
|
|
Ircd {
|
|
server: Server::new(cfg, event_tx),
|
|
commands: command_table(),
|
|
modules: crate::modules::default_modules(),
|
|
}
|
|
}
|
|
|
|
/// Run until the event channel closes (i.e. the listener is gone).
|
|
pub fn run(mut self, rx: Receiver<Event>) {
|
|
for ev in rx {
|
|
match ev {
|
|
Event::Connect {
|
|
uid,
|
|
addr,
|
|
out,
|
|
sock,
|
|
secure,
|
|
link,
|
|
outbound,
|
|
} => {
|
|
if link {
|
|
self.server.add_link(uid, addr, out, sock, outbound);
|
|
} else {
|
|
self.server.add_conn(uid, addr, out, sock, secure);
|
|
}
|
|
}
|
|
Event::Line { uid, line } => {
|
|
if self.server.links.contains_key(&uid) {
|
|
if let Some(msg) = message::parse(&line) {
|
|
self.server.on_link(uid, &msg);
|
|
}
|
|
} else {
|
|
self.on_line(uid, &line);
|
|
}
|
|
}
|
|
Event::Disconnect { uid } => {
|
|
if self.server.links.contains_key(&uid) {
|
|
self.server.close_link(uid, "Connection closed");
|
|
} else {
|
|
self.quit_user(uid, "Connection closed");
|
|
}
|
|
}
|
|
Event::ResolvedHost { uid, host, dnsbl } => {
|
|
self.server.on_resolved(uid, host, dnsbl);
|
|
// now that the notice block has printed, replay the handshake
|
|
// lines we held while resolving
|
|
for line in self.server.take_deferred(uid) {
|
|
if !self.server.users.contains_key(&uid) {
|
|
break; // a replayed QUIT/ban already dropped them
|
|
}
|
|
self.on_line(uid, &line);
|
|
}
|
|
self.try_register(uid); // DNS may have been the last thing we waited on
|
|
}
|
|
Event::Tick => self.on_tick(),
|
|
}
|
|
self.drain_hooks();
|
|
}
|
|
}
|
|
|
|
fn on_line(&mut self, uid: Uid, line: &str) {
|
|
let Some(msg) = message::parse(line) else {
|
|
return;
|
|
};
|
|
// stash this line's client-only tags for TAGMSG / PRIVMSG relay
|
|
self.server.line_ctags = msg.ctags.clone();
|
|
// any valid line means the connection is alive
|
|
if let Some(u) = self.server.users.get_mut(&uid) {
|
|
u.last_active = crate::server::now();
|
|
u.ping_sent = false;
|
|
}
|
|
let cmd = msg.command.as_str();
|
|
let registered = self
|
|
.server
|
|
.users
|
|
.get(&uid)
|
|
.map(|u| u.registered)
|
|
.unwrap_or(false);
|
|
|
|
// Hold the handshake while the connect-time DNS/DNSBL lookups run, so the
|
|
// "*** ..." notices print as one block; replayed in Event::ResolvedHost.
|
|
if !registered && self.server.defer_if_resolving(uid, line) {
|
|
return;
|
|
}
|
|
|
|
// module pre-command gate
|
|
for m in &mut self.modules {
|
|
if m.on_pre_command(&mut self.server, uid, cmd, &msg.params) == ModResult::Deny {
|
|
return;
|
|
}
|
|
}
|
|
// message pre-hook (PRIVMSG/NOTICE)
|
|
if matches!(cmd, "PRIVMSG" | "NOTICE") && msg.params.len() >= 2 {
|
|
let (target, text) = (msg.params[0].clone(), msg.params[1].clone());
|
|
for m in &mut self.modules {
|
|
if m.on_pre_message(&mut self.server, uid, &target, &text) == ModResult::Deny {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
let Some(handler) = self.commands.get(cmd) else {
|
|
if registered {
|
|
self.server
|
|
.numeric(uid, ERR_UNKNOWNCOMMAND, &format!("{cmd} :Unknown command"));
|
|
}
|
|
return;
|
|
};
|
|
if !registered && !handler.before_reg() {
|
|
self.server
|
|
.numeric(uid, ERR_NOTREGISTERED, ":You have not registered");
|
|
return;
|
|
}
|
|
if msg.params.len() < handler.min_params() {
|
|
self.server.numeric(
|
|
uid,
|
|
ERR_NEEDMOREPARAMS,
|
|
&format!("{cmd} :Not enough parameters"),
|
|
);
|
|
return;
|
|
}
|
|
let _ = handler.handle(&mut self.server, uid, &msg.params);
|
|
|
|
for m in &mut self.modules {
|
|
m.on_post_command(&mut self.server, uid, cmd);
|
|
}
|
|
|
|
// a command may have asked to quit (QUIT)
|
|
if let Some(reason) = self.server.take_quit(uid) {
|
|
self.quit_user(uid, &reason);
|
|
return;
|
|
}
|
|
// …or completed the registration handshake
|
|
if !registered {
|
|
self.try_register(uid);
|
|
}
|
|
}
|
|
|
|
/// Finish registration if NICK, USER, CAP and the reverse-DNS lookup are all
|
|
/// done. Called after each command and when a DNS result arrives.
|
|
fn try_register(&mut self, uid: Uid) {
|
|
let ready = self
|
|
.server
|
|
.users
|
|
.get(&uid)
|
|
.map(|u| {
|
|
!u.registered
|
|
&& !u.nick.is_empty()
|
|
&& !u.ident.is_empty()
|
|
&& !u.cap
|
|
&& !u.dns_pending
|
|
})
|
|
.unwrap_or(false);
|
|
if ready {
|
|
self.complete_registration(uid);
|
|
}
|
|
}
|
|
|
|
fn complete_registration(&mut self, uid: Uid) {
|
|
for m in &mut self.modules {
|
|
if m.on_user_register(&mut self.server, uid) == ModResult::Deny {
|
|
self.server.send(
|
|
uid,
|
|
"ERROR :Closing link (registration refused)".to_string(),
|
|
);
|
|
self.server.remove_user(uid, "Registration refused");
|
|
return;
|
|
}
|
|
}
|
|
// x-line: refuse a banned host / ip before welcoming
|
|
let (ident, host, ip) = {
|
|
let u = &self.server.users[&uid];
|
|
(u.ident.clone(), u.host.clone(), u.addr.ip().to_string())
|
|
};
|
|
if let Some(reason) = self.server.matched_xline(&ident, &host, &ip) {
|
|
self.server
|
|
.send(uid, format!("ERROR :Closing link: ({reason})"));
|
|
self.server.remove_user(uid, &reason);
|
|
return;
|
|
}
|
|
self.server.welcome(uid);
|
|
}
|
|
|
|
fn quit_user(&mut self, uid: Uid, reason: &str) {
|
|
if !self.server.users.contains_key(&uid) {
|
|
return;
|
|
}
|
|
let registered = self.server.users[&uid].registered;
|
|
if registered {
|
|
// fire the quit hook while the user still exists
|
|
for m in &mut self.modules {
|
|
m.on_user_quit(&mut self.server, uid, reason);
|
|
}
|
|
}
|
|
self.server.remove_user(uid, reason);
|
|
}
|
|
|
|
/// Background timer: PING idle clients, reap the unresponsive and the
|
|
/// never-registered.
|
|
fn on_tick(&mut self) {
|
|
self.server.ping_links(); // keepalive on every server link
|
|
self.server.purge_xlines(); // drop expired server bans
|
|
let now = crate::server::now();
|
|
let (to_ping, to_quit) = self.server.idle_check(now);
|
|
for uid in to_ping {
|
|
let token = self.server.name.clone();
|
|
self.server.send(uid, format!("PING :{token}"));
|
|
if let Some(u) = self.server.users.get_mut(&uid) {
|
|
u.ping_sent = true;
|
|
}
|
|
}
|
|
for uid in to_quit {
|
|
let reg = self
|
|
.server
|
|
.users
|
|
.get(&uid)
|
|
.map(|u| u.registered)
|
|
.unwrap_or(false);
|
|
let reason = if reg {
|
|
"Ping timeout"
|
|
} else {
|
|
"Registration timeout"
|
|
};
|
|
self.server
|
|
.send(uid, format!("ERROR :Closing link: ({reason})"));
|
|
self.quit_user(uid, reason);
|
|
}
|
|
}
|
|
|
|
/// Fire queued notify-hooks. Draining a queue (not iterating in place) lets a
|
|
/// hook enqueue more work (e.g. a module forcing a join) without surprises.
|
|
fn drain_hooks(&mut self) {
|
|
while let Some(hook) = self.server.events.pop_front() {
|
|
match hook {
|
|
Hook::Connect(uid) => {
|
|
for m in &mut self.modules {
|
|
m.on_user_connect(&mut self.server, uid);
|
|
}
|
|
// burst to links after modules (so the cloak is already set)
|
|
self.server.introduce_to_links(uid);
|
|
}
|
|
Hook::Join(uid, chan) => {
|
|
for m in &mut self.modules {
|
|
m.on_join(&mut self.server, uid, &chan);
|
|
}
|
|
}
|
|
Hook::Part(uid, chan, reason) => {
|
|
for m in &mut self.modules {
|
|
m.on_part(&mut self.server, uid, &chan, &reason);
|
|
}
|
|
}
|
|
Hook::Quit(uid, reason) => {
|
|
for m in &mut self.modules {
|
|
m.on_user_quit(&mut self.server, uid, &reason);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|