websocat 4.0.0-alpha1

Command-line client for web sockets, like netcat/curl/socat for ws://.
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
109
110
111
112
113
114
115
116
117
118
119
120

use crate::{cli::WebsocatArgs, scenario_executor::utils::ToNeutralAddress};

use super::{scenarioprinter::ScenarioPrinter, types::Endpoint, utils::IdentifierGenerator};

impl Endpoint {
    pub(super) fn begin_print_udp(
        &self,
        printer: &mut ScenarioPrinter,
        vars: &mut IdentifierGenerator,
        opts: &WebsocatArgs,
    ) -> anyhow::Result<String> {
        match self {
            Endpoint::UdpConnect(a) => {
                let varnam = vars.getnewvarname("udp");
                let maybetextmode = if opts.text { ", tag_as_text: true" } else { "" };
                printer.print_line(&format!(
                    "let {varnam} = udp_socket(#{{addr: \"{a}\"{maybetextmode}}});"
                ));
                Ok(varnam)
            }
            Endpoint::UdpBind(a) => {
                let varnam = vars.getnewvarname("udp");

                let mut udp_bind_redirect_to_last_seen_address =
                    opts.udp_bind_redirect_to_last_seen_address;
                let mut udp_bind_connect_to_first_seen_address =
                    opts.udp_bind_connect_to_first_seen_address;

                if opts.udp_bind_restrict_to_one_address && opts.udp_bind_target_addr.is_none() {
                    anyhow::bail!("It is meaningless to --udp-bind-restrict-to-one-address without also specifying --udp-bind-target-addr")
                }
                if opts.udp_bind_restrict_to_one_address
                    && (opts.udp_bind_connect_to_first_seen_address
                        || opts.udp_bind_redirect_to_last_seen_address)
                {
                    anyhow::bail!("It is meaningless to use --udp-bind-restrict-to-one-address with another option to react at new incoming addresses")
                }

                if opts.udp_bind_target_addr.is_none() {
                    udp_bind_connect_to_first_seen_address = true;
                }
                if udp_bind_connect_to_first_seen_address {
                    udp_bind_redirect_to_last_seen_address = true;
                }

                let toaddr = opts.udp_bind_target_addr.unwrap_or(a.to_neutral_address());

                let mut o = String::with_capacity(64);
                o.push_str(&format!("bind: \"{a}\","));
                o.push_str(&format!("addr: \"{toaddr}\","));
                o.push_str(&format!("sendto_mode: true,"));

                if !opts.udp_bind_restrict_to_one_address {
                    o.push_str(&format!("allow_other_addresses: true,"));
                }
                if udp_bind_redirect_to_last_seen_address {
                    o.push_str(&format!("redirect_to_last_seen_address: true,"));
                }
                if udp_bind_connect_to_first_seen_address {
                    o.push_str(&format!("connect_to_first_seen_address: true,"));
                }
                if opts.udp_bind_inhibit_send_errors {
                    o.push_str(&format!("inhibit_send_errors: true,"));
                }

                if opts.text {
                    o.push_str(&format!("tag_as_text: true,"));
                }

                printer.print_line(&format!("let {varnam} = udp_socket(#{{{o}}});"));
                Ok(varnam)
            }
            Endpoint::UdpServer(a) => {
                let varnam = vars.getnewvarname("udp");
                let fromaddr = vars.getnewvarname("from");

                let mut o = String::with_capacity(64);
                o.push_str(&format!("bind: \"{a}\","));
                if opts.udp_bind_inhibit_send_errors {
                    o.push_str(&format!("inhibit_send_errors: true,"));
                }
                if opts.text {
                    o.push_str(&format!("tag_as_text: true,"));
                }
                if opts.udp_server_backpressure {
                    o.push_str(&format!("backpressure: true,"));
                }
                if let Some(x) = opts.udp_server_timeout_ms {
                    o.push_str(&format!("timeout_ms: {x},"));
                }
                if let Some(x) = opts.udp_server_max_clients {
                    o.push_str(&format!("max_clients: {x},"));
                }
                if let Some(x) = opts.udp_server_buffer_size {
                    o.push_str(&format!("buffer_size: {x},"));
                }
                if let Some(x) = opts.udp_server_qlen {
                    o.push_str(&format!("qlen: {x},"));
                }

                printer.print_line(&format!("udp_server(#{{{o}}}, |{varnam}, {fromaddr}| {{",));
                printer.increase_indent();
                Ok(varnam)
            }
            _ => panic!(),
        }
    }

    pub(super) fn end_print_udp(&self, printer: &mut ScenarioPrinter) {
        match self {
            Endpoint::UdpConnect(_) => {}
            Endpoint::UdpBind(_) => (),
            Endpoint::UdpServer(_) => {
                printer.decrease_indent();
                printer.print_line("})");
            }
            _ => panic!(),
        }
    }
}