crabterm 0.1.0

A terminal (UART) server and client
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
121
122
123
124
125
126
127
128
129
130
131
132

use crate::traits::{IoInstance, IoResult};
use log::{error, info};
use mio::net::{TcpListener, TcpStream};
use mio::{Interest, Poll, Token};
use std::io::{ErrorKind, Read, Result, Write};
use std::net::{IpAddr, Ipv4Addr, Shutdown, SocketAddr};

pub struct TcpServer {
    listener: TcpListener,
}

impl TcpServer {
    pub fn new(port: u16) -> Result<Self> {
        let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), port);
        let listener = TcpListener::bind(addr)?;

        Ok(TcpServer { listener })
    }

    pub fn register(&mut self, poll: &mut Poll, token: Token) -> Result<()> {
        poll.registry()
            .register(&mut self.listener, token, Interest::READABLE)
    }

    pub fn accept(&mut self) -> Option<Box<dyn IoInstance>> {
        match self.listener.accept() {
            Ok((stream, addr)) => {
                info!("{}: New client connected", addr);
                let client = TcpClient {
                    stream,
                    addr,
                    connected: true,
                };
                Some(Box::new(client))
            }

            Err(ref e) if e.kind() == ErrorKind::WouldBlock => None,

            Err(e) => {
                error!("Accept error: {}", e);
                None
            }
        }
    }
}

pub struct TcpClient {
    stream: TcpStream,
    addr: SocketAddr,
    connected: bool,
}

impl TcpClient {
    fn close(&mut self) {
        self.connected = false;
        if let Err(e) = self.stream.shutdown(Shutdown::Both) {
            error!("{}: Shutdown error: {}", self.addr, e);
        }
    }
}

impl IoInstance for TcpClient {
    fn connect(&mut self, poll: &mut Poll, token: Token) -> Result<()> {
        poll.registry()
            .register(&mut self.stream, token, Interest::READABLE)
            .map_err(|e| {
                error!("{}: Register error: {}", self.addr, e);
                e
            })
    }

    fn connected(&self) -> bool {
        self.connected
    }

    fn addr_as_string(&self) -> String {
        self.addr.to_string()
    }

    fn disconnect(&mut self, poll: &mut Poll) {
        self.close();

        if let Err(e) = poll.registry().deregister(&mut self.stream) {
            error!("{}: Deregister error: {}", self.addr, e);
        }
    }

    fn read(&mut self) -> Result<IoResult> {
        let mut tmp = [0u8; 1024];

        match self.stream.read(&mut tmp) {
            Ok(0) => Ok(IoResult::None),

            Ok(n) => Ok(IoResult::Data(tmp[..n].to_vec())),

            Err(ref e) if e.kind() == ErrorKind::WouldBlock => {
                // Not ready yet — ignore and wait for next event
                Ok(IoResult::None)
            }

            Err(e) => {
                info!("{}: Read error: {}", self.addr, e);
                self.close();
                Err(e)
            }
        }
    }

    fn write(&mut self, buf: &[u8]) -> Result<IoResult> {
        match self.stream.write(buf) {
            Ok(n) => Ok(IoResult::Data(buf[..n].to_vec())),
            Err(e) => {
                info!("{}: Write error: {}", self.addr, e);
                self.close();
                Err(e)
            }
        }
    }

    fn flush(&mut self) {
        if let Err(e) = self.stream.flush() {
            info!("{}: Flush error: {}", self.addr, e);
            self.close();
        }
    }
}

impl Drop for TcpClient {
    fn drop(&mut self) {
        info!("{}: dropped", self.addr);
    }
}