From ab8b3790971138dcaa48b6f241efd4f377f0d140 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 24 Oct 2026 16:21:53 +0200 Subject: [PATCH] Dedicated server: offer server.properties' resource pack as vanilla does ServerResourcePackConfigurationTask: after the tags, the configuration phase sends the pack (id from the URL when none is given, hash, required, prompt) and waits for a final answer, with keepalives every 15 s. A declined required pack disconnects with multiplayer.requiredTexturePrompt.disconnect, in configuration or in play, with vanilla's log lines. tools/test_server_resource_pack_parity.py drives a vanilla 26.3 server and Horizon's with the same five players (declines, accepts then declines in play, fails the download, answers after 20 s, declines an optional pack) and compares what each one receives. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/dedicated.rs | 1 + crates/horizon-client/src/lan/conn.rs | 215 +++++++++- crates/horizon-client/src/lan/mod.rs | 4 + docs/hosting.md | 2 + .../horizonlab/parity/ServerPackClient.java | 378 ++++++++++++++++++ tools/test_server_resource_pack_parity.py | 172 ++++++++ 6 files changed, 766 insertions(+), 6 deletions(-) create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/ServerPackClient.java create mode 100644 tools/test_server_resource_pack_parity.py diff --git a/crates/horizon-client/src/game/dedicated.rs b/crates/horizon-client/src/game/dedicated.rs index f6e0ae567..eee12fe3f 100644 --- a/crates/horizon-client/src/game/dedicated.rs +++ b/crates/horizon-client/src/game/dedicated.rs @@ -608,6 +608,7 @@ impl Game<'_> { lang: Arc::new(horizon_client::net::load_language(&self.options.resources)), log_ips: props.log_ips, }), + resource_pack: props.resource_pack.clone(), }; let config = HubConfig { default_game_mode: game_mode, diff --git a/crates/horizon-client/src/lan/conn.rs b/crates/horizon-client/src/lan/conn.rs index a8ec46dad..fb91f3006 100644 --- a/crates/horizon-client/src/lan/conn.rs +++ b/crates/horizon-client/src/lan/conn.rs @@ -119,6 +119,88 @@ fn component_value(tag: &horizon_world::nbt::Tag) -> crate::server::json::Json { } } +/// The inverse of [`component_value`]: a JSON component (a server.properties +/// prompt) as ComponentSerialization.CODEC writes it with NbtOps. An array is +/// its first component with the rest appended (`createFromList`); a list of +/// components mixing plain strings and objects has the strings as `{text}`. +pub fn component_tag(v: &crate::server::json::Json) -> horizon_world::nbt::Tag { + use crate::server::json::Json; + use horizon_world::nbt::{JavaString, Tag}; + fn list(items: &[Json]) -> Tag { + same_kind(items.iter().map(component_tag).collect()) + } + fn same_kind(mut tags: Vec) -> Tag { + if tags.iter().any(|t| matches!(t, Tag::Compound(_))) { + for t in &mut tags { + if let Tag::String(s) = t { + *t = Tag::compound([("text", Tag::String(s.clone()))]); + } + } + } + Tag::List(tags) + } + fn value(v: &Json) -> Tag { + match v { + Json::Bool(b) => Tag::Byte(i8::from(*b)), + Json::Number(n) => n.parse().map_or_else( + |_| Tag::Double(n.parse::().unwrap_or(0.0).to_bits()), + Tag::Int, + ), + Json::String(s) => Tag::String(JavaString::from(s.as_str())), + Json::Array(items) => list(items), + Json::Object(members) => Tag::compound( + members + .iter() + .map(|(k, v)| (k.as_str(), value(v))) + .collect::>(), + ), + Json::Null => Tag::String(JavaString::from("")), + } + } + match v { + Json::Array(items) if !items.is_empty() => { + let mut first = component_tag(&items[0]); + if let Tag::String(s) = &first { + first = Tag::compound([("text", Tag::String(s.clone()))]); + } + if let Tag::Compound(map) = &mut first { + let mut extra = match map.remove(&JavaString::from("extra")) { + Some(Tag::List(e)) => e, + _ => Vec::new(), + }; + extra.extend(items[1..].iter().map(component_tag)); + map.insert(JavaString::from("extra"), same_kind(extra)); + } + first + } + Json::Object(members) => { + if let [(key, Json::String(text))] = members.as_slice() + && key == "text" + { + return Tag::String(JavaString::from(text.as_str())); + } + Tag::compound( + members + .iter() + .map(|(k, v)| { + let tag = match k.as_str() { + "extra" | "with" => match v { + Json::Array(items) => list(items), + other => value(other), + }, + _ => value(v), + }; + (k.as_str(), tag) + }) + .collect::>(), + ) + } + Json::String(s) | Json::Number(s) => Tag::String(JavaString::from(s.as_str())), + Json::Bool(b) => Tag::String(JavaString::from(b.to_string().as_str())), + _ => Tag::String(JavaString::from("")), + } +} + /// 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) @@ -745,6 +827,14 @@ fn login_and_configure( send(c, cfg::Clientbound::RegistryData(packet))?; } send(c, cfg::Clientbound::UpdateTags(sync.tags.clone()))?; + if let Some(pack) = &shared.config.resource_pack + && let Some(rejected) = offer_pack(c, pack, &mut info)? + { + let (reason, text) = pack_rejected(shared, name, rejected); + let _ = send(c, cfg::Clientbound::Disconnect(cfg::Disconnect { reason })); + lost(shared, &format!("{name} ({})", uuid_string(uuid)), &text); + return Ok(None); + } send(c, cfg::Clientbound::FinishConfiguration(Empty))?; loop { let (id, payload) = c.recv().map_err(e)?; @@ -763,6 +853,79 @@ fn login_and_configure( })) } +/// ServerboundResourcePackPacket.Action.DECLINED. +const PACK_DECLINED: i32 = 1; + +/// ServerCommonPacketListenerImpl.handleResourcePackResponse: a player who +/// declined the required pack is disconnected. The reason and its text. +fn pack_rejected(shared: &Shared, name: &str, pack: u128) -> (horizon_world::nbt::Tag, String) { + let reason = translatable("multiplayer.requiredTexturePrompt.disconnect", &[]); + let Some(log) = &shared.config.log else { + return (reason, String::new()); + }; + let line = format!( + "Disconnecting {name} due to resource pack {} rejection", + uuid_string(pack) + ); + (log.write)("Server thread", "INFO", &line); + let text = horizon_protocol::text::plain(&reason, &log.lang); + (reason, text) +} + +/// ServerResourcePackConfigurationTask: offer the server's pack, then wait +/// for the client's final answer (`Action.isTerminal`: anything but +/// ACCEPTED or DOWNLOADED). The player may take a while to answer the +/// prompt, so the connection is kept alive meanwhile, as +/// ServerConfigurationPacketListenerImpl.tick does. The id of a required +/// pack the client declined, which disconnects it. +fn offer_pack( + c: &mut Connection, + pack: &crate::server::properties::ResourcePackInfo, + info: &mut ClientInformation, +) -> Result, String> { + let e = |e: horizon_protocol::Error| e.to_string(); + let push = cfg::ResourcePackPush { + id: pack.id, + url: pack.url.clone(), + hash: pack.hash.clone(), + required: pack.required, + prompt: pack.prompt.as_ref().map(component_tag), + }; + c.send(&cfg::Clientbound::ResourcePackPush(push).encode()) + .map_err(e)?; + std::thread::scope(|scope| { + let (stop, stopped) = channel::<()>(); + let writer = &mut c.writer; + scope.spawn(move || { + let start = Instant::now(); + while stopped.recv_timeout(KEEP_ALIVE_EVERY) == Err(RecvTimeoutError::Timeout) { + let id = i64::try_from(start.elapsed().as_millis()).unwrap_or(0); + let keep_alive = cfg::Clientbound::KeepAlive(cfg::KeepAlive { id }); + if writer.send(&keep_alive.encode()).is_err() { + break; + } + } + }); + let answer = loop { + let (id, payload) = match c.reader.recv() { + Ok(packet) => packet, + Err(err) => break Err(err.to_string()), + }; + match cfg::Serverbound::decode(id, &payload) { + Ok(cfg::Serverbound::ResourcePack(r)) if !matches!(r.action, 3 | 4) => { + let rejected = r.action == PACK_DECLINED && pack.required; + break Ok(rejected.then_some(r.id)); + } + Ok(cfg::Serverbound::ClientInformation(i)) => *info = i, + Ok(_) => {} + Err(err) => break Err(err.to_string()), + } + }; + drop(stop); + answer + }) +} + fn play(c: Connection, shared: &Arc, parts: Parts, address: std::net::SocketAddr) { let conn_id = shared.next_id(); let events = shared.events.clone(); @@ -784,6 +947,7 @@ fn play(c: Connection, shared: &Arc, parts: Parts, address: std::net::So }) .ok() }; + let name = parts.name.clone(); let joined = Joined { conn: conn_id, uuid: parts.uuid, @@ -795,8 +959,20 @@ fn play(c: Connection, shared: &Arc, parts: Parts, address: std::net::So latency, address, }; + let required_pack = shared + .config + .resource_pack + .as_ref() + .is_some_and(|p| p.required); let reason = if events.send(NetEvent::Joined(Box::new(joined))).is_ok() { - read_loop(&mut reader, conn_id, &events, &alive) + match read_loop(&mut reader, conn_id, &events, &alive, required_pack) { + Ok(reason) => reason, + Err(rejected) => { + let (reason, text) = pack_rejected(shared, &name, rejected); + let _ = tx.send(Out::Disconnect(reason)); + text + } + } } else { "server closed".to_owned() }; @@ -808,12 +984,16 @@ fn play(c: Connection, shared: &Arc, parts: Parts, address: std::net::So shared.release(parts.uuid); } +/// Forward the player's packets until the connection ends: why it did, or +/// the id of a required resource pack the player declined (with +/// `required_pack`), which disconnects them. fn read_loop( reader: &mut ConnReader, conn: u32, events: &Sender, alive: &AtomicI64, -) -> String { + required_pack: bool, +) -> Result { loop { let (id, payload) = match reader.recv() { Ok(p) => p, @@ -824,19 +1004,24 @@ fn read_loop( || e.0.contains("reset by peer") || e.0.contains("aborted") => { - return "Disconnected".to_owned(); + return Ok("Disconnected".to_owned()); } - Err(e) => return e.to_string(), + Err(e) => return Ok(e.to_string()), }; match play::Serverbound::decode(id, &payload) { Ok(play::Serverbound::KeepAlive(k)) => alive.store(k.id, Ordering::Relaxed), + Ok(play::Serverbound::ResourcePack(r)) + if r.action == PACK_DECLINED && required_pack => + { + return Err(r.id); + } Ok(p) => { if events.send(NetEvent::Packet(conn, Box::new(p))).is_err() { - return "server closed".to_owned(); + return Ok("server closed".to_owned()); } } // A malformed packet disconnects like vanilla's decoder exception. - Err(e) => return format!("Invalid packet {id}: {e}"), + Err(e) => return Ok(format!("Invalid packet {id}: {e}")), } } } @@ -988,6 +1173,24 @@ fn write_loop( mod tests { use super::*; + #[test] + fn prompts_become_the_components_vanilla_sends() { + let tag = |json: &str| { + let tag = component_tag(&crate::server::json::parse(json, true).unwrap()); + component_json(&tag) + }; + assert_eq!(tag(r#"{"text":"Hi"}"#), r#""Hi""#); + assert_eq!(tag(r#""Hi""#), r#""Hi""#); + assert_eq!( + tag(r#"["Hi ",{"text":"there","bold":true}]"#), + r#"{"text":"Hi ","extra":[{"text":"there","bold":true}]}"# + ); + assert_eq!( + tag(r#"{"translate":"a","with":["b",{"text":"c","color":"red"}]}"#), + r#"{"translate":"a","with":["b",{"text":"c","color":"red"}]}"# + ); + } + fn unpack(out: Out) -> Vec> { match out { Out::Packet(body) => vec![body], diff --git a/crates/horizon-client/src/lan/mod.rs b/crates/horizon-client/src/lan/mod.rs index e2f0a719f..3e9b93cac 100644 --- a/crates/horizon-client/src/lan/mod.rs +++ b/crates/horizon-client/src/lan/mod.rs @@ -139,6 +139,9 @@ pub struct NetConfig { /// Online mode: players are authenticated (none on a LAN world). pub online: Option>, pub log: Option, + /// server.properties `resource-pack`: offered to every player during + /// configuration (a dedicated server's; MinecraftServer.getServerResourcePack). + pub resource_pack: Option, } impl NetConfig { /// MinecraftServer.enforceSecureProfile. @@ -164,6 +167,7 @@ impl NetConfig { gate: None, online: None, log: None, + resource_pack: None, } } } diff --git a/docs/hosting.md b/docs/hosting.md index 2cfe64231..bf431cada 100644 --- a/docs/hosting.md +++ b/docs/hosting.md @@ -165,6 +165,8 @@ hardcore = false # Any other server.properties key, spelled as vanilla spells it: [properties] # spawn-protection = 16 +# resource-pack = "https://example.com/pack.zip" # offered to players as they join; with +# resource-pack-sha1, require-resource-pack and resource-pack-prompt, as on vanilla [engine] path = "" # the game program; empty: the one beside horizon-server diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/ServerPackClient.java b/mods/horizon/src/test/java/dev/horizonlab/parity/ServerPackClient.java new file mode 100644 index 000000000..ac59104d9 --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/ServerPackClient.java @@ -0,0 +1,378 @@ +package dev.horizonlab.parity; + +import com.mojang.serialization.JsonOps; +import io.netty.buffer.ByteBuf; +import io.netty.buffer.Unpooled; +import java.io.BufferedReader; +import java.io.ByteArrayInputStream; +import java.io.DataInputStream; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.io.PrintWriter; +import java.net.InetSocketAddress; +import java.net.Socket; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.zip.Deflater; +import java.util.zip.Inflater; +import net.minecraft.SharedConstants; +import net.minecraft.core.UUIDUtil; +import net.minecraft.network.ProtocolInfo; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.chat.Component; +import net.minecraft.network.chat.ComponentSerialization; +import net.minecraft.network.protocol.Packet; +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.ClientboundResourcePackPushPacket; +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.ServerboundResourcePackPacket; +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.ClientboundLoginPacket; +import net.minecraft.network.protocol.game.GameProtocols; +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.server.level.ClientInformation; + +/** + * Players made of vanilla's own protocol code that answer a server's resource pack offer + * (tools/test_server_resource_pack_parity.py). Script on stdin: {@code join NAME DELAY ACTIONS} joins and, once the + * pack is offered, waits DELAY seconds (answering keep-alives) then sends ACTIONS, a comma-separated list of + * ServerboundResourcePackPacket.Action names (or {@code none}); it returns once the player is in play or + * disconnected. {@code play NAME ACTION} sends an answer to the same pack in play and waits up to 10 s for a disconnect; + * {@code end} writes the transcript. Each player records the configuration packets it was sent (runs of one packet + * counted), the offer, whether it was kept alive while it waited, and how the connection ended. + */ +public final class ServerPackClient { + public static void main(String[] args) throws Exception { + ParityData.init(); + String host = args[0]; + int port = Integer.parseInt(args[1]); + Path output = Path.of(args[2]); + Map players = new LinkedHashMap<>(); + BufferedReader script = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8)); + String line; + while ((line = script.readLine()) != null) { + String[] w = line.trim().split(" "); + try { + switch (w[0]) { + case "join" -> { + Player p = new Player(w[1]); + players.put(w[1], p); + p.join(host, port, Double.parseDouble(w[2]), w[3]); + } + case "play" -> players.get(w[1]).answerInPlay(action(w[2])); + case "end" -> { + try (PrintWriter out = new PrintWriter(Files.newBufferedWriter(output, StandardCharsets.UTF_8))) { + for (Player p : players.values()) { + synchronized (p.lines) { + for (String l : p.lines) out.println(p.name + " " + l); + } + } + } + for (Player p : players.values()) p.close(); + System.exit(0); + } + default -> throw new IllegalArgumentException("unknown script line " + line); + } + } catch (Exception e) { + Player p = w.length > 1 ? players.get(w[1]) : null; + if (p != null) p.record("error " + w[0] + " " + e); + else System.err.println("error " + line + ": " + e); + } + } + System.exit(1); + } + + private static ServerboundResourcePackPacket.Action action(String name) { + return ServerboundResourcePackPacket.Action.valueOf(name.toUpperCase(Locale.ROOT)); + } + + private static String json(Component c) { + return ComponentSerialization.CODEC.encodeStart(ParityData.access.createSerializationContext(JsonOps.INSTANCE), c) + .getOrThrow().toString(); + } + + private static final class Player { + final String name; + final List lines = new ArrayList<>(); + private Socket socket; + private DataInputStream in; + private OutputStream out; + private int threshold = -1; + private ProtocolInfo inbound; + private ProtocolInfo outbound; + private final Object ended = new Object(); + private boolean disconnected; + /** The pack offered during configuration (the one answered in play). */ + private java.util.UUID offered; + private String lastConfig; + private int run; + + Player(String name) { + this.name = name; + } + + void record(String line) { + synchronized (lines) { + lines.add(line); + } + } + + /** A configuration packet: consecutive ones of the same type are one line with their count. */ + private void config(Packet p) { + String type = p.type().id().getPath(); + if (type.equals(lastConfig)) { + run++; + return; + } + flushConfig(); + lastConfig = type; + run = 1; + } + + private void flushConfig() { + if (lastConfig != null) record("config " + lastConfig + (run > 1 ? " x" + run : "")); + lastConfig = null; + } + + void close() throws Exception { + if (socket != null) socket.close(); + } + + void answerInPlay(ServerboundResourcePackPacket.Action action) throws Exception { + synchronized (ended) { + send(new ServerboundResourcePackPacket(offered, action)); + long until = System.nanoTime() + 10_000_000_000L; + while (!disconnected) { + long left = (until - System.nanoTime()) / 1_000_000L; + if (left <= 0) { + record("still connected after " + action); + return; + } + ended.wait(left); + } + } + } + + void join(String host, int port, double delay, String actions) throws Exception { + socket = new Socket(); + socket.connect(new InetSocketAddress(host, port), 10_000); + socket.setTcpNoDelay(true); + in = new DataInputStream(socket.getInputStream()); + out = socket.getOutputStream(); + outbound = HandshakeProtocols.SERVERBOUND; + send(new ClientIntentionPacket(SharedConstants.getProtocolVersion(), host, port, ClientIntent.LOGIN)); + outbound = LoginProtocols.SERVERBOUND; + inbound = LoginProtocols.CLIENTBOUND; + send(new ServerboundHelloPacket(name, UUIDUtil.createOfflinePlayerUUID(name))); + while (true) { + Packet p = read(); + if (p instanceof ClientboundLoginCompressionPacket c) { + threshold = c.getCompressionThreshold(); + } else if (p instanceof ClientboundLoginFinishedPacket) { + send(ServerboundLoginAcknowledgedPacket.INSTANCE); + break; + } else if (p instanceof ClientboundLoginDisconnectPacket d) { + record("login refused " + d.reason().getString()); + return; + } + } + outbound = ConfigurationProtocols.SERVERBOUND; + inbound = ConfigurationProtocols.CLIENTBOUND; + send(new ServerboundCustomPayloadPacket(new BrandPayload("vanilla"))); + send(new ServerboundClientInformationPacket(ClientInformation.createDefault())); + boolean keptAlive = false; + while (true) { + Packet p; + try { + p = read(); + } catch (java.io.EOFException | java.net.SocketException e) { + flushConfig(); + record("connection closed in configuration"); + return; + } + if (!(p instanceof ClientboundKeepAlivePacket)) config(p); + if (p instanceof ClientboundSelectKnownPacks k) { + send(new ServerboundSelectKnownPacks(k.knownPacks())); + } else if (p instanceof ClientboundKeepAlivePacket k) { + // Kept alive while the player looks at the prompt (once is enough to know). + if (offered != null && !keptAlive) { + flushConfig(); + record("kept alive while the offer was open"); + keptAlive = true; + } + send(new ServerboundKeepAlivePacket(k.getId())); + } else if (p instanceof ClientboundPingPacket k) { + send(new ServerboundPongPacket(k.getId())); + } else if (p instanceof ClientboundResourcePackPushPacket push) { + flushConfig(); + record("offer id=" + push.id() + " url=" + push.url() + " hash=" + push.hash() + " required=" + + push.required() + " prompt=" + push.prompt().map(ServerPackClient::json).orElse("none")); + offered = push.id(); + Thread answer = new Thread(() -> { + try { + Thread.sleep((long) (delay * 1000)); + if (actions.equals("none")) return; + for (String a : actions.split(",")) send(new ServerboundResourcePackPacket(push.id(), action(a))); + } catch (Exception e) { + record("error answering " + e); + } + }, name + "-answer"); + answer.setDaemon(true); + answer.start(); + } else if (p instanceof ClientboundFinishConfigurationPacket) { + flushConfig(); + send(ServerboundFinishConfigurationPacket.INSTANCE); + break; + } else if (p instanceof ClientboundDisconnectPacket d) { + flushConfig(); + record("disconnected in configuration: " + d.reason().getString()); + return; + } + } + outbound = GameProtocols.SERVERBOUND_TEMPLATE.bind(RegistryFriendlyByteBuf.decorator(ParityData.access), + new GameProtocols.Context() { + @Override + public boolean hasInfiniteMaterials() { + return false; + } + + @Override + public boolean canUseCommandBlocks() { + return false; + } + }); + inbound = GameProtocols.CLIENTBOUND_TEMPLATE.bind(RegistryFriendlyByteBuf.decorator(ParityData.access)); + while (!(read() instanceof ClientboundLoginPacket)) { + } + record("joined"); + Thread reader = new Thread(this::play, name); + reader.setDaemon(true); + reader.start(); + } + + private void play() { + try { + while (true) { + Packet p = read(); + if (p instanceof ClientboundKeepAlivePacket k) { + send(new ServerboundKeepAlivePacket(k.getId())); + } else if (p instanceof ClientboundPingPacket k) { + send(new ServerboundPongPacket(k.getId())); + } else if (p instanceof ClientboundDisconnectPacket d) { + record("disconnected in play: " + d.reason().getString()); + synchronized (ended) { + disconnected = true; + ended.notifyAll(); + } + return; + } + } + } catch (Exception e) { + if (!socket.isClosed()) record("error play " + e); + } + } + + private Packet 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.type().id() + " was larger than expected: " + buf.readableBytes() + " bytes left"); + } + return packet; + } + + synchronized 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()) inner.writeBytes(tmp, 0, d.deflate(tmp)); + 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(); + } + + private byte[] readFrame() throws Exception { + byte[] frame = new byte[readVarInt(in)]; + in.readFully(frame); + if (threshold < 0) return frame; + ByteArrayInputStream header = new ByteArrayInputStream(frame); + int dataLength = readVarInt(header); + int skip = frame.length - header.available(); + if (dataLength == 0) return java.util.Arrays.copyOfRange(frame, skip, frame.length); + Inflater inflater = new Inflater(); + inflater.setInput(frame, skip, frame.length - skip); + byte[] raw = new byte[dataLength]; + int n = inflater.inflate(raw); + inflater.end(); + if (n != dataLength) throw new IllegalStateException("decompressed " + n + " of " + dataLength + " bytes"); + return raw; + } + } + + private static int readVarInt(InputStream in) throws Exception { + int value = 0; + for (int shift = 0; shift < 35; shift += 7) { + int b = in.read(); + if (b < 0) throw new java.io.EOFException(); + value |= (b & 0x7F) << shift; + 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); + } +} diff --git a/tools/test_server_resource_pack_parity.py b/tools/test_server_resource_pack_parity.py new file mode 100644 index 000000000..0f5d258c6 --- /dev/null +++ b/tools/test_server_resource_pack_parity.py @@ -0,0 +1,172 @@ +#!/usr/bin/env python3 +"""A dedicated server's resource pack (server.properties `resource-pack`), against vanilla's, as vanilla clients see it. + +A vanilla dedicated server and Horizon's (`horizon-client --dedicated --nogui`) each serve a copy of one flat world +vanilla generated first, twice: once with a required pack (an id, a SHA-1 and a prompt), once with an optional one +(none of those: the id is derived from the URL). ServerPackClient, players made of vanilla's protocol code, join each +and answer the offer the way vanilla's client can: + +- required: declined (disconnected with vanilla's reason), accepted then downloaded then loaded (joins, then a + declined answer in play disconnects it too), accepted then failed to download (joins: only declining is refused), + and loaded after 20 seconds (the server keeps the connection alive while the player reads the prompt); +- optional: declined (joins). + +Compared exactly, per player: the configuration packets in order (runs counted), the offer (id, URL, hash, +required, the prompt as a component), whether a keep-alive came while the offer was open, and how the connection +ended. The server logs' "due to resource pack ... rejection" lines are compared too. No pack is downloaded: the +servers only offer it. +""" +import os +from pathlib import Path +import platform +import re +import shutil +import subprocess +import sys + +try: + from . import lab, test_rust_parity as base + from .test_dedicated_server_parity import Server, free_port + from .test_locator_bar_parity import generate_world +except ImportError: + import lab + import test_rust_parity as base + from test_dedicated_server_parity import Server, free_port + from test_locator_bar_parity import generate_world + +NAME = 'server-resource-pack-parity' +PROPERTIES = { + 'online-mode': 'false', + 'white-list': 'false', + 'level-seed': '12345', + 'level-type': 'minecraft\\:flat', + 'generate-structures': 'false', + 'view-distance': '2', + 'simulation-distance': '2', + 'max-players': '5', + 'pause-when-empty-seconds': '-1', +} +# The URL is never fetched: the servers only offer it. +URL = 'http://127.0.0.1:9/horizon-test-pack.zip' +SERVERS = { + 'required': { + 'resource-pack': URL, + 'resource-pack-id': '5b2c7a4e-1f3d-4c8b-9a6e-2d4f8b1c3e5a', + 'resource-pack-sha1': '0123456789abcdef0123456789abcdef01234567', + 'require-resource-pack': 'true', + 'resource-pack-prompt': '["Our pack: ",{"text":"blue dirt","color":"aqua","bold":true}]', + }, + 'optional': { + 'resource-pack': URL, + 'require-resource-pack': 'false', + }, +} +# (server, player, seconds before answering, the answers, an answer in play or None). +PLAYERS = [ + ('required', 'Alice', 0, 'declined', None), + ('required', 'Bob', 0, 'accepted,downloaded,successfully_loaded', 'declined'), + ('required', 'Carol', 0, 'accepted,failed_download', None), + ('required', 'Dave', 20, 'accepted,downloaded,successfully_loaded', None), + ('optional', 'Erin', 0, 'declined', None), +] +REJECTION = re.compile(r'Disconnecting (\S+) due to resource pack (\S+) rejection') + + +def server_dir(directory, world, pack): + if directory.exists(): + shutil.rmtree(directory) + directory.mkdir(parents=True) + port = free_port() + props = dict(PROPERTIES, **pack, **{'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') + shutil.copytree(world, directory / 'world') + (directory / 'world' / 'session.lock').unlink(missing_ok=True) + return port + + +def run_side(label, kind, server_command, client_command, build, world): + """One server with this pack: every player's transcript, and the server's rejection log lines.""" + directory = build / f'{label}-{kind}' + port = server_dir(directory, world, SERVERS[kind]) + out = build / f'{label}-{kind}.txt' + out.unlink(missing_ok=True) + server = Server(server_command, directory, f'{label}-{kind}') + try: + server.wait_for(r'Done \(') + with (build / f'{label}-{kind}-client.log').open('w') as log: + client = subprocess.Popen([*map(str, client_command), '127.0.0.1', str(port), str(out)], + cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, + text=True) + try: + for server_kind, name, delay, answers, in_play in PLAYERS: + if server_kind != kind: + continue + client.stdin.write(f'join {name} {delay} {answers}\n') + if in_play: + client.stdin.write(f'play {name} {in_play}\n') + client.stdin.write('end\n') + client.stdin.flush() + client.wait(timeout=180) + finally: + if client.poll() is None: + client.kill() + finally: + server.stop() + if not out.exists(): + raise AssertionError(f'{label}: the client wrote no transcript (see {build}/{label}-{kind}-client.log)') + rejections = [' '.join(m.groups()) for m in map(REJECTION.search, server.lines) if m] + return out.read_text(encoding='utf-8').splitlines() + [f'log rejected {r}' for r in rejections] + + +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/ServerPackClient.java' + classes = build / 'classes' + shutil.rmtree(classes, ignore_errors=True) + classes.mkdir() + dependencies = os.pathsep.join(map(str, [jars['server'], *libraries])) + subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-nowarn', '-sourcepath', + lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle], + cwd=lab.ROOT, check=True, capture_output=True) + subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT, + check=True, capture_output=True) + binary = lab.cargo_target() / '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'] + client = ['java', '-Xmx1g', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.ServerPackClient'] + + world = generate_world(vanilla_server, build) + differ = [] + for kind in SERVERS: + vanilla = run_side('vanilla', kind, vanilla_server, client, build, world) + horizon = run_side('horizon', kind, horizon_server, client, build, world) + if not any('offer ' in l for l in vanilla) or any(' error ' in f' {l} ' for l in vanilla): + raise AssertionError(f'{kind}: vanilla offered no pack or the client failed: {vanilla}') + if vanilla != horizon: + import difflib + differ.append(f'{kind}:\n' + '\n'.join(difflib.unified_diff(vanilla, horizon, 'vanilla', 'horizon', + n=2, lineterm=''))) + if differ: + raise AssertionError(f'the servers differ (see {build}):\n' + '\n'.join(differ)[:8000]) + lab.write_json(report, dict( + schema=1, minecraft=lock['minecraft']['version'], platform=platform.platform(), + java=subprocess.check_output(['java', '--version'], text=True).splitlines()[0], + players=len(PLAYERS), + scope='A dedicated server\'s resource pack as vanilla-codec players see it: the offer during configuration ' + '(id, URL, hash, required, prompt), its place among the configuration packets, the keep-alives while ' + 'the player decides, and each answer\'s outcome (declined, loaded, failed download, declined in ' + 'play) for a required and an optional pack, with the server\'s rejection log lines.')) + print(f'server resource pack: {len(PLAYERS)} players identical') + + +if __name__ == '__main__': + try: + main() + except AssertionError as error: + sys.exit(f'{NAME}: {error}')