socks5rs 0.3.1

Minimal, Low-Level and simple socks5 protocol implementation
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
109
110

#[repr(u8)]
#[non_exhaustive]
#[derive(Debug, Clone, Copy)]
/// Socks5 related errors that can be sent to client as Reply
pub enum Socks5ErrorKind {
    GeneralServerFailure = 0x01,
    ConnectionNotAllowed,
    NetworkUnreachable,
    HostUnreachable,
    ConnectionRefused,
    TTLExpired,
    CommandNotSupported,
    AddressTypeNotSupported,
}

impl Into<u8> for Socks5ErrorKind {
    fn into(self) -> u8 {
        self as u8
    }
}

impl ToString for Socks5ErrorKind {
    fn to_string(&self) -> String {
        let s: &'static str = match self {
            Socks5ErrorKind::GeneralServerFailure    => "general server failure",
            Socks5ErrorKind::ConnectionNotAllowed    => "connection not allowed",
            Socks5ErrorKind::NetworkUnreachable      => "network unreachable",
            Socks5ErrorKind::HostUnreachable         => "host unreachable",
            Socks5ErrorKind::ConnectionRefused       => "host unreachable",
            Socks5ErrorKind::TTLExpired              => "TTL expired",
            Socks5ErrorKind::CommandNotSupported     => "command not supported",
            Socks5ErrorKind::AddressTypeNotSupported => "address type not supported"
        };
        String::from(s)
    }
}

#[non_exhaustive]
#[derive(Debug, Clone, Copy)]
/// Errors that are related to parsing Socks5 requests
pub enum ParserErrorKind {
    /// Buffer is shorter than expected
    ShortBuffer,
    /// No authentication methods provided in first client request
    ZeroAuthMethods,
}

#[derive(Debug, Clone, Copy)]
/// Error representation. This enum captures IO, Socks5 and Parser related errors.
pub enum Repr {
    Socks5(Socks5ErrorKind),
    Parser(ParserErrorKind),
}

#[derive(Debug)]
pub struct Error {
    repr: Repr,
}

impl Error {
    pub const SHORT_BUFFER_ERROR: Error = Error {repr: Repr::Parser(ParserErrorKind::ShortBuffer)};

    /// Convert Error type to Socks5 reply byte
    pub fn to_socks5_reply(&self) -> u8 {
        match self.repr {
            Repr::Socks5(e) => e.into(),
            Repr::Parser(_) => Socks5ErrorKind::GeneralServerFailure as u8,
        }
    }
}

impl From<Socks5ErrorKind> for Error {
    fn from(value: Socks5ErrorKind) -> Self {
        Self { repr: Repr::Socks5(value) }
    }
}

impl From<ParserErrorKind> for Error {
    fn from(value: ParserErrorKind) -> Self {
        Self { repr: Repr::Parser(value) }
    }
}

impl<E> From<E> for Error
    where E: std::error::Error
{
    fn from(_: E) -> Self {
        Self { repr: Repr::Socks5(Socks5ErrorKind::GeneralServerFailure) }
    }
}

impl Into<u8> for Error {
    fn into(self) -> u8 {
        self.to_socks5_reply()
    }
}


impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.repr {
            Repr::Socks5(e) => write!(f, "{}", e.to_string()),
            Repr::Parser(e) => write!(f, "{e:?}"),
        }
    }
}

/// Socks5 result type to capture all kinds of errors that might be happen while
/// working with the protocol.
pub type Result<T> = std::result::Result<T, Error>;