N6: Joining games: direct connect, LAN and server list
- LAN discovery: a listening server answers QUERY packets on its game port plus one (ServerBeacon, off with --no-lan). ServerBrowser scans eight game ports from 24650 by broadcast. - A self-hostable list server: --list-server [--port=N] (ListServer, default UDP 24660). Game servers register with --list=HOST[:PORT] and --name=NAME; they are listed under their source address only after echoing a CHALLENGE token. Entries expire after 45 s, 8 per address, 256 in all; every source is rate-limited (SourceLimiter). - NetDiscovery messages: every QUERY is padded to 512 bytes and no answer is bigger, so neither service amplifies spoofed requests. - tidewall --browse [--list=...] [--lan-target=IP] [--lan-port=N] prints the servers found as JSON until menus (A10) show them. - People who connect mid-match or during results watch a living player (Match.watch) and take places ahead of bots in the next lobby, instead of being told the server is full. Bots fill only the places left when the match starts. - Tests: codec round trips, size limits and a 40,000-message fuzz; list server with fake servers (challenge, stolen and wrong tokens, renewal, expiry, caps, flood); LAN scan over loopback; watchers over UDP; lobby backfill. make discovery-check runs it all as real processes. Closes #37 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,140 @@
|
||||
extends TestCase
|
||||
|
||||
## Issue N6: the discovery messages. Round trips, the rule that no answer is bigger
|
||||
## than the query that asked for it, and malformed input refused without errors.
|
||||
|
||||
|
||||
func _server(port: int = 24650, name: String = "Harbour Light") -> Dictionary:
|
||||
return NetDiscovery.info(port, 3, 24, Match.PLAY, name)
|
||||
|
||||
|
||||
func test_query_round_trip_and_padding() -> void:
|
||||
var bytes: PackedByteArray = NetDiscovery.encode_query(7)
|
||||
assert_eq(bytes.size(), NetDiscovery.QUERY_BYTES)
|
||||
assert_eq(NetDiscovery.decode_query(bytes), {"version": NetProtocol.VERSION, "page": 7})
|
||||
assert_eq(NetDiscovery.decode_query(bytes.slice(0, 64)), {}, "an unpadded query is refused")
|
||||
|
||||
|
||||
func test_info_round_trip() -> void:
|
||||
var server: Dictionary = _server()
|
||||
var decoded: Dictionary = NetDiscovery.decode_info(NetDiscovery.encode_info(server))
|
||||
assert_eq(decoded, server)
|
||||
|
||||
|
||||
func test_register_and_challenge_round_trip() -> void:
|
||||
var server: Dictionary = _server(24652)
|
||||
var decoded: Dictionary = NetDiscovery.decode_register(NetDiscovery.encode_register(0xDEADBEEF, server))
|
||||
assert_eq(decoded["token"], 0xDEADBEEF)
|
||||
decoded.erase("token")
|
||||
assert_eq(decoded, server)
|
||||
assert_eq(NetDiscovery.decode_challenge(NetDiscovery.encode_challenge(42)), {"token": 42})
|
||||
|
||||
|
||||
func test_list_round_trip() -> void:
|
||||
var entries: Array[Dictionary] = []
|
||||
for index: int in NetDiscovery.ENTRIES_PER_PAGE:
|
||||
var entry: Dictionary = _server(24650 + index * 2, "Server %d" % index)
|
||||
entry["address"] = "2001:db8::%d" % index if index % 2 == 0 else "192.0.2.%d" % (index + 1)
|
||||
entries.append(entry)
|
||||
var decoded: Dictionary = NetDiscovery.decode_list(NetDiscovery.encode_list(1, 3, entries))
|
||||
assert_eq(decoded["page"], 1)
|
||||
assert_eq(decoded["pages"], 3)
|
||||
assert_eq(decoded["servers"], entries)
|
||||
|
||||
|
||||
func test_no_answer_is_bigger_than_a_query() -> void:
|
||||
# The longest possible names and addresses.
|
||||
var long_name: String = "W".repeat(200)
|
||||
var entries: Array[Dictionary] = []
|
||||
for index: int in NetDiscovery.ENTRIES_PER_PAGE + 3:
|
||||
var entry: Dictionary = NetDiscovery.info(65535, 255, 255, 255, long_name)
|
||||
entry["address"] = "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"
|
||||
entries.append(entry)
|
||||
var list: PackedByteArray = NetDiscovery.encode_list(255, 255, entries)
|
||||
assert_true(list.size() <= NetDiscovery.QUERY_BYTES, "a full page is %d bytes" % list.size())
|
||||
# That longest address isn't one an IP check accepts; a full-length plain one is.
|
||||
for entry: Dictionary in entries:
|
||||
entry["address"] = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"
|
||||
var decoded: Dictionary = NetDiscovery.decode_list(NetDiscovery.encode_list(255, 255, entries))
|
||||
assert_eq((decoded.get("servers", []) as Array).size(), NetDiscovery.ENTRIES_PER_PAGE)
|
||||
var info: PackedByteArray = NetDiscovery.encode_info(entries[0])
|
||||
assert_true(info.size() <= NetDiscovery.QUERY_BYTES)
|
||||
assert_true(NetDiscovery.encode_challenge(1).size() < NetDiscovery.encode_register(0, entries[0]).size(), "a challenge is smaller than what prompted it")
|
||||
# Multi-byte names are cut on the byte limit too.
|
||||
var wide: Dictionary = NetDiscovery.info(1, 0, 1, 0, "浪".repeat(40))
|
||||
assert_true(String(wide["name"]).to_utf8_buffer().size() <= NetDiscovery.SERVER_NAME_MAX_BYTES)
|
||||
|
||||
|
||||
func test_server_names_are_cleaned() -> void:
|
||||
assert_eq(NetDiscovery.clean_server_name(" Harbour\u202E Light\t "), "Harbour Light")
|
||||
assert_eq(NetDiscovery.clean_server_name(""), NetDiscovery.DEFAULT_SERVER_NAME)
|
||||
assert_eq(NetDiscovery.clean_server_name("\u200B\u0007"), NetDiscovery.DEFAULT_SERVER_NAME)
|
||||
assert_eq(NetDiscovery.clean_server_name("A".repeat(60)).length(), NetDiscovery.SERVER_NAME_MAX_CHARS)
|
||||
|
||||
|
||||
func test_list_entries_with_bad_addresses_or_fields_are_refused() -> void:
|
||||
var entry: Dictionary = _server()
|
||||
entry["address"] = "192.0.2.1"
|
||||
var good: PackedByteArray = NetDiscovery.encode_list(0, 1, [entry])
|
||||
assert_false(NetDiscovery.decode_list(good).is_empty())
|
||||
var bad_address: PackedByteArray = good.duplicate()
|
||||
bad_address[9] = 0x2F # "/" in the address
|
||||
assert_eq(NetDiscovery.decode_list(bad_address), {})
|
||||
var trailing: PackedByteArray = good.duplicate()
|
||||
trailing.append(0)
|
||||
assert_eq(NetDiscovery.decode_list(trailing), {})
|
||||
var crowded: Dictionary = NetDiscovery.info(24650, 30, 24, 0, "x")
|
||||
assert_eq(NetDiscovery.decode_info(NetDiscovery.encode_info(crowded)).get("players", -1), 24, "clamped when made")
|
||||
var raw: PackedByteArray = NetDiscovery.encode_info(_server())
|
||||
raw[9] = 30 # more people than places
|
||||
assert_eq(NetDiscovery.decode_info(raw), {})
|
||||
raw = NetDiscovery.encode_info(_server())
|
||||
raw.encode_u16(7, 0) # no game port
|
||||
assert_eq(NetDiscovery.decode_info(raw), {})
|
||||
|
||||
|
||||
## Random and mutated messages: every decoder and the list server's handler take them
|
||||
## all without an engine error or growing without bound.
|
||||
func test_fuzzed_messages_are_refused_quietly() -> void:
|
||||
var rng: RandomNumberGenerator = RandomNumberGenerator.new()
|
||||
rng.seed = 612
|
||||
var seeds: Array[PackedByteArray] = [
|
||||
NetDiscovery.encode_query(), NetDiscovery.encode_info(_server()),
|
||||
NetDiscovery.encode_register(9, _server()), NetDiscovery.encode_challenge(9),
|
||||
]
|
||||
var entry: Dictionary = _server()
|
||||
entry["address"] = "198.51.100.4"
|
||||
seeds.append(NetDiscovery.encode_list(0, 1, [entry, entry]))
|
||||
var list: ListServer = ListServer.new()
|
||||
list.limiter = SourceLimiter.new(1 << 30)
|
||||
var accepted: int = 0
|
||||
for round_index: int in 40000:
|
||||
var bytes: PackedByteArray
|
||||
if round_index % 4 == 0:
|
||||
bytes = PackedByteArray()
|
||||
bytes.resize(rng.randi_range(0, 600))
|
||||
for index: int in bytes.size():
|
||||
bytes[index] = rng.randi_range(0, 255)
|
||||
else:
|
||||
bytes = seeds[rng.randi_range(0, seeds.size() - 1)].duplicate()
|
||||
for _flip: int in rng.randi_range(1, 4):
|
||||
if bytes.is_empty():
|
||||
break
|
||||
match rng.randi_range(0, 2):
|
||||
0:
|
||||
bytes[rng.randi_range(0, bytes.size() - 1)] = rng.randi_range(0, 255)
|
||||
1:
|
||||
bytes.resize(rng.randi_range(0, bytes.size()))
|
||||
2:
|
||||
bytes.append(rng.randi_range(0, 255))
|
||||
for decoded: Dictionary in [
|
||||
NetDiscovery.decode_query(bytes), NetDiscovery.decode_info(bytes), NetDiscovery.decode_register(bytes),
|
||||
NetDiscovery.decode_challenge(bytes), NetDiscovery.decode_list(bytes),
|
||||
]:
|
||||
if not decoded.is_empty():
|
||||
accepted += 1
|
||||
list.handle(bytes, "203.0.113.%d" % (round_index % 200), 40000 + round_index % 7, 0)
|
||||
assert_true(accepted > 0, "some mutations are still valid messages")
|
||||
assert_true(list.entry_count() <= ListServer.MAX_ENTRIES)
|
||||
# Nothing registered without the token: a fuzzer can't guess it.
|
||||
assert_eq(list.entry_count(), 0)
|
||||
@@ -0,0 +1 @@
|
||||
uid://cj6ax5huaigav
|
||||
Reference in New Issue
Block a user