## The wire protocol's handshake: message layouts, the protocol version, the reasons a ## server turns a client away, and what to tell the player about each. ## ## Everything is little-endian. The handshake runs on channel 0, reliable: ## ## client -> HELLO u8 type, 4 bytes "TDWL", u16 protocol version, u8 name length, ## name in UTF-8 ## server -> WELCOME u8 type, u16 protocol version, u32 handle, u8 tick rate, ## u8 max players, u64 match seed, u8 name length, name as accepted ## server -> REJECT u8 type, u8 reason, u16 the server's protocol version ## ## After a REJECT the server disconnects, with the reason again as the disconnect's ## data, so a client that lost the message still learns why. Decoders return an empty ## Dictionary for anything malformed and never raise an error. class_name NetProtocol extends RefCounted ## Raised whenever the wire format changes in a way old clients can't read. const VERSION: int = 4 const MAGIC: String = "TDWL" const CHANNEL_CONTROL: int = 0 ## Unreliable game traffic: commands up, snapshots down. const CHANNEL_STATE: int = 1 const CHANNEL_COUNT: int = 2 const MSG_HELLO: int = 1 const MSG_WELCOME: int = 2 const MSG_REJECT: int = 3 ## Why a connection ended. Sent in REJECT and as disconnect data. ## ENet's timeout limit for every peer: a reliable message is given up on after this ## many round-trip timeouts' worth of resends (and at least the peer's minimum timeout), ## or after its maximum timeout. ENet's own default. 0, which this once was, gives up as ## soon as any reliable message has waited the minimum timeout: over a link losing 2% ## of datagrams each way, a run of unlucky resends then dropped a few soak clients a ## match (issue N8). const PEER_TIMEOUT_LIMIT: int = 32 const REASON_NONE: int = 0 const REASON_VERSION: int = 1 const REASON_FULL: int = 2 const REASON_BAD_HELLO: int = 3 const REASON_HANDSHAKE_TIMEOUT: int = 4 const REASON_SHUTDOWN: int = 5 const REASON_KICKED: int = 6 const REASON_LEFT: int = 7 ## Client-side only: nothing answered, or the connection went quiet. const REASON_NO_ANSWER: int = 8 const REASON_LOST: int = 9 ## Too many connections from one address in a short time. const REASON_BUSY: int = 10 const NAME_MAX_CHARS: int = 16 const NAME_MAX_BYTES: int = 64 const DEFAULT_NAME: String = "Castaway" ## No handshake message is longer than this; anything bigger is refused unread. const MAX_HANDSHAKE_BYTES: int = 96 ## A name fit to show: no control or formatting characters, single spaces, at most ## NAME_MAX_CHARS characters, and never empty. Server names use longer limits. static func clean_name(raw: String, max_chars: int = NAME_MAX_CHARS, max_bytes: int = NAME_MAX_BYTES, fallback: String = DEFAULT_NAME) -> String: var kept: String = "" var spaced: bool = true for index: int in raw.length(): var code: int = raw.unicode_at(index) var space: bool = code == 0x20 or code == 0x09 or code == 0xA0 # Control characters, bidirectional overrides, zero-width marks and private use. var hidden: bool = code < 0x20 or (code >= 0x7F and code < 0xA0) \ or (code >= 0x200B and code <= 0x200F) or (code >= 0x202A and code <= 0x202E) \ or (code >= 0x2060 and code <= 0x206F) or code == 0xFEFF or (code >= 0xE000 and code <= 0xF8FF) \ or code == 0xFFFD or code > 0x2FFFF if space: if not spaced: kept += " " spaced = true elif not hidden: kept += String.chr(code) spaced = false if kept.length() >= max_chars: break kept = kept.strip_edges() while kept.to_utf8_buffer().size() > max_bytes: kept = kept.substr(0, kept.length() - 1) return kept if not kept.is_empty() else fallback static func encode_hello(player_name: String, version: int = VERSION) -> PackedByteArray: var name_bytes: PackedByteArray = clean_name(player_name).to_utf8_buffer() var out: StreamPeerBuffer = _writer() out.put_u8(MSG_HELLO) out.put_data(MAGIC.to_ascii_buffer()) out.put_u16(version) out.put_u8(name_bytes.size()) out.put_data(name_bytes) return out.data_array ## {"version", "name"} or an empty Dictionary. The name is returned cleaned. static func decode_hello(bytes: PackedByteArray) -> Dictionary: if bytes.size() < 8 or bytes.size() > MAX_HANDSHAKE_BYTES or bytes[0] != MSG_HELLO: return {} if bytes.slice(1, 5) != MAGIC.to_ascii_buffer(): return {} var name_size: int = bytes[7] if name_size > NAME_MAX_BYTES or bytes.size() != 8 + name_size: return {} var player_name: String = _utf8(bytes.slice(8)) if name_size > 0 and player_name.is_empty(): return {} return {"version": bytes.decode_u16(5), "name": clean_name(player_name)} static func encode_welcome(handle: int, match_seed: int, max_players: int, player_name: String) -> PackedByteArray: var name_bytes: PackedByteArray = clean_name(player_name).to_utf8_buffer() var out: StreamPeerBuffer = _writer() out.put_u8(MSG_WELCOME) out.put_u16(VERSION) out.put_u32(handle) out.put_u8(Tuning.TICK_RATE_HZ) out.put_u8(clampi(max_players, 0, 255)) out.put_64(match_seed) out.put_u8(name_bytes.size()) out.put_data(name_bytes) return out.data_array ## {"version", "handle", "tick_rate", "max_players", "seed", "name"} or empty. static func decode_welcome(bytes: PackedByteArray) -> Dictionary: if bytes.size() < 18 or bytes.size() > MAX_HANDSHAKE_BYTES or bytes[0] != MSG_WELCOME: return {} var name_size: int = bytes[17] if name_size > NAME_MAX_BYTES or bytes.size() != 18 + name_size: return {} var handle: int = bytes.decode_u32(3) if handle <= 0: return {} return { "version": bytes.decode_u16(1), "handle": handle, "tick_rate": bytes[7], "max_players": bytes[8], "seed": bytes.decode_s64(9), "name": clean_name(_utf8(bytes.slice(18))), } static func encode_reject(reason: int) -> PackedByteArray: var out: StreamPeerBuffer = _writer() out.put_u8(MSG_REJECT) out.put_u8(reason) out.put_u16(VERSION) return out.data_array ## {"reason", "server_version"} or empty. static func decode_reject(bytes: PackedByteArray) -> Dictionary: if bytes.size() != 4 or bytes[0] != MSG_REJECT: return {} return {"reason": bytes[1], "server_version": bytes.decode_u16(2)} ## What to tell the player when a connection ends for `reason`. `server_version` is ## the server's protocol version if it said, or 0. static func reason_text(reason: int, server_version: int = 0, own_version: int = VERSION) -> String: match reason: REASON_VERSION: if server_version > own_version: return "This server runs a newer version of Tidewall (protocol %d; this game speaks %d). Update the game to join." % [server_version, own_version] if server_version > 0: return "This server runs an older version of Tidewall (protocol %d; this game speaks %d). It needs updating before you can join." % [server_version, own_version] return "This server runs a different version of Tidewall (this game speaks protocol %d)." % own_version REASON_FULL: return "The server is full." REASON_BAD_HELLO: return "The server didn't understand this game's greeting. It may not be a Tidewall server." REASON_HANDSHAKE_TIMEOUT: return "The server gave up waiting for this game to introduce itself." REASON_SHUTDOWN: return "The server shut down." REASON_KICKED: return "The server removed you from the game." REASON_LEFT: return "You left the game." REASON_BUSY: return "Too many connections from your address just now. Wait a few seconds and try again." REASON_NO_ANSWER: return "No answer from the server. Check the address and port, and that the server is running." REASON_LOST: return "The connection to the server was lost." return "Disconnected." static func _writer() -> StreamPeerBuffer: var out: StreamPeerBuffer = StreamPeerBuffer.new() out.big_endian = false return out ## Strict UTF-8: an empty string for bytes that aren't valid, with no engine error. static func _utf8(bytes: PackedByteArray) -> String: var index: int = 0 while index < bytes.size(): var lead: int = bytes[index] var extra: int = 0 if lead < 0x80: extra = 0 elif lead >= 0xC2 and lead < 0xE0: extra = 1 elif lead >= 0xE0 and lead < 0xF0: extra = 2 elif lead >= 0xF0 and lead < 0xF5: extra = 3 else: return "" if index + extra > bytes.size() - 1: return "" for offset: int in range(1, extra + 1): if bytes[index + offset] & 0xC0 != 0x80: return "" # Overlong forms, surrogates and code points past the end of Unicode. if extra >= 2: var second: int = bytes[index + 1] if (lead == 0xE0 and second < 0xA0) or (lead == 0xED and second >= 0xA0) \ or (lead == 0xF0 and second < 0x90) or (lead == 0xF4 and second >= 0x90): return "" index += extra + 1 return bytes.get_string_from_utf8()