mt-lang 0.2.0 → 0.2.1

data/std/net/nat.mt

@@ -0,0 +1,122 @@
+import std.net as net
+import std.net.stun as stun
+import std.string as string
+
+const google_primary: str = "stun.l.google.com"
+const google_alternate: str = "stun1.l.google.com"
+const google_port: int = 19302
+
+const err_resolve: int = -1
+const err_bind: int = -2
+const err_discover: int = -3
+const err_blocked: int = -4
+
+public enum NatType: ubyte
+    blocked = 0
+    open_internet = 1
+    cone = 2
+    symmetric = 3
+
+public struct NatResult:
+    nat_type: NatType
+    public_address: net.SocketAddress
+
+public struct Error:
+    code: int
+    message: string.String
+
+
+extending Error:
+    public editable function release() -> void:
+        this.message.release()
+
+
+extending NatResult:
+    public editable function release() -> void:
+        this.public_address.release()
+
+
+function nat_error(code: int, msg: str) -> Error:
+    return Error(code = code, message = string.String.from_str(msg))
+
+
+public async function detect(
+    socket: net.UdpSocket,
+    primary_server: net.SocketAddress,
+    alternate_server: net.SocketAddress
+) -> Result[NatResult, Error]:
+    let primary_result = await stun.resolve_public_address(socket, primary_server)
+    match primary_result:
+        Result.failure:
+            return Result[NatResult, Error].failure(
+                error = nat_error(err_blocked, "UDP blocked or STUN unreachable")
+            )
+        Result.success as pr:
+            var public_1 = pr.value
+            defer public_1.release()
+
+            let local_result = socket.local_address()
+            match local_result:
+                Result.failure:
+                    return Result[NatResult, Error].failure(
+                        error = nat_error(err_bind, "failed to get local address")
+                    )
+                Result.success as lp:
+                    if public_1.public_address.equal(lp.value):
+                        return Result[NatResult, Error].success(
+                            value = NatResult(
+                                nat_type = NatType.open_internet,
+                                public_address = public_1.public_address
+                            )
+                        )
+
+                    let alt_result_output = await stun.resolve_public_address(socket, alternate_server)
+                    match alt_result_output:
+                        Result.failure:
+                            return Result[NatResult, Error].failure(
+                                error = nat_error(err_discover, "alternate STUN probe failed")
+                            )
+                        Result.success as ar:
+                            var public_2 = ar.value
+                            defer public_2.release()
+
+                            if not public_1.public_address.equal(public_2.public_address):
+                                return Result[NatResult, Error].success(
+                                    value = NatResult(
+                                        nat_type = NatType.symmetric,
+                                        public_address = public_1.public_address
+                                    )
+                                )
+
+                            return Result[NatResult, Error].success(
+                                value = NatResult(
+                                    nat_type = NatType.cone,
+                                    public_address = public_1.public_address
+                                )
+                            )
+
+
+public async function detect_default(
+    socket: net.UdpSocket
+) -> Result[NatResult, Error]:
+    let primary_result = net.ipv4(google_primary, google_port)
+    match primary_result:
+        Result.failure:
+            return Result[NatResult, Error].failure(
+                error = nat_error(err_resolve, "failed to resolve primary STUN server")
+            )
+        Result.success as pp:
+            var primary = pp.value
+            defer primary.release()
+
+            let alt_result = net.ipv4(google_alternate, google_port)
+            match alt_result:
+                Result.failure:
+                    return Result[NatResult, Error].failure(
+                        error = nat_error(err_resolve, "failed to resolve alternate STUN server")
+                    )
+                Result.success as ap:
+                    var alternate = ap.value
+                    defer alternate.release()
+
+                    return await detect(socket, primary, alternate)

data/std/net/packet.mt

@@ -0,0 +1,219 @@
+import std.async as aio
+import std.bytes as bytes
+import std.net as net
+import std.string as string
+import std.vec as vec
+
+const frame_header_bytes: ptr_uint = 4
+const discard_chunk_bytes: ptr_uint = 4096
+const max_frame_payload_bytes: ptr_uint = 0xFFFFFFFF
+
+public struct Error:
+    code: int
+    message: string.String
+
+public struct Stream:
+    stream: net.TcpStream
+    max_packet_bytes: ptr_uint
+
+public struct Listener:
+    listener: net.TcpListener
+    max_packet_bytes: ptr_uint
+
+
+function packet_error(code: int, message: str) -> Error:
+    return Error(code = code, message = string.String.from_str(message))
+
+
+function error_from_net(source: net.Error) -> Error:
+    return Error(code = source.code, message = source.message)
+
+
+function encode_packet_length(length: ptr_uint) -> array[ubyte, 4]:
+    let raw = uint<-length
+    return array[ubyte, 4](
+        ubyte<-((raw >> 24) & 255),
+        ubyte<-((raw >> 16) & 255),
+        ubyte<-((raw >> 8) & 255),
+        ubyte<-(raw & 255)
+    )
+
+
+function decode_packet_length(header: bytes.Bytes) -> ptr_uint:
+    if header.len != frame_header_bytes:
+        fatal(c"packet frame header length mismatch")
+
+    let header_span = header.as_span()
+    let length = ((uint<-header_span[0]) << 24) | ((uint<-header_span[1]) << 16) | ((uint<-header_span[2]) << 8) | (uint<-header_span[3])
+    return length
+
+
+function frame_bytes(content: span[ubyte]) -> bytes.Bytes:
+    var framed = vec.Vec[ubyte].with_capacity(frame_header_bytes + content.len)
+    defer framed.release()
+
+    let header = encode_packet_length(content.len)
+    framed.append_array(header)
+    framed.append_span(content)
+    return bytes.Bytes.copy(framed.as_span())
+
+
+async function discard_exactly(stream: net.TcpStream, byte_count: ptr_uint) -> Result[bool, Error]:
+    var remaining = byte_count
+    while remaining != 0:
+        var chunk_bytes = discard_chunk_bytes
+        if remaining < chunk_bytes:
+            chunk_bytes = remaining
+
+        let discard_result = await stream.read_exactly(chunk_bytes)
+        match discard_result:
+            Result.failure as payload:
+                return Result[bool, Error].failure(error = error_from_net(payload.error))
+            Result.success as payload:
+                var chunk = payload.value
+                chunk.release()
+                remaining -= chunk_bytes
+
+    return Result[bool, Error].success(value = true)
+
+
+public async function connect_on(
+    runtime: aio.Runtime,
+    address: net.SocketAddress,
+    max_packet_bytes: ptr_uint
+) -> Result[Stream, Error]:
+    let connect_result = await net.connect_on(runtime, address)
+    match connect_result:
+        Result.failure as payload:
+            return Result[Stream, Error].failure(error = error_from_net(payload.error))
+        Result.success as payload:
+            return Result[Stream, Error].success(value = wrap(payload.value, max_packet_bytes))
+
+
+public async function connect(address: net.SocketAddress, max_packet_bytes: ptr_uint) -> Result[Stream, Error]:
+    return await connect_on(aio.current_runtime(), address, max_packet_bytes)
+
+
+public function listen_on(
+    runtime: aio.Runtime,
+    address: net.SocketAddress,
+    backlog: int,
+    max_packet_bytes: ptr_uint
+) -> Result[Listener, Error]:
+    let listen_result = net.listen_on(runtime, address, backlog)
+    match listen_result:
+        Result.failure as payload:
+            return Result[Listener, Error].failure(error = error_from_net(payload.error))
+        Result.success as payload:
+            return Result[Listener, Error].success(value = Listener(
+                listener = payload.value,
+                max_packet_bytes = max_packet_bytes
+            ))
+
+
+public function listen(address: net.SocketAddress, backlog: int, max_packet_bytes: ptr_uint) -> Result[Listener, Error]:
+    return listen_on(aio.current_runtime(), address, backlog, max_packet_bytes)
+
+
+public function wrap(stream: net.TcpStream, max_packet_bytes: ptr_uint) -> Stream:
+    return Stream(stream = stream, max_packet_bytes = max_packet_bytes)
+
+
+extending Error:
+    public editable function release() -> void:
+        this.message.release()
+
+
+extending Stream:
+    public editable function release() -> void:
+        this.stream.release()
+
+
+    public function local_address() -> Result[net.SocketAddress, net.Error]:
+        return this.stream.local_address()
+
+
+    public function peer_address() -> Result[net.SocketAddress, net.Error]:
+        return this.stream.peer_address()
+
+
+    public function socket_fd() -> Result[int, net.Error]:
+        return this.stream.socket_fd()
+
+
+    public function max_packet_bytes() -> ptr_uint:
+        return this.max_packet_bytes
+
+
+    public function shutdown() -> Task[Result[bool, net.Error]]:
+        return this.stream.shutdown()
+
+
+    public async function write_packet(content: span[ubyte]) -> Result[ptr_uint, Error]:
+        if content.len > this.max_packet_bytes:
+            return Result[ptr_uint, Error].failure(error = packet_error(-2, "packet exceeds configured maximum"))
+
+        if content.len > max_frame_payload_bytes:
+            return Result[ptr_uint, Error].failure(error = packet_error(-3, "packet exceeds 32-bit frame limit"))
+
+        var framed = frame_bytes(content)
+        defer framed.release()
+
+        let write_result = await this.stream.write_bytes(framed.as_span())
+        match write_result:
+            Result.failure as error_payload:
+                return Result[ptr_uint, Error].failure(error = error_from_net(error_payload.error))
+            Result.success as write_payload:
+                unsafe: write_payload.value
+                return Result[ptr_uint, Error].success(value = content.len)
+
+
+    public async function read_packet() -> Result[bytes.Bytes, Error]:
+        let header_result = await this.stream.read_exactly(frame_header_bytes)
+        match header_result:
+            Result.failure as payload:
+                return Result[bytes.Bytes, Error].failure(error = error_from_net(payload.error))
+            Result.success as payload:
+                var header = payload.value
+                defer header.release()
+                let packet_length = decode_packet_length(header)
+                if packet_length > this.max_packet_bytes:
+                    let discard_result = await discard_exactly(this.stream, packet_length)
+                    match discard_result:
+                        Result.failure as discard_payload:
+                            return Result[bytes.Bytes, Error].failure(error = discard_payload.error)
+                        Result.success as discard_payload:
+                            unsafe: discard_payload.value
+                            return Result[bytes.Bytes, Error].failure(error = packet_error(
+                                -2,
+                                "packet exceeds configured maximum"
+                            ))
+
+                let payload_result = await this.stream.read_exactly(packet_length)
+                match payload_result:
+                    Result.failure as read_payload:
+                        return Result[bytes.Bytes, Error].failure(error = error_from_net(read_payload.error))
+                    Result.success as read_payload:
+                        return Result[bytes.Bytes, Error].success(value = read_payload.value)
+
+
+extending Listener:
+    public editable function release() -> void:
+        this.listener.release()
+
+
+    public function local_address() -> Result[net.SocketAddress, net.Error]:
+        return this.listener.local_address()
+
+
+    public function max_packet_bytes() -> ptr_uint:
+        return this.max_packet_bytes
+
+
+    public async function accept() -> Result[Stream, Error]:
+        let accept_result = await this.listener.accept()
+        match accept_result:
+            Result.failure as payload:
+                return Result[Stream, Error].failure(error = error_from_net(payload.error))
+            Result.success as payload:
+                return Result[Stream, Error].success(value = wrap(payload.value, this.max_packet_bytes))

data/std/net/punch.mt

@@ -0,0 +1,162 @@
+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 punch_magic: array[ubyte, 4] = array[ubyte, 4](0x4D, 0x54, 0x50, 0x43)
+
+const burst_count: uint = 3
+const burst_delay: ptr_uint = 20
+const timeout_frames: uint = 120
+
+const err_send_failed: int = -1
+const err_no_response: int = -2
+
+public enum CandidateKind: ubyte
+    local = 0
+    server_reflexive = 1
+
+public struct Candidate:
+    address: net.SocketAddress
+    kind: CandidateKind
+
+public struct PunchResult:
+    address: net.SocketAddress
+
+public struct Error:
+    code: int
+    message: string.String
+
+
+extending Error:
+    public editable function release() -> void:
+        this.message.release()
+
+
+extending Candidate:
+    public editable function release() -> void:
+        this.address.release()
+
+
+extending PunchResult:
+    public editable function release() -> void:
+        this.address.release()
+
+
+function punch_error(code: int, msg: str) -> Error:
+    return Error(code = code, message = string.String.from_str(msg))
+
+
+function matches_any_candidate(source: net.SocketAddress, candidates: vec.Vec[Candidate]) -> bool:
+    var i: ptr_uint = 0
+    while i < candidates.len:
+        let cand_ptr = candidates.get(i) else:
+            break
+        if source.equal(unsafe: read(cand_ptr).address):
+            return true
+        i += 1
+    return false
+
+
+public function build_punch_probe() -> bytes.Bytes:
+    var w = bin.Writer.with_capacity(4)
+    w.write_ubyte(punch_magic[0])
+    w.write_ubyte(punch_magic[1])
+    w.write_ubyte(punch_magic[2])
+    w.write_ubyte(punch_magic[3])
+    return w.finish()
+
+
+public function is_punch_probe(data: span[ubyte]) -> bool:
+    if data.len < 4z:
+        return false
+    return data[0] == punch_magic[0] and data[1] == punch_magic[1] and data[2] == punch_magic[2] and data[3] == punch_magic[3]
+
+
+function result_from_datagram(
+    datagram: net.UdpDatagram,
+    remote_candidates: vec.Vec[Candidate]
+) -> Option[PunchResult]:
+    if not is_punch_probe(datagram.data.as_span()):
+        return Option[PunchResult].none()
+    if not matches_any_candidate(datagram.source, remote_candidates):
+        return Option[PunchResult].none()
+    let addr_copy = datagram.source.copy()
+    match addr_copy:
+        Result.success as ac:
+            return Option[PunchResult].some(value = PunchResult(address = ac.value))
+        Result.failure:
+            pass
+    return Option[PunchResult].none()
+
+
+function poll_recv(
+    recv_task: Task[Result[net.UdpDatagram, net.Error]],
+    remote_candidates: vec.Vec[Candidate]
+) -> Option[PunchResult]:
+    if not aio.completed(recv_task):
+        return Option[PunchResult].none()
+    let recv_result = aio.result(recv_task)
+    match recv_result:
+        Result.failure:
+            return Option[PunchResult].none()
+        Result.success as dp:
+            var dg = dp.value
+            defer dg.data.release()
+            defer dg.source.release()
+            return result_from_datagram(dg, remote_candidates)
+
+
+public async function punch(
+    socket: net.UdpSocket,
+    remote_candidates: vec.Vec[Candidate]
+) -> Result[PunchResult, Error]:
+    var probe = build_punch_probe()
+    defer probe.release()
+    var recv_task = socket.recv_from(512)
+
+    var c: uint = 0
+    while c < burst_count:
+        var i: ptr_uint = 0
+        while i < remote_candidates.len:
+            let cand_ptr = remote_candidates.get(i) else:
+                break
+            let send_result = await socket.send_to(probe.as_span(), unsafe: read(cand_ptr).address)
+            match send_result:
+                Result.failure as sp:
+                    return Result[PunchResult, Error].failure(
+                        error = punch_error(err_send_failed, "burst send failed")
+                    )
+                Result.success:
+                    pass
+            i += 1
+
+        let opt = poll_recv(recv_task, remote_candidates)
+        match opt:
+            Option.some as rp:
+                return Result[PunchResult, Error].success(value = rp.value)
+            Option.none:
+                pass
+        recv_task = socket.recv_from(512)
+
+        if c < burst_count - 1:
+            await aio.sleep(burst_delay)
+        c += 1
+
+    var frame: uint = 0
+    while frame < timeout_frames:
+        let opt = poll_recv(recv_task, remote_candidates)
+        match opt:
+            Option.some as rp:
+                return Result[PunchResult, Error].success(value = rp.value)
+            Option.none:
+                pass
+        recv_task = socket.recv_from(512)
+        await aio.sleep(50)
+        frame += 1
+
+    return Result[PunchResult, Error].failure(
+        error = punch_error(err_no_response, "no punch response received")
+    )

data/std/net/rpc.mt

@@ -0,0 +1,119 @@
+import std.async as aio
+import std.binary as bin
+import std.bytes as bytes
+import std.net.mux as mux
+import std.string as string
+
+const header_bytes: ptr_uint = 4
+
+const err_send_failed: int = -1
+const err_timeout: int = -2
+const err_unexpected: int = -3
+
+public struct Error:
+    code: int
+    message: string.String
+
+
+extending Error:
+    public editable function release() -> void:
+        this.message.release()
+
+
+function rpc_error(code: int, msg: str) -> Error:
+    return Error(code = code, message = string.String.from_str(msg))
+
+
+public function build_call(request_id: uint, payload: span[ubyte]) -> bytes.Bytes:
+    var w = bin.Writer.with_capacity(header_bytes + payload.len)
+    w.write_uint(request_id)
+    var i: ptr_uint = 0
+    while i < payload.len:
+        w.write_ubyte(payload[i])
+        i += 1
+    return w.finish()
+
+
+public function build_reply(request_id: uint, payload: span[ubyte]) -> bytes.Bytes:
+    return build_call(request_id, payload)
+
+
+public function parse_request_id(data: span[ubyte]) -> Result[uint, Error]:
+    if data.len < header_bytes:
+        return Result[uint, Error].failure(error = rpc_error(err_unexpected, "rpc frame too small"))
+    var r = bin.reader(data)
+    return r.read_uint().map_error(proc(_: bin.Error) -> Error: rpc_error(err_unexpected, "malformed rpc frame"))
+
+
+public function payload_after_header(data: span[ubyte]) -> span[ubyte]:
+    if data.len <= header_bytes:
+        let empty = bytes.Bytes.empty()
+        let result = empty.as_span()
+        return result
+    unsafe:
+        return span[ubyte](data = data.data + header_bytes, len = data.len - header_bytes)
+
+
+public async function call_and_wait(
+    conn: ref[mux.MuxedConnection],
+    channel_id: ubyte,
+    call_type_id: ushort,
+    response_type_id: ushort,
+    request_id: uint,
+    payload: span[ubyte]
+) -> Result[bytes.Bytes, Error]:
+    var call_packet = build_call(request_id, payload)
+    defer call_packet.release()
+
+    let send_result = await conn.mux_send(channel_id, call_type_id, call_packet.as_span(), mux.flag_reliable)
+    match send_result:
+        Result.failure:
+            return Result[bytes.Bytes, Error].failure(error = rpc_error(err_send_failed, "rpc send failed"))
+        Result.success:
+            pass
+
+    var frame: uint = 0
+    while frame < 120:
+        let msg_opt = conn.try_recv()
+        match msg_opt:
+            Option.some as mp:
+                var msg = mp.value
+                defer msg.release()
+                if msg.type_id == response_type_id and msg.channel_id == channel_id:
+                    let id_result = parse_request_id(msg.payload.as_span())
+                    match id_result:
+                        Result.success as ip:
+                            if ip.value == request_id:
+                                let result_data = payload_after_header(msg.payload.as_span())
+                                var copy = bin.Writer.with_capacity(result_data.len)
+                                var i: ptr_uint = 0
+                                while i < result_data.len:
+                                    copy.write_ubyte(result_data[i])
+                                    i += 1
+                                return Result[bytes.Bytes, Error].success(value = copy.finish())
+                        Result.failure:
+                            pass
+            Option.none:
+                pass
+
+        await aio.sleep(16)
+        frame += 1
+
+    return Result[bytes.Bytes, Error].failure(error = rpc_error(err_timeout, "rpc call timed out"))
+
+
+public async function send_reply(
+    conn: ref[mux.MuxedConnection],
+    channel_id: ubyte,
+    response_type_id: ushort,
+    request_id: uint,
+    payload: span[ubyte]
+) -> Result[bool, Error]:
+    var reply_packet = build_reply(request_id, payload)
+    defer reply_packet.release()
+    let send_result = await conn.mux_send(channel_id, response_type_id, reply_packet.as_span(), mux.flag_reliable)
+    match send_result:
+        Result.failure:
+            return Result[bool, Error].failure(error = rpc_error(err_send_failed, "reply send failed"))
+        Result.success:
+            return Result[bool, Error].success(value = true)