extends TestCase ## Issue N1: a real NetServer and NetClients over loopback UDP. Handshake, refusals, ## clean leaves, timeouts, and hostile or broken peers. const HOST: String = "127.0.0.1" var server: NetServer var clients: Array[NetClient] = [] ## Every server event since the test began. var seen: Array[Dictionary] = [] var raw_hosts: Array[ENetConnection] = [] ## Game packets the server handed to its owner since the test began. var handed: int = 0 func before_each() -> void: server = NetServer.new() server.match_seed = 4242 clients.clear() seen.clear() handed = 0 raw_hosts.clear() assert_eq(server.listen(0, HOST), OK) assert_true(server.port() > 0) func after_each() -> void: for client: NetClient in clients: client.leave() for host: ENetConnection in raw_hosts: host.destroy() server.close() func _client(wanted: String) -> NetClient: var client: NetClient = NetClient.new() clients.append(client) assert_eq(client.connect_to(HOST, server.port(), wanted), OK) return client ## Polls everything until `done` is true or `limit_msec` passes. Returns `done`'s answer. func _pump(done: Callable, limit_msec: int = 4000) -> bool: var started: int = Time.get_ticks_msec() while Time.get_ticks_msec() - started < limit_msec: server.poll() seen.append_array(server.events) handed += server.packets.size() for client: NetClient in clients: client.poll() for host: ENetConnection in raw_hosts: _service_raw(host) if done.call(): return true OS.delay_msec(2) return bool(done.call()) func _events(type: String) -> Array[Dictionary]: var found: Array[Dictionary] = [] for event: Dictionary in seen: if event["type"] == type: found.append(event) return found # A bare ENet peer, for sending what a real client never would. var _raw_state: Dictionary = {} func _raw() -> ENetPacketPeer: var host: ENetConnection = ENetConnection.new() assert_eq(host.create_host(1, NetProtocol.CHANNEL_COUNT), OK) var peer: ENetPacketPeer = host.connect_to_host(HOST, server.port(), NetProtocol.CHANNEL_COUNT) raw_hosts.append(host) _raw_state[host] = {"connected": false, "disconnect_data": -1, "packets": []} assert_true(_pump(func() -> bool: return _raw_state[host]["connected"]), "the raw peer connected") return peer func _service_raw(host: ENetConnection) -> void: while true: var event: Array = host.service(0) if event[0] == ENetConnection.EVENT_NONE or event[0] == ENetConnection.EVENT_ERROR: return var state: Dictionary = _raw_state[host] if event[0] == ENetConnection.EVENT_CONNECT: state["connected"] = true elif event[0] == ENetConnection.EVENT_DISCONNECT: state["disconnect_data"] = int(event[2]) elif event[0] == ENetConnection.EVENT_RECEIVE: state["packets"].append((event[1] as ENetPacketPeer).get_packet()) func test_a_client_joins() -> void: var client: NetClient = _client(" Mara\tof the Reef ") assert_eq(client.state, NetClient.CONNECTING) assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED), client.status_text()) assert_eq(client.handle, 1) assert_eq(client.player_name, "Mara of the Reef") assert_eq(client.match_seed, 4242) assert_eq(client.max_players, Tuning.SOLO_PLAYERS) assert_eq(client.tick_rate, Tuning.TICK_RATE_HZ) assert_eq(client.server_version, NetProtocol.VERSION) assert_eq(_events("joined"), [{"type": "joined", "handle": 1, "name": "Mara of the Reef"}] as Array[Dictionary]) assert_eq(server.player_count(), 1) assert_eq(server.guest_count(), 0) assert_eq(server.name_of(1), "Mara of the Reef") assert_eq(client.status_text(), "Joined as Mara of the Reef.") func test_a_version_mismatch_is_refused_clearly() -> void: var client: NetClient = NetClient.new() client.protocol_version = NetProtocol.VERSION + 1 clients.append(client) assert_eq(client.connect_to(HOST, server.port(), "Mara"), OK) assert_true(_pump(func() -> bool: return client.state == NetClient.CLOSED), client.state_name()) assert_eq(client.close_reason, NetProtocol.REASON_VERSION) assert_eq(client.server_version, NetProtocol.VERSION) var text: String = client.status_text() assert_true(text.contains("older version") and text.contains("protocol %d" % NetProtocol.VERSION), text) assert_eq(server.player_count(), 0) assert_eq(_events("refused"), [{"type": "refused", "reason": NetProtocol.REASON_VERSION}] as Array[Dictionary]) assert_true(_events("joined").is_empty()) func test_a_full_server_says_so() -> void: server.max_players = 2 var first: NetClient = _client("One") var second: NetClient = _client("Two") assert_true(_pump(func() -> bool: return first.state == NetClient.JOINED and second.state == NetClient.JOINED)) var third: NetClient = _client("Three") assert_true(_pump(func() -> bool: return third.state == NetClient.CLOSED)) assert_eq(third.close_reason, NetProtocol.REASON_FULL) assert_eq(third.status_text(), "The server is full.") assert_eq(server.player_count(), 2) # A place opens when someone leaves. first.leave() assert_true(_pump(func() -> bool: return server.player_count() == 1)) var fourth: NetClient = _client("Four") assert_true(_pump(func() -> bool: return fourth.state == NetClient.JOINED)) assert_eq(fourth.handle, 3, "handles are never reused") func test_duplicate_names_get_a_number() -> void: var first: NetClient = _client("Mara") assert_true(_pump(func() -> bool: return first.state == NetClient.JOINED)) var second: NetClient = _client("mara") var third: NetClient = _client("Mara") assert_true(_pump(func() -> bool: return second.state == NetClient.JOINED and third.state == NetClient.JOINED)) var names: Array[String] = [first.player_name, second.player_name, third.player_name] names.sort() assert_eq(names.size(), 3) assert_true(names.has("Mara") and (names.has("mara 2") or names.has("Mara 2")), "names %s" % [names]) assert_ne(second.player_name.to_lower(), third.player_name.to_lower()) func test_a_clean_leave_is_seen_at_once() -> void: server.peer_timeout_min_msec = 60000 server.peer_timeout_max_msec = 60000 var client: NetClient = _client("Mara") assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED)) client.leave() assert_eq(client.state, NetClient.CLOSED) assert_eq(client.close_reason, NetProtocol.REASON_LEFT) assert_true(_pump(func() -> bool: return not _events("left").is_empty(), 2000), "the server heard the goodbye, not a timeout") assert_eq(_events("left"), [{"type": "left", "handle": 1, "name": "Mara", "reason": NetProtocol.REASON_LEFT}] as Array[Dictionary]) assert_eq(server.player_count(), 0) func test_a_client_that_vanishes_times_out() -> void: server.close() server.peer_timeout_min_msec = 300 server.peer_timeout_max_msec = 600 assert_eq(server.listen(0, HOST), OK) var client: NetClient = _client("Mara") assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED)) # Pull the plug: no goodbye. client._drop() clients.clear() assert_true(_pump(func() -> bool: return not _events("left").is_empty(), 8000), "the server noticed") assert_eq(_events("left")[0]["reason"], NetProtocol.REASON_LOST) assert_eq(server.player_count(), 0) func test_a_silent_guest_is_dropped() -> void: server.handshake_timeout_msec = 200 _raw() var host: ENetConnection = raw_hosts[0] assert_true(_pump(func() -> bool: return server.guest_count() == 1 or _raw_state[host]["disconnect_data"] >= 0)) assert_true(_pump(func() -> bool: return _raw_state[host]["disconnect_data"] >= 0), "the guest was disconnected") assert_eq(_raw_state[host]["disconnect_data"], NetProtocol.REASON_HANDSHAKE_TIMEOUT) assert_eq(NetProtocol.decode_reject(_raw_state[host]["packets"][0])["reason"], NetProtocol.REASON_HANDSHAKE_TIMEOUT) assert_eq(server.guest_count(), 0) assert_eq(server.player_count(), 0) func test_malformed_handshakes_are_refused_and_the_server_carries_on() -> void: var good: PackedByteArray = NetProtocol.encode_hello("Mara") var huge: PackedByteArray = PackedByteArray() huge.resize(60000) huge.fill(0x41) var wrong_magic: PackedByteArray = good.duplicate() wrong_magic[1] = 0x00 var bad_name: PackedByteArray = good.slice(0, 7) bad_name.append_array(PackedByteArray([2, 0xC3, 0x28])) var packets: Array[PackedByteArray] = [ PackedByteArray([0]), PackedByteArray([NetProtocol.MSG_HELLO]), good.slice(0, 6), wrong_magic, huge, bad_name, NetProtocol.encode_welcome(1, 1, 24, "Mara"), NetProtocol.encode_reject(NetProtocol.REASON_FULL), ] for bytes: PackedByteArray in packets: var peer: ENetPacketPeer = _raw() peer.send(NetProtocol.CHANNEL_CONTROL, bytes, ENetPacketPeer.FLAG_RELIABLE) # A good HELLO on the wrong channel is no handshake either. var stray: ENetPacketPeer = _raw() stray.send(NetProtocol.CHANNEL_STATE, good, ENetPacketPeer.FLAG_RELIABLE) var expected: int = packets.size() + 1 assert_true(_pump(func() -> bool: return _events("refused").size() >= expected), "refused %d of %d" % [_events("refused").size(), expected]) for event: Dictionary in _events("refused"): assert_eq(event["reason"], NetProtocol.REASON_BAD_HELLO) assert_eq(server.bad_packets, expected) assert_true(_pump(func() -> bool: for host: ENetConnection in raw_hosts: if _raw_state[host]["disconnect_data"] < 0: return false return true), "every bad peer was disconnected") assert_eq(server.guest_count(), 0) assert_eq(server.player_count(), 0) # Still serving. var client: NetClient = _client("Mara") assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED)) func test_random_packets_from_guests_and_players_never_crash_the_server() -> void: var rng: RandomNumberGenerator = RandomNumberGenerator.new() rng.seed = 77 var member: NetClient = _client("Mara") assert_true(_pump(func() -> bool: return member.state == NetClient.JOINED)) for _round: int in 12: var peer: ENetPacketPeer = _raw() for _packet: int in 6: var bytes: PackedByteArray = PackedByteArray() bytes.resize(rng.randi_range(0, 300)) for index: int in bytes.size(): bytes[index] = rng.randi_range(0, 255) peer.send(rng.randi_range(0, 1), bytes, ENetPacketPeer.FLAG_RELIABLE) # A player who keeps sending HELLOs and junk stays a player and changes nothing. The # HELLOs are dropped; junk on the game channel goes to the owner, who can't read it. for _packet: int in 20: member._peer.send(NetProtocol.CHANNEL_CONTROL, NetProtocol.encode_hello("Someone Else"), ENetPacketPeer.FLAG_RELIABLE) member._peer.send(NetProtocol.CHANNEL_STATE, PackedByteArray([1, 2, 3]), ENetPacketPeer.FLAG_RELIABLE) assert_true(_pump(func() -> bool: return _events("refused").size() >= 12 and server.bad_packets >= 32 and handed >= 20), "refused %d, dropped %d, handed on %d" % [_events("refused").size(), server.bad_packets, handed]) assert_eq(handed, 20) assert_eq(server.player_count(), 1) assert_eq(server.name_of(1), "Mara") assert_eq(_events("joined").size(), 1) assert_eq(member.state, NetClient.JOINED) func test_no_server_means_no_answer() -> void: var port: int = server.port() server.close() var client: NetClient = NetClient.new() client.connect_timeout_msec = 300 clients.append(client) assert_eq(client.connect_to(HOST, port, "Mara"), OK) assert_true(_pump(func() -> bool: return client.state == NetClient.CLOSED, 3000)) assert_eq(client.close_reason, NetProtocol.REASON_NO_ANSWER) assert_true(client.status_text().contains("No answer")) func test_a_server_shutting_down_tells_its_players() -> void: var client: NetClient = _client("Mara") assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED)) server.close() assert_false(server.is_listening()) assert_eq(server.port(), 0) assert_true(_pump(func() -> bool: return client.state == NetClient.CLOSED)) assert_eq(client.close_reason, NetProtocol.REASON_SHUTDOWN) assert_eq(client.status_text(), "The server shut down.") func test_a_kicked_player_is_told_and_removed() -> void: var client: NetClient = _client("Mara") assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED)) assert_true(server.kick(1)) assert_eq(server.events[-1], {"type": "left", "handle": 1, "name": "Mara", "reason": NetProtocol.REASON_KICKED}) assert_false(server.kick(1)) assert_eq(server.player_count(), 0) assert_true(_pump(func() -> bool: return client.state == NetClient.CLOSED)) assert_eq(client.close_reason, NetProtocol.REASON_KICKED) assert_false(client.send(NetProtocol.CHANNEL_STATE, PackedByteArray([1]), false)) func test_two_servers_cannot_share_a_port() -> void: var other: NetServer = NetServer.new() expect_error("Couldn't create an ENet host") assert_ne(other.listen(server.port(), HOST), OK) assert_false(other.is_listening()) assert_true(server.is_listening()) func test_a_burst_of_connections_from_one_address_is_turned_away() -> void: server.connect_limiter = SourceLimiter.new(3, 60000) var burst: Array[NetClient] = [] for index: int in 5: burst.append(_client("Wave %d" % index)) assert_true(_pump(func() -> bool: var settled: int = 0 for client: NetClient in burst: if client.state == NetClient.JOINED or client.state == NetClient.CLOSED: settled += 1 return settled == burst.size())) var joined: int = 0 for client: NetClient in burst: if client.state == NetClient.JOINED: joined += 1 else: assert_eq(client.close_reason, NetProtocol.REASON_BUSY) assert_eq(joined, 3) assert_eq(server.player_count(), 3) assert_true(NetProtocol.reason_text(NetProtocol.REASON_BUSY).begins_with("Too many connections")) func test_handshakes_held_open_from_one_address_are_capped() -> void: server.max_guests_per_address = 2 # Raw peers that connect and never say hello. for _index: int in 4: _raw() assert_true(_pump(func() -> bool: return _events("refused").size() >= 2)) assert_eq(server.guest_count(), 2) for event: Dictionary in _events("refused"): assert_eq(event["reason"], NetProtocol.REASON_BUSY) ## N8: a server stopping with a grace sends its notice reliably, so clients behind a ## link that loses half its datagrams still hear it instead of timing out. func test_a_graceful_shutdown_reaches_clients_on_a_lossy_link() -> void: var relays: Array[UdpRelay] = [] var lossy: Array[NetClient] = [] for index: int in 4: var relay: UdpRelay = UdpRelay.new(0.0, 0.0, 0.0, 11 + index) assert_eq(relay.open(0, HOST, server.port()), OK) relays.append(relay) var client: NetClient = NetClient.new() assert_eq(client.connect_to(HOST, relay.port(), "Lossy%d" % index), OK) lossy.append(client) var joined: Callable = func() -> bool: for relay: UdpRelay in relays: relay.poll() for client: NetClient in lossy: if client.state != NetClient.JOINED: return false return true for _round: int in 2000: server.poll() for client: NetClient in lossy: client.poll() if joined.call(): break OS.delay_msec(2) assert_true(joined.call(), "every client joined") for relay: UdpRelay in relays: relay.loss = 0.5 # The clients go on being serviced in another thread while the server closes. var stop: Array = [false] var worker: Thread = Thread.new() worker.start(func() -> void: while not stop[0]: for relay: UdpRelay in relays: relay.poll() for client: NetClient in lossy: client.poll() OS.delay_msec(2)) server.close(3000) var started: int = Time.get_ticks_msec() var all_closed: bool = false while Time.get_ticks_msec() - started < 3000 and not all_closed: OS.delay_msec(20) all_closed = true for client: NetClient in lossy: all_closed = all_closed and client.state == NetClient.CLOSED stop[0] = true worker.wait_to_finish() for client: NetClient in lossy: assert_eq(client.state, NetClient.CLOSED) assert_eq(client.close_reason, NetProtocol.REASON_SHUTDOWN, "%s was told the server stopped" % client.player_name) for relay: UdpRelay in relays: relay.close() ## H5: a peer that connects and then never answers again: it doesn't say hello, and ## doesn't acknowledge being turned away, so ENet alone would keep its slot for seconds. func _silent(silent: Array[ENetConnection]) -> void: var host: ENetConnection = ENetConnection.new() assert_eq(host.create_host(1, NetProtocol.CHANNEL_COUNT), OK) host.connect_to_host(HOST, server.port(), NetProtocol.CHANNEL_COUNT) silent.append(host) var connected: Array[bool] = [false] _pump(func() -> bool: var event: Array = host.service(0) if event[0] == ENetConnection.EVENT_CONNECT: connected[0] = true return connected[0], 2000) # The acknowledgement goes out on the next service; send it, then never again. host.flush() var before: int = server.guest_count() + _events("refused").size() + server.evicted _pump(func() -> bool: return server.guest_count() + _events("refused").size() + server.evicted > before, 1000) func _destroy(silent: Array[ENetConnection]) -> void: for host: ENetConnection in silent: host.destroy() func test_a_flood_from_one_address_cannot_hold_the_slots() -> void: server.close() server.max_players = 2 server.peer_slots = 0 server.connect_limiter = SourceLimiter.new(3, 60000) server.max_guests_per_address = 3 server.handshake_timeout_msec = 60000 assert_eq(server.listen(0, HOST), OK) # Ten slots: three silent guests, then peers turned away for flooding. var silent: Array[ENetConnection] = [] for _index: int in 9: _silent(silent) assert_eq(server.guest_count(), 3) assert_eq(server.leaving_count(), 0, "peers turned away for flooding don't keep a slot") assert_eq(_events("refused").size(), 6) # The flood has passed; a real player still finds a slot. server.connect_limiter = SourceLimiter.new(32, 10000) server.max_guests_per_address = 8 var client: NetClient = _client("After") assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED or client.state == NetClient.CLOSED, 3000)) assert_eq(client.state, NetClient.JOINED) _destroy(silent) func test_silent_guests_make_room_for_a_newcomer() -> void: server.close() server.max_players = 2 server.peer_slots = 0 server.max_guests_per_address = 64 server.handshake_timeout_msec = 60000 assert_eq(server.listen(0, HOST), OK) # More silent guests than the ten slots: the oldest make way, one slot stays free. var silent: Array[ENetConnection] = [] for _index: int in 12: _silent(silent) assert_true(server.guest_count() <= 9, "a slot is kept free, %d guests" % server.guest_count()) assert_true(server.evicted >= 3) var client: NetClient = _client("Newcomer") assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED or client.state == NetClient.CLOSED, 3000)) assert_eq(client.state, NetClient.JOINED) assert_eq(server.player_count(), 1) _destroy(silent) func test_a_peer_that_never_acknowledges_leaving_is_cut_off() -> void: server.close() server.max_players = 2 server.handshake_timeout_msec = 100 server.leave_grace_msec = 300 assert_eq(server.listen(0, HOST), OK) var silent: Array[ENetConnection] = [] _silent(silent) assert_true(_pump(func() -> bool: return server.leaving_count() == 1, 2000), "the silent guest was told to go") assert_true(_pump(func() -> bool: return server.leaving_count() == 0, 2000), "and cut off after its grace") assert_eq(server.evicted, 1) _destroy(silent) ## H5: a client turned away for flooding learns why from the disconnect alone. func test_busy_reaches_the_client_without_a_reject_message() -> void: assert_true(NetProtocol.is_server_reason(NetProtocol.REASON_BUSY)) assert_false(NetProtocol.is_server_reason(NetProtocol.REASON_NONE)) assert_false(NetProtocol.is_server_reason(NetProtocol.REASON_LOST)) server.connect_limiter = SourceLimiter.new(1, 60000) var first: NetClient = _client("First") var second: NetClient = _client("Second") assert_true(_pump(func() -> bool: return second.state == NetClient.CLOSED and first.state == NetClient.JOINED)) assert_eq(second.close_reason, NetProtocol.REASON_BUSY)