zssh 0.2.0

Minimal SSH server for embedded applications.
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

use crate::wire::DisconnectReason;

use embedded_io_async::ReadExactError;

/// Set of possible protocol errors.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ProtocolError {
    /// The packet buffer was too small to hold a packet.
    BufferExhausted,
    /// The client sent an invalid identification string.
    BadIdentificationString,
    /// A string was not supplied in the required encoding.
    BadStringEncoding,
    /// A name list was found to contain an invalid name.
    BadNameList,
    /// A string had a length different than was expected.
    BadStringLength,
    /// There were some bytes left after object decoding.
    TrailingPayload,
    /// A malformed client packet was seen by the server.
    MalformedPacket,
    /// The channel's window overflowed during transfer.
    WindowOverflow,
}

impl From<core::str::Utf8Error> for ProtocolError {
    fn from(_: core::str::Utf8Error) -> Self {
        Self::BadStringEncoding
    }
}

/// Set of possible transport errors.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Error<E> {
    /// The transport's stream reached EOF unexpectedly.
    UnexpectedEof,
    /// The transport's stream encountered an I/O error.
    IO(E),
    /// The transport encountered a fatal protocol error.
    Protocol(ProtocolError),
    /// The server ended communication by disconnecting.
    ServerDisconnect(DisconnectReason),
    /// The client ended communication by disconnecting.
    ClientDisconnect(DisconnectReason),
}

impl<E: embedded_io_async::Error> From<E> for Error<E> {
    fn from(value: E) -> Self {
        Self::IO(value)
    }
}

impl<E> From<ProtocolError> for Error<E> {
    fn from(value: ProtocolError) -> Self {
        Self::Protocol(value)
    }
}

impl<E: embedded_io_async::Error> From<ReadExactError<E>> for Error<E> {
    fn from(value: ReadExactError<E>) -> Self {
        match value {
            ReadExactError::UnexpectedEof => Self::UnexpectedEof,
            ReadExactError::Other(other_err) => other_err.into(),
        }
    }
}