websocat 4.0.0-alpha3

Command-line client for web sockets, like netcat/curl/socat for ws://.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use rhai::Engine;
use std::{
    sync::{Arc, Mutex},
    task::Poll,
};

use crate::scenario_executor::{
    types::{
        BufferFlag, BufferFlags, DatagramRead, DatagramWrite, Handle, PacketRead, PacketWrite,
    },
    utils1::HandleExt,
};

use super::types::PacketReadResult;

struct TrivialPkts {
    n: u8,
}

impl PacketRead for TrivialPkts {
    fn poll_read(
        mut self: std::pin::Pin<&mut Self>,
        _cx: &mut std::task::Context<'_>,
        buf: &mut [u8],
    ) -> Poll<std::io::Result<PacketReadResult>> {
        let mut this = self.as_mut();
        if this.n == 0 {
            Poll::Ready(Ok(PacketReadResult {
                flags: BufferFlag::Eof.into(),
                buffer_subset: 0..0,
            }))
        } else {
            let msg = format!("{}", this.n);
            let msg = msg.as_bytes();
            let l = msg.len();
            buf[..l].copy_from_slice(msg);
            this.n -= 1;
            Poll::Ready(Ok(PacketReadResult {
                flags: BufferFlag::Text.into(),
                buffer_subset: 0..l,
            }))
        }
    }
}

//@ Sample source of packets for demonstration purposes
fn trivial_pkts() -> Handle<DatagramRead> {
    Some(DatagramRead {
        src: Box::pin(TrivialPkts { n: 3 }),
    })
    .wrap()
}

struct DisplayPkts {}

impl PacketWrite for DisplayPkts {
    fn poll_write(
        self: std::pin::Pin<&mut Self>,
        _cx: &mut std::task::Context<'_>,
        buf: &mut [u8],
        flags: BufferFlags,
    ) -> Poll<std::io::Result<()>> {
        eprint!("P len={}", buf.len());
        if flags.contains(BufferFlag::Text) {
            eprint!(" [T]");
        }
        if flags.contains(BufferFlag::Eof) {
            eprint!(" [E]");
        }
        if flags.contains(BufferFlag::Ping) {
            eprint!(" [Pi]");
        }
        if flags.contains(BufferFlag::Pong) {
            eprint!(" [Po]");
        }
        if flags.contains(BufferFlag::NonFinalChunk) {
            eprint!(" [C]");
        }
        eprintln!();
        Poll::Ready(Ok(()))
    }
}

//@ Sample sink for packets for demonstration purposes
fn display_pkts() -> Handle<DatagramWrite> {
    let snk = Box::pin(DisplayPkts {});
    Arc::new(Mutex::new(Some(DatagramWrite { snk })))
}

pub fn register(engine: &mut Engine) {
    engine.register_fn("trivial_pkts", trivial_pkts);
    engine.register_fn("display_pkts", display_pkts);
}