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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use std::net::SocketAddr;

use rhai::{Dynamic, Engine};

use super::http1::{
    Http1Client, IncomingRequest, IncomingResponse, OutgoingRequest, OutgoingResponse,
};
use super::reuser::{SimpleReuser, SimpleReuserListener};
use super::trivials3::{TriggerableEvent, TriggerableEventTrigger};
use super::types::DatagramSocketSlot;
use super::types::{
    ChannelReceiver, ChannelSender, DatagramRead, DatagramSocket, DatagramWrite, Handle, Hangup,
    Promise, Slot, StreamRead, StreamSocket, StreamWrite, Task,
};
use std::ffi::OsString;
use tokio::process::{Child, Command};

/// Register Rhai functions
pub fn register_functions(engine: &mut Engine) {
    super::trivials1::register(engine);
    super::trivials2::register(engine);
    super::trivials3::register(engine);
    super::reuser::register(engine);
    super::linemode::register(engine);
    super::lengthprefixed::register(engine);
    super::logoverlay::register(engine);
    super::copydata::register(engine);
    super::misc::register(engine);
    super::tcp::register(engine);
    super::udp::register(engine);
    super::udpserver::register(engine);
    super::fluff::register(engine);
    super::http1::register(engine);
    super::wsframer::register(engine);
    super::wswithpings::register(engine);
    #[cfg(feature = "ssl")]
    super::nativetls::register(engine);
    #[cfg(feature = "rustls")]
    super::rustls::register(engine);
    super::subprocess::register(engine);
    super::osstr::register(engine);
    #[cfg(unix)]
    super::unix1::register(engine);
    #[cfg(unix)]
    super::unix2::register(engine);
    super::mockbytestream::register(engine);
    super::registryconnectors::register(engine);
    super::file::register(engine);
    super::tee::register(engine);
    engine.register_fn("is_null", is_null);
}

#[macro_export]
macro_rules! all_types {
    ($x:ident) => {
        $x!(Task);
        $x!(Hangup);
        $x!(StreamRead);
        $x!(StreamWrite);
        $x!(StreamSocket);
        $x!(DatagramRead);
        $x!(DatagramWrite);
        $x!(DatagramSocket);
        $x!(SocketAddr);
        $x!(IncomingRequest);
        $x!(OutgoingResponse);
        $x!(OutgoingRequest);
        $x!(IncomingResponse);
        $x!(Http1Client);
        $x!(Command);
        $x!(Child);
        $x!(OsString);
        $x!(TriggerableEvent);
        $x!(TriggerableEventTrigger);
        $x!(SocketAddr);
        $x!(SimpleReuser);
        $x!(SimpleReuserListener);
        $x!(DatagramSocketSlot);
        $x!(Slot);
        $x!(Promise);
        $x!(ChannelReceiver);
        $x!(ChannelSender);
    };
}

/// Register most custom Rhai types.
pub fn register_types(engine: &mut Engine) {
    macro_rules! regtyp {
        ($t:ty) => {
            engine.register_type_with_name::<Handle<$t>>(stringify!($t));
        };
    }
    all_types!(regtyp);
}

//@ Check if given handle is null.
fn is_null(x: Dynamic) -> bool {
    macro_rules! check_for_type {
        ($t:ty) => {
            if let Some(x) = x.clone().try_cast::<Handle<$t>>() {
                return x.lock().unwrap().is_none();
            }
        };
    }
    crate::all_types!(check_for_type);

    false
}