fedserv/echo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Group the module crates under modules/

Browse source 
The service pseudo-clients and the ircd protocol link sat flat at the
repo root, mixed in with the daemon core and the SDK. Move them all
under modules/ so the tree separates concerns cleanly: the daemon in
src/, the SDK every module links against in api/, and the loadable
modules — the pseudo-clients plus the protocol link — in modules/.

Workspace members, the daemon's per-crate dependency paths, and each
module's api path are updated to match; the docs follow. No code change.
This commit is contained in:
Jean Chevronnet 2026-07-14 14:19:43 +00:00
parent 6f76f9722c
commit ad2a623120
No known key found for this signature in database
116 changed files with 69 additions and 46 deletions
Download patch file Download diff file Expand all files Collapse all files

184
operserv/src/xline.rs
View file

@ -1,184 +0,0 @@
use fedserv_api::{parse_duration, Sender, ServiceCtx, Store};
use std::time::{SystemTime, UNIX_EPOCH};
// A network-ban command family (AKILL, SQLINE, …): the ircd X-line `kind`, the
// user-facing command `name`, and the mask shape it accepts. One implementation
// drives ADD / DEL / LIST for every kind so they stay consistent.
pub struct Xline {
pub kind: &'static str,
pub name: &'static str,
pub target: &'static str, // e.g. "user@host" or "nick" — shown in syntax
pub normalize: fn(&str) -> Option<String>,
}
impl Xline {
pub fn handle(&self, me: &str, from: &Sender, args: &[&str], ctx: &mut ServiceCtx, db: &mut dyn Store) {
match args.get(1).map(|s| s.to_ascii_uppercase()).as_deref() {
Some("ADD") => self.add(me, from, &args[2..], ctx, db),
Some("DEL") | Some("REMOVE") => self.del(me, from, args.get(2).copied(), ctx, db),
Some("LIST") | Some("VIEW") => self.list(me, from, args.get(2).copied(), ctx, db),
_ => ctx.notice(me, from.uid, format!("Syntax: {0} ADD [+expiry] <{1}> <reason> | {0} DEL <{1}|number> | {0} LIST [pattern]", self.name, self.target)),
}
}
fn add(&self, me: &str, from: &Sender, rest: &[&str], ctx: &mut ServiceCtx, db: &mut dyn Store) {
// An optional leading +duration, then the mask, then a free-text reason.
let mut rest = rest;
let duration = rest.first().and_then(|t| t.strip_prefix('+')).and_then(parse_duration);
if duration.is_some() {
rest = &rest[1..];
}
let Some((&raw, reason_words)) = rest.split_first() else {
ctx.notice(me, from.uid, format!("Syntax: {} ADD [+expiry] <{}> <reason>", self.name, self.target));
return;
};
let Some(mask) = (self.normalize)(raw) else {
ctx.notice(me, from.uid, format!("\x02{raw}\x02 isn't a valid \x02{}\x02 mask.", self.target));
return;
};
if reason_words.is_empty() {
ctx.notice(me, from.uid, "Please give a reason.");
return;
}
if too_wide(&mask) {
ctx.notice(me, from.uid, "That mask is too wide — it would match almost everyone.");
return;
}
let reason = reason_words.join(" ");
let setter = from.account.unwrap_or(from.nick);
let expires = duration.map(|secs| now() + secs);
match db.akill_add(self.kind, &mask, setter, &reason, expires) {
Ok(fresh) => {
ctx.add_line(self.kind, &mask, from.nick, duration.unwrap_or(0), &reason);
let word = if fresh { "added" } else { "updated" };
let expiry = if expires.is_some() { " (temporary)" } else { "" };
ctx.notice(me, from.uid, format!("{} {word} for \x02{mask}\x02{expiry}.", self.name));
}
Err(_) => ctx.notice(me, from.uid, "Sorry, that didn't work. Please try again in a moment."),
}
}
fn del(&self, me: &str, from: &Sender, arg: Option<&str>, ctx: &mut ServiceCtx, db: &mut dyn Store) {
let Some(arg) = arg else {
ctx.notice(me, from.uid, format!("Syntax: {} DEL <{}|number>", self.name, self.target));
return;
};
// A number targets the nth entry of this kind in the list; else a mask.
let mask = match arg.parse::<usize>() {
Ok(n) if n >= 1 => match self.mine(db).get(n - 1) {
Some(mask) => mask.clone(),
None => {
ctx.notice(me, from.uid, format!("There's no {} number \x02{n}\x02.", self.name));
return;
}
},
_ => (self.normalize)(arg).unwrap_or_else(|| arg.to_string()),
};
match db.akill_del(self.kind, &mask) {
Ok(true) => {
ctx.del_line(self.kind, &mask);
ctx.notice(me, from.uid, format!("{} for \x02{mask}\x02 removed.", self.name));
}
Ok(false) => ctx.notice(me, from.uid, format!("No {} matches \x02{mask}\x02.", self.name)),
Err(_) => ctx.notice(me, from.uid, "Sorry, that didn't work. Please try again in a moment."),
}
}
fn list(&self, me: &str, from: &Sender, pattern: Option<&str>, ctx: &mut ServiceCtx, db: &mut dyn Store) {
let pat = pattern.map(|p| p.to_ascii_lowercase());
let mut shown = 0;
for (i, a) in db.akills().iter().filter(|a| a.kind == self.kind).enumerate() {
if let Some(p) = &pat {
if !a.mask.to_ascii_lowercase().contains(p.as_str()) {
continue;
}
}
let expiry = match a.expires {
Some(e) => format!(", expires in {}", human_secs(e.saturating_sub(now()))),
None => String::new(),
};
ctx.notice(me, from.uid, format!("{}. \x02{}\x02 by {} — {}{}", i + 1, a.mask, a.setter, a.reason, expiry));
shown += 1;
}
if shown == 0 {
ctx.notice(me, from.uid, format!("No matching {} entries.", self.name));
} else {
ctx.notice(me, from.uid, format!("End of {} list ({shown} shown).", self.name));
}
}
// The live masks of this kind, in list order (for DEL by number).
fn mine(&self, db: &dyn Store) -> Vec<String> {
db.akills().into_iter().filter(|a| a.kind == self.kind).map(|a| a.mask).collect()
}
}
// AKILL: a user@host G-line. Strips any nick! prefix, lowercases both sides.
pub const AKILL: Xline = Xline { kind: "G", name: "AKILL", target: "user@host", normalize: norm_userhost };
// SQLINE: a nick Q-line. The mask is a nick glob (no '@'); wildcards allowed.
pub const SQLINE: Xline = Xline { kind: "Q", name: "SQLINE", target: "nick", normalize: norm_nick };
// SNLINE: a realname R-line. The mask is a regex the ircd matches against a
// connecting user's realname (use `.` for spaces, e.g. `.*free.money.*`).
pub const SNLINE: Xline = Xline { kind: "R", name: "SNLINE", target: "realname-regex", normalize: norm_realname };
// SHUN: a user@host shun. A matching user stays connected but the ircd silently
// drops their commands — a quieter alternative to an AKILL.
pub const SHUN: Xline = Xline { kind: "SHUN", name: "SHUN", target: "user@host", normalize: norm_userhost };
// CBAN: a channel-name ban. Users can't join (or create) a channel matching the
// mask, which is a channel glob like `#warez*`.
pub const CBAN: Xline = Xline { kind: "CBAN", name: "CBAN", target: "#channel", normalize: norm_channel };
fn norm_userhost(input: &str) -> Option<String> {
let body = input.rsplit('!').next().unwrap_or(input);
let (user, host) = body.split_once('@')?;
if user.is_empty() || host.is_empty() || host.contains('@') {
return None;
}
Some(format!("{}@{}", user.to_ascii_lowercase(), host.to_ascii_lowercase()))
}
fn norm_nick(input: &str) -> Option<String> {
// A nick mask, not a hostmask: reject an '@' so a user typo can't become an
// over-broad ban, and keep it non-empty.
if input.is_empty() || input.contains('@') || input.contains('!') {
return None;
}
Some(input.to_ascii_lowercase())
}
fn norm_realname(input: &str) -> Option<String> {
// A realname regex the ircd evaluates: keep it verbatim (case matters), just
// require it non-empty. A single token — use `.`/`\s` for spaces.
(!input.is_empty()).then(|| input.to_string())
}
fn norm_channel(input: &str) -> Option<String> {
// A channel-name glob: must carry a channel prefix and a non-empty body.
if (!input.starts_with('#') && !input.starts_with('&')) || input.len() < 2 || input.contains(|c: char| c.is_whitespace() || c == ',') {
return None;
}
Some(input.to_ascii_lowercase())
}
// A mask whose every meaningful character is a wildcard would match nearly all.
// A leading channel prefix is ignored so `#*` counts as too wide.
fn too_wide(mask: &str) -> bool {
let body = mask.strip_prefix('#').or_else(|| mask.strip_prefix('&')).unwrap_or(mask);
body.is_empty() || body.chars().all(|c| c == '*' || c == '?' || c == '.' || c == '@')
}
fn human_secs(secs: u64) -> String {
match secs {
0 => "moments".to_string(),
s if s < 3600 => format!("{}m", s / 60),
s if s < 86_400 => format!("{}h", s / 3600),
s => format!("{}d", s / 86_400),
}
}
fn now() -> u64 {
SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0)
}