actix-tls 3.6.1

TLS acceptor and connector services for Actix ecosystem
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
111
112

//! The [`Host`] trait.

/// An interface for types where host parts (hostname and port) can be derived.
///
/// The [WHATWG URL Standard] defines the terminology used for this trait and its methods.
///
/// ```plain
/// +------------------------+
/// |          host          |
/// +-----------------+------+
/// |    hostname     | port |
/// |                 |      |
/// | sub.example.com : 8080 |
/// +-----------------+------+
/// ```
///
/// [WHATWG URL Standard]: https://url.spec.whatwg.org/
pub trait Host: Unpin + 'static {
    /// Extract hostname.
    fn hostname(&self) -> &str;

    /// Extract optional port.
    fn port(&self) -> Option<u16> {
        None
    }
}

impl Host for String {
    fn hostname(&self) -> &str {
        split_host(self).0
    }

    fn port(&self) -> Option<u16> {
        split_host(self).1.and_then(|port| port.parse().ok())
    }
}

impl Host for &'static str {
    fn hostname(&self) -> &str {
        split_host(self).0
    }

    fn port(&self) -> Option<u16> {
        split_host(self).1.and_then(|port| port.parse().ok())
    }
}

fn split_host(host: &str) -> (&str, Option<&str>) {
    if host.starts_with('[') {
        if let Some(end) = host.find(']') {
            let (hostname, rest) = host.split_at(end + 1);

            if rest.is_empty() {
                return (hostname, None);
            }

            if let Some(port) = rest.strip_prefix(':') {
                return (hostname, Some(port));
            }
        }
    }

    match host.split_once(':') {
        Some((hostname, port)) => (hostname, Some(port)),
        None => (host, None),
    }
}

#[cfg(test)]
mod tests {
    use std::net::SocketAddr;

    use actix_service::Service as _;

    use super::*;
    use crate::connect::{ConnectInfo, Resolver};

    macro_rules! assert_connection_info_eq {
        ($req:expr, $hostname:expr, $port:expr) => {{
            assert_eq!($req.hostname(), $hostname);
            assert_eq!($req.port(), $port);
        }};
    }

    #[test]
    fn host_parsing() {
        assert_connection_info_eq!("example.com", "example.com", None);
        assert_connection_info_eq!("example.com:8080", "example.com", Some(8080));
        assert_connection_info_eq!("example.com:8080".to_owned(), "example.com", Some(8080));
        assert_connection_info_eq!("example:8080", "example", Some(8080));
        assert_connection_info_eq!("example.com:false", "example.com", None);
        assert_connection_info_eq!("example.com:false:false", "example.com", None);
    }

    #[test]
    fn bracketed_ipv6_hosts() {
        assert_connection_info_eq!("[::1]:8080", "[::1]", Some(8080));
        assert_connection_info_eq!("[::1]:8080".to_owned(), "[::1]", Some(8080));

        assert_connection_info_eq!("[::1]", "[::1]", None);
        assert_connection_info_eq!("[::1]".to_owned(), "[::1]", None);
    }

    #[actix_rt::test]
    async fn bracketed_ipv6_host_resolves_to_socket_address() {
        let request = ConnectInfo::new("[::1]:8080");
        let resolved = Resolver::default().service().call(request).await.unwrap();
        let expected = "[::1]:8080".parse::<SocketAddr>().unwrap();

        assert_eq!(resolved.addrs().collect::<Vec<_>>(), vec![expected]);
    }
}