Merge branch 'parity/dedicated-server' into parity-base

This commit is contained in:
Ludovic Marie
2026-10-13 01:44:30 +02:00
19 changed files with 3463 additions and 176 deletions
@@ -0,0 +1,46 @@
//! Horizon's LAN world discovery for tools/test_lan_parity.py: the cases of
//! VanillaLanOracle (announcements sent, datagrams heard, list resets) run
//! through `lan::discovery`, printing the same lines.
use horizon_client::lan::discovery::{
LanGame, add_server, parse_address, parse_motd, ping_string_text,
};
fn hex(bytes: &[u8]) -> String {
bytes.iter().map(|b| format!("{b:02x}")).collect()
}
fn unhex(s: &str) -> Vec<u8> {
(0..s.len() / 2)
.map(|i| u8::from_str_radix(&s[2 * i..2 * i + 2], 16).unwrap())
.collect()
}
fn main() {
let args: Vec<String> = std::env::args().collect();
let cases = std::fs::read_to_string(&args[1]).unwrap();
let mut out = String::new();
let mut games: Vec<LanGame> = Vec::new();
for line in cases.lines() {
let f: Vec<&str> = line.split('\t').collect();
match f[0] {
"ping" => out += &format!("ping {}\n", hex(ping_string_text(f[1], f[2]).as_bytes())),
"heard" => {
let received = String::from_utf8_lossy(&unhex(f[2])).into_owned();
out += &format!(
"heard motd={} address={}\n",
parse_motd(&received),
parse_address(&received).unwrap_or_else(|| "null".into())
);
if add_server(&mut games, &received, f[1]) {
out += "list";
for g in &games {
out += &format!(" [{} @ {}]", g.motd, g.address);
}
out += "\n";
}
}
"reset" => games.clear(),
other => panic!("{other}"),
}
}
std::fs::write(&args[2], out).unwrap();
}
+16 -2
View File
@@ -329,12 +329,26 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
}
impl Audio {
pub fn new(root: &Path) -> Self {
Self::with_output(root, true)
}
/// No output device: the dedicated server.
pub fn silent(root: &Path) -> Self {
Self::with_output(root, false)
}
fn with_output(root: &Path, output: bool) -> Self {
let registry = SoundRegistry::load(root);
let mixer = Arc::new(Mutex::new(Mixer::default()));
let (stream, live) = match Self::open(mixer.clone()) {
let opened = if output {
Self::open(mixer.clone())
} else {
Err("no output on a dedicated server".into())
};
let (stream, live) = match opened {
Ok(v) => (Some(v), true),
Err(e) => {
eprintln!("Horizon: audio unavailable: {e}");
if output {
eprintln!("Horizon: audio unavailable: {e}");
}
(None, false)
}
};
+33 -1
View File
@@ -22,6 +22,7 @@ mod copper_golems;
mod creaking;
mod creatures;
mod crossbow;
mod dedicated;
mod dispense_fixture;
mod dispenser;
mod dragon;
@@ -58,6 +59,7 @@ mod music;
mod names;
mod natural_spawning;
mod nautili;
mod net_harness;
mod options;
mod packs;
mod paintings;
@@ -184,6 +186,9 @@ struct Options {
/// Multiplayer: `--server HOST[:PORT]` joins at start; `--name` is the offline player name.
server: Option<String>,
player_name: String,
/// `--dedicated`: run as a dedicated server; vanilla's server arguments
/// (`--nogui`, `--port`, `--world`, `--universe`, `--initSettings`) follow.
dedicated: Option<Vec<String>>,
}
impl Options {
fn read() -> Result<Option<Self>> {
@@ -215,6 +220,7 @@ impl Options {
control: None,
server: None,
player_name: std::env::var("HORIZON_PLAYER_NAME").unwrap_or_else(|_| "Player".into()),
dedicated: None,
};
let mut args = std::env::args().skip(1);
while let Some(arg) = args.next() {
@@ -225,6 +231,10 @@ impl Options {
);
return Ok(None);
}
"--dedicated" => {
o.dedicated = Some(args.by_ref().collect());
break;
}
"--creative" => o.creative = true,
"--test-terrain" => o.test_terrain = true,
"--no-pause" => o.no_pause = true,
@@ -2573,6 +2583,10 @@ impl Game<'_> {
}
let riding = self.riding.is_some();
let Some(player) = self.player.as_mut() else {
// A dedicated server has no local player: the world still runs.
if self.options.dedicated.is_some() {
return self.tick_world(running);
}
return Ok(());
};
// Hold position until the surrounding terrain exists.
@@ -2760,6 +2774,11 @@ impl Game<'_> {
self.screen = Screen::Dead;
self.capture(false);
}
self.tick_world(running)
}
/// What the tick runs after the local player's own update: effects, the
/// world's entities and blocks, and the network hub.
fn tick_world(&mut self, running: bool) -> Result<()> {
self.tick_effects();
self.tick_burning();
self.tick_using();
@@ -8053,6 +8072,9 @@ pub fn run() -> Result<()> {
let Some(mut options) = Options::read()? else {
return Ok(());
};
if options.dedicated.is_some() && !dedicated::preflight(&mut options)? {
return Ok(());
}
let started = Instant::now();
let vanilla_root = options.resources.clone();
let early_settings = Settings::load(&std::env::current_dir()?.join("options.txt"));
@@ -8127,7 +8149,11 @@ pub fn run() -> Result<()> {
.join("saves")
.join(".horizon-title"),
));
let audio = Audio::new(&root);
let audio = if options.dedicated.is_some() {
Audio::silent(&root)
} else {
Audio::new(&root)
};
let world = World::new(facts.air, 0);
let creative = options.creative;
let stations = horizon_client::stations::StationData::load(&root, &items);
@@ -8417,6 +8443,9 @@ pub fn run() -> Result<()> {
if let Ok(spec) = std::env::var("HORIZON_SCULK_FIXTURE") {
return game.sculk_fixture(&spec);
}
if game.options.dedicated.is_some() {
return game.run_dedicated();
}
match game.options.world.clone() {
_ if game.options.server.is_some() => {
let (address, name) = (
@@ -8424,6 +8453,9 @@ pub fn run() -> Result<()> {
game.options.player_name.clone(),
);
game.connect_server(&address, &name)?;
if let Some(report) = std::env::var_os("HORIZON_NET_REPORT") {
return game.run_net_harness(report.as_ref());
}
}
Some(folder) => {
let (seed, creative) = (game.options.seed, game.options.creative);
File diff suppressed because it is too large Load Diff
+96 -37
View File
@@ -7,7 +7,7 @@ use horizon_client::{
Result,
items::ItemStack,
lan::{
self, Lan, MAX_PLAYERS,
self, Lan, MAX_PLAYERS, NetConfig,
chunks::ChunkEncoder,
data::SyncData,
entity::EntityState,
@@ -345,6 +345,40 @@ impl Game<'_> {
if self.lan.is_some() || self.remote.is_some() || self.title.is_some() {
return Err("already open".into());
}
let motd = format!("{PLAYER_NAME} - {}", self.level.name);
let host_uuid = self.level.player_uuid.map_or_else(
|| offline_uuid(PLAYER_NAME),
|u| {
u128::from(u[0] as u32) << 96
| u128::from(u[1] as u32) << 64
| u128::from(u[2] as u32) << 32
| u128::from(u[3] as u32)
},
);
let config = HubConfig {
default_game_mode: self.level.mode(),
guest_commands: settings.guest_commands,
force_game_mode: settings.force_game_mode,
hardcore: self.level.hardcore,
view_distance: self.settings.render_distance.clamp(2, 32),
simulation_distance: self.settings.render_distance.clamp(2, 32),
dimension: self.dim.id().to_owned(),
seed: self.level.seed,
max_players: MAX_PLAYERS,
dedicated: false,
};
let net = NetConfig::lan(settings.port, motd, MAX_PLAYERS);
self.lan_host(settings, net, config, Some(host_uuid))
}
/// Start the network side and the play-state hub: for the LAN (with the
/// host's own profile reserved) or for a dedicated server (no host).
pub(super) fn lan_host(
&mut self,
settings: LanSettings,
net: NetConfig,
config: HubConfig,
host: Option<u128>,
) -> Result<()> {
let root = self.options.resources.clone();
let sync = SYNC
.get_or_init(|| SyncData::load(&root).map(Arc::new))
@@ -362,7 +396,7 @@ impl Game<'_> {
.get("minecraft:worldgen/biome")
.map(|v| v.iter().map(|(n, _)| n.clone()).collect())
.unwrap_or_default();
let encoder = ChunkEncoder::new(
let mut encoder = ChunkEncoder::new(
self.res
.facts
.states
@@ -372,37 +406,20 @@ impl Game<'_> {
&biome_names,
&registry,
);
let motd = format!("{PLAYER_NAME} - {}", self.level.name);
let lan = Lan::start(sync.clone(), settings.port, motd, MAX_PLAYERS)?;
let host_uuid = self.level.player_uuid.map_or_else(
|| offline_uuid(PLAYER_NAME),
|u| {
u128::from(u[0] as u32) << 96
| u128::from(u[1] as u32) << 64
| u128::from(u[2] as u32) << 32
| u128::from(u[3] as u32)
},
encoder.tables = Some(
self.save
.tables
.get_or_init(|| Arc::new(horizon_client::save::SaveTables::new(&self.res.assets)))
.clone(),
);
lan.reserve(host_uuid);
let lan = Lan::start_with(sync.clone(), net)?;
if let Some(uuid) = host {
lan.reserve(uuid);
}
let host_uuid = host.unwrap_or(0);
self.next_entity += 1;
let host_entity = self.next_entity as i32;
let hub = Hub::new(
lan,
sync,
encoder,
HubConfig {
default_game_mode: self.level.mode(),
guest_commands: settings.guest_commands,
force_game_mode: settings.force_game_mode,
hardcore: self.level.hardcore,
view_distance: self.settings.render_distance.clamp(2, 32),
simulation_distance: self.settings.render_distance.clamp(2, 32),
dimension: self.dim.id().to_owned(),
seed: self.level.seed,
max_players: MAX_PLAYERS,
dedicated: false,
},
);
let hub = Hub::new(lan, sync, encoder, config);
let port = hub.lan.port;
self.world.block_log = Some(Vec::new());
self.lan = Some(LanHost {
@@ -543,7 +560,9 @@ impl Game<'_> {
let Some(mut host) = self.lan.take() else {
return;
};
if let Some(state) = self.lan_host_state(&host) {
let state = self.lan_host_state(&host);
// A dedicated server runs the hub without a host player.
if state.is_some() || host.hub.config.dedicated {
let has_guests = !host.hub.guests.is_empty();
let entities = if has_guests {
self.lan_entities(&mut host.hub)
@@ -554,7 +573,7 @@ impl Game<'_> {
let events = {
let mut ctx = TickCtx {
world: &mut self.world,
host: Some(&state),
host: state.as_ref(),
entities: &entities,
next_entity: &mut self.next_entity,
spawn,
@@ -570,18 +589,56 @@ impl Game<'_> {
};
host.hub.tick(&mut ctx)
};
if host.host_mode != state.game_mode {
if let Some(state) = &state
&& host.host_mode != state.game_mode
{
host.host_mode = state.game_mode;
host.hub.set_host_game_mode(state.uuid, state.game_mode);
}
for event in events {
match event {
HostEvent::Joined(conn) => {
self.lan_guest_joined(&mut host, conn, &state, &entities, spawn)
self.lan_guest_joined(&mut host, conn, state.as_ref(), &entities, spawn);
if self.options.dedicated.is_some()
&& let Some(g) = host.hub.guest(conn)
{
// PlayerList.placeNewPlayer, then the broadcast join message.
let [x, y, z] = g.position;
super::dedicated::log(
"INFO",
&format!(
"{}[/{}] logged in with entity id {} at ({}, {}, {})",
g.name,
g.address,
g.entity_id,
super::dedicated::java_double(x),
super::dedicated::java_double(y),
super::dedicated::java_double(z)
),
);
super::dedicated::log(
"INFO",
&format!("System chat: {} joined the game", g.name),
);
}
}
HostEvent::Left(guest) => {
playerdata::save(&guest, &self.world_root);
host.models.remove(&guest.conn);
if self.options.dedicated.is_some() && guest.placed {
super::dedicated::log(
"INFO",
&format!("{} lost connection: {}", guest.name, guest.left_reason),
);
super::dedicated::log(
"INFO",
&format!("System chat: {} left the game", guest.name),
);
}
}
// MinecraftServer.logChatMessage of an unsigned message.
HostEvent::Chat(line) if self.options.dedicated.is_some() => {
super::dedicated::log("INFO", &format!("[Not Secure] {line}"));
}
HostEvent::Chat(line) => self.system_message(Text::literal(line)),
HostEvent::Packet(conn, packet) => {
@@ -602,7 +659,7 @@ impl Game<'_> {
&mut self,
host: &mut LanHost,
conn: u32,
state: &HostState,
state: Option<&HostState>,
entities: &[EntityState],
spawn: [f64; 3],
) {
@@ -624,7 +681,7 @@ impl Game<'_> {
}
let mut ctx = TickCtx {
world: &mut self.world,
host: Some(state),
host: state,
entities,
next_entity: &mut self.next_entity,
spawn,
@@ -688,7 +745,9 @@ impl Game<'_> {
.guests
.iter()
.filter(|g| g.placed)
.map(|g| (g.chunk(), g.view_distance + 1))
// The tracked square's corners and their lit neighbours lie
// within (view distance + 2) * √2 of the player's chunk.
.map(|g| (g.chunk(), (g.view_distance + 2) * 3 / 2 + 1))
.collect();
}
@@ -511,6 +511,21 @@ impl Game<'_> {
/// Commands.performCommand for a guest with command access.
fn guest_command(&mut self, host: &mut LanHost, conn: u32, command: &str) {
// ListPlayersCommand needs no permission and lists every player.
let words: Vec<&str> = command.trim_start_matches('/').split(' ').collect();
if words[0] == "list" && (words.len() == 1 || words[1..] == ["uuids"]) {
let me = (self.options.dedicated.is_none() && self.player.is_some())
.then_some((host.host_uuid, super::chat::PLAYER_NAME));
let content = host.hub.list_reply(me, words.len() == 2);
host.hub.send_to(
conn,
&C::SystemChat(play::SystemChat {
content,
overlay: false,
}),
);
return;
}
if !host.settings.guest_commands || !self.cheats {
host.hub.send_to(
conn,
@@ -0,0 +1,93 @@
//! Headless multiplayer client for `tools/test_dedicated_server_parity.py`:
//! with `--server` and `HORIZON_NET_REPORT` set, the client joins without a
//! window, waits until it stands in the world with the chunks around it,
//! sends a chat message and `/list`, collects the chat it is shown, leaves
//! and writes a JSON report (position, chunks, chat lines, whether the
//! server kept it connected throughout).
use super::Game;
use horizon_client::Result;
use serde_json::json;
use std::{
path::Path,
time::{Duration, Instant},
};
impl Game<'_> {
pub(super) fn run_net_harness(&mut self, report: &Path) -> Result<()> {
let deadline = Instant::now() + Duration::from_secs(120);
let mut next = Instant::now();
let mut spawned_at: Option<Instant> = None;
let mut last_chunks = 0;
let mut quiet_since = Instant::now();
let mut step = 0;
let mut step_at = Instant::now();
let mut position = None;
let mut chunks = 0;
let mut error = None;
while Instant::now() < deadline {
self.update_world();
if self.remote.is_none() {
error = Some("disconnected".to_owned());
break;
}
if Instant::now() >= next {
next += Duration::from_millis(50);
self.tick()?;
}
let now = Instant::now();
if let Some(p) = &self.player {
spawned_at.get_or_insert(now);
position.get_or_insert([p.position.x, p.position.y, p.position.z]);
}
let count = self.world.chunks.len();
if count != last_chunks {
last_chunks = count;
quiet_since = now;
}
match step {
0 if spawned_at.is_some()
&& count > 0
&& now - quiet_since > Duration::from_secs(3) =>
{
chunks = count;
self.send_chat("hello from the horizon client");
step = 1;
step_at = now;
}
1 if now - step_at > Duration::from_millis(1500) => {
self.send_chat("/list");
step = 2;
step_at = now;
}
2 if now - step_at > Duration::from_millis(1500) => {
step = 3;
break;
}
_ => {}
}
std::thread::sleep(Duration::from_millis(5));
}
if step < 3 && error.is_none() {
error = Some(format!("timed out at step {step}"));
}
let chat: Vec<String> = self
.remote
.as_ref()
.map(|r| r.chat.iter().map(|(t, _)| t.clone()).collect())
.unwrap_or_default();
if self.remote.is_some() {
self.leave_server(None)?;
}
std::fs::write(
report,
json!({
"position": position,
"chunks": chunks,
"chat": chat,
"error": error,
})
.to_string(),
)?;
Ok(())
}
}
+168 -21
View File
@@ -88,6 +88,8 @@ pub struct ChunkEncoder {
biome_bits: u8,
/// The block registry id of each state's block, for BlockEvent.
pub block_ids: Vec<i32>,
/// The save's tables, for the heightmaps.
pub tables: Option<Arc<crate::save::SaveTables>>,
}
impl ChunkEncoder {
/// `biome_names`: the internal biome list in order; `biome_registry`:
@@ -140,6 +142,7 @@ impl ChunkEncoder {
biome_ids,
biome_bits: ceil_log2(biome_registry.len()),
block_ids,
tables: None,
}
}
pub fn entity_type(&self, state: u16) -> Option<i32> {
@@ -194,6 +197,38 @@ impl ChunkEncoder {
}
/// The chunk column with its light and block entities.
/// The non-air sections of a column as bits (LevelChunkSection.hasOnlyAir).
fn occupied(&self, chunk: &Chunk) -> u64 {
let mut bits = 0u64;
for (i, s) in chunk.sections.iter().enumerate() {
let mut unpacked = [0u16; BLOCKS];
s.unpack(&mut unpacked);
let any = unpacked
.iter()
.any(|&v| self.flags.get(usize::from(v)).copied().unwrap_or(0) & NON_AIR != 0);
if any {
bits |= 1 << i;
}
}
bits
}
/// The chunk column with its light and block entities. `world` gives the
/// neighbouring columns, whose sections decide which light layers exist.
pub fn encode_in(&self, chunk: &Chunk, world: &crate::world::World) -> LevelChunkWithLight {
let mut around = 0u64;
for dz in -1..=1 {
for dx in -1..=1 {
if let Some(c) = world.chunks.get(&(chunk.x + dx, chunk.z + dz)) {
around |= self.occupied(c);
}
}
}
let mut packet = self.encode(chunk, &world.block_entities);
packet.light = light_data(chunk, around);
packet
}
pub fn encode(
&self,
chunk: &Chunk,
@@ -215,12 +250,12 @@ impl ChunkEncoder {
packed_xz: ((x << 4) | z) as i8,
y: wy as i16,
kind,
// BlockEntityInfo.create: an empty update tag is not sent.
tag: block_entities
.get(&pos)
.and_then(entity_tag)
.unwrap_or_else(
|| Tag::compound(Vec::<(&str, Tag)>::new()),
),
.or_else(|| saved_update_tag(chunk, pos))
.unwrap_or(Tag::End),
});
}
}
@@ -229,19 +264,118 @@ impl ChunkEncoder {
}
sections.push(encoded);
}
java_hash_order(&mut entity_infos, |e| {
(
chunk.x * 16 + i32::from(e.packed_xz as u8 >> 4),
i32::from(e.y),
chunk.z * 16 + i32::from(e.packed_xz as u8 & 15),
)
});
LevelChunkWithLight {
x: chunk.x,
z: chunk.z,
chunk: ChunkData {
heightmaps: Vec::new(),
heightmaps: self
.tables
.as_ref()
.map(|t| crate::save::client_heightmaps(chunk, t))
.unwrap_or_default(),
buffer: ChunkData::from_sections(&sections),
block_entities: entity_infos,
},
light: light_data(chunk),
light: light_data(chunk, u64::MAX),
}
}
}
/// The order LevelChunk.getBlockEntities() iterates in: a fastutil
/// Object2ObjectOpenHashMap keyed by BlockPos (linear probing from
/// HashCommon.mix(hashCode), grown at 3/4 by reinserting from the top of
/// the table, iterated from the top down), filled in the order of the
/// java.util.HashMap of pending block entities that the loaded chunk's list
/// (`items` in section order) went through.
fn java_hash_order<T>(items: &mut Vec<T>, pos: impl Fn(&T) -> (i32, i32, i32)) {
// Vec3i.hashCode.
let hash = |&(x, y, z): &(i32, i32, i32)| {
y.wrapping_add(z.wrapping_mul(31))
.wrapping_mul(31)
.wrapping_add(x)
};
let keys: Vec<i32> = items.iter().map(|i| hash(&pos(i))).collect();
// java.util.HashMap: buckets in index order, insertion order within one.
let mut capacity = 16usize;
while keys.len() * 4 > capacity * 3 {
capacity *= 2;
}
let mut order: Vec<usize> = (0..keys.len()).collect();
order.sort_by_key(|&i| {
((keys[i] ^ ((keys[i] as u32) >> 16) as i32) as u32 as usize) & (capacity - 1)
});
// Object2ObjectOpenHashMap.
let mix = |h: i32| {
let h = h.wrapping_mul(0x9E37_79B9_u32 as i32) as u32;
(h ^ (h >> 16)) as usize
};
let put = |table: &mut Vec<Option<usize>>, i: usize| {
let mask = table.len() - 1;
let mut at = mix(keys[i]) & mask;
while table[at].is_some() {
at = (at + 1) & mask;
}
table[at] = Some(i);
};
// Default expected size 16: HashCommon.arraySize(16, 0.75) = 32 slots.
let mut table: Vec<Option<usize>> = vec![None; 32];
for (size, &i) in order.iter().enumerate() {
put(&mut table, i);
// insert: `if (size++ >= maxFill) rehash(arraySize(size + 1, f))`.
let max_fill = (table.len() * 3).div_ceil(4).min(table.len() - 1);
if size >= max_fill {
let grown = ((size + 2) * 4).div_ceil(3).next_power_of_two().max(2);
let old = std::mem::replace(&mut table, vec![None; grown]);
for &j in old.iter().rev().flatten() {
put(&mut table, j);
}
}
}
let iteration: Vec<usize> = table.iter().rev().flatten().copied().collect();
let mut slots: Vec<Option<T>> = items.drain(..).map(Some).collect();
items.extend(iteration.into_iter().filter_map(|i| slots[i].take()));
}
/// The update tag of a block entity Horizon keeps only as loaded NBT:
/// SpawnerBlockEntity.getUpdateTag is its saved fields without
/// SpawnPotentials (saveCustomOnly, so no id or position).
fn saved_update_tag(chunk: &Chunk, pos: (i32, i32, i32)) -> Option<Tag> {
let saved = chunk.saved.as_ref()?;
let tag = saved.block_entities.iter().find(|t| {
let Tag::Compound(c) = t else { return false };
let at = |k: &str| match c.get(&k.into()) {
Some(Tag::Int(v)) => Some(*v),
_ => None,
};
(at("x"), at("y"), at("z")) == (Some(pos.0), Some(pos.1), Some(pos.2))
})?;
if crate::block_entity_nbt::id(tag).as_deref() != Some("minecraft:mob_spawner") {
return None;
}
let Tag::Compound(mut c) = crate::block_entity_nbt::canonical(tag)? else {
return None;
};
for key in [
"id",
"x",
"y",
"z",
"keepPacked",
"SpawnPotentials",
"components",
] {
c.remove(&key.into());
}
Some(Tag::Compound(c))
}
/// The update tag of a block entity (getUpdateTag) for what the client shows.
pub fn entity_tag(entity: &BlockEntity) -> Option<Tag> {
match entity {
@@ -251,8 +385,12 @@ pub fn entity_tag(entity: &BlockEntity) -> Option<Tag> {
}
}
/// Light sections run from one below the world to one above it.
fn light_data(chunk: &Chunk) -> LightData {
/// Light sections run from one below the world to one above it. A layer
/// exists where vanilla's light storage keeps one: within one section of a
/// non-air section of this column or a neighbouring one (`around`, bit i for
/// section i; LayerLightSectionStorage.updateSectionStatus). An existing
/// layer is sent, or marked empty when all dark; the others are left out.
fn light_data(chunk: &Chunk, around: u64) -> LightData {
let mut data = LightData {
sky_mask: Vec::new(),
block_mask: Vec::new(),
@@ -261,14 +399,24 @@ fn light_data(chunk: &Chunk) -> LightData {
sky: Vec::new(),
block: Vec::new(),
};
// The section below the world has no sky light; the one above is full.
set_bit(&mut data.empty_sky_mask, 0);
set_bit(&mut data.empty_block_mask, 0);
for (i, s) in chunk.sections.iter().enumerate() {
let bit = i + 1;
// Light section b holds chunk section b - 1.
let exists = |b: usize| {
(b.saturating_sub(2)..=b.min(SECTIONS - 1)).any(|s| s + 2 >= b && around >> s & 1 != 0)
};
let full_sky = Light::Uniform(0xF0);
for b in 0..SECTIONS + 2 {
if !exists(b) {
continue;
}
let light = match b {
// Below the world nothing is lit; above it the sky is full.
0 => &Light::Uniform(0),
_ if b == SECTIONS + 1 => &full_sky,
_ => &chunk.sections[b - 1].light,
};
let (mut sky, mut block) = (vec![0u8; 2048], vec![0u8; 2048]);
let (mut sky_any, mut block_any) = (false, false);
match &s.light {
match light {
Light::Uniform(v) => {
let (sk, bl) = (v >> 4, v & 15);
sky_any = sk != 0;
@@ -293,21 +441,18 @@ fn light_data(chunk: &Chunk) -> LightData {
}
}
if sky_any {
set_bit(&mut data.sky_mask, bit);
set_bit(&mut data.sky_mask, b);
data.sky.push(sky);
} else {
set_bit(&mut data.empty_sky_mask, bit);
set_bit(&mut data.empty_sky_mask, b);
}
if block_any {
set_bit(&mut data.block_mask, bit);
set_bit(&mut data.block_mask, b);
data.block.push(block);
} else {
set_bit(&mut data.empty_block_mask, bit);
set_bit(&mut data.empty_block_mask, b);
}
}
set_bit(&mut data.sky_mask, SECTIONS + 1);
data.sky.push(vec![0xFF; 2048]);
set_bit(&mut data.empty_block_mask, SECTIONS + 1);
data
}
@@ -335,7 +480,9 @@ mod tests {
#[test]
fn light_masks_cover_the_world_plus_borders() {
let chunk = Chunk::empty(0, 0);
let data = light_data(&chunk);
// A column with nothing around it has no light layers at all.
assert!(light_data(&chunk, 0).sky.is_empty());
let data = light_data(&chunk, u64::MAX);
// Default sections are full sky light and no block light.
assert_eq!(data.sky.len(), SECTIONS + 1);
assert_eq!(data.block.len(), 0);
+205 -23
View File
@@ -35,16 +35,88 @@ const KEEP_ALIVE_EVERY: Duration = Duration::from_secs(15);
const KEEP_ALIVE_TIMEOUT: Duration = Duration::from_secs(30);
/// Packets queued for one client beyond this many bytes disconnect it.
const MAX_PENDING: usize = 96 << 20;
/// Connection.setupCompression threshold of the integrated server.
const COMPRESSION_THRESHOLD: i32 = 256;
/// Vanilla's server-side disconnect during login is a JSON component.
fn login_disconnect(c: &mut Connection, key: &str) {
let json = format!("{{\"translate\":\"{key}\"}}");
fn login_disconnect(c: &mut Connection, reason: &horizon_world::nbt::Tag) {
let json = component_json(reason);
let _ =
c.send(&login::Clientbound::Disconnect(login::Disconnect { reason_json: json }).encode());
}
/// A component as ComponentSerialization.CODEC writes it with JsonOps (and
/// Gson without HTML escaping): plain text collapses to a string, the
/// content fields come first, then `extra`, then the style.
pub fn component_json(tag: &horizon_world::nbt::Tag) -> String {
component_value(tag).compact()
}
fn component_value(tag: &horizon_world::nbt::Tag) -> crate::server::json::Json {
use crate::server::json::Json;
use horizon_world::nbt::Tag;
const ORDER: &[&str] = &[
"type",
"text",
"translate",
"fallback",
"with",
"score",
"selector",
"separator",
"keybind",
"nbt",
"interpret",
"block",
"entity",
"storage",
"source",
"object",
"sprite",
"atlas",
"player",
"hat",
"extra",
"color",
"shadow_color",
"bold",
"italic",
"underlined",
"strikethrough",
"obfuscated",
"click_event",
"hover_event",
"insertion",
"font",
];
match tag {
Tag::String(s) => Json::String(s.to_string_lossy()),
Tag::List(items) => Json::Array(items.iter().map(component_value).collect()),
Tag::Compound(map) => {
if map.len() == 1
&& let Some(Tag::String(t)) = map.get(&horizon_world::nbt::JavaString::from("text"))
{
return Json::String(t.to_string_lossy());
}
let mut keys: Vec<String> = map.keys().map(|k| k.to_string_lossy()).collect();
keys.sort_by_key(|k| ORDER.iter().position(|o| o == k).unwrap_or(ORDER.len()));
Json::Object(
keys.into_iter()
.map(|k| {
let v = &map[&horizon_world::nbt::JavaString::from(k.as_str())];
let value = match v {
Tag::Byte(b) => Json::Bool(*b != 0),
Tag::Int(i) => Json::Number(i.to_string()),
other => component_value(other),
};
(k, value)
})
.collect(),
)
}
Tag::Byte(b) => Json::Bool(*b != 0),
Tag::Int(i) => Json::Number(i.to_string()),
Tag::Long(i) => Json::Number(i.to_string()),
_ => Json::Null,
}
}
/// StringUtil.isValidPlayerName.
pub fn valid_name(name: &str) -> bool {
(1..=16).contains(&name.len()) && name.chars().all(|c| c as u32 > 32 && (c as u32) < 127)
@@ -63,8 +135,88 @@ impl PlayerSender {
}
}
pub fn serve(stream: TcpStream, shared: Arc<Shared>) -> Result<(), String> {
/// LegacyQueryHandler: the pre-1.7 server list ping. What the first read
/// holds decides the reply (1.3 and older: no more bytes; 1.4 and 1.5: 0x01;
/// 1.6: 0x01 then the MC|PingHost payload); anything else gets no reply.
fn serve_legacy(mut stream: TcpStream, shared: &Shared) -> Result<(), String> {
use std::io::{Read, Write};
let _ = stream.set_read_timeout(Some(Duration::from_millis(100)));
let mut data = Vec::new();
let mut chunk = [0u8; 1024];
// The bytes of the first read: what arrived together.
if let Ok(n) = stream.read(&mut chunk) {
data.extend_from_slice(&chunk[..n]);
}
let in_string = |d: &[u8], at: &mut usize| -> Option<String> {
let len = usize::from(u16::from_be_bytes([*d.get(*at)?, *d.get(*at + 1)?]));
let bytes = d.get(*at + 2..*at + 2 + len * 2)?;
*at += 2 + len * 2;
Some(String::from_utf16_lossy(
&bytes
.chunks(2)
.map(|c| u16::from_be_bytes([c[0], c[1]]))
.collect::<Vec<_>>(),
))
};
let motd = shared.motd();
let (online, max) = (shared.online(), shared.max_players());
let body = if data.len() == 1 {
format!("{motd}\u{a7}{online}\u{a7}{max}")
} else {
if data[1] != 1 {
return Ok(());
}
if data.len() > 2 {
// readCustomPayloadPacket.
let mut at = 3;
let valid = data[2] == 0xFA
&& in_string(&data, &mut at).as_deref() == Some("MC|PingHost")
&& data
.get(at..at + 2)
.map(|b| usize::from(u16::from_be_bytes([b[0], b[1]])))
== Some(data.len().saturating_sub(at + 2))
&& {
at += 2;
data.get(at).is_some_and(|v| *v >= 73)
}
&& {
at += 1;
in_string(&data, &mut at).is_some()
}
&& data
.get(at..at + 4)
.is_some_and(|b| i32::from_be_bytes([b[0], b[1], b[2], b[3]]) <= 65535);
if !valid {
return Ok(());
}
}
format!("\u{a7}1\0127\026.3\0{motd}\0{online}\0{max}")
};
let units: Vec<u16> = body.encode_utf16().collect();
let mut out = vec![0xFF];
out.extend_from_slice(&(units.len() as u16).to_be_bytes());
for u in units {
out.extend_from_slice(&u.to_be_bytes());
}
stream.write_all(&out).map_err(|e| e.to_string())?;
let _ = stream.shutdown(std::net::Shutdown::Both);
Ok(())
}
pub fn serve(
stream: TcpStream,
address: std::net::SocketAddr,
shared: Arc<Shared>,
) -> Result<(), String> {
let e = |e: horizon_protocol::Error| e.to_string();
// LegacyQueryHandler, ahead of the frame decoder while status is on.
let mut first = [0u8; 1];
if shared.config.enable_status
&& stream.peek(&mut first).is_ok_and(|n| n == 1)
&& first[0] == 0xFE
{
return serve_legacy(stream, &shared);
}
let mut c = Connection::from_stream(stream).map_err(e)?;
c.reader
.set_read_timeout(Some(Duration::from_secs(30)))
@@ -75,10 +227,20 @@ pub fn serve(stream: TcpStream, shared: Arc<Shared>) -> Result<(), String> {
_ => return Err("expected a handshake".into()),
};
match intention.intent {
// ServerHandshakePacketListenerImpl: a server that does not reply
// to status requests closes the connection.
handshake::STATUS if !shared.config.enable_status => Ok(()),
handshake::STATUS => serve_status(&mut c, &shared),
handshake::TRANSFER if !shared.config.accepts_transfers => {
login_disconnect(
&mut c,
&translatable("multiplayer.disconnect.transfers_disabled", &[]),
);
Ok(())
}
handshake::LOGIN | handshake::TRANSFER => {
if intention.protocol != PROTOCOL_VERSION {
let key = if intention.protocol < PROTOCOL_VERSION {
let key = if intention.protocol < 754 {
"multiplayer.disconnect.outdated_client"
} else {
"multiplayer.disconnect.incompatible"
@@ -93,7 +255,7 @@ pub fn serve(stream: TcpStream, shared: Arc<Shared>) -> Result<(), String> {
);
return Ok(());
}
serve_login(c, &shared)
serve_login(c, address, &shared)
}
other => Err(format!("unknown intent {other}")),
}
@@ -101,10 +263,14 @@ pub fn serve(stream: TcpStream, shared: Arc<Shared>) -> Result<(), String> {
fn serve_status(c: &mut Connection, shared: &Shared) -> Result<(), String> {
let e = |e: horizon_protocol::Error| e.to_string();
let mut requested = false;
loop {
let (id, payload) = c.recv().map_err(e)?;
match status::Serverbound::decode(id, &payload).map_err(e)? {
// ServerStatusPacketListenerImpl: a second request disconnects.
status::Serverbound::StatusRequest(_) if requested => return Ok(()),
status::Serverbound::StatusRequest(_) => {
requested = true;
let json = shared.status_json();
c.send(
&status::Clientbound::StatusResponse(status::StatusResponse { json }).encode(),
@@ -121,7 +287,11 @@ fn serve_status(c: &mut Connection, shared: &Shared) -> Result<(), String> {
}
}
fn serve_login(mut c: Connection, shared: &Arc<Shared>) -> Result<(), String> {
fn serve_login(
mut c: Connection,
address: std::net::SocketAddr,
shared: &Arc<Shared>,
) -> Result<(), String> {
let e = |e: horizon_protocol::Error| e.to_string();
let (id, payload) = c.recv().map_err(e)?;
let hello = match login::Serverbound::decode(id, &payload).map_err(e)? {
@@ -129,20 +299,23 @@ fn serve_login(mut c: Connection, shared: &Arc<Shared>) -> Result<(), String> {
_ => return Err("expected a login hello".into()),
};
if !valid_name(&hello.name) {
login_disconnect(&mut c, "multiplayer.disconnect.invalid_name");
login_disconnect(
&mut c,
&translatable("multiplayer.disconnect.invalid_name", &[]),
);
return Ok(());
}
// Offline mode: the profile is derived from the name (PlayerList.canPlayerLogin
// then rejects duplicates and a full server).
let uuid = offline_uuid(&hello.name);
if let Some(reason) = shared.try_admit(uuid, &hello.name) {
login_disconnect(&mut c, reason);
if let Some(reason) = shared.try_admit(address, uuid, &hello.name) {
login_disconnect(&mut c, &reason);
return Ok(());
}
let result = login_and_configure(&mut c, shared, uuid, &hello.name);
match result {
Ok(Some(parts)) => {
play(c, shared, parts);
play(c, shared, parts, address);
Ok(())
}
Ok(None) => {
@@ -170,14 +343,12 @@ fn login_and_configure(
name: &str,
) -> Result<Option<Parts>, String> {
let e = |e: horizon_protocol::Error| e.to_string();
c.send(
&login::Clientbound::Compression(login::Compression {
threshold: COMPRESSION_THRESHOLD,
})
.encode(),
)
.map_err(e)?;
c.set_compression(COMPRESSION_THRESHOLD);
let threshold = shared.config.compression_threshold;
if threshold >= 0 {
c.send(&login::Clientbound::Compression(login::Compression { threshold }).encode())
.map_err(e)?;
c.set_compression(threshold);
}
c.send(
&login::Clientbound::LoginFinished(login::LoginFinished {
profile: login::GameProfile {
@@ -208,7 +379,8 @@ fn login_and_configure(
channel: "minecraft:brand".into(),
data: {
let mut w = horizon_protocol::buf::Writer::new();
w.string("horizon");
// MinecraftServer.getServerModName.
w.string("vanilla");
w.data
},
}),
@@ -266,7 +438,7 @@ fn login_and_configure(
}))
}
fn play(c: Connection, shared: &Arc<Shared>, parts: Parts) {
fn play(c: Connection, shared: &Arc<Shared>, parts: Parts, address: std::net::SocketAddr) {
let conn_id = shared.next_id();
let events = shared.events.clone();
let _ = c.reader.set_read_timeout(Some(KEEP_ALIVE_TIMEOUT));
@@ -294,6 +466,7 @@ fn play(c: Connection, shared: &Arc<Shared>, parts: Parts) {
brand: parts.brand,
sender,
latency,
address,
};
let reason = if events.send(NetEvent::Joined(Box::new(joined))).is_ok() {
read_loop(&mut reader, conn_id, &events, &alive)
@@ -317,6 +490,15 @@ fn read_loop(
loop {
let (id, payload) = match reader.recv() {
Ok(p) => p,
// The client closed the connection: Connection.channelInactive
// without details, multiplayer.disconnect.generic.
Err(e)
if e.0 == "Connection closed by the server"
|| e.0.contains("reset by peer")
|| e.0.contains("aborted") =>
{
return "Disconnected".to_owned();
}
Err(e) => return e.to_string(),
};
match play::Serverbound::decode(id, &payload) {
+58 -35
View File
@@ -10,34 +10,61 @@ use std::{
atomic::{AtomicBool, Ordering},
},
thread::JoinHandle,
time::{Duration, Instant},
time::Duration,
};
pub const GROUP: Ipv4Addr = Ipv4Addr::new(224, 0, 2, 60);
pub const PORT: u16 = 4445;
/// LanServerPinger sleeps 1500 ms between announcements.
const INTERVAL: Duration = Duration::from_millis(1500);
/// LanServerDetection.LanServerList drops entries not refreshed for 5 s.
const EXPIRY: Duration = Duration::from_secs(5);
/// LanServerPinger.createPingString.
pub fn ping_string(motd: &str, port: u16) -> String {
format!("[MOTD]{motd}[/MOTD][AD]{port}[/AD]")
ping_string_text(motd, &port.to_string())
}
fn between<'a>(s: &'a str, open: &str, close: &str) -> Option<&'a str> {
let start = s.find(open)? + open.len();
let end = s[start..].find(close)? + start;
Some(&s[start..end])
/// LanServerPinger.createPingString with the address as text.
pub fn ping_string_text(motd: &str, address: &str) -> String {
format!("[MOTD]{motd}[/MOTD][AD]{address}[/AD]")
}
/// LanServerPinger.parseMotd; vanilla shows "missing no" when absent.
/// String.indexOf(needle, from) on a Rust string (byte offsets).
fn index_of(s: &str, needle: &str, from: usize) -> Option<usize> {
s.get(from..)?.find(needle).map(|i| i + from)
}
/// LanServerPinger.parseMotd; "missing no" when there is none.
pub fn parse_motd(s: &str) -> String {
between(s, "[MOTD]", "[/MOTD]")
.unwrap_or("missing no")
.to_owned()
let Some(start) = s.find("[MOTD]") else {
return "missing no".to_owned();
};
match index_of(s, "[/MOTD]", start + "[MOTD]".len()) {
Some(end) => s[start + "[MOTD]".len()..end].to_owned(),
None => "missing no".to_owned(),
}
}
/// LanServerPinger.parseAddress: the announced port, if present and valid.
pub fn parse_port(s: &str) -> Option<u16> {
between(s, "[AD]", "[/AD]")?.parse().ok().filter(|p| *p > 0)
/// LanServerPinger.parseAddress: the text between [AD] and [/AD] after the
/// only [/MOTD], as announced (vanilla does not check it is a port).
pub fn parse_address(s: &str) -> Option<String> {
let end_motd = s.find("[/MOTD]")?;
if index_of(s, "[/MOTD]", end_motd + "[/MOTD]".len()).is_some() {
return None;
}
let start = index_of(s, "[AD]", end_motd + "[/MOTD]".len())?;
let end = index_of(s, "[/AD]", start + "[AD]".len())?;
Some(s[start + "[AD]".len()..end].to_owned())
}
/// LanServerDetection.LanServerList.addServer: an announcement from `ip`.
/// A new address joins the list; a known one keeps its first MOTD. True
/// when the list changed.
pub fn add_server(games: &mut Vec<LanGame>, ping: &str, ip: &str) -> bool {
let motd = parse_motd(ping);
let Some(address) = parse_address(ping) else {
return false;
};
let address = format!("{ip}:{address}");
if games.iter().any(|g| g.address == address) {
return false;
}
games.push(LanGame { motd, address });
true
}
/// Announces one hosted world until dropped.
@@ -48,7 +75,6 @@ pub struct Pinger {
impl Pinger {
pub fn start(motd: String, port: u16) -> io::Result<Self> {
let socket = UdpSocket::bind(("0.0.0.0", 0))?;
let _ = socket.set_multicast_ttl_v4(4);
let stop = Arc::new(AtomicBool::new(false));
let flag = stop.clone();
let message = ping_string(&motd, port);
@@ -86,7 +112,7 @@ pub struct LanGame {
pub motd: String,
pub address: String,
}
type Games = Arc<Mutex<Vec<(LanGame, Instant)>>>;
type Games = Arc<Mutex<Vec<LanGame>>>;
/// Listens for announcements until the last clone is dropped.
#[derive(Clone, Debug)]
@@ -118,11 +144,10 @@ impl Scanner {
inner: Arc::new(ScanInner { games, stop }),
}
}
/// The live announcements, oldest first.
/// The worlds announced since the scan started, in order (vanilla's
/// list keeps them while the multiplayer screen is open).
pub fn games(&self) -> Vec<LanGame> {
let mut games = self.inner.games.lock().unwrap();
games.retain(|(_, seen)| seen.elapsed() < EXPIRY);
games.iter().map(|(g, _)| g.clone()).collect()
self.inner.games.lock().unwrap().clone()
}
}
fn bind_listener() -> io::Result<UdpSocket> {
@@ -138,18 +163,7 @@ fn listen(socket: UdpSocket, games: Games, stop: Arc<AtomicBool>) {
continue;
};
let text = String::from_utf8_lossy(&buf[..n]);
let Some(port) = parse_port(&text) else {
continue;
};
let game = LanGame {
motd: parse_motd(&text),
address: format!("{}:{port}", from.ip()),
};
let mut games = games.lock().unwrap();
match games.iter_mut().find(|(g, _)| g.address == game.address) {
Some(entry) => *entry = (game, Instant::now()),
None => games.push((game, Instant::now())),
}
add_server(&mut games.lock().unwrap(), &text, &from.ip().to_string());
}
}
@@ -162,8 +176,17 @@ mod tests {
let s = ping_string("Steve - World", 25565);
assert_eq!(s, "[MOTD]Steve - World[/MOTD][AD]25565[/AD]");
assert_eq!(parse_motd(&s), "Steve - World");
assert_eq!(parse_port(&s), Some(25565));
assert_eq!(parse_port("[AD]0[/AD]"), None);
assert_eq!(parse_address(&s).as_deref(), Some("25565"));
assert_eq!(parse_address("[AD]1[/AD]"), None);
assert_eq!(parse_address("[/MOTD][AD]x[/AD][/MOTD]"), None);
assert_eq!(parse_motd("junk"), "missing no");
let mut games = Vec::new();
assert!(add_server(&mut games, &s, "10.0.0.2"));
assert!(!add_server(
&mut games,
&ping_string("Other", 25565),
"10.0.0.2"
));
assert_eq!(games[0].motd, "Steve - World");
}
}
+20
View File
@@ -20,6 +20,20 @@ pub const SPECTATOR: i32 = 3;
pub struct Guest {
pub conn: u32,
/// The client's address (IP bans, `list`).
pub address: std::net::SocketAddr,
/// The hub tick of the player's last action (ServerPlayer.lastActionTime),
/// for player-idle-timeout.
pub last_action_tick: u64,
/// The next ClientboundPlayerChatPacket.globalIndex for this connection.
pub chat_index: i32,
/// The hub tick the player was placed on: chunks go out from the tick
/// after next, behind the first doTick's packets, as vanilla's do.
pub placed_at: u64,
/// The chunk cache centre placeNewPlayer already sent.
pub center_sent: Option<(i32, i32)>,
/// Why the connection closed (the console's "lost connection").
pub left_reason: String,
pub uuid: u128,
pub name: String,
pub entity_id: i32,
@@ -97,6 +111,12 @@ impl Guest {
pub fn new(j: Joined, entity_id: i32, position: [f64; 3], view_distance: i32) -> Self {
Self {
conn: j.conn,
address: j.address,
last_action_tick: 0,
chat_index: 0,
placed_at: 0,
center_sent: None,
left_reason: String::new(),
uuid: j.uuid,
name: j.name,
entity_id,
+248 -27
View File
@@ -126,6 +126,54 @@ pub fn yellow_translation(key: &str, args: &[&str]) -> Tag {
t
}
/// Player.getDisplayName for a player in no team: the name, suggesting
/// `/tell NAME `, showing the player on hover and inserting the name.
pub fn display_name(uuid: u128, name: &str) -> Tag {
let words = [
(uuid >> 96) as i32,
(uuid >> 64) as i32,
(uuid >> 32) as i32,
uuid as i32,
];
Tag::compound([
("text", string(name)),
(
"click_event",
Tag::compound([
("action", string("suggest_command")),
("command", string(&format!("/tell {name} "))),
]),
),
(
"hover_event",
Tag::compound([
("action", string("show_entity")),
("id", string("minecraft:player")),
("uuid", Tag::IntArray(words.to_vec())),
("name", string(name)),
]),
),
("insertion", string(name)),
])
}
/// A yellow translation of player names (`multiplayer.player.joined`).
fn yellow_names(key: &str, names: Vec<Tag>) -> Tag {
Tag::compound([
("translate", string(key)),
("with", Tag::List(names)),
("color", string("yellow")),
])
}
/// ChunkTrackingView.contains: the chunks a player at (cx, cz) with view
/// distance `r` is sent (isWithinDistance with the neighbours' buffer).
fn tracked(cx: i32, cz: i32, r: i32, x: i32, z: i32) -> bool {
let dx = i64::from(((x - cx).abs() - 2).max(0));
let dz = i64::from(((z - cz).abs() - 2).max(0));
dx * dx + dz * dz < i64::from(r) * i64::from(r)
}
impl Hub {
pub fn new(lan: Lan, sync: Arc<SyncData>, encoder: ChunkEncoder, config: HubConfig) -> Self {
let chat_type = sync
@@ -214,19 +262,123 @@ impl Hub {
overlay: false,
}));
}
/// A chat message from `sender` (PlayerChatMessage as a disguised chat).
/// A chat message from the host (a disguised chat: the host has no
/// connection to sign with).
pub fn chat(&self, sender: &str, text: &str) {
self.broadcast(&self.chat_packet(sender, text));
}
fn chat_packet(&self, sender: &str, text: &str) -> C {
C::DisguisedChat(play::DisguisedChat {
self.broadcast(&C::DisguisedChat(play::DisguisedChat {
message: literal(text),
chat_type: play::ChatTypeBound {
chat_type: self.chat_type,
name: literal(sender),
target: None,
},
})
}));
}
/// ListPlayersCommand's reply: the players in join order (the host of a
/// LAN world first), as display names or names with ids, joined by
/// gray commas (ComponentUtils.formatList).
pub fn list_reply(&self, host: Option<(u128, &str)>, uuids: bool) -> Tag {
let players: Vec<(u128, &str)> = host
.into_iter()
.chain(
self.guests
.iter()
.filter(|g| g.placed)
.map(|g| (g.uuid, g.name.as_str())),
)
.collect();
let format = |(uuid, name): (u128, &str)| {
if uuids {
Tag::compound([
("translate", string("commands.list.nameAndId")),
(
"with",
Tag::List(vec![
string(name),
string(&horizon_protocol::crypto::uuid_string(uuid)),
]),
),
])
} else {
display_name(uuid, name)
}
};
let names = match players.len() {
0 => string(""),
1 => format(players[0]),
_ => {
let mut extra = Vec::new();
for (k, p) in players.iter().enumerate() {
if k > 0 {
extra.push(Tag::compound([
("text", string(", ")),
("color", string("gray")),
]));
}
extra.push(format(*p));
}
Tag::compound([("text", string("")), ("extra", Tag::List(extra))])
}
};
Tag::compound([
("translate", string("commands.list.players")),
(
"with",
Tag::List(vec![
Tag::Int(players.len() as i32),
Tag::Int(self.lan.shared.max_players() as i32),
names,
]),
),
])
}
/// SayCommand from a source without a player: a disguised chat of type
/// say_command named after the source.
pub fn say(&self, source: &str, text: &str) {
let chat_type = self
.sync
.id("minecraft:chat_type", "minecraft:say_command")
.unwrap_or(self.chat_type);
self.broadcast(&C::DisguisedChat(play::DisguisedChat {
message: literal(text),
chat_type: play::ChatTypeBound {
chat_type,
name: literal(source),
target: None,
},
}));
}
/// PlayerList.broadcastChatMessage of a guest's unsigned message
/// (PlayerChatMessage.unsigned): a ClientboundPlayerChatPacket to every
/// player, each connection numbering its messages.
pub fn player_chat(&mut self, from: usize, text: &str) {
let (uuid, name) = (self.guests[from].uuid, self.guests[from].name.clone());
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |d| d.as_millis() as i64);
let bound = play::ChatTypeBound {
chat_type: self.chat_type,
name: display_name(uuid, &name),
target: None,
};
for g in self.guests.iter_mut().filter(|g| g.placed) {
let packet = C::PlayerChat(play::PlayerChat {
global_index: g.chat_index,
sender: uuid,
index: 0,
signature: None,
content: text.to_owned(),
timestamp,
salt: 0,
last_seen: Vec::new(),
unsigned_content: None,
filter: (0, Vec::new()),
chat_type: bound.clone(),
});
g.chat_index += 1;
g.send(&packet);
}
}
/// Disconnect a guest with a reason (ServerGamePacketListenerImpl.disconnect).
@@ -275,6 +427,7 @@ impl Hub {
*ctx.next_entity += 1;
let conn = j.conn;
let mut guest = Guest::new(j, entity_id, ctx.spawn, self.config.view_distance);
guest.last_action_tick = self.ticks;
guest.game_mode = self.config.default_game_mode;
guest.permission = self.default_permission(guest.uuid);
guest.joined_tick = self.ticks;
@@ -356,7 +509,10 @@ impl Hub {
self.broadcast_except(
conn,
&C::SystemChat(play::SystemChat {
content: yellow_translation("multiplayer.player.joined", &[&name]),
content: yellow_names(
"multiplayer.player.joined",
vec![display_name(self.guests[i].uuid, &name)],
),
overlay: false,
}),
);
@@ -365,7 +521,7 @@ impl Hub {
let g = &self.guests[i];
g.send(&C::ServerData(play::ServerData {
motd: literal(&self.lan.shared.motd()),
icon: None,
icon: self.lan.shared.config.favicon.clone(),
}));
// The player list: everyone already here, then the newcomer to all.
let mut entries = Vec::new();
@@ -390,6 +546,15 @@ impl Hub {
};
self.broadcast(&C::PlayerInfoUpdate(newcomer));
self.send_level_info(i, ctx);
// ServerLevel.addNewPlayer: the chunk tracking starts at the player.
let g = &mut self.guests[i];
let (cx, cz) = g.chunk();
g.send(&C::SetChunkCacheCenter(play::SetChunkCacheCenter {
x: cx,
z: cz,
}));
g.center_sent = Some((cx, cz));
g.placed_at = self.ticks;
// ServerPlayer.sendPostEffects and initInventoryMenu.
self.guests[i].send(&raw(ids::POST_EFFECTS, vec![0]));
self.send_inventory(i);
@@ -409,9 +574,7 @@ impl Hub {
/// The permissions changed: tell everyone their level and commands again.
pub fn resend_commands(&mut self) {
for i in 0..self.guests.len() {
if !self.config.dedicated {
self.guests[i].permission = self.default_permission(self.guests[i].uuid);
}
self.guests[i].permission = self.default_permission(self.guests[i].uuid);
if self.guests[i].placed {
self.send_permission_level(i);
}
@@ -586,6 +749,20 @@ impl Hub {
g.inbox.push_back(*packet);
}
}
NetEvent::Duplicate(uuid) => {
let conns: Vec<u32> = self
.guests
.iter()
.filter(|g| g.uuid == uuid)
.map(|g| g.conn)
.collect();
for conn in conns {
self.kick(
conn,
translatable("multiplayer.disconnect.duplicate_login", &[]),
);
}
}
}
}
for i in 0..self.guests.len() {
@@ -639,7 +816,8 @@ impl Hub {
}
fn remove_guest(&mut self, i: usize, reason: &str) -> Guest {
let g = self.guests.remove(i);
let mut g = self.guests.remove(i);
g.left_reason = reason.to_owned();
if std::env::var_os("HORIZON_NET_DEBUG").is_some() {
eprintln!("[lan] {} left: {reason}", g.name);
}
@@ -652,7 +830,10 @@ impl Hub {
self.broadcast(&C::RemoveEntities(play::RemoveEntities {
ids: vec![g.entity_id],
}));
self.system_message(yellow_translation("multiplayer.player.left", &[&g.name]));
self.system_message(yellow_names(
"multiplayer.player.left",
vec![display_name(g.uuid, &g.name)],
));
g
}
@@ -729,27 +910,31 @@ impl Hub {
let g = &mut self.guests[i];
if g.center != Some((cx, cz)) {
g.center = Some((cx, cz));
g.send(&C::SetChunkCacheCenter(play::SetChunkCacheCenter {
x: cx,
z: cz,
}));
if g.center_sent.take() != Some((cx, cz)) {
g.send(&C::SetChunkCacheCenter(play::SetChunkCacheCenter {
x: cx,
z: cz,
}));
}
// Chunks that left the view.
let forget: Vec<_> = g
.sent_chunks
.iter()
.copied()
.filter(|&(x, z)| (x - cx).abs().max((z - cz).abs()) > r)
.filter(|&(x, z)| !tracked(cx, cz, r, x, z))
.collect();
for (x, z) in forget {
g.sent_chunks.remove(&(x, z));
g.send(&C::ForgetLevelChunk(play::ForgetLevelChunk { pos: [x, z] }));
}
g.chunk_queue
.retain(|&(x, z)| (x - cx).abs().max((z - cz).abs()) <= r);
for dz in -r..=r {
for dx in -r..=r {
g.chunk_queue.retain(|&(x, z)| tracked(cx, cz, r, x, z));
for dz in -r - 2..=r + 2 {
for dx in -r - 2..=r + 2 {
let key = (cx + dx, cz + dz);
if !g.sent_chunks.contains(&key) && !g.chunk_queue.contains(&key) {
if tracked(cx, cz, r, key.0, key.1)
&& !g.sent_chunks.contains(&key)
&& !g.chunk_queue.contains(&key)
{
g.chunk_queue.push(key);
}
}
@@ -758,7 +943,7 @@ impl Hub {
.sort_by_key(|&(x, z)| i64::from(x - cx).pow(2) + i64::from(z - cz).pow(2));
}
// Send ready chunks, closest first, in batches.
if g.chunk_queue.is_empty() || g.unacknowledged >= 10 {
if g.chunk_queue.is_empty() || g.unacknowledged >= 10 || self.ticks <= g.placed_at + 1 {
return;
}
g.chunk_credit = (g.chunk_credit + g.chunks_per_tick).min(g.chunks_per_tick.max(1.0) * 2.0);
@@ -779,7 +964,7 @@ impl Hub {
continue;
}
packets.push(C::LevelChunkWithLight(
self.encoder.encode(chunk, &ctx.world.block_entities),
self.encoder.encode_in(chunk, ctx.world),
));
taken.push(idx);
}
@@ -806,7 +991,7 @@ impl Hub {
let Some(chunk) = world.chunks.get(&(x, z)) else {
return;
};
let packet = C::LevelChunkWithLight(self.encoder.encode(chunk, &world.block_entities));
let packet = C::LevelChunkWithLight(self.encoder.encode_in(chunk, world));
let body = packet.encode();
for g in self
.guests
@@ -1092,6 +1277,15 @@ impl Hub {
/// ServerPlayer.doTick: health, food, experience and the inventory menu.
fn sync_player_state(&mut self, i: usize) {
// ServerEntity.sendDirtyEntityData on the player's first tick: the
// health its creation set is still dirty, and goes to the player too.
if self.guests[i].sent_health.is_none() {
let g = &self.guests[i];
g.send(&C::SetEntityData(play::SetEntityData {
id: g.entity_id,
values: vec![(9, serializer::FLOAT, Value::Float(g.health))],
}));
}
let health = {
let g = &self.guests[i];
(g.health, g.food, g.saturation)
@@ -1142,6 +1336,13 @@ impl Hub {
// ---- incoming ------------------------------------------------------
/// The squared movement past 1.0E-5F (handlePlayerKnownMovement).
fn moved_far(&self, i: usize, to: [f64; 3]) -> bool {
let from = self.guests[i].position;
let d: f64 = (0..3).map(|k| (to[k] - from[k]).powi(2)).sum();
d > f64::from(1.0E-5_f32)
}
fn process_inbox(&mut self, i: usize, ctx: &mut TickCtx, events: &mut Vec<HostEvent>) {
let mut budget = 400;
while budget > 0 {
@@ -1150,6 +1351,26 @@ impl Hub {
};
budget -= 1;
let conn = self.guests[i].conn;
// ServerPlayer.resetLastActionTime: every handler of a player's
// own action resets it, movement only when it moved
// (handlePlayerKnownMovement), PlayerInput once loaded.
let acted = match &packet {
S::AcceptTeleportation(_)
| S::MovePlayerStatus(_)
| S::MovePlayerRot(_)
| S::PlayerLoaded(_)
| S::ChunkBatchReceived(_)
| S::ClientInformation(_)
| S::ClientTickEnd(_)
| S::KeepAlive(_) => false,
S::MovePlayerPos(p) => self.moved_far(i, [p.x, p.y, p.z]),
S::MovePlayerPosRot(p) => self.moved_far(i, [p.x, p.y, p.z]),
S::PlayerInput(_) => self.guests[i].loaded,
_ => true,
};
if acted {
self.guests[i].last_action_tick = self.ticks;
}
match packet {
S::AcceptTeleportation(p) => {
let g = &mut self.guests[i];
@@ -1202,7 +1423,7 @@ impl Hub {
let text: String = c.message.chars().filter(|c| !c.is_control()).collect();
if !text.is_empty() {
let name = self.guests[i].name.clone();
self.chat(&name, &text);
self.player_chat(i, &text);
events.push(HostEvent::Chat(format!("<{name}> {text}")));
}
}
+228 -29
View File
@@ -20,14 +20,17 @@ pub mod tracking;
pub use conn::PlayerSender;
use horizon_protocol::packets::play;
use horizon_protocol::{GAME_VERSION, PROTOCOL_VERSION, packets::configuration::ClientInformation};
use horizon_protocol::{
GAME_VERSION, PROTOCOL_VERSION, crypto::uuid_string, packets::configuration::ClientInformation,
text::translatable,
};
use std::{
collections::HashSet,
io,
net::{SocketAddr, TcpListener, TcpStream},
sync::{
Arc, Mutex,
atomic::{AtomicBool, AtomicI32, AtomicU32, Ordering},
atomic::{AtomicBool, AtomicI32, AtomicU32, AtomicUsize, Ordering},
mpsc::{Receiver, Sender, channel},
},
thread::JoinHandle,
@@ -44,6 +47,9 @@ pub enum NetEvent {
Packet(u32, Box<play::Serverbound>),
/// The connection ended (reason for the log).
Left(u32, String),
/// PlayerList.disconnectAllPlayersWithProfile: a new login of this
/// profile replaces the player already in the world.
Duplicate(u128),
}
pub struct Joined {
pub conn: u32,
@@ -54,6 +60,7 @@ pub struct Joined {
pub sender: PlayerSender,
/// Smoothed keep-alive round trip in milliseconds.
pub latency: Arc<AtomicI32>,
pub address: SocketAddr,
}
/// Queued for a connection's writer thread.
pub enum Out {
@@ -64,54 +71,232 @@ pub enum Out {
Close,
}
/// PlayerList.canPlayerLogin for a dedicated server: the disconnect reason
/// (bans, whitelist) for a profile connecting from an address, if refused.
pub type LoginGate =
Arc<dyn Fn(SocketAddr, u128, &str) -> Option<horizon_world::nbt::Tag> + Send + Sync>;
/// How the server side of the network behaves: an integrated server's LAN
/// uses the defaults, a dedicated server takes them from server.properties.
#[derive(Clone)]
pub struct NetConfig {
/// server-ip (all interfaces when absent).
pub bind: Option<std::net::IpAddr>,
/// 0 picks a free port.
pub port: u16,
pub motd: String,
pub max_players: usize,
/// network-compression-threshold; negative disables compression.
pub compression_threshold: i32,
/// enable-status: answer status pings.
pub enable_status: bool,
pub hide_online_players: bool,
/// server-icon.png (64x64 PNG bytes).
pub favicon: Option<Vec<u8>>,
/// MinecraftServer.enforceSecureProfile.
pub enforces_secure_chat: bool,
pub accepts_transfers: bool,
/// LanServerPinger: announce the world on the local network.
pub announce: bool,
/// Ops bypass a full server (ServerOpList.canBypassPlayerLimit).
pub bypasses_limit: Option<Arc<dyn Fn(u128) -> bool + Send + Sync>>,
pub gate: Option<LoginGate>,
}
impl NetConfig {
/// IntegratedServer.publishServer.
pub fn lan(port: u16, motd: String, max_players: usize) -> Self {
Self {
bind: None,
port,
motd,
max_players,
compression_threshold: 256,
enable_status: true,
hide_online_players: false,
favicon: None,
enforces_secure_chat: false,
accepts_transfers: false,
announce: true,
bypasses_limit: None,
gate: None,
}
}
}
/// State shared with the connection threads.
pub struct Shared {
pub sync: Arc<data::SyncData>,
pub events: Sender<NetEvent>,
pub config: NetConfig,
motd: Mutex<String>,
online: Mutex<HashSet<u128>>,
max_players: usize,
max_players: AtomicUsize,
/// PlayerList.players in join order: profile id and name.
online: Mutex<Vec<(u128, String)>>,
/// Profiles held by the host (the LAN host's own name).
reserved: Mutex<HashSet<u128>>,
next: AtomicU32,
stop: AtomicBool,
random: Mutex<u64>,
}
impl Shared {
pub fn next_id(&self) -> u32 {
self.next.fetch_add(1, Ordering::Relaxed)
}
/// PlayerList.canPlayerLogin: duplicates and a full server are refused.
pub fn try_admit(&self, uuid: u128, _name: &str) -> Option<&'static str> {
let mut online = self.online.lock().unwrap();
if online.contains(&uuid) {
return Some("multiplayer.disconnect.duplicate_login");
/// PlayerList.canPlayerLogin then disconnectAllPlayersWithProfile: the
/// refusal reason, or None once the profile holds a place. A profile
/// already playing is kicked and its place awaited.
pub fn try_admit(
&self,
address: SocketAddr,
uuid: u128,
name: &str,
) -> Option<horizon_world::nbt::Tag> {
if let Some(gate) = &self.config.gate
&& let Some(reason) = gate(address, uuid, name)
{
return Some(reason);
}
if online.len() >= self.max_players {
return Some("multiplayer.disconnect.server_full");
if self.reserved.lock().unwrap().contains(&uuid) {
return Some(translatable("multiplayer.disconnect.duplicate_login", &[]));
}
online.insert(uuid);
{
let online = self.online.lock().unwrap();
let bypass = self.config.bypasses_limit.as_ref().is_some_and(|b| b(uuid));
let taken = online.len() + self.reserved.lock().unwrap().len();
if taken >= self.max_players() && !bypass {
return Some(translatable("multiplayer.disconnect.server_full", &[]));
}
}
if self.is_online(uuid) {
let _ = self.events.send(NetEvent::Duplicate(uuid));
let deadline = std::time::Instant::now() + Duration::from_secs(30);
while self.is_online(uuid) {
if std::time::Instant::now() > deadline {
return Some(translatable("multiplayer.disconnect.slow_login", &[]));
}
std::thread::sleep(Duration::from_millis(10));
}
}
self.online.lock().unwrap().push((uuid, name.to_owned()));
None
}
fn is_online(&self, uuid: u128) -> bool {
self.online.lock().unwrap().iter().any(|(u, _)| *u == uuid)
}
pub fn motd(&self) -> String {
self.motd.lock().unwrap().clone()
}
pub fn max_players(&self) -> usize {
self.max_players.load(Ordering::Relaxed)
}
pub fn set_max_players(&self, n: usize) {
self.max_players.store(n, Ordering::Relaxed);
}
pub fn release(&self, uuid: u128) {
self.online.lock().unwrap().remove(&uuid);
self.online.lock().unwrap().retain(|(u, _)| *u != uuid);
}
pub fn online(&self) -> usize {
self.online.lock().unwrap().len()
self.online.lock().unwrap().len() + self.reserved.lock().unwrap().len()
}
/// The status response (ServerStatus): version, players and the MOTD.
fn next_random(&self, bound: usize) -> usize {
let mut r = self.random.lock().unwrap();
*r = r
.wrapping_mul(6_364_136_223_846_793_005)
.wrapping_add(1_442_695_040_888_963_407);
((*r >> 33) as usize) % bound.max(1)
}
/// The status response (MinecraftServer.buildServerStatus encoded with
/// ServerStatus.CODEC): description, players with up to 12 shuffled
/// names, version, favicon and enforcesSecureChat when true.
pub fn status_json(&self) -> String {
use crate::server::json::Json;
let motd = self.motd.lock().unwrap().clone();
serde_json::json!({
"version": { "name": GAME_VERSION, "protocol": PROTOCOL_VERSION },
"players": { "max": self.max_players, "online": self.online() },
"description": { "text": motd },
"enforcesSecureChat": false,
})
.to_string()
let online: Vec<(u128, String)> = self.online.lock().unwrap().clone();
let count = self.online();
let mut players = vec![
(
"max".to_owned(),
Json::Number(self.max_players().to_string()),
),
("online".to_owned(), Json::Number(count.to_string())),
];
if !self.config.hide_online_players && !online.is_empty() {
let size = online.len().min(12);
let offset = self.next_random(online.len() - size + 1);
let mut sample: Vec<(u128, String)> = online[offset..offset + size].to_vec();
for i in (1..sample.len()).rev() {
let j = self.next_random(i + 1);
sample.swap(i, j);
}
players.push((
"sample".to_owned(),
Json::Array(
sample
.into_iter()
.map(|(u, n)| {
Json::Object(vec![
("id".to_owned(), Json::String(uuid_string(u))),
("name".to_owned(), Json::String(n)),
])
})
.collect(),
),
));
}
let mut status = vec![
("description".to_owned(), Json::String(motd)),
("players".to_owned(), Json::Object(players)),
(
"version".to_owned(),
Json::Object(vec![
("name".to_owned(), Json::String(GAME_VERSION.to_owned())),
(
"protocol".to_owned(),
Json::Number(PROTOCOL_VERSION.to_string()),
),
]),
),
];
if let Some(icon) = &self.config.favicon {
status.push((
"favicon".to_owned(),
Json::String(format!("data:image/png;base64,{}", base64(icon))),
));
}
if self.config.enforces_secure_chat {
status.push(("enforcesSecureChat".to_owned(), Json::Bool(true)));
}
Json::Object(status).compact()
}
}
/// java.util.Base64.getEncoder (padded, no line breaks).
pub fn base64(data: &[u8]) -> String {
const A: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
let mut out = String::with_capacity(data.len().div_ceil(3) * 4);
for chunk in data.chunks(3) {
let b = [
chunk[0],
*chunk.get(1).unwrap_or(&0),
*chunk.get(2).unwrap_or(&0),
];
let n = u32::from(b[0]) << 16 | u32::from(b[1]) << 8 | u32::from(b[2]);
out.push(char::from(A[(n >> 18) as usize & 63]));
out.push(char::from(A[(n >> 12) as usize & 63]));
out.push(if chunk.len() > 1 {
char::from(A[(n >> 6) as usize & 63])
} else {
'='
});
out.push(if chunk.len() > 2 {
char::from(A[n as usize & 63])
} else {
'='
});
}
out
}
/// A running LAN server.
pub struct Lan {
pub shared: Arc<Shared>,
@@ -129,19 +314,33 @@ impl Lan {
motd: String,
max_players: usize,
) -> io::Result<Self> {
let listener = TcpListener::bind(("0.0.0.0", port))?;
Self::start_with(sync, NetConfig::lan(port, motd, max_players))
}
/// ServerConnectionListener.startTcpServerListener with a configuration.
pub fn start_with(sync: Arc<data::SyncData>, config: NetConfig) -> io::Result<Self> {
let bind = config
.bind
.unwrap_or(std::net::IpAddr::V4(std::net::Ipv4Addr::UNSPECIFIED));
let listener = TcpListener::bind((bind, config.port))?;
listener.set_nonblocking(true)?;
let port = listener.local_addr()?.port();
let _pinger = discovery::Pinger::start(motd.clone(), port).ok();
let _pinger = if config.announce {
discovery::Pinger::start(config.motd.clone(), port).ok()
} else {
None
};
let (tx, events) = channel();
let shared = Arc::new(Shared {
sync,
events: tx,
motd: Mutex::new(motd),
online: Mutex::new(HashSet::new()),
max_players,
motd: Mutex::new(config.motd.clone()),
max_players: AtomicUsize::new(config.max_players),
online: Mutex::new(Vec::new()),
reserved: Mutex::new(HashSet::new()),
next: AtomicU32::new(1),
stop: AtomicBool::new(false),
random: Mutex::new(crate::server::java_properties::now_millis() as u64 | 1),
config,
});
let accept_shared = shared.clone();
let listener = std::thread::Builder::new()
@@ -161,7 +360,7 @@ impl Lan {
}
/// Reserve a uuid for the host so a guest cannot take the name.
pub fn reserve(&self, uuid: u128) {
self.shared.online.lock().unwrap().insert(uuid);
self.shared.reserved.lock().unwrap().insert(uuid);
}
pub fn set_motd(&self, motd: &str) {
*self.shared.motd.lock().unwrap() = motd.to_owned();
@@ -198,7 +397,7 @@ fn accept_loop(listener: TcpListener, shared: Arc<Shared>) {
}
fn handle(stream: TcpStream, addr: SocketAddr, shared: Arc<Shared>) {
let _ = stream.set_nonblocking(false);
if let Err(e) = conn::serve(stream, shared)
if let Err(e) = conn::serve(stream, addr, shared)
&& std::env::var_os("HORIZON_NET_DEBUG").is_some()
{
eprintln!("[lan] {addr}: {e}");
+26
View File
@@ -640,6 +640,32 @@ fn heightmaps(chunk: &Chunk, tables: &SaveTables) -> Tag {
)
}))
}
/// The heightmaps a ClientboundLevelChunkPacketData carries (the types with
/// sendToClient: WORLD_SURFACE, MOTION_BLOCKING, MOTION_BLOCKING_NO_LEAVES),
/// as (network id, packed longs) in Heightmap.Types order.
pub fn client_heightmaps(chunk: &Chunk, tables: &SaveTables) -> Vec<(i32, Vec<i64>)> {
let kinds = [
(1, HeightmapType::WorldSurface),
(4, HeightmapType::MotionBlocking),
(5, HeightmapType::MotionBlockingNoLeaves),
];
let mut maps: Vec<(i32, Heightmap)> = kinds
.iter()
.filter_map(|(id, k)| {
Heightmap::new(*k, MIN_Y, SECTIONS as i32 * 16)
.ok()
.map(|m| (*id, m))
})
.collect();
let view = HeightmapView { chunk, tables };
let mut refs: Vec<&mut Heightmap> = maps.iter_mut().map(|(_, m)| m).collect();
if Heightmap::prime(&view, &mut refs).is_err() {
return Vec::new();
}
maps.iter()
.map(|(id, m)| (*id, m.raw_data().iter().map(|&w| w as i64).collect()))
.collect()
}
/// Vanilla light layer (nibbles, index y<<8|z<<4|x, low nibble first).
fn nibbles(light: &Light, sky: bool) -> Vec<u8> {
let mut out = vec![0u8; 2048];
+2 -1
View File
@@ -302,7 +302,8 @@ fn status_and_join() {
});
let v: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(v["version"]["protocol"], 777);
assert_eq!(v["description"]["text"], "Test - World");
// ServerStatus.CODEC writes a plain literal MOTD as a bare string.
assert_eq!(v["description"], "Test - World");
// Join, receive the world, place a block, see another player arrive.
let report = run(&mut s, move || {
@@ -0,0 +1,52 @@
package dev.horizonlab.parity;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HexFormat;
import java.util.List;
import net.minecraft.client.server.LanServer;
import net.minecraft.client.server.LanServerDetection;
import net.minecraft.client.server.LanServerPinger;
/**
* Vanilla's LAN world discovery for tools/test_lan_parity.py. Each input
* line is a case: `ping MOTD PORT` prints the announcement
* LanServerPinger sends (its UTF-8 bytes); `heard IP HEX` decodes a received
* datagram as LanServerDetection does and adds it to the list
* (LanServerList.addServer), printing what it parsed and the list when it
* changed; `reset` starts a new list (a new multiplayer screen).
*/
public final class VanillaLanOracle {
public static void main(String[] args) throws Exception {
List<String> cases = Files.readAllLines(Path.of(args[0]), StandardCharsets.UTF_8);
try (PrintWriter out = new PrintWriter(Files.newBufferedWriter(Path.of(args[1]), StandardCharsets.UTF_8))) {
LanServerDetection.LanServerList list = new LanServerDetection.LanServerList();
for (String line : cases) {
String[] f = line.split("\t", -1);
switch (f[0]) {
case "ping" -> {
String ping = LanServerPinger.createPingString(f[1], f[2]);
out.println("ping " + HexFormat.of().formatHex(ping.getBytes(StandardCharsets.UTF_8)));
}
case "heard" -> {
byte[] bytes = HexFormat.of().parseHex(f[2]);
String received = new String(bytes, 0, bytes.length, StandardCharsets.UTF_8);
out.println("heard motd=" + LanServerPinger.parseMotd(received) + " address=" + LanServerPinger.parseAddress(received));
list.addServer(received, InetAddress.getByName(f[1]));
List<LanServer> dirty = list.takeDirtyServers();
if (dirty != null) {
StringBuilder b = new StringBuilder("list");
for (LanServer s : dirty) b.append(" [").append(s.getMotd()).append(" @ ").append(s.getAddress()).append(']');
out.println(b);
}
}
case "reset" -> list = new LanServerDetection.LanServerList();
default -> throw new IllegalArgumentException(line);
}
}
}
}
}
@@ -0,0 +1,661 @@
package dev.horizonlab.parity;
import com.google.gson.JsonElement;
import com.mojang.serialization.JsonOps;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.MessageDigest;
import java.time.Instant;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.HexFormat;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.TreeMap;
import java.util.UUID;
import java.util.zip.DataFormatException;
import java.util.zip.Deflater;
import java.util.zip.Inflater;
import net.minecraft.SharedConstants;
import net.minecraft.core.UUIDUtil;
import net.minecraft.network.FriendlyByteBuf;
import net.minecraft.network.RegistryFriendlyByteBuf;
import net.minecraft.world.level.chunk.LevelChunkSection;
import net.minecraft.world.level.chunk.PalettedContainerFactory;
import net.minecraft.network.chat.Component;
import net.minecraft.network.chat.ComponentSerialization;
import net.minecraft.network.chat.LastSeenMessages;
import net.minecraft.network.protocol.Packet;
import net.minecraft.network.ProtocolInfo;
import net.minecraft.network.protocol.common.ClientboundCustomPayloadPacket;
import net.minecraft.network.protocol.common.ClientboundDisconnectPacket;
import net.minecraft.network.protocol.common.ClientboundKeepAlivePacket;
import net.minecraft.network.protocol.common.ClientboundPingPacket;
import net.minecraft.network.protocol.common.ServerboundClientInformationPacket;
import net.minecraft.network.protocol.common.ServerboundCustomPayloadPacket;
import net.minecraft.network.protocol.common.ServerboundKeepAlivePacket;
import net.minecraft.network.protocol.common.ServerboundPongPacket;
import net.minecraft.network.protocol.common.custom.BrandPayload;
import net.minecraft.network.protocol.configuration.ClientboundFinishConfigurationPacket;
import net.minecraft.network.protocol.configuration.ClientboundSelectKnownPacks;
import net.minecraft.network.protocol.configuration.ConfigurationProtocols;
import net.minecraft.network.protocol.configuration.ServerboundFinishConfigurationPacket;
import net.minecraft.network.protocol.configuration.ServerboundSelectKnownPacks;
import net.minecraft.network.protocol.game.ClientboundChunkBatchFinishedPacket;
import net.minecraft.network.protocol.game.ClientboundDisguisedChatPacket;
import net.minecraft.network.protocol.game.ClientboundLevelChunkPacketData;
import net.minecraft.network.protocol.game.ClientboundLevelChunkWithLightPacket;
import net.minecraft.network.protocol.game.ClientboundPlayerChatPacket;
import net.minecraft.network.protocol.game.ClientboundPlayerPositionPacket;
import net.minecraft.network.protocol.game.ClientboundSystemChatPacket;
import net.minecraft.network.protocol.game.GameProtocols;
import net.minecraft.network.protocol.game.ServerboundAcceptTeleportationPacket;
import net.minecraft.network.protocol.game.ServerboundChatCommandPacket;
import net.minecraft.network.protocol.game.ServerboundChatPacket;
import net.minecraft.network.protocol.game.ServerboundChunkBatchReceivedPacket;
import net.minecraft.network.protocol.game.ServerboundMovePlayerPacket;
import net.minecraft.network.protocol.game.ServerboundPlayerLoadedPacket;
import net.minecraft.network.protocol.handshake.ClientIntent;
import net.minecraft.network.protocol.handshake.ClientIntentionPacket;
import net.minecraft.network.protocol.handshake.HandshakeProtocols;
import net.minecraft.network.protocol.login.ClientboundLoginCompressionPacket;
import net.minecraft.network.protocol.login.ClientboundLoginDisconnectPacket;
import net.minecraft.network.protocol.login.ClientboundLoginFinishedPacket;
import net.minecraft.network.protocol.login.LoginProtocols;
import net.minecraft.network.protocol.login.ServerboundHelloPacket;
import net.minecraft.network.protocol.login.ServerboundLoginAcknowledgedPacket;
import net.minecraft.network.protocol.ping.ClientboundPongResponsePacket;
import net.minecraft.network.protocol.ping.ServerboundPingRequestPacket;
import net.minecraft.network.protocol.status.ClientboundStatusResponsePacket;
import net.minecraft.network.protocol.status.ServerStatus;
import net.minecraft.network.protocol.status.ServerboundStatusRequestPacket;
import net.minecraft.network.protocol.status.StatusProtocols;
import net.minecraft.server.level.ClientInformation;
import net.minecraft.world.entity.PositionMoveRotation;
import net.minecraft.world.phys.Vec3;
/**
* A headless client made of vanilla's own protocol: it frames, compresses and
* decodes every packet with the codecs of the pinned server JAR (the client
* shares them), so any byte a server sends that vanilla would not read is
* recorded as an error. tools/test_dedicated_server_parity.py points it at a
* vanilla dedicated server and at Horizon's, with the same settings and
* world, and compares the transcripts.
*
* <p>{@code VanillaProtocolClient HOST PORT NAME OUT} pings the server (status
* and ping), joins as NAME in offline mode, goes through login and
* configuration, accepts the spawn teleport, waits for the chunks around the
* spawn, sends a chat message and the {@code /list} command, and leaves.
* Each transcript line is a section and a summary: the login and
* configuration packets in order; in play, the packets up to the first chunk
* batch in order, then the chunks by position with the hash of their bytes
* and the replies to the chat and command. Values that change between runs
* (entity ids, keep-alive ids, times, salts) are not part of the summaries.
*/
public final class VanillaProtocolClient {
private Socket socket;
private DataInputStream in;
private OutputStream out;
private int threshold = -1;
private final List<String> lines = new ArrayList<>();
private ProtocolInfo<?> inbound;
private ProtocolInfo<?> outbound;
private String state;
public static void main(String[] args) throws Exception {
ParityData.init();
String host = args[0];
int port = Integer.parseInt(args[1]);
String name = args[2];
Path output = Path.of(args[3]);
VanillaProtocolClient client = new VanillaProtocolClient();
try {
client.status(host, port);
client.join(host, port, name);
} catch (Exception e) {
client.lines.add("error " + client.state + " " + e);
} finally {
if (client.socket != null) client.socket.close();
}
try (PrintWriter w = new PrintWriter(Files.newBufferedWriter(output, StandardCharsets.UTF_8))) {
for (String line : client.lines) w.println(line);
}
System.exit(0);
}
// ---- connection ---------------------------------------------------
private void open(String host, int port) throws Exception {
socket = new Socket();
socket.connect(new InetSocketAddress(host, port), 10_000);
socket.setSoTimeout(30_000);
socket.setTcpNoDelay(true);
in = new DataInputStream(socket.getInputStream());
out = socket.getOutputStream();
threshold = -1;
}
private static int readVarInt(InputStream in) throws Exception {
int value = 0;
for (int i = 0; i < 5; i++) {
int b = in.read();
if (b < 0) throw new EOFException();
value |= (b & 0x7F) << (7 * i);
if ((b & 0x80) == 0) return value;
}
throw new IllegalStateException("VarInt too big");
}
private static void writeVarInt(ByteBuf buf, int value) {
while ((value & ~0x7F) != 0) {
buf.writeByte((value & 0x7F) | 0x80);
value >>>= 7;
}
buf.writeByte(value);
}
@SuppressWarnings({"unchecked", "rawtypes"})
private void send(Packet<?> packet) throws Exception {
ByteBuf body = Unpooled.buffer();
((ProtocolInfo) outbound).codec().encode(body, packet);
byte[] raw = new byte[body.readableBytes()];
body.readBytes(raw);
ByteBuf frame = Unpooled.buffer();
if (threshold >= 0) {
ByteBuf inner = Unpooled.buffer();
if (raw.length >= threshold) {
writeVarInt(inner, raw.length);
Deflater d = new Deflater();
d.setInput(raw);
d.finish();
byte[] tmp = new byte[raw.length + 64];
while (!d.finished()) {
int n = d.deflate(tmp);
inner.writeBytes(tmp, 0, n);
}
d.end();
} else {
writeVarInt(inner, 0);
inner.writeBytes(raw);
}
writeVarInt(frame, inner.readableBytes());
frame.writeBytes(inner);
} else {
writeVarInt(frame, raw.length);
frame.writeBytes(raw);
}
byte[] bytes = new byte[frame.readableBytes()];
frame.readBytes(bytes);
out.write(bytes);
out.flush();
}
/** The next packet's raw payload, decompressed as CompressionDecoder does (validating). */
private byte[] readFrame() throws Exception {
int length = readVarInt(in);
byte[] frame = new byte[length];
in.readFully(frame);
if (threshold < 0) return frame;
ByteBuf buf = Unpooled.wrappedBuffer(frame);
int dataLength = readVarInt(new java.io.ByteArrayInputStream(frame));
int header = varIntSize(dataLength);
buf.skipBytes(header);
if (dataLength == 0) {
byte[] raw = new byte[buf.readableBytes()];
buf.readBytes(raw);
return raw;
}
if (dataLength < threshold) {
throw new IllegalStateException("Badly compressed packet - size of " + dataLength + " is below server threshold of " + threshold);
}
if (dataLength > 8388608) {
throw new IllegalStateException("Badly compressed packet - size of " + dataLength + " is larger than protocol maximum of 8388608");
}
Inflater inflater = new Inflater();
inflater.setInput(frame, header, frame.length - header);
byte[] raw = new byte[dataLength];
int n;
try {
n = inflater.inflate(raw);
} catch (DataFormatException e) {
throw new IllegalStateException("bad zlib data", e);
}
boolean finished = inflater.finished();
inflater.end();
if (n != dataLength || !finished) throw new IllegalStateException("decompressed " + n + " of " + dataLength + " bytes");
return raw;
}
private static int varIntSize(int v) {
int n = 1;
while ((v & ~0x7F) != 0) {
v >>>= 7;
n++;
}
return n;
}
private record Received(Packet<?> packet, byte[] payload, String type) {}
/** The next packet, decoded with the inbound protocol; leftover bytes are an error (PacketDecoder). */
private Received read() throws Exception {
byte[] payload = readFrame();
ByteBuf buf = Unpooled.wrappedBuffer(payload);
Packet<?> packet = inbound.codec().decode(buf);
if (buf.readableBytes() > 0) {
throw new IllegalStateException("Packet " + inbound.id().id() + "/" + packet.type().id() + " was larger than I expected, found "
+ buf.readableBytes() + " bytes extra whilst reading");
}
return new Received(packet, payload, packet.type().id().toString());
}
// ---- summaries ----------------------------------------------------
private static String sha(byte[] bytes) {
try {
return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(bytes)).substring(0, 16);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private static String json(Component c) {
JsonElement e = ComponentSerialization.CODEC.encodeStart(ParityData.access.createSerializationContext(JsonOps.INSTANCE), c).getOrThrow();
return e.toString();
}
/** A record's text without object identities; other objects by their fields. */
private static String text(Object o) {
String s = String.valueOf(o);
if (o != null && s.matches("[\\w.$]+@[0-9a-f]+")) {
StringBuilder b = new StringBuilder(o.getClass().getSimpleName()).append('{');
for (Class<?> c = o.getClass(); c != null && c != Object.class; c = c.getSuperclass()) {
for (java.lang.reflect.Field f : c.getDeclaredFields()) {
if (java.lang.reflect.Modifier.isStatic(f.getModifiers())) continue;
try {
f.setAccessible(true);
b.append(f.getName()).append('=').append(text(f.get(o))).append(", ");
} catch (Exception e) {
b.append(f.getName()).append("=?, ");
}
}
}
return b.append('}').toString();
}
return s.replaceAll("\\$\\$Lambda/0x[0-9a-f]+@", "\\$\\$Lambda@").replaceAll("@[0-9a-f]{4,}", "@");
}
private void record(String section, String line) {
lines.add(section + " " + line);
}
// ---- status -------------------------------------------------------
private void status(String host, int port) throws Exception {
state = "status";
open(host, port);
outbound = HandshakeProtocols.SERVERBOUND;
send(new ClientIntentionPacket(SharedConstants.getProtocolVersion(), host, port, ClientIntent.STATUS));
outbound = StatusProtocols.SERVERBOUND;
inbound = StatusProtocols.CLIENTBOUND;
send(ServerboundStatusRequestPacket.INSTANCE);
Received r = read();
if (r.packet instanceof ClientboundStatusResponsePacket p) {
JsonElement e = ServerStatus.CODEC.encodeStart(JsonOps.INSTANCE, p.status()).getOrThrow();
// The favicon is compared by its bytes' hash.
String s = e.toString().replaceAll("\"favicon\":\"[^\"]*\"", "\"favicon\":\"" + p.status().favicon().map(f -> sha(f.iconBytes())).orElse("") + "\"");
record("status", r.type + " " + s);
} else {
record("status", r.type + " " + text(r.packet));
}
send(new ServerboundPingRequestPacket(1234567890123L));
Received pong = read();
record("status", pong.type + " " + (pong.packet instanceof ClientboundPongResponsePacket p ? p.time() : text(pong.packet)));
int after = in.read();
record("status", "closed-after-pong " + (after < 0));
socket.close();
}
// ---- join ---------------------------------------------------------
private void join(String host, int port, String name) throws Exception {
open(host, port);
state = "login";
outbound = HandshakeProtocols.SERVERBOUND;
send(new ClientIntentionPacket(SharedConstants.getProtocolVersion(), host, port, ClientIntent.LOGIN));
outbound = LoginProtocols.SERVERBOUND;
inbound = LoginProtocols.CLIENTBOUND;
UUID uuid = UUIDUtil.createOfflinePlayerUUID(name);
send(new ServerboundHelloPacket(name, uuid));
while (true) {
Received r = read();
if (r.packet instanceof ClientboundLoginCompressionPacket p) {
threshold = p.getCompressionThreshold();
record("login", r.type + " " + threshold);
} else if (r.packet instanceof ClientboundLoginFinishedPacket p) {
record("login", r.type + " " + p.gameProfile().id() + " " + p.gameProfile().name() + " " + p.gameProfile().properties().size());
send(ServerboundLoginAcknowledgedPacket.INSTANCE);
break;
} else if (r.packet instanceof ClientboundLoginDisconnectPacket p) {
record("login", r.type + " " + json(p.reason()));
return;
} else {
record("login", r.type + " " + text(r.packet));
}
}
state = "configuration";
outbound = ConfigurationProtocols.SERVERBOUND;
inbound = ConfigurationProtocols.CLIENTBOUND;
// ClientHandshakePacketListenerImpl.handleLoginFinished: brand, then the options.
send(new ServerboundCustomPayloadPacket(new BrandPayload("vanilla")));
send(new ServerboundClientInformationPacket(ClientInformation.createDefault()));
while (true) {
Received r = read();
if (r.packet instanceof ClientboundSelectKnownPacks p) {
record("config", r.type + " " + text(p.knownPacks()));
send(new ServerboundSelectKnownPacks(p.knownPacks()));
} else if (r.packet instanceof ClientboundKeepAlivePacket p) {
record("config", r.type);
send(new ServerboundKeepAlivePacket(p.getId()));
} else if (r.packet instanceof ClientboundPingPacket p) {
record("config", r.type);
send(new ServerboundPongPacket(p.getId()));
} else if (r.packet instanceof ClientboundCustomPayloadPacket p) {
record("config", r.type + " " + text(p.payload()));
} else if (r.packet instanceof net.minecraft.network.protocol.common.ClientboundUpdateTagsPacket p) {
// Each registry's tags and what they hold. Vanilla sends the
// registries and tags in the order of maps keyed by interned
// ResourceKeys (identity hashes), which changes between runs.
var registries = new TreeMap<String, String>();
for (var e : p.tags().entrySet()) {
var tags = new TreeMap<String, String>();
for (var t : e.getValue().tags().entrySet()) {
tags.put(t.getKey().toString(), t.getValue().toString());
}
registries.put(e.getKey().identifier().toString(), tags.size() + " " + sha(tags.toString().getBytes()));
}
record("config", r.type + " " + registries.size() + " registries");
registries.forEach((k, v) -> record("config-tags", k + " " + v));
} else if (r.packet instanceof ClientboundFinishConfigurationPacket) {
record("config", r.type);
send(ServerboundFinishConfigurationPacket.INSTANCE);
break;
} else if (r.packet instanceof ClientboundDisconnectPacket p) {
record("config", r.type + " " + json(p.reason()));
return;
} else {
record("config", r.type + " " + (r.payload.length > 200 ? "sha=" + sha(r.payload) : text(r.packet)));
}
}
play();
}
private void play() throws Exception {
state = "play";
GameProtocols.Context context = new GameProtocols.Context() {
@Override
public boolean hasInfiniteMaterials() {
return false;
}
@Override
public boolean canUseCommandBlocks() {
return false;
}
};
outbound = GameProtocols.SERVERBOUND_TEMPLATE.bind(RegistryFriendlyByteBuf.decorator(ParityData.access), context);
inbound = GameProtocols.CLIENTBOUND_TEMPLATE.bind(RegistryFriendlyByteBuf.decorator(ParityData.access));
socket.setSoTimeout(250);
Map<String, String> chunks = new TreeMap<>();
Map<String, String> layers = new TreeMap<>();
Map<String, Integer> counts = new TreeMap<>();
boolean ordered = true;
boolean loaded = false;
PositionMoveRotation position = new PositionMoveRotation(Vec3.ZERO, Vec3.ZERO, 0, 0);
long lastChunk = 0;
long deadline = System.currentTimeMillis() + 90_000;
int step = 0;
long stepAt = 0;
while (System.currentTimeMillis() < deadline) {
Received r;
try {
r = read();
} catch (SocketTimeoutException e) {
r = null;
}
long now = System.currentTimeMillis();
if (r != null) {
Packet<?> packet = r.packet;
counts.merge(r.type, 1, Integer::sum);
if (r.type.equals("minecraft:chunk_batch_start")) ordered = false;
if (packet instanceof ClientboundKeepAlivePacket p) {
send(new ServerboundKeepAlivePacket(p.getId()));
} else if (packet instanceof ClientboundPingPacket p) {
send(new ServerboundPongPacket(p.getId()));
} else if (packet instanceof ClientboundPlayerPositionPacket p) {
position = PositionMoveRotation.calculateAbsolute(position, p.change(), p.relatives());
record("play-move", text(position.position()) + " " + position.yRot() + " " + position.xRot());
send(new ServerboundAcceptTeleportationPacket(p.id(), position.position().x, position.position().y, position.position().z,
position.yRot(), position.xRot()));
send(new ServerboundMovePlayerPacket.PosRot(position.position(), position.yRot(), position.xRot(), false, false));
if (!loaded) {
send(new ServerboundPlayerLoadedPacket());
loaded = true;
}
} else if (packet instanceof ClientboundChunkBatchFinishedPacket) {
send(new ServerboundChunkBatchReceivedPacket(64.0F));
} else if (packet instanceof ClientboundLevelChunkWithLightPacket p) {
chunks.put(p.x() + "," + p.z(), chunkHash(p));
layers.put(p.x() + "," + p.z(), lightLayers(p));
lastChunk = now;
int px = (int) Math.floor(position.position().x) >> 4;
int pz = (int) Math.floor(position.position().z) >> 4;
if (p.x() == px && p.z() == pz) chunkParts(p);
} else if (packet instanceof ClientboundSystemChatPacket p && step > 0) {
record("play-chat", "system " + p.overlay() + " " + json(p.content()));
} else if (packet instanceof ClientboundPlayerChatPacket p && step > 0) {
record("play-chat", "player " + p.sender() + " " + p.index() + " " + p.body().content() + " " + p.signature().isPresent()
+ " " + p.unsignedContent().map(VanillaProtocolClient::json) + " " + text(p.filterMask()) + " "
+ p.chatType().chatType().getRegisteredName() + " " + json(p.chatType().name()) + " "
+ p.chatType().targetName().map(VanillaProtocolClient::json));
} else if (packet instanceof ClientboundDisguisedChatPacket p && step > 0) {
record("play-chat", "disguised " + json(p.message()) + " " + p.chatType().chatType().getRegisteredName());
} else if (packet instanceof ClientboundDisconnectPacket p) {
record("play", r.type + " " + json(p.reason()));
break;
}
if (ordered) {
record("play-start", r.type + " " + summary(r));
}
if (packet instanceof net.minecraft.network.protocol.game.ClientboundCommandsPacket p && counts.get(r.type) == 1) {
commandTree(p);
}
}
// Once the chunks stop coming: chat, then /list, then leave.
if (loaded && lastChunk > 0 && now - lastChunk > 3000 && step == 0) {
record("play-chunks", chunks.size() + " " + chunks);
BLOCK_ENTITIES.forEach((k, v) -> record("play-block-entities", k + " " + v));
// Which light layers exist depends on the neighbouring
// columns: compared where all eight were sent.
Map<String, String> inner = new TreeMap<>();
layers.forEach((k, v) -> {
String[] xz = k.split(",");
int x = Integer.parseInt(xz[0]), z = Integer.parseInt(xz[1]);
boolean all = true;
for (int dz = -1; dz <= 1; dz++) for (int dx = -1; dx <= 1; dx++) all &= chunks.containsKey((x + dx) + "," + (z + dz));
if (all) inner.put(k, v);
});
record("play-light-layers", inner.size() + " " + inner);
step = 1;
stepAt = now;
send(new ServerboundChatPacket("hello from the parity client", Instant.now(), 0L, Optional.empty(),
new LastSeenMessages.Update(0, new BitSet(), (byte) 0)));
} else if (step == 1 && now - stepAt > 1500) {
step = 2;
stepAt = now;
send(new ServerboundChatCommandPacket("list"));
} else if (step == 2 && now - stepAt > 1500) {
record("play-counts", "chunks " + counts.getOrDefault("minecraft:level_chunk_with_light", 0));
return;
}
}
record("error", "timed out in play, step " + step + ", chunks " + chunks.size());
}
/**
* A chunk's blocks, biomes, heightmaps and block entities (its
* ClientboundLevelChunkPacketData bytes). The light is left out: both servers relight around chunks
* loaded with their saved light, which test_light_parity covers.
*/
private static final Map<String, String> BLOCK_ENTITIES = new TreeMap<>();
private static String chunkHash(ClientboundLevelChunkWithLightPacket p) {
var data = p.chunkData();
var heightmaps = new TreeMap<String, String>();
data.getHeightmaps().forEach((k, v) -> heightmaps.put(k.getSerializedName(), java.util.Arrays.toString(v)));
FriendlyByteBuf buf = data.getReadBuffer();
byte[] sections = new byte[buf.readableBytes()];
buf.getBytes(buf.readerIndex(), sections);
// What the sections hold, apart from how their palettes encode it.
FriendlyByteBuf copy = new FriendlyByteBuf(Unpooled.wrappedBuffer(sections));
var factory = PalettedContainerFactory.create(ParityData.access);
StringBuilder content = new StringBuilder();
while (copy.isReadable()) {
LevelChunkSection section = new LevelChunkSection(factory);
section.read(copy);
for (int y = 0; y < 16; y++) for (int z = 0; z < 16; z++) for (int x = 0; x < 16; x++) {
content.append(net.minecraft.world.level.block.Block.getId(section.getBlockState(x, y, z))).append(',');
}
for (int y = 0; y < 4; y++) for (int z = 0; z < 4; z++) for (int x = 0; x < 4; x++) {
content.append(section.getNoiseBiome(x, y, z).getRegisteredName()).append(',');
}
}
StringBuilder entities = new StringBuilder();
data.forEachBlockEntityTag(p.x(), p.z(), (pos, type, tag) -> entities.append(pos.toShortString()).append(' ')
.append(net.minecraft.core.registries.BuiltInRegistries.BLOCK_ENTITY_TYPE.getKey(type)).append(' ').append(tag).append(';'));
if (entities.length() > 0) BLOCK_ENTITIES.put(p.x() + "," + p.z(), entities.toString());
return "c" + sha(content.toString().getBytes()).substring(0, 8) + "s" + sha(sections).substring(0, 8) + "h" + sha(heightmaps.toString().getBytes()).substring(0, 8) + "e"
+ sha(entities.toString().getBytes()).substring(0, 8);
}
/** The light layers a chunk has, sky then block (with data or empty). */
private static String lightLayers(ClientboundLevelChunkWithLightPacket p) {
var light = p.lightData();
BitSet sky = (BitSet) light.skyYMask().clone();
sky.or(light.emptySkyYMask());
BitSet block = (BitSet) light.blockYMask().clone();
block.or(light.emptyBlockYMask());
return sky + "/" + block;
}
/** The player's chunk part by part, so a difference in its bytes can be told apart. */
private void chunkParts(ClientboundLevelChunkWithLightPacket p) {
var data = p.chunkData();
for (var e : new TreeMap<>(data.getHeightmaps().entrySet().stream()
.collect(java.util.stream.Collectors.toMap(x -> x.getKey().getSerializedName(), x -> x.getValue()))).entrySet()) {
record("chunk-heightmap", e.getKey() + " " + java.util.Arrays.toString(e.getValue()).hashCode());
}
FriendlyByteBuf buf = data.getReadBuffer();
byte[] all = new byte[buf.readableBytes()];
buf.getBytes(buf.readerIndex(), all);
var factory = PalettedContainerFactory.create(ParityData.access);
int index = 0;
while (buf.isReadable()) {
int start = buf.readerIndex();
LevelChunkSection section = new LevelChunkSection(factory);
section.read(buf);
StringBuilder states = new StringBuilder();
for (int y = 0; y < 16; y++) for (int z = 0; z < 16; z++) for (int x = 0; x < 16; x++) {
states.append(net.minecraft.world.level.block.Block.getId(section.getBlockState(x, y, z))).append(',');
}
StringBuilder biomes = new StringBuilder();
for (int y = 0; y < 4; y++) for (int z = 0; z < 4; z++) for (int x = 0; x < 4; x++) {
biomes.append(section.getNoiseBiome(x, y, z).getRegisteredName()).append(',');
}
byte[] bytes = new byte[buf.readerIndex() - start];
buf.getBytes(start, bytes);
record("chunk-section", index++ + " states=" + sha(states.toString().getBytes()) + " biomes=" + sha(biomes.toString().getBytes())
+ " count=" + (((bytes[0] & 0xFF) << 8) | (bytes[1] & 0xFF)) + " bytes=" + sha(bytes));
}
StringBuilder entities = new StringBuilder();
data.forEachBlockEntityTag(p.x(), p.z(), (pos, type, tag) -> entities.append(pos.toShortString()).append(' ')
.append(net.minecraft.core.registries.BuiltInRegistries.BLOCK_ENTITY_TYPE.getKey(type)).append(' ').append(tag).append(';'));
record("chunk-block-entities", entities.toString());
}
/** The command tree, one line per top-level command with its subtree. */
private void commandTree(net.minecraft.network.protocol.game.ClientboundCommandsPacket p) {
var context = net.minecraft.commands.CommandBuildContext.simple(ParityData.access, net.minecraft.world.flag.FeatureFlags.VANILLA_SET);
var root = p.getRoot(context, new net.minecraft.network.protocol.game.ClientboundCommandsPacket.NodeBuilder<Object>() {
@Override
public com.mojang.brigadier.builder.ArgumentBuilder<Object, ?> createLiteral(String id) {
return com.mojang.brigadier.builder.LiteralArgumentBuilder.literal(id);
}
@Override
public com.mojang.brigadier.builder.ArgumentBuilder<Object, ?> createArgument(String id, com.mojang.brigadier.arguments.ArgumentType<?> type,
net.minecraft.resources.Identifier suggestionId) {
return com.mojang.brigadier.builder.RequiredArgumentBuilder.argument(id + ":" + type.getClass().getSimpleName() + ":" + suggestionId, type);
}
@Override
public com.mojang.brigadier.builder.ArgumentBuilder<Object, ?> configure(com.mojang.brigadier.builder.ArgumentBuilder<Object, ?> input,
boolean executable, boolean restricted) {
if (executable) input.executes(c -> 0);
return input;
}
});
// Vanilla sends each node's children in registration order, which
// its commands report (sorted) does not keep: compared as sets.
var lines = new TreeMap<String, String>();
for (var child : root.getChildren()) {
var paths = new java.util.TreeSet<String>();
describe(child, "", paths, new java.util.IdentityHashMap<>());
lines.put(child.getName(), paths.size() + " " + sha(String.join("\n", paths).getBytes()));
}
lines.forEach((k, v) -> record("play-command", k + " " + v));
}
private static void describe(com.mojang.brigadier.tree.CommandNode<Object> node, String path, java.util.Set<String> out,
java.util.IdentityHashMap<Object, Boolean> seen) {
String here = path + " " + node.getName() + (node.getCommand() != null ? "*" : "");
out.add(here + (node.getRedirect() != null ? " -> " + node.getRedirect().getName() : ""));
if (seen.put(node, true) != null) return;
for (var child : node.getChildren()) describe(child, here, out, seen);
}
/** The first play packets: entity ids, seeds and times aside. */
private String summary(Received r) {
String t = r.type;
if (t.equals("minecraft:login")) {
// levels: the server's level keys, in an identity-hashed order after the overworld.
var login = (net.minecraft.network.protocol.game.ClientboundLoginPacket) r.packet;
var levels = new java.util.TreeSet<String>();
login.levels().forEach(l -> levels.add(l.identifier().toString()));
return text(r.packet).replaceAll("playerId=-?\\d+", "playerId=_").replaceAll("levels=\\[(ResourceKey\\[[^\\]]*\\](, )?)*\\]", "levels=" + levels);
}
if (t.equals("minecraft:set_time") || t.equals("minecraft:keep_alive") || t.equals("minecraft:ping")) return "";
// The tree is compared below, as sets: the children's order is vanilla's registration order.
if (t.equals("minecraft:commands")) return "";
if (t.equals("minecraft:set_entity_data")) {
return text(((net.minecraft.network.protocol.game.ClientboundSetEntityDataPacket) r.packet).packedItems());
}
if (t.contains("entity") || t.equals("minecraft:add_entity") || t.equals("minecraft:update_attributes")
|| t.equals("minecraft:player_info_update") || t.equals("minecraft:player_position")) {
return "";
}
return r.payload.length > 200 ? "sha=" + sha(r.payload) : text(r.packet);
}
}
+392
View File
@@ -0,0 +1,392 @@
#!/usr/bin/env python3
"""The dedicated server against vanilla's, seen from a vanilla client.
The pinned server JAR first generates a world (offline mode, a fixed seed,
respawn_radius 0) and stops; a vanilla dedicated server and Horizon's
(`horizon-client --dedicated --nogui`) then serve copies of it with the same
server.properties, server-icon.png and lists. VanillaProtocolClient, a
headless client made of vanilla's own codecs (any byte vanilla would not
read is an error), pings each server, joins it in offline mode through
login, configuration and play, accepts the spawn teleport, receives the
chunks around the spawn (their bytes are compared: the world is loaded from
the same files), chats, runs /list and leaves. The console then runs `list`
and `say` and `stop`. Compared, all of them exactly:
- the status response (MOTD, players, version, favicon) and the ping;
- the legacy (pre-1.7, 0xFE) ping reply;
- the login and configuration packets in order (compression, profile,
brand, features, known packs, every registry, tags);
- the play packets up to the first chunk batch, in order, with entity ids,
keep-alive ids and times left out; the chunks sent and their bytes; the
replies to the chat message and to /list;
- the console lines about the player, the chat, `list`, `say` and `stop`;
- the files the servers leave: server.properties (but the date line),
eula.txt, ops.json, whitelist.json, banned-players.json, banned-ips.json.
Online mode needs Mojang's session servers and is not tested.
"""
import json
import os
from pathlib import Path
import platform
import re
import shutil
import socket
import struct
import subprocess
import sys
import threading
import time
import zlib
try:
from . import lab, oracle_harness as oh, test_rust_parity as base
except ImportError:
import lab
import oracle_harness as oh
import test_rust_parity as base
NAME = 'dedicated-server-parity'
SEED = 12345
PLAYER = 'Tester'
# Packets Horizon's server does not send yet, listed rather than compared:
# the recipe property sets and stonecutter recipes (ClientboundUpdateRecipes)
# and a player's advancements (ClientboundUpdateAdvancements, and the recipe
# unlocks their first tick grants). Each is reported on every run.
KNOWN_GAPS = {
'minecraft:update_recipes': 'ClientboundUpdateRecipesPacket (recipe property sets, stonecutter recipes)',
'minecraft:update_advancements': 'ClientboundUpdateAdvancementsPacket (player advancements)',
'minecraft:recipe_book_add+': 'recipes unlocked by advancements on the first tick',
}
def gap(line):
"""The known gap a vanilla play-start line belongs to, if any."""
parts = line.split(' ')
if len(parts) < 2 or parts[0] != 'play-start':
return None
if parts[1] in KNOWN_GAPS:
return parts[1]
if parts[1] == 'minecraft:recipe_book_add' and 'entries=[]' not in line:
return 'minecraft:recipe_book_add+'
return None
PROPERTIES = {
'online-mode': 'false',
'white-list': 'false',
'level-seed': str(SEED),
'view-distance': '4',
'simulation-distance': '4',
'spawn-protection': '0',
'max-players': '5',
'motd': '\\u00a7aHorizon \\u00a7rparity \\u00e9t\\u00e9',
'pause-when-empty-seconds': '-1',
}
def free_port():
with socket.socket() as s:
s.bind(('127.0.0.1', 0))
return s.getsockname()[1]
def icon_png():
"""A 64x64 RGBA PNG (server-icon.png)."""
rows = b''.join(b'\0' + b''.join(bytes((x * 4, y * 4, (x ^ y) * 4, 255)) for x in range(64)) for y in range(64))
def chunk(kind, data):
return struct.pack('>I', len(data)) + kind + data + struct.pack('>I', zlib.crc32(kind + data))
return (b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', struct.pack('>IIBBBBB', 64, 64, 8, 6, 0, 0, 0))
+ chunk(b'IDAT', zlib.compress(rows)) + chunk(b'IEND', b''))
def write_server_dir(directory, port, world=None):
if directory.exists():
shutil.rmtree(directory)
directory.mkdir(parents=True)
props = dict(PROPERTIES, **{'server-port': str(port)})
(directory / 'server.properties').write_text(''.join(f'{k}={v}\n' for k, v in props.items()), encoding='iso-8859-1')
(directory / 'eula.txt').write_text('eula=true\n')
(directory / 'server-icon.png').write_bytes(icon_png())
if world is not None:
shutil.copytree(world, directory / 'world')
for lock in (directory / 'world').glob('session.lock'):
lock.unlink()
class Server:
"""A server process with its console on stdin and its log collected."""
def __init__(self, command, directory, log_name):
self.log_path = directory.parent / f'{log_name}.log'
self.log = self.log_path.open('w', encoding='utf-8')
self.lines = []
self.process = subprocess.Popen(list(map(str, command)), cwd=directory, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
encoding='utf-8', errors='replace')
self.reader = threading.Thread(target=self._read, daemon=True)
self.reader.start()
def _read(self):
for line in self.process.stdout:
self.lines.append(line.rstrip('\n'))
self.log.write(line)
self.log.flush()
def wait_for(self, pattern, timeout=300):
deadline = time.time() + timeout
regex = re.compile(pattern)
while time.time() < deadline:
if any(regex.search(l) for l in self.lines):
return
if self.process.poll() is not None:
time.sleep(0.5)
raise AssertionError(f'{self.log_path.name}: server exited ({self.process.returncode}):\n'
+ '\n'.join(self.lines[-30:]))
time.sleep(0.2)
raise AssertionError(f'{self.log_path.name}: no line matching {pattern!r} in {timeout} s:\n' + '\n'.join(self.lines[-30:]))
def console(self, command):
self.process.stdin.write(command + '\n')
self.process.stdin.flush()
def stop(self, timeout=120):
if self.process.poll() is None:
try:
self.console('stop')
self.process.wait(timeout=timeout)
except (BrokenPipeError, subprocess.TimeoutExpired):
self.process.kill()
self.process.wait()
self.reader.join(timeout=10)
self.log.close()
def legacy_ping(port):
"""The reply to a 1.6 client's 0xFE 0x01 0xFA MC|PingHost query (LegacyQueryHandler)."""
host = 'localhost'
data = (b'\xfe\x01\xfa' + struct.pack('>H', 11) + 'MC|PingHost'.encode('utf-16-be')
+ struct.pack('>H', 7 + 2 * len(host)) + bytes([78]) + struct.pack('>H', len(host))
+ host.encode('utf-16-be') + struct.pack('>I', port))
with socket.create_connection(('127.0.0.1', port), timeout=10) as s:
s.sendall(data)
reply = b''
while True:
try:
chunk = s.recv(4096)
except TimeoutError:
return reply.hex() + ' <no close>'
if not chunk:
break
reply += chunk
return reply.hex()
CONSOLE_LINE = re.compile(r'^\[\d\d:\d\d:\d\d\] \[([^\]]+)\]: (.*)$')
KEPT = re.compile(r'Tester|\[Server\]|\[Not Secure\]|There are|Stopping|Saving|ThreadedAnvilChunkStorage|All dimensions|Unknown or incomplete')
def console_lines(lines):
"""The console lines the comparison covers, timestamps and ports aside."""
out = []
for line in lines:
m = CONSOLE_LINE.match(line)
if not m or not KEPT.search(m.group(2)):
continue
text = re.sub(r'/127\.0\.0\.1:\d+', '/127.0.0.1:_', m.group(2))
text = re.sub(r'entity id \d+', 'entity id _', text)
out.append(f'[{m.group(1)}] {text}')
# Vanilla saves its levels in the order of an identity-hashed map, which
# changes between runs: each block of saves is compared sorted.
i = 0
while i < len(out):
j = i
while j < len(out) and 'Saving chunks for level' in out[j]:
j += 1
out[i:j] = sorted(out[i:j])
i = j + 1 if j == i else j
return out
def server_files(directory):
out = []
for name in ['server.properties', 'eula.txt', 'ops.json', 'whitelist.json', 'banned-players.json', 'banned-ips.json']:
path = directory / name
if not path.exists():
out.append(f'{name}: missing')
continue
text = path.read_bytes().decode('iso-8859-1')
if name in ('server.properties', 'eula.txt'):
# The second comment line is the date Properties.store wrote.
text = re.sub(r'^(#[^\n]*\n)#[^\n]*\n', r'\1#<date>\n', text)
# Random per server, and each side has its own port.
text = re.sub(r'\n(management-server-secret|server-port)=[^\n]*', r'\n\1=<varies>', text)
out.append(f'{name}: {text!r}')
return out
def run_side(label, command, directory, client):
server = Server(command, directory, label)
try:
server.wait_for(r'Done \(')
port = int(PROPERTIES_PORTS[label])
legacy = legacy_ping(port)
client(port, directory.parent / f'{label}-client.txt')
time.sleep(1)
server.console('list')
server.console('say console says hi')
server.wait_for(r'\[Server\] console says hi', timeout=30)
finally:
server.stop()
transcript = (directory.parent / f'{label}-client.txt').read_text(encoding='utf-8').splitlines()
return (['legacy-ping ' + legacy] + transcript + ['console ' + l for l in console_lines(server.lines)]
+ ['file ' + l for l in server_files(directory)])
PROPERTIES_PORTS = {}
def horizon_client_joins(vanilla_server, binary, world, build, reference):
"""Horizon's client joins a vanilla dedicated server headless: it must
land where the vanilla client did, receive as many chunks, see its chat
and /list reply, and leave as a vanilla client does (the server's log)."""
label = 'vanilla-for-horizon-client'
PROPERTIES_PORTS[label] = port = free_port()
directory = build / label
write_server_dir(directory, port, world)
client_dir = build / 'horizon-client'
shutil.rmtree(client_dir, ignore_errors=True)
client_dir.mkdir()
report = build / 'horizon-client-report.json'
report.unlink(missing_ok=True)
server = Server(vanilla_server, directory, label)
try:
server.wait_for(r'Done \(')
env = dict(os.environ, HORIZON_NO_AUDIO='1', HORIZON_NET_REPORT=str(report))
with (build / 'horizon-client-run.log').open('w') as log:
subprocess.run([str(c) for c in [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--render-distance', 2,
'--server', f'127.0.0.1:{port}', '--name', PLAYER]],
cwd=client_dir, env=env, stdout=log, stderr=subprocess.STDOUT, timeout=300, check=True)
server.wait_for(r'left the game', timeout=30)
finally:
server.stop()
got = json.loads(report.read_text())
move = next(l for l in reference if l.startswith('play-move'))
want_position = [float(v) for v in re.match(r'play-move \(([^,]+), ([^,]+), ([^)]+)\)', move).groups()]
want_chunks = int(next(l for l in reference if l.startswith('play-counts')).split()[-1])
expected = {
'connected throughout': None,
'spawn position': want_position,
'chunks received': want_chunks,
'own chat shown': True,
'/list reply shown': True,
'server log': ['logged in', 'Tester joined the game', '[Not Secure] <Tester> hello from the horizon client',
'Tester lost connection: Disconnected', 'Tester left the game'],
}
log = '\n'.join(server.lines)
actual = {
'connected throughout': got['error'],
'spawn position': got['position'],
'chunks received': got['chunks'],
'own chat shown': any('<Tester> hello from the horizon client' in c for c in got['chat']),
'/list reply shown': any('There are 1 of a max of 5 players online: Tester' in c for c in got['chat']),
'server log': [k for k in expected['server log'] if k in log],
}
return [f'horizon-client {k}: {"ok" if actual[k] == v else f"expected {v!r}, got {actual[k]!r}"}'
for k, v in expected.items()]
def main():
lock, jars, libraries = base.verify_artifacts()
build = lab.LOCAL / NAME
build.mkdir(parents=True, exist_ok=True)
report = build / 'report.json'
report.unlink(missing_ok=True)
oracle = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaProtocolClient.java'
classes = build / 'classes'
shutil.rmtree(classes, ignore_errors=True)
classes.mkdir()
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
oh.run_logged(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-nowarn', '-sourcepath',
lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle],
build, 'compile-java')
oh.run_logged(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], build,
'compile-rust')
metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
cwd=lab.ROOT, text=True))
binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
# The world, generated once by vanilla.
generate = build / 'generate'
write_server_dir(generate, free_port())
server = Server(vanilla_server, generate, 'generate')
try:
server.wait_for(r'Done \(')
server.console('gamerule respawn_radius 0')
server.wait_for(r'respawn_radius', timeout=30)
# Vanilla keeps no spawn chunks: force-load the area the client is
# sent and its neighbours (the console stands at the world spawn) so
# both servers load full chunks instead of finishing proto-chunks.
server.console('forceload add ~-80 ~-80 ~80 ~80')
server.wait_for(r'chunks in the Overworld are now force loaded|forceloaded|force loaded', timeout=60)
time.sleep(20)
server.console('forceload remove all')
server.console('save-all flush')
server.wait_for(r'Saved the game', timeout=120)
finally:
server.stop()
world = generate / 'world'
(world / 'playerdata').mkdir(exist_ok=True)
def client(port, out):
oh.run_logged(['java', '-Xmx1g', '-Duser.timezone=UTC', '-cp', str(classes) + os.pathsep + dependencies,
'dev.horizonlab.parity.VanillaProtocolClient', '127.0.0.1', port, PLAYER, out], build,
out.stem, timeout=300)
results = {}
for label, command in [('vanilla', vanilla_server), ('horizon', horizon_server)]:
PROPERTIES_PORTS[label] = free_port()
directory = build / label
write_server_dir(directory, PROPERTIES_PORTS[label], world)
results[label] = run_side(label, command, directory, client)
(build / f'{label}.txt').write_text('\n'.join(results[label]) + '\n', encoding='utf-8')
client_checks = horizon_client_joins(vanilla_server, binary, world, build, results['vanilla'])
vanilla, horizon = results['vanilla'], results['horizon']
gaps = sorted({gap(l) for l in vanilla if gap(l)})
vanilla = [l for l in vanilla if not gap(l)]
for g in gaps:
print(f'known gap: {KNOWN_GAPS[g]}')
errors = [l for l in vanilla + horizon if l.startswith('error')] + [l for l in client_checks if not l.endswith(': ok')]
for line in client_checks:
print(line)
differences = []
import difflib
for line in difflib.unified_diff(vanilla, horizon, 'vanilla', 'horizon', n=0, lineterm=''):
differences.append(line[:400])
# Name the chunks that differ instead of the whole line.
chunk_lines = [dict(re.findall(r'(-?\d+,-?\d+)=(\w+)', next((l for l in side if l.startswith('play-chunks')), '')))
for side in (vanilla, horizon)]
for key in sorted(set(chunk_lines[0]) | set(chunk_lines[1])):
a, b = chunk_lines[0].get(key), chunk_lines[1].get(key)
if a != b:
differences.append(f'chunk {key}: vanilla {a} horizon {b}')
if differences or errors:
raise AssertionError(f'{len([d for d in differences if d[:1] in "+-" and d[:3] not in ("+++", "---")])} differing lines '
f'(see {build}/vanilla.txt and horizon.txt):\n' + '\n'.join(differences[:80]))
lab.write_json(report, dict(
schema=1, minecraft=lock['minecraft']['version'], platform=platform.platform(),
java=subprocess.check_output(['java', '--version'], text=True).splitlines()[0],
lines=len(vanilla), known_gaps=[KNOWN_GAPS[g] for g in gaps], output_sha256=lab.digest(build / 'horizon.txt', 'sha256'),
scope='Dedicated server seen by a vanilla-codec client: status, legacy ping, login, configuration, play '
'start, chunks, chat, /list, console list/say/stop, files written. Offline mode.'))
print(f'dedicated server: {len(vanilla)} transcript lines identical')
if __name__ == '__main__':
try:
main()
except AssertionError as error:
sys.exit(f'{NAME}: {error}')
+48
View File
@@ -0,0 +1,48 @@
#!/usr/bin/env python3
"""LAN world discovery against the pinned client's LanServerPinger and
LanServerDetection: the announcement an opened world multicasts
(`[MOTD]...[/MOTD][AD]port[/AD]` in UTF-8), and how the multiplayer screen
parses what it hears (parseMotd, parseAddress, UTF-8 decoding of malformed
bytes) and keeps its list (LanServerList.addServer: one entry per
address, the first MOTD kept, never expired while the screen is open).
VanillaLanOracle and the `lan_probe` example must print the same lines."""
import random
try:
from . import oracle_harness as oh
except ImportError:
import oracle_harness as oh
NAME = 'lan-parity'
def make_input(build):
rng = random.Random(4445)
lines = []
motds = ['Player - New World', 'Steve - §aGreen §lWorld', 'été 日本語 ✓', '', '[MOTD]', 'a[/MOTD]b', 'x' * 300,
'tab\\there', '[AD]25565[/AD]']
for motd in motds:
for port in ['25565', '1024', '65535', '0', 'abc', '']:
lines.append(f'ping\t{motd}\t{port}')
fragments = [b'[MOTD]', b'[/MOTD]', b'[AD]', b'[/AD]', b'25565', b'1234', b'Steve - World', b'\xc3\xa9', b'\xe6\x97',
b'\xff', b'\xc0\x80', b'\xed\xa0\x80', b'\xf0\x9f\x98\x80', b'\xf0\x9f', b'abc', b' ', b'\x00', b'-1']
ips = ['192.168.1.10', '10.0.0.2', '127.0.0.1']
good = lambda motd, port: f'[MOTD]{motd}[/MOTD][AD]{port}[/AD]'.encode()
for i in range(400):
if i % 50 == 0:
lines.append('reset')
if rng.random() < 0.4:
data = good(rng.choice(['A - W', 'B - W', 'é', '']), rng.choice(['25565', '25566', 'x', '']))
else:
data = b''.join(rng.choice(fragments) for _ in range(rng.randint(0, 9)))
lines.append(f'heard\t{rng.choice(ips)}\t{data.hex()}')
path = build / 'cases.txt'
path.write_text('\n'.join(lines) + '\n', encoding='utf-8')
return path, len(lines)
if __name__ == '__main__':
oh.differential(NAME, 'VanillaLanOracle', 'lan_probe', make_input,
'LanServerPinger.createPingString/parseMotd/parseAddress, LanServerDetection decoding and '
'LanServerList.addServer/takeDirtyServers',
sources=[oh.lab.ROOT / 'crates/horizon-client/src/lan/discovery.rs'])