eggress-server 1.0.3

Connection handling and server orchestration for eggress
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

#[derive(Debug, thiserror::Error)]
pub enum SessionOpenError {
    #[error("connection timed out")]
    Timeout,
    #[error("connection refused")]
    Refused,
    #[error("network unreachable")]
    NetworkUnreachable,
    #[error("host unreachable")]
    HostUnreachable,
    #[error("DNS resolution failed")]
    Dns,
    #[error("upstream authentication failed")]
    UpstreamAuthentication,
    #[error("request rejected by policy")]
    PolicyDenied,
    #[error("no eligible upstream available (transient)")]
    UpstreamUnavailable,
    #[error("route failed at hop {hop}")]
    Hop {
        hop: usize,
        source: Box<SessionOpenError>,
    },
    #[error("other connection error: {0}")]
    Other(String),
}

impl From<eggress_core::ConnectError> for SessionOpenError {
    fn from(e: eggress_core::ConnectError) -> Self {
        match e {
            eggress_core::ConnectError::ConnectionRefused => SessionOpenError::Refused,
            eggress_core::ConnectError::Timeout => SessionOpenError::Timeout,
            eggress_core::ConnectError::DnsResolution(_) => SessionOpenError::Dns,
            eggress_core::ConnectError::TlsHandshake(_) => {
                SessionOpenError::Other("TLS handshake failed".into())
            }
            eggress_core::ConnectError::Io(io) => SessionOpenError::Other(io.to_string()),
            eggress_core::ConnectError::ReservedTarget(addr) => {
                SessionOpenError::Other(format!("reserved target: {addr}"))
            }
        }
    }
}

impl From<eggress_core::chain::ChainError> for SessionOpenError {
    fn from(e: eggress_core::chain::ChainError) -> Self {
        match e {
            eggress_core::chain::ChainError::ConnectFailed {
                hop_index, source, ..
            } => SessionOpenError::Hop {
                hop: hop_index,
                source: Box::new(SessionOpenError::from(source)),
            },
            eggress_core::chain::ChainError::HandshakeFailed {
                hop_index, source, ..
            } => SessionOpenError::Hop {
                hop: hop_index,
                source: Box::new(SessionOpenError::Other(source.to_string())),
            },
            eggress_core::chain::ChainError::EmptyChain => {
                SessionOpenError::Other("empty chain".into())
            }
            eggress_core::chain::ChainError::InvalidChain { reason } => {
                SessionOpenError::Other(format!("invalid chain: {reason}"))
            }
        }
    }
}

impl From<eggress_protocol_http::HttpError> for SessionOpenError {
    fn from(e: eggress_protocol_http::HttpError) -> Self {
        match e {
            eggress_protocol_http::HttpError::AuthRequired
            | eggress_protocol_http::HttpError::AuthFailed => {
                SessionOpenError::UpstreamAuthentication
            }
            eggress_protocol_http::HttpError::ConnectionRefused => SessionOpenError::Refused,
            eggress_protocol_http::HttpError::GatewayTimeout => SessionOpenError::Timeout,
            other => SessionOpenError::Other(other.to_string()),
        }
    }
}

impl From<eggress_protocol_socks::Socks5Error> for SessionOpenError {
    fn from(e: eggress_protocol_socks::Socks5Error) -> Self {
        match e {
            eggress_protocol_socks::Socks5Error::ConnectionRefused => SessionOpenError::Refused,
            eggress_protocol_socks::Socks5Error::AuthFailed => {
                SessionOpenError::UpstreamAuthentication
            }
            other => SessionOpenError::Other(other.to_string()),
        }
    }
}