websocket

import websocket from "websocket";
import io from "io";

var s: websocket.Socket = websocket.connect("wss://echo.example/chat", websocket.options()) or {
    io.eprintln("connect failed: {err.desc()}");
    return 1;
};
defer s.free();
s.send_text("hello") or { return 1; };
let m: websocket.Message = s.recv() or { return 1; };
io.println("got {m.kind.desc()}: {m.data}");
s.close(1000, "bye") or { return 1; };

pub enum Kind : u8 { Text = 1; Binary = 2; Close = 8; Ping = 9; Pong = 10; }   // k.desc() is "text", ...
pub struct Message {
    kind: Kind;
    data: []const u8;   // the payload; a Close's reason
    code: u16;          // a Close's status code
}

let m: websocket.Message = s.recv() or { return 1; };
let kept: string = str.from_view(m.data);

pub struct Options {
    protocols: []const []const u8 = [];     // subprotocols to offer, preferred first
    headers: []const http.Field = [];       // more request headers: Origin, Authorization, Cookie, ...
    deflate: bool = false;                  // offer permessage-deflate
    max_message: i64 = 16777216;            // the largest message accepted, bytes
    max_head: i64 = 16384;                  // the largest handshake response head, bytes
    auto_pong: bool = true;                 // answer Pings yourself when false
    connect_timeout: ?time.Duration = null; // options() sets 30 s
    io_timeout: ?time.Duration = null;      // each wait of recv and of a send; null: none
    trust: ?*const x509.TrustStore = null;  // wss: null is tape's bundled roots
}

var o: websocket.Options = websocket.options();
o.protocols = ["chat.v2", "chat.v1"];
o.headers = [http.Field { name: "Authorization"; value: "Bearer abc123"; }];
o.deflate = true;
var s: websocket.Socket = websocket.connect("ws://127.0.0.1:9000/lobby?room=3", o) or {
    io.eprintln("{err.desc()}");
    return 1;
};
defer s.free();
if (s.protocol() != null) { io.println("speaking {s.protocol()!}"); }
if (s.compressed()) { io.println("compressed"); }

let u: http.Url = websocket.parse_url("wss://[::1]:9443/feed?id=7") or { return 1; };
io.println("{u.scheme} {u.host} {u.port} {u.target}");   // wss ::1 9443 /feed?id=7

var s: websocket.Socket = websocket.start_connect("ws://game.example:7000/play", websocket.options()) or { return 1; };
defer s.free();
var clock: time.FrameClock = time.frame_clock(time.from_hz(60.0));
while (s.phase() != websocket.Phase.Closed) {
    while (true) {
        let m: ?websocket.Message = s.poll() or {
            io.eprintln("connection failed: {err.desc()}");
            return 1;
        };
        if (m == null) { break; }
        if (m!.kind == websocket.Kind.Binary) { apply_snapshot(m!.data); }
        if (m!.kind == websocket.Kind.Close) { io.println("server closed: {m!.code}"); }
    }
    if (s.phase() == websocket.Phase.Open) {
        s.send_binary(encode_input()) or {};
    }
    clock.tick();
    while (clock.step()) { simulate(clock.dt()); }
    render(clock.alpha());
}

pub enum Phase : u8 {
    Connecting = 0;     // the opening handshake is under way
    Open = 1;           // messages both ways
    Closing = 2;        // you sent Close; the peer's has not come yet
    Closed = 3;         // both Closes, a failure, or the connection ended
}

var items: [2]net.PollItem = [a.poll_item(net.READABLE), b.poll_item(net.READABLE)];
if (!a.buffered() && !b.buffered()) { net.poll(items[0..2], time.millis(16)) or { return 1; }; }

while (true) {
    let m: ?websocket.Message = s.recv_for(time.millis(50)) or { return 1; };
    if (m == null) { do_housekeeping(); continue; }
    if (m!.kind == websocket.Kind.Close) { break; }
    handle(m!);
}

// a large file as one message in 64 KiB frames
var buf: [65536]u8;
while (true) {
    let n: i64 = f.read(buf[0..65536]) or { return 1; };
    s.send_part(websocket.Kind.Binary, buf[0..n], n == 0) or { return 1; };
    if (n == 0) { break; }
}

s.close(1000, "bye") or {};
while (true) {
    let m: websocket.Message = s.recv() or { break; };
    if (m.kind == websocket.Kind.Close) { break; }
}
s.free();

pub struct ServerOptions {
    protocols: []const []const u8 = [];     // ours, preferred first: the first the client offers is chosen
    protocol_required: bool = false;        // refuse a client that offers none of ours (400)
    origins: []const []const u8 = [];       // accepted Origin values (ignoring case); empty: any
    headers: []const http.Field = [];       // more headers on the 101 answer
    deflate: bool = false;                  // accept permessage-deflate when offered
    max_message: i64 = 16777216;
    max_head: i64 = 16384;                  // the largest request head, bytes
    auto_pong: bool = true;
    handshake_timeout: ?time.Duration = null;   // server_options() sets 10 s
    io_timeout: ?time.Duration = null;
}

var l: net.TcpListener = net.listen(net.any_v4(9000)) or { return 1; };
defer l.close();
var so: websocket.ServerOptions = websocket.server_options();
so.protocols = ["chat.v1"];
so.origins = ["https://game.example"];
while (true) {
    let a: net.Accepted = l.accept() or { continue; };
    var s: websocket.Socket = websocket.accept(a.stream, so) or {
        io.eprintln("refused: {err.desc()}");
        continue;
    };
    let ua: ?[]const u8 = s.header("User-Agent");
    if (ua != null) { io.println("{s.target()} from {ua!}"); }
    serve(&s);      // recv and send until the Close
    s.free();
}

let req: ?*const http.RequestHead = srv.request();
if (req != null && req!.upgrade && bytes.eq(req!.target, "/ws")) {
    let up: websocket.Upgrade = websocket.negotiate(req!, &opts) or {
        websocket.refuse(&srv, err, now);
        return;
    };
    up.respond(&srv, now);
    conn.ws = up.conn();
    // from here: the bytes srv.feed did not take, then everything the
    // socket receives, go to conn.ws.feed; conn.ws.output() goes out
}

pub enum Role : u8 { Client = 1; Server = 2; }
pub struct ConnOptions {
    max_message: i64 = 16777216;
    auto_pong: bool = true;
    deflate: ?Deflate = null;      // permessage-deflate, as the handshake agreed
}
pub struct Deflate {
    server_no_context_takeover: bool = false;
    client_no_context_takeover: bool = false;
    server_max_window_bits: i64 = 15;
    client_max_window_bits: i64 = 15;
}

var seed: [32]u8;
os.random_bytes(seed[0..32]) or { return 1; };
var c: websocket.Conn = websocket.conn(websocket.Role.Client, websocket.ConnOptions { }, seed[0..32]);
defer c.free();
c.send_text("hello");
transport_send(c.output());
c.advance_output(c.output().len);

let got: []const u8 = transport_receive();
var at: i64 = 0;
while (at < got.len) {
    let n: i64 = c.feed(got[at..got.len]) or { break; };   // our Close is in output()
    at = at + n;
    var m: ?websocket.Message = c.next();
    while (m != null) {
        io.println("{m!.kind.desc()}: {m!.data}");
        m = c.next();
    }
}
transport_send(c.output());     // Pongs, the answer to a Close
c.advance_output(c.output().len);

pub tagged WsError {
    Io { e: io.IoError; }              // the connection: refused, reset, timed out, NotConnected
    Tls { e: tls.TlsError; }           // wss: the certificate, the handshake, the records
    Http { e: http.ProtocolError; }    // the handshake's HTTP
    Refused { status: i64; }           // the server answered the upgrade with this status, not 101
    Handshake { e: HandshakeError; }
    Protocol { e: ProtocolError; }     // the peer broke the protocol; our Close went with its code
}

let s: websocket.Socket = websocket.connect(url, o) or {
    match (err) {
        websocket.WsError.Refused { status } => { io.eprintln("the server said {status}"); }
        websocket.WsError.Tls { e } => { io.eprintln("TLS: {e.desc()}"); }
        websocket.WsError.Io { e } => { io.eprintln("network: {e.desc()}"); }
        websocket.WsError.Http { e } => { io.eprintln("HTTP: {e.desc()}"); }
        websocket.WsError.Handshake { e } => { io.eprintln("handshake: {e.desc()}"); }
        websocket.WsError.Protocol { e } => { io.eprintln("protocol: {e.desc()}"); }
    }
    return 1;
};