coreutiles 0.1.0

Core utils in Rust
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::{ToSocketAddrs, UdpSocket};
use std::{io::{self, stdin, stdout, Read, Write}, net::{IpAddr, SocketAddr, TcpListener, TcpStream}};

use clap::{ArgAction, Parser, Subcommand};

#[derive(Parser)]
#[command(version, about)]
#[command(propagate_version = true)]
pub struct Config {
    #[clap(long, short, action, action=ArgAction::SetFalse)]
    /// Use the TCP protocol
    tcp: bool,

    #[clap(long, short, action)]
    /// Use the UDP protocol
    udp: bool,

    #[command(subcommand)]
    command: Op,
}

#[derive(Subcommand)]
enum Op {
    /// Send command
    Send { host: String, port: u16 },
    /// Listen command
    Listen {
        /// Port to listen on
        port: u16,
    }
}

fn write_all(mut from: impl Read, mut to: impl Write) -> io::Result<usize> {
    let mut buf = [0_u8; 1024];
    let mut total = 0;
    while let Ok(n) = from.read(&mut buf) {
        if n == 0 { break; }
        total += n;
        to.write_all(&buf[0..n])?;
    }
    Ok(total)
}

fn tcp(conf: Config) -> crate::Result<()> {
    match conf.command {
        Op::Send { host, port } => {
            let stream = TcpStream::connect(format!("{}:{}",host,port))?;
            let stdin = stdin().lock();
            write_all(stdin, stream)?;
        }
        Op::Listen { port } => {
            let ip = IpAddr::V6([0_u8; 16].into());
            let socket = SocketAddr::new(ip, port);
            let stream = TcpListener::bind(socket)?;
            let mut stdout = stdout().lock();
            println!("Listening on {socket}");
            let stream = stream.incoming().next().unwrap()?;
            write_all(stream, &mut stdout)?;
        }
    }
    Ok(())
}

fn udp(conf: Config) -> crate::Result<()> {
    let mut buf = [0_u8; 65600];

    match conf.command {
        Op::Send { host, port } => {
            let stream = UdpSocket::bind("0.0.0.0:0")?;
            let target = format!("{}:{}",host,port).to_socket_addrs()?.next().unwrap();

            let mut stdin = stdin().lock();

            while let Ok(n) = stdin.read(&mut buf) {
                if n == 0 { break }
                let mut sent = 0;
                loop {
                    sent += stream.send_to(&buf[sent..n], target)?;
                    if sent == n { break }
                }
            }
        }
        Op::Listen { port } => {
            let ip = IpAddr::V6([0_u8; 16].into());
            let socket = SocketAddr::new(ip, port);
            let listener = UdpSocket::bind(socket)?;
            let mut stdout = stdout().lock();
            let (_,addr) = listener.peek_from(&mut buf)?;
            listener.connect(addr)?;
            while let Ok(n) = listener.recv(&mut buf) {
                if n == 0 { break }
                stdout.write_all(&buf[..n])?;
            }
        }
    }
    Ok(())
}

pub fn run() -> crate::Result<()> {
    let conf = Config::parse();

    if conf.udp {
        udp(conf)
    } else {
        tcp(conf)
    }
}