mt-lang 0.2.0 → 0.2.1

data/std/net/clock.mt

@@ -0,0 +1,237 @@
+import std.async as aio
+import std.binary as bin
+import std.bytes as bytes
+import std.libuv as libuv
+import std.net as net
+import std.string as string
+
+const clock_magic: array[ubyte, 8] = array[ubyte, 8](
+    0x4Dub, 0x54ub, 0x43ub, 0x4Cub,
+    0x4Fub, 0x43ub, 0x4Bub, 0x00ub
+)
+
+const sync_request: ubyte = 0x01
+const sync_response: ubyte = 0x02
+
+const header_bytes: ptr_uint = 9
+const request_bytes: ptr_uint = 17
+const response_bytes: ptr_uint = 25
+
+const err_send_failed: int = -1
+const err_recv_failed: int = -2
+const err_timeout: int = -3
+const err_bad_packet: int = -4
+
+public struct ClockSync:
+    offset_us: int
+    rtt_us: ptr_uint
+
+public struct TickClock:
+    tick: uint
+    rate: uint
+    epoch: ulong
+
+public struct Error:
+    code: int
+    message: string.String
+
+
+extending Error:
+    public editable function release() -> void:
+        this.message.release()
+
+
+function clock_error(code: int, msg: str) -> Error:
+    return Error(code = code, message = string.String.from_str(msg))
+
+
+public function monotonic_ns() -> ulong:
+    return libuv.hrtime()
+
+
+public function monotonic_us() -> ulong:
+    return libuv.hrtime() / 1000ul
+
+
+public function build_request(t1: ulong) -> bytes.Bytes:
+    var w = bin.Writer.with_capacity(request_bytes)
+    var i: ptr_uint = 0
+    while i < 8z:
+        w.write_ubyte(clock_magic[i])
+        i += 1
+    w.write_ubyte(sync_request)
+    w.write_ulong(t1)
+    return w.finish()
+
+
+public function build_response(t1_client: ulong, t2_server: ulong) -> bytes.Bytes:
+    var w = bin.Writer.with_capacity(response_bytes)
+    var i: ptr_uint = 0
+    while i < 8z:
+        w.write_ubyte(clock_magic[i])
+        i += 1
+    w.write_ubyte(sync_response)
+    w.write_ulong(t1_client)
+    w.write_ulong(t2_server)
+    return w.finish()
+
+
+function is_clock_packet(data: span[ubyte]) -> bool:
+    if data.len < header_bytes:
+        return false
+    var i: ptr_uint = 0
+    while i < 8z:
+        if data[i] != clock_magic[i]:
+            return false
+        i += 1
+    return true
+
+
+public function parse_request(data: span[ubyte]) -> Result[ulong, Error]:
+    if data.len < request_bytes or data[8z] != sync_request:
+        return Result[ulong, Error].failure(error = clock_error(err_bad_packet, "not a clock sync request"))
+    var r = bin.reader(data)
+    var _bp = r.read_bytes(9z).map_error(proc(_: bin.Error) -> Error: clock_error(err_bad_packet, "malformed request"))?
+    _bp.release()
+    return r.read_ulong().map_error(proc(_: bin.Error) -> Error: clock_error(err_bad_packet, "malformed timestamp"))
+
+
+public function parse_response(data: span[ubyte]) -> Result[ClockSync, Error]:
+    if data.len < response_bytes or data[8z] != sync_response:
+        return Result[ClockSync, Error].failure(error = clock_error(err_bad_packet, "not a clock sync response"))
+    var r = bin.reader(data)
+    match r.read_bytes(9z):
+        Result.failure:
+            return Result[ClockSync, Error].failure(error = clock_error(err_bad_packet, "malformed response"))
+        Result.success as bp:
+            bp.value.release()
+    match r.read_ulong():
+        Result.failure:
+            return Result[ClockSync, Error].failure(error = clock_error(err_bad_packet, "malformed t1"))
+        Result.success as t1_payload:
+            let t1_client = t1_payload.value
+            match r.read_ulong():
+                Result.failure:
+                    return Result[ClockSync, Error].failure(error = clock_error(err_bad_packet, "malformed t2"))
+                Result.success as t2_payload:
+                    let t2_svr = t2_payload.value
+                    let t4 = libuv.hrtime()
+                    let rtt = t4 - t1_client
+                    let half_rtt = rtt / 2ul
+                    if t2_svr > t1_client + half_rtt:
+                        let offset_ns = t2_svr - t1_client - half_rtt
+                        return Result[ClockSync, Error].success(
+                            value = ClockSync(
+                                offset_us = int<-(offset_ns / 1000ul),
+                                rtt_us = ptr_uint<-(rtt / 1000ul)
+                            )
+                        )
+                    return Result[ClockSync, Error].success(
+                        value = ClockSync(offset_us = 0, rtt_us = ptr_uint<-(rtt / 1000ul))
+                    )
+
+
+public async function measure_offset(
+    socket: net.UdpSocket,
+    peer: net.SocketAddress
+) -> Result[ClockSync, Error]:
+    let t1 = libuv.hrtime()
+    var request = build_request(t1)
+    defer request.release()
+    (await socket.send_to(request.as_span(), peer)).map_error(proc(_: net.Error) -> Error:
+        clock_error(err_send_failed, "failed to send sync request")
+    )?
+
+    var frame: uint = 0
+    let recv_task = socket.recv_from(512)
+    while frame < 40:
+        if aio.completed(recv_task):
+            let recv_result = aio.result(recv_task)
+            match recv_result:
+                Result.failure:
+                    return Result[ClockSync, Error].failure(
+                        error = clock_error(err_recv_failed, "recv failed")
+                    )
+                Result.success as dp:
+                    var datagram = dp.value
+                    defer datagram.data.release()
+                    defer datagram.source.release()
+                    if is_clock_packet(datagram.data.as_span()):
+                        let parse_result = parse_response(datagram.data.as_span())
+                        match parse_result:
+                            Result.failure:
+                                continue
+                            Result.success as sp:
+                                return Result[ClockSync, Error].success(value = sp.value)
+        await aio.sleep(50)
+        frame += 1
+
+    return Result[ClockSync, Error].failure(
+        error = clock_error(err_timeout, "clock sync request timed out")
+    )
+
+
+public async function respond_to_sync(
+    socket: net.UdpSocket
+) -> void:
+    var recv_task = socket.recv_from(512)
+    var frame: uint = 0
+    while frame < 60:
+        if aio.completed(recv_task):
+            let recv_result = aio.result(recv_task)
+            match recv_result:
+                Result.success as dp:
+                    var datagram = dp.value
+                    defer datagram.data.release()
+                    defer datagram.source.release()
+                    if is_clock_packet(datagram.data.as_span()):
+                        let parse_result = parse_request(datagram.data.as_span())
+                        match parse_result:
+                            Result.success as tp:
+                                let t2 = libuv.hrtime()
+                                var resp = build_response(tp.value, t2)
+                                defer resp.release()
+                                let _ = await socket.send_to(resp.as_span(), datagram.source)
+                            Result.failure:
+                                pass
+                Result.failure:
+                    pass
+            recv_task = socket.recv_from(512)
+        await aio.sleep(100)
+        frame += 1
+
+
+public function tick_clock_new(rate: uint) -> TickClock:
+    return TickClock(tick = 0u, rate = rate, epoch = monotonic_ns())
+
+
+public function tick_clock_from_seed(rate: uint, seed_tick: uint, epoch_ns: ulong) -> TickClock:
+    return TickClock(tick = seed_tick, rate = rate, epoch = epoch_ns)
+
+
+extending TickClock:
+    public editable function advance() -> void:
+        this.tick += 1
+
+
+    public function elapsed_ticks() -> uint:
+        let now = monotonic_ns()
+        let elapsed_ns = now - this.epoch
+        let tick_duration_ns = (1000000000ul / ulong<-this.rate)
+        if tick_duration_ns == 0ul:
+            return 0u
+        return uint<-(elapsed_ns / tick_duration_ns)
+
+
+    public function time_to_next_tick() -> ptr_uint:
+        let now = monotonic_ns()
+        let elapsed_ns = now - this.epoch
+        let tick_ns = (1000000000ul / (ulong<-this.rate))
+        let into_current = elapsed_ns % tick_ns
+        let remaining = tick_ns - into_current
+        return (remaining / 1000ul)
+
+
+    public function tick_ready() -> bool:
+        let elapsed = this.elapsed_ticks()
+        return elapsed > this.tick

data/std/net/discovery.mt

@@ -0,0 +1,277 @@
+import std.async as aio
+import std.binary as bin
+import std.bytes as bytes
+import std.net as net
+import std.string as string
+import std.vec as vec
+
+const discovery_magic: array[ubyte, 4] = array[ubyte, 4](
+    ubyte<-0x4D, ubyte<-0x54, ubyte<-0x44, ubyte<-0x53
+)
+
+const probe_bytes: ptr_uint = 4
+const min_response_bytes: ptr_uint = 11
+const default_discovery_port_offset: int = 1
+
+public struct ServerInfo:
+    address: net.SocketAddress
+    game_port: int
+    player_count: ubyte
+    max_players: ubyte
+    game_name: string.String
+
+
+extending ServerInfo:
+    public editable function release() -> void:
+        this.address.release()
+        this.game_name.release()
+
+
+public function build_probe() -> bytes.Bytes:
+    var w = bin.Writer.with_capacity(probe_bytes)
+    w.write_ubyte(discovery_magic[0])
+    w.write_ubyte(discovery_magic[1])
+    w.write_ubyte(discovery_magic[2])
+    w.write_ubyte(discovery_magic[3])
+    return w.finish()
+
+
+public function build_response(
+    game_port: int,
+    player_count: ubyte,
+    max_players: ubyte,
+    game_name: str
+) -> bytes.Bytes:
+    var w = bin.Writer.with_capacity(probe_bytes + 6z + game_name.len)
+    w.write_ubyte(discovery_magic[0])
+    w.write_ubyte(discovery_magic[1])
+    w.write_ubyte(discovery_magic[2])
+    w.write_ubyte(discovery_magic[3])
+    w.write_ushort(ushort<-game_port)
+    w.write_ubyte(player_count)
+    w.write_ubyte(max_players)
+    w.write_str(game_name)
+    return w.finish()
+
+
+function is_probe(data: span[ubyte]) -> bool:
+    if data.len < probe_bytes:
+        return false
+    return (
+        data[0] == discovery_magic[0]
+        and data[1] == discovery_magic[1]
+        and data[2] == discovery_magic[2]
+        and data[3] == discovery_magic[3]
+    )
+
+
+function discovery_error(message: str) -> net.Error:
+    return net.net_error(message)
+
+
+function parse_response(data: span[ubyte]) -> Result[ServerInfo, net.Error]:
+    if data.len < min_response_bytes:
+        return Result[ServerInfo, net.Error].failure(
+            error = discovery_error("discovery response too short")
+        )
+
+    if (
+        data[0] != discovery_magic[0]
+        or data[1] != discovery_magic[1]
+        or data[2] != discovery_magic[2]
+        or data[3] != discovery_magic[3]
+    ):
+        return Result[ServerInfo, net.Error].failure(
+            error = discovery_error("discovery response bad magic")
+        )
+
+    var r = bin.reader(data)
+
+    var _bp = r.read_bytes(probe_bytes).map_error(proc(_: bin.Error) -> net.Error:
+        discovery_error("discovery response malformed header")
+    )?
+    _bp.release()
+
+    var game_port: int = 0
+    game_port = r.read_ushort().map_error(proc(_: bin.Error) -> net.Error:
+        discovery_error("discovery response malformed port")
+    )?
+
+    var player_count: ubyte = 0
+    player_count = r.read_ubyte().map_error(proc(_: bin.Error) -> net.Error:
+        discovery_error("discovery response malformed player_count")
+    )?
+
+    var max_players: ubyte = 0
+    max_players = r.read_ubyte().map_error(proc(_: bin.Error) -> net.Error:
+        discovery_error("discovery response malformed max_players")
+    )?
+
+    let game_name = r.read_str().map_error(proc(_: bin.Error) -> net.Error:
+        discovery_error("discovery response malformed name")
+    )?
+    return Result[ServerInfo, net.Error].success(value = ServerInfo(
+        address = zero[net.SocketAddress],
+        game_port = game_port,
+        player_count = player_count,
+        max_players = max_players,
+        game_name = game_name
+    ))
+
+
+public async function announce(
+    game_port: int,
+    max_players: ubyte,
+    game_name: str
+) -> void:
+    let discovery_port = game_port + default_discovery_port_offset
+    match net.ipv4("0.0.0.0", discovery_port):
+        Result.failure:
+            return
+        Result.success as addr_p:
+            var announce_addr = addr_p.value
+            defer announce_addr.release()
+
+            match net.udp_bind(announce_addr):
+                Result.failure:
+                    return
+                Result.success as bp:
+                    var socket = bp.value
+                    defer socket.release()
+
+                    var response = build_response(game_port, ubyte<-0, max_players, game_name)
+                    defer response.release()
+
+                    while true:
+                        let recv_task = socket.recv_from(1500)
+                        var frame: uint = 0
+                        while frame < 120:
+                            if aio.completed(recv_task):
+                                let recv_result = aio.result(recv_task)
+                                match recv_result:
+                                    Result.success as dp:
+                                        var datagram = dp.value
+                                        if is_probe(datagram.data.as_span()):
+                                            let _ = await socket.send_to(
+                                                response.as_span(),
+                                                datagram.source
+                                            )
+                                        datagram.data.release()
+                                        datagram.source.release()
+                                        break
+                                    Result.failure:
+                                        break
+                            await aio.sleep(100)
+                            frame += 1
+
+
+public async function discover_on(
+    runtime: aio.Runtime,
+    game_port: int,
+    timeout_frames: uint
+) -> Result[vec.Vec[ServerInfo], net.Error]:
+    match net.ipv4("0.0.0.0", 0):
+        Result.failure:
+            return Result[vec.Vec[ServerInfo], net.Error].failure(
+                error = discovery_error("failed to create local address")
+            )
+        Result.success as la:
+            var local_addr = la.value
+            defer local_addr.release()
+
+            match net.udp_bind_on(runtime, local_addr):
+                Result.failure:
+                    return Result[vec.Vec[ServerInfo], net.Error].failure(
+                        error = discovery_error("failed to bind discovery socket")
+                    )
+                Result.success as bp:
+                    var socket = bp.value
+                    defer socket.release()
+
+                    match socket.set_broadcast(true):
+                        0:
+                            pass
+                        _:
+                            return Result[vec.Vec[ServerInfo], net.Error].failure(
+                                error = discovery_error("failed to enable broadcast")
+                            )
+
+                    let broadcast_addr_result = net.ipv4(
+                        "255.255.255.255",
+                        game_port + default_discovery_port_offset
+                    )
+                    match broadcast_addr_result:
+                        Result.failure:
+                            return Result[vec.Vec[ServerInfo], net.Error].failure(
+                                error = discovery_error("failed to create broadcast address")
+                            )
+                        Result.success as broad_addr:
+                            var broadcast_addr = broad_addr.value
+                            defer broadcast_addr.release()
+
+                            var probe = build_probe()
+                            defer probe.release()
+
+                            var results = vec.Vec[ServerInfo].create()
+
+                            var burst: uint = 0
+                            while burst < 3:
+                                let _ = await socket.send_to(probe.as_span(), broadcast_addr)
+                                burst += 1
+
+                            var recv_task = socket.recv_from(1500)
+                            var frame: uint = 0
+                            while frame < timeout_frames:
+                                if aio.completed(recv_task):
+                                    let recv_result = aio.result(recv_task)
+                                    match recv_result:
+                                        Result.success as dp:
+                                            var datagram = dp.value
+                                            let parse_result = parse_response(
+                                                datagram.data.as_span()
+                                            )
+                                            datagram.data.release()
+                                            match parse_result:
+                                                Result.success as sp:
+                                                    var info = sp.value
+                                                    info.address = datagram.source
+                                                    datagram.source = zero[net.SocketAddress]
+                                                    if not already_discovered(
+                                                        ref_of(results),
+                                                        ref_of(info)
+                                                    ):
+                                                        results.push(info)
+                                                    else:
+                                                        info.release()
+                                                Result.failure:
+                                                    datagram.source.release()
+                                        Result.failure:
+                                            break
+                                    recv_task = socket.recv_from(1500)
+                                await aio.sleep(50)
+                                frame += 1
+
+                            return Result[vec.Vec[ServerInfo], net.Error].success(
+                                value = results
+                            )
+
+
+public async function discover(
+    game_port: int,
+    timeout_frames: uint
+) -> Result[vec.Vec[ServerInfo], net.Error]:
+    return await discover_on(aio.current_runtime(), game_port, timeout_frames)
+
+
+function already_discovered(
+    results: ref[vec.Vec[ServerInfo]],
+    info: ref[ServerInfo]
+) -> bool:
+    var index: ptr_uint = 0
+    while index < results.len():
+        let existing_ptr = results.get(index) else:
+            break
+        if unsafe: read(existing_ptr).address.equal(info.address):
+            return true
+        index += 1
+    return false