Files
horizon-airdef/crates/horizon-server/src/lists.rs
T
Ludovic Marie 43287c18c2 horizon-server whitelist add: the offline UUID on a running offline server
The game resolves names as vanilla does, Mojang first, so on an offline server a name someone owns got that
account's UUID and the player, who joins under the offline UUID, was refused. horizon-server now writes the
offline entry and has the game reload the whitelist.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 14:24:15 +02:00

211 lines
8.5 KiB
Rust

//! `op`, `deop` and `whitelist`. While the server runs, the game owns the lists: the command goes to its
//! console. While it is stopped, they edit vanilla's files with the code the game reads them with
//! (horizon-server-files) and answer with vanilla's console messages.
//!
//! One exception: `whitelist add` on a running offline server. The game asks Mojang for the name first, as
//! vanilla does, so a name someone owns gets that account's UUID, and the player, who joins under the
//! offline UUID, is still refused. There the offline entry is written to whitelist.json and the game
//! reloads it (`whitelist reload`), as it would be written while the server is stopped.
use crate::{config, supervisor};
use horizon_server_files::user_lists::{NameAndId, OpEntry, OpList, WhiteEntry, WhiteList};
use std::path::Path;
pub fn run(dir: &Path, command: &str, args: &[String]) -> Result<(), String> {
let config = config::Config::load(dir)?;
// Holding the folder's lock keeps the server from starting halfway through.
let Ok(_lock) = supervisor::lock(dir) else {
if let ("whitelist", [add, name]) = (command, args)
&& add == "add"
&& !config.server.online_mode
{
return add_offline(dir, name);
}
let mut words = vec![command.to_owned()];
words.extend_from_slice(args);
return crate::cli::command(dir, &words);
};
let args: Vec<&str> = args.iter().map(String::as_str).collect();
let ops_path = dir.join("ops.json");
let white_path = dir.join("whitelist.json");
let message = match (command, args.as_slice()) {
("op", [name]) => {
let mut ops = load(OpList::new(ops_path))?;
let user = account(name, config.server.online_mode)?;
if ops.contains(&user) {
"Nothing changed. The player already is an operator".to_owned()
} else {
ops.add(OpEntry {
user,
level: 4,
bypasses_player_limit: false,
});
format!("Made {name} a server operator")
}
}
("deop", [name]) => {
let mut ops = load(OpList::new(ops_path))?;
let user = listed(ops.entries().iter().map(|e| &e.user), name);
if user.is_some_and(|user| ops.remove(&user)) {
format!("Made {name} no longer a server operator")
} else {
"Nothing changed. The player is not an operator".to_owned()
}
}
("whitelist", ["add", name]) => {
let mut white = load(WhiteList::new(white_path))?;
let user = account(name, config.server.online_mode)?;
if white.contains(&user) {
"Player is already whitelisted".to_owned()
} else {
white.add(WhiteEntry { user });
format!("Added {name} to the whitelist")
}
}
("whitelist", ["remove", name]) => {
let mut white = load(WhiteList::new(white_path))?;
let user = listed(white.entries().iter().map(|e| &e.user), name);
if user.is_some_and(|user| white.remove(&user)) {
format!("Removed {name} from the whitelist")
} else {
"Player is not whitelisted".to_owned()
}
}
("whitelist", [state @ ("on" | "off")]) => {
let on = *state == "on";
match (on, config.server.whitelist) {
(true, true) => "Whitelist is already turned on".to_owned(),
(false, false) => "Whitelist is already turned off".to_owned(),
_ => {
config::update(dir, "server", "whitelist", toml::Value::Boolean(on))?;
format!("Whitelist is now turned {state}")
}
}
}
("whitelist", ["list"]) => {
let white = load(WhiteList::new(white_path))?;
let names: Vec<String> = white
.entries()
.iter()
.map(|e| e.user.name.clone())
.collect();
let state = if config.server.whitelist { "on" } else { "off" };
if names.is_empty() {
format!("There are no whitelisted players (the whitelist is {state})")
} else {
format!(
"There are {} whitelisted player(s): {} (the whitelist is {state})",
names.len(),
names.join(", ")
)
}
}
_ => {
return Err(
"use: op NAME, deop NAME, whitelist on|off|list, whitelist add|remove NAME".into(),
);
}
};
println!("{message}");
Ok(())
}
/// `whitelist add` on a running offline server: the offline entry, then the game reloads the list.
fn add_offline(dir: &Path, name: &str) -> Result<(), String> {
if crate::api::Client::open(dir)?.is_none() {
return Err(format!("no server is running in {}", dir.display()));
}
let user = account(name, false)?;
let mut white = load(WhiteList::new(dir.join("whitelist.json")))?;
if white.contains(&user) {
println!("Player is already whitelisted");
return Ok(());
}
white.add(WhiteEntry { user });
white
.save()
.map_err(|e| format!("{}: {e}", white.file.display()))?;
crate::cli::command(dir, &["whitelist".to_owned(), "reload".to_owned()])?;
println!("Added {name} to the whitelist");
Ok(())
}
/// The profile a running server would store for `name`: the offline one, or in online mode the account the
/// services know by that name.
pub fn account(name: &str, online: bool) -> Result<NameAndId, String> {
horizon_server_files::profiles::resolve(name, online).ok_or_else(|| {
if online {
format!("That player does not exist (no Minecraft account is named {name}, or the services didn't answer)")
} else {
"That player does not exist".to_owned()
}
})
}
/// The entry already on a list under `name` (any case), so removing needs no lookup.
fn listed<'a>(mut users: impl Iterator<Item = &'a NameAndId>, name: &str) -> Option<NameAndId> {
users.find(|u| u.name.eq_ignore_ascii_case(name)).cloned()
}
/// A list from its file; a missing file is an empty list, a broken one an error (vanilla would replace it).
fn load<E: horizon_server_files::user_lists::Entry>(
mut list: horizon_server_files::user_lists::UserList<E>,
) -> Result<horizon_server_files::user_lists::UserList<E>, String> {
if list.file.exists() {
list.load()
.map_err(|e| format!("{}: {e}", list.file.display()))?;
}
Ok(list)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn edits_the_lists_while_stopped() {
let dir = std::env::temp_dir().join(format!("horizon-server-lists-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
std::fs::write(dir.join(config::FILE), config::TEMPLATE).unwrap();
let s = |v: &[&str]| v.iter().map(|a| (*a).to_owned()).collect::<Vec<_>>();
run(&dir, "op", &s(&["Alex"])).unwrap();
run(&dir, "whitelist", &s(&["add", "Steve"])).unwrap();
run(&dir, "whitelist", &s(&["off"])).unwrap();
assert!(
std::fs::read_to_string(dir.join("ops.json"))
.unwrap()
.contains("Alex")
);
assert!(
std::fs::read_to_string(dir.join("whitelist.json"))
.unwrap()
.contains("Steve")
);
assert!(!config::Config::load(&dir).unwrap().server.whitelist);
run(&dir, "deop", &s(&["Alex"])).unwrap();
assert!(
!std::fs::read_to_string(dir.join("ops.json"))
.unwrap()
.contains("Alex")
);
// A running server owns the lists: without its API, nothing changes.
let lock = supervisor::lock(&dir).unwrap();
assert!(run(&dir, "op", &s(&["Alex"])).is_err());
config::update(&dir, "server", "online_mode", toml::Value::Boolean(false)).unwrap();
assert!(run(&dir, "whitelist", &s(&["add", "Kai"])).is_err());
drop(lock);
assert!(
!std::fs::read_to_string(dir.join("ops.json"))
.unwrap()
.contains("Alex")
);
assert!(
!std::fs::read_to_string(dir.join("whitelist.json"))
.unwrap()
.contains("Kai")
);
std::fs::remove_dir_all(&dir).unwrap();
}
}