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

move metadata out of core into its own module file

Browse source
This commit is contained in:
Jean Chevronnet 2026-08-08 22:44:58 +00:00
parent ee98fade40
commit 50a95c6686
4 changed files with 213 additions and 164 deletions
Download patch file Download diff file Expand all files Collapse all files

145
src/coremods/core_message.rs
View file

@ -126,7 +126,6 @@ pub fn commands() -> Vec<Box<dyn Command>> {
Box::new(ChatHistory),
Box::new(Redact),
Box::new(MarkRead),
Box::new(Metadata),
Box::new(Batch),
]
}
@ -161,150 +160,6 @@ impl Command for Batch {
}
}
/// METADATA — draft/metadata-2. `METADATA <target> <GET|LIST|SET|CLEAR> [args]`.
/// `<target>` is `*` (self), a nick, or a `#channel`. Anyone may GET/LIST; only the
/// user themselves or a channel op/oper may SET/CLEAR. Values are public (`*`
/// visibility); a change is pushed as `:<setter> METADATA <target> <key> * [:val]`
/// to metadata-capable viewers (self for a user, members for a channel).
struct Metadata;
impl Command for Metadata {
fn name(&self) -> &'static str {
"METADATA"
}
fn min_params(&self) -> usize {
2
}
fn handle(&self, s: &mut Server, uid: Uid, params: &[String]) -> CmdResult {
let target = params[0].clone();
let sub = params[1].to_ascii_uppercase();
let me_key = format!("u{uid}");
let key = if target == "*" {
me_key.clone()
} else {
match s.meta_key(&target) {
Some(k) => k,
None => {
s.fail(
uid,
"METADATA",
"INVALID_TARGET",
&format!("{target} invalid target"),
);
return CmdResult::Fail;
}
}
};
let reqnick = s
.users
.get(&uid)
.map(|u| u.nick.clone())
.unwrap_or_else(|| "*".to_string());
let disp = if target == "*" {
reqnick.clone()
} else {
target.clone()
};
let can_set = key == me_key
|| (key.starts_with('#') && s.rank(uid, &key) >= RANK_HALFOP)
|| s.is_oper(uid);
match sub.as_str() {
"GET" | "LIST" => {
// GET lists the named keys; LIST lists every set key
let keys: Vec<String> = if sub == "LIST" {
s.metadata
.get(&key)
.map(|m| m.keys().cloned().collect())
.unwrap_or_default()
} else {
params[2..].to_vec()
};
let bref = s.next_msgid().replace('-', "");
s.send(uid, format!(":{} BATCH +{bref} metadata", s.name));
for k in keys {
let line = match s.metadata.get(&key).and_then(|m| m.get(&k)) {
Some(v) => format!(
"@batch={bref} :{} {RPL_KEYVALUE} {reqnick} {disp} {k} * :{v}",
s.name
),
None => format!(
"@batch={bref} :{} {RPL_KEYNOTSET} {reqnick} {disp} {k} :key not set",
s.name
),
};
s.send(uid, line);
}
s.send(uid, format!(":{} BATCH -{bref}", s.name));
}
"SET" => {
if !can_set {
s.fail(
uid,
"METADATA",
"KEY_NO_PERMISSION",
&format!("{disp} permission denied"),
);
return CmdResult::Fail;
}
let Some(mkey) = params.get(2).cloned() else {
s.fail(uid, "METADATA", "KEY_INVALID", "missing key");
return CmdResult::Fail;
};
let value = params.get(3).cloned(); // no value => delete the key
match &value {
Some(v) => {
s.metadata
.entry(key.clone())
.or_default()
.insert(mkey.clone(), v.clone());
}
None => {
if let Some(m) = s.metadata.get_mut(&key) {
m.remove(&mkey);
}
}
}
let setter = s.users.get(&uid).map(|u| u.prefix()).unwrap_or_default();
let note = match &value {
Some(v) => format!(":{setter} METADATA {disp} {mkey} * :{v}"),
None => format!(":{setter} METADATA {disp} {mkey} *"),
};
let recips: Vec<Uid> = if key.starts_with('#') {
s.channels
.get(&key)
.map(|c| c.members.keys().copied().collect())
.unwrap_or_default()
} else {
vec![uid]
};
for r in recips {
if s.users.get(&r).map(|u| u.caps.metadata).unwrap_or(false) {
s.send(r, note.clone());
}
}
}
"CLEAR" => {
if !can_set {
s.fail(
uid,
"METADATA",
"KEY_NO_PERMISSION",
&format!("{disp} permission denied"),
);
return CmdResult::Fail;
}
s.metadata.remove(&key);
}
"SUB" | "UNSUB" => {} // all metadata is public here; subscriptions are a no-op
_ => {
s.fail(uid, "METADATA", "INVALID_SUBCOMMAND", &sub);
return CmdResult::Fail;
}
}
CmdResult::Ok
}
}
/// MARKREAD — draft/read-marker. `MARKREAD <target> [timestamp=<iso>]`. With a
/// timestamp it sets the read marker (only ever advancing) and echoes it to every
/// connection sharing the user's identity (multi-device); without one it returns