Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-std

Source of release 0.7.3

0.7.3 / tests / net_protocols / main.lucb

import c
import collections
import files
import io
import memory
import net
import strings
import utf8

struct CappedWriter: io.Writer:
    var sink: io.SliceWriter

    pub func write(data: const u8[]) -> usize!:
        let size: usize = data.length if data.length < 3 else 3
        return try self.sink.write(data[..<size])

func request_rejected(text: str):
    var fields: net.HttpField[100]
    var rejected = false
    _ = net.http_parse_request(text.bytes, fields) catch problem:
        rejected = true
        recover net.HttpHead()
    assert(rejected)

func test_http() -> !:
    var fields: net.HttpField[100]
    let wire = (str)(b"POST /data?q=1 HTTP/1.1\r\nHost: example.test\r\nContent-Length: 5, 05\r\nContent-Length: 5\r\nConnection: keep-alive, close\r\nX-Raw: \xff\r\n\r\n")
    let head = try net.http_parse_request(wire.bytes, fields)
    assert(head.body_kind == net.HttpBodyKind.fixed and head.body_length == 5)
    assert(not head.keep_alive and head.field_count("CONTENT-LENGTH") == 2)
    assert((head.field("x-raw") else "").bytes[0] == 255)
    for length in 0..<wire.length:
        assert(net.http_head_end(wire.bytes[..<length]) == none)
    assert(net.http_head_end(wire.bytes) == wire.length)
    let bad: str[14] = ["GET / HTTP/1.1\r\n\r\n", "GET / HTTP/1.1\r\nHost: a\r\nHost: b\r\n\r\n", "GET / HTTP/1.1\r\nHost: a\r\n folded: x\r\n\r\n", "GET / HTTP/1.1\r\nHost : a\r\n\r\n", "GET / HTTP/1.1\r\nHost: a\r\nContent-Length: -1\r\n\r\n", "GET / HTTP/1.1\r\nHost: a\r\nContent-Length: 1,2\r\n\r\n", "GET / HTTP/1.1\r\nHost: a\r\nContent-Length: 1\r\nTransfer-Encoding: chunked\r\n\r\n", "GET / HTTP/1.1\r\nHost: a\r\nTransfer-Encoding: chunked,chunked\r\n\r\n", "GET / HTTP/1.0\r\nTransfer-Encoding: chunked\r\n\r\n", "GET / HTTP/1.1\r\nHost: a\r\nContent-Length: 18446744073709551616\r\n\r\n", "GET / HTTP/1.1\r\nHost: a\r\nExpect: magic\r\n\r\n", "GET / HTTP/1.1\r\nHost: a\nX: b\r\n\r\n", "GET / HTTP/1.1\r\nHost: a\r\n\r\nx", "GET / HTTP/2.0\r\nHost: a\r\n\r\n"]
    for text in bad:
        request_rejected(text)
    let bad_targets: str[7] = ["GET * HTTP/1.1\r\nHost: a\r\n\r\n", "CONNECT [::1] HTTP/1.1\r\nHost: a\r\n\r\n", "GET /bad%2 HTTP/1.1\r\nHost: a\r\n\r\n", "GET relative HTTP/1.1\r\nHost: a\r\n\r\n", "GET / HTTP/1.1\r\nHost: [xyz]\r\n\r\n", "GET / HTTP/1.1\r\nHost: bad%GG\r\n\r\n", "CONNECT host: HTTP/1.1\r\nHost: a\r\n\r\n"]
    for text in bad_targets:
        request_rejected(text)
    _ = try net.http_parse_request("OPTIONS * HTTP/1.1\r\nHost: example.test\r\n\r\n".bytes, fields)
    _ = try net.http_parse_request("CONNECT [::1]:443 HTTP/1.1\r\nHost: [::1]:443\r\n\r\n".bytes, fields)
    _ = try net.http_parse_request("GET /caf%C3%A9 HTTP/1.1\r\nHost: [v1.future:address]\r\n\r\n".bytes, fields)
    let response = try net.http_parse_response("HTTP/1.1 200 OK\r\nContent-Length: 9999999999\r\n\r\n".bytes, fields, "HEAD")
    assert(response.body_kind == net.HttpBodyKind.empty)
    let tunnel = try net.http_parse_response("HTTP/1.1 200 OK\r\nContent-Length: wrong\r\n\r\n".bytes, fields, "CONNECT")
    assert(tunnel.body_kind == net.HttpBodyKind.tunnel)
    let eof = try net.http_parse_response("HTTP/1.1 200 OK\r\n\r\n".bytes, fields)
    assert(eof.body_kind == net.HttpBodyKind.until_eof and not eof.keep_alive)
    # 1xx, 204 and 304 responses have no body whatever framing fields they carry
    let bodiless: str[4] = ["HTTP/1.1 204 No Content\r\nContent-Length: 0\r\n\r\n", "HTTP/1.1 304 Not Modified\r\nContent-Length: 12\r\n\r\n", "HTTP/1.1 103 Early Hints\r\nContent-Length: 0\r\n\r\n", "HTTP/1.1 204 No Content\r\nTransfer-Encoding: chunked\r\n\r\n"]
    for text in bodiless:
        let empty = try net.http_parse_response(text.bytes, fields)
        assert(empty.body_kind == net.HttpBodyKind.empty and empty.keep_alive)
    var output: u8[4096]
    var outgoing: net.HttpField[1] = [net.HttpField(name = "Host", value = "example.test")]
    let encoded = try net.http_encode_head(output, net.HttpHead(method = "POST", target = "/", version = "HTTP/1.1", fields = outgoing, body_kind = net.HttpBodyKind.chunked, keep_alive = true))
    assert((try net.http_parse_request(encoded, fields)).body_kind == net.HttpBodyKind.chunked)
    let chunks = "3;name=\"a\\\"b\"\r\nabc\r\n2\r\nde\r\n0\r\nX-Checksum: test\r\n\r\nNEXT"
    for fragment in 1..=chunks.length:
        var decoder = try net.HttpBodyDecoder.create(net.HttpBodyKind.chunked, maximum = 5)
        var body: collections.Buffer
        defer body.destroy()
        var at: usize = 0
        var trailers: usize = 0
        while not decoder.finished():
            let end = at + fragment if at + fragment < chunks.length else chunks.length
            let step = try decoder.consume(chunks.bytes[at..<end])
            assert(step.consumed > 0)
            at += step.consumed
            _ = try body.write(step.body)
            if let trailer = step.trailer:
                assert(net.http_equal(trailer.name, "x-checksum") and trailer.value == "test")
                trailers += 1
        try decoder.finish()
        assert(body.text() == "abcde" and trailers == 1)
        assert((str)chunks.bytes[at..] == "NEXT")
    var fixed = try net.HttpBodyDecoder.create(net.HttpBodyKind.fixed, 2)
    assert((try fixed.consume("abc".bytes)).consumed == 2 and fixed.finished())
    var premature = try net.HttpBodyDecoder.create(net.HttpBodyKind.fixed, 2)
    _ = try premature.consume("a".bytes)
    var incomplete = false
    premature.finish() catch problem:
        assert(problem.code == io.unexpected_eof)
        incomplete = true
    assert(incomplete)
    let malformed: str[10] = ["x\r\n", "1\r\naX", "0\r\nHost: x\r\n\r\n", "1 \r\n", "1;\r\n", "1; a=\"unterminated\r\n", "10000000000000000\r\n", "0\r\n folded: x\r\n\r\n", "6\r\n", "1\na"]
    for text in malformed:
        var decoder = try net.HttpBodyDecoder.create(net.HttpBodyKind.chunked, maximum = 5)
        var at: usize = 0
        var refused = false
        while at < text.length and not refused:
            let step = decoder.consume(text.bytes[at..]) catch problem:
                refused = true
                recover net.HttpBodyStep(consumed = text.length - at)
            at += step.consumed
        assert(refused)
        assert(not decoder.finished())
    var writer = io.SliceWriter.over(output)
    try net.http_write_chunk(&writer, "abc".bytes)
    try net.http_write_chunk(&writer, "".bytes)
    try net.http_end_chunks(&writer)
    assert((str)writer.written() == "3\r\nabc\r\n0\r\n\r\n")
    var capped = CappedWriter(sink = io.SliceWriter.over(output))
    var body_writer = try net.HttpBodyWriter.over(&capped, net.HttpBodyKind.fixed, 6)
    assert((try body_writer.write("abcdef".bytes)) == 6)
    try body_writer.finish()
    assert((str)capped.sink.written() == "abcdef")
    var too_short = try net.HttpBodyWriter.over(&capped, net.HttpBodyKind.fixed, 2)
    var refused_length = false
    too_short.finish() catch problem:
        assert(problem.code == io.unexpected_eof)
        refused_length = true
    assert(refused_length)
    print("ok HTTP heads, framing, every fragment size, limits and EOF")

func test_websocket() -> !:
    var accept: u8[28]
    assert((try net.websocket_accept_key("dGhlIHNhbXBsZSBub25jZQ==", accept)) == "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=")
    var request: u8[1024]
    var response: u8[1024]
    var fields: net.HttpField[100]
    var response_fields: net.HttpField[100]
    let key = "dGhlIHNhbXBsZSBub25jZQ=="
    let outgoing = try net.websocket_encode_request(request, "example.test", "/chat", key, "chat, binary")
    let head = try net.http_parse_request(outgoing, fields)
    assert((try net.websocket_check_request(head)) == key)
    let incoming = try net.websocket_encode_response(response, head, "chat")
    let answer = try net.http_parse_response(incoming, response_fields)
    assert((try net.websocket_check_response(answer, key, "chat, binary")) == "chat")
    var nonce: u8[24]
    let fresh = try net.websocket_client_key(nonce)
    _ = try net.websocket_accept_key(fresh, accept)
    var protocol_output: u8[1024]
    var duplicate = false
    _ = net.websocket_encode_request(protocol_output, "example.test", "/", key, "chat, chat") catch problem:
        assert(problem.code == net.websocket_invalid)
        duplicate = true
        recover "".bytes
    assert(duplicate)
    _ = try net.websocket_encode_request(protocol_output, "example.test", "/", key, "chat, Chat")
    var repeated = head
    fields[head.fields.length] = net.HttpField(name = "Sec-WebSocket-Protocol", value = "chat")
    repeated.fields = fields[..<head.fields.length + 1]
    duplicate = false
    _ = net.websocket_check_request(repeated) catch problem:
        duplicate = true
        recover ""
    assert(duplicate)
    # an empty list element is ignored (RFC 9110 section 5.6.1.2)
    _ = try net.websocket_encode_request(protocol_output, "example.test", "/", key, "chat,,binary")
    # a control frame the peer had queued may follow its close (RFC 6455 section 5.5.1)
    var late: u8[64]
    var late_sink = io.SliceWriter.over(late)
    var late_encoder = net.WebSocketEncoder.create(true)
    try late_encoder.write(&late_sink, net.WebSocketOpcode.close, b"\x03\xe8")
    try late_encoder.write(&late_sink, net.WebSocketOpcode.pong, "".bytes)
    var late_decoder = net.WebSocketDecoder.create(true)
    var late_output: u8[8]
    var late_at: usize = 0
    while late_at < late_sink.written().length:
        let late_step = try late_decoder.consume(late_sink.written()[late_at..], late_output)
        late_at += late_step.consumed
    # RFC 6455 section 5.7's masked Hello frame is independent of our encoder.
    let example = b"\x81\x85\x37\xfa\x21\x3d\x7f\x9f\x4d\x51\x58"
    var example_decoder = net.WebSocketDecoder.create(true)
    var example_output: u8[5]
    let example_step = try example_decoder.consume(example, example_output)
    assert(example_step.consumed == example.length and example_step.message_end and (str)example_output == "Hello")
    var abnormal = false
    example_decoder.finish() catch problem:
        assert(problem.code == io.unexpected_eof)
        abnormal = true
    assert(abnormal)
    var wire: u8[4096]
    var sink = io.SliceWriter.over(wire)
    var encoder = net.WebSocketEncoder.create(true)
    # The euro sign's UTF-8 sequence straddles frames, with a ping between them.
    try encoder.write(&sink, net.WebSocketOpcode.text, b"\xe2", false)
    try encoder.write(&sink, net.WebSocketOpcode.ping, "ping".bytes)
    try encoder.write(&sink, net.WebSocketOpcode.continuation, b"\x82\xac!")
    try encoder.write(&sink, net.WebSocketOpcode.close, b"\x03\xe8bye")
    for fragment in 1..=sink.written().length:
        var decoder = net.WebSocketDecoder.create(true)
        var output: u8[2]
        var at: usize = 0
        var body: collections.Buffer
        defer body.destroy()
        var frames: usize = 0
        var messages: usize = 0
        while at < sink.written().length:
            let end = at + fragment if at + fragment < sink.written().length else sink.written().length
            let step = try decoder.consume(sink.written()[at..<end], output)
            assert(step.consumed > 0)
            at += step.consumed
            if (u8)step.opcode < 8:
                _ = try body.write(output[..<step.written])
            if step.frame_end:
                frames += 1
            if step.message_end:
                messages += 1
        try decoder.finish()
        assert(body.text() == "€!" and frames == 4 and messages == 1)
    let bad: str[10] = [(str)(b"\xc1\x00"), (str)(b"\x83\x00"), (str)(b"\x81\x80\x00\x00\x00\x00"), (str)(b"\x89\x7e\x00\x7e"), (str)(b"\x09\x00"), (str)(b"\x82\x7e\x00\x01"), (str)(b"\x82\x7f\x80\x00\x00\x00\x00\x00\x00\x00"), (str)(b"\x80\x00"), (str)(b"\x81\x01\xff"), (str)(b"\x88\x01x")]
    for text in bad:
        var decoder = net.WebSocketDecoder.create(false)
        var output: u8[128]
        var refused = false
        _ = decoder.consume(text.bytes, output) catch problem:
            refused = true
            recover net.WebSocketStep()
        assert(refused)
        var latched = false
        _ = decoder.consume("".bytes, output) catch problem:
            latched = true
            recover net.WebSocketStep()
        assert(latched)
    # A failed writer must not attempt a second frame on the same stream.
    var tiny: u8[1]
    var short_sink = io.SliceWriter.over(tiny)
    var short_encoder = net.WebSocketEncoder.create(false)
    var failed = false
    short_encoder.write(&short_sink, net.WebSocketOpcode.binary, "abc".bytes) catch problem:
        failed = true
    assert(failed)
    let lengths: usize[4] = [125, 126, 65535, 65536]
    for size in lengths:
        let payload = try new u8[size] ---
        defer free(payload)
        memory.set(payload, 97)
        let encoded_storage = try new u8[size + 14] ---
        defer free(encoded_storage)
        var capped = CappedWriter(sink = io.SliceWriter.over(encoded_storage))
        var boundary_encoder = net.WebSocketEncoder.create(true)
        try boundary_encoder.write(&capped, net.WebSocketOpcode.binary, payload)
        let encoded = capped.sink.written()
        let frame = try net.websocket_parse_frame(encoded, true) else trap("missing complete frame")
        assert(frame.length == (u64)size and frame.header_bytes == encoded.length - size)
        var boundary_decoder = net.WebSocketDecoder.create(true)
        var output: u8[127]
        var at: usize = 0
        var received: usize = 0
        var ended = false
        while at < encoded.length:
            let step = try boundary_decoder.consume(encoded[at..], output)
            assert(step.consumed > 0)
            at += step.consumed
            received += step.written
            for byte in output[..<step.written]:
                assert(byte == 97)
            ended = step.message_end
        assert(received == size and ended)
    print("ok WebSocket handshake, masking, fragmented UTF-8, control frames and errors")

## Arbitrary wire bytes must yield bounded progress or a normal error, never a
## trap. A fixed seed makes every failing input reproducible on both backends.
func test_mutations() -> !:
    var seed: u64 = 81985529216486895
    var fields: net.HttpField[16]
    var input: u8[256]
    var output: u8[31]
    for iteration in 0..<10000:
        seed = seed *% 6364136223846793005 +% 1442695040888963407
        let size = (usize)(seed % 256)
        for index in 0..<size:
            seed = seed *% 6364136223846793005 +% 1442695040888963407
            input[index] = (u8)(seed >> 32)
        _ = net.http_parse_request(input[..<size], fields) catch problem:
            recover net.HttpHead()
        _ = net.http_parse_response(input[..<size], fields) catch problem:
            recover net.HttpHead()
        var body = try net.HttpBodyDecoder.create(net.HttpBodyKind.chunked, maximum = 1024)
        var frames = net.WebSocketDecoder.create(iteration % 2 == 0, 1024, 1024)
        var at: usize = 0
        while at < size:
            let step = body.consume(input[at..<size]) catch problem:
                break
            assert(step.consumed <= size - at)
            if step.finished:
                break
            assert(step.consumed > 0)
            at += step.consumed
        at = 0
        while at < size:
            let step = frames.consume(input[at..<size], output) catch problem:
                break
            assert(step.consumed > 0 and step.consumed <= size - at and step.written <= output.length)
            at += step.consumed
    print("ok 10000 deterministic malformed-input cases")

pub func main(arguments: c.str[]) -> i32!:
    if arguments.length == 4 and (str)arguments[1] == "frame-file":
        let payload_file = try files.read(arguments[3])
        defer payload_file.release()
        let payload = payload_file.value
        var encoder = net.WebSocketEncoder.create((str)arguments[2] == "client")
        try encoder.write(io.stdout(), net.WebSocketOpcode.binary, payload)
        return 0
    if arguments.length == 4 and (str)arguments[1] == "frame":
        var encoder = net.WebSocketEncoder.create((str)arguments[2] == "client")
        try encoder.write(io.stdout(), net.WebSocketOpcode.binary, ((str)arguments[3]).bytes)
        return 0
    if arguments.length == 3 and (str)arguments[1] == "accept":
        var output: u8[28]
        print(try net.websocket_accept_key((str)arguments[2], output))
        return 0
    with memory.heap:
        try test_http()
        try test_websocket()
        try test_mutations()
    return 0