rustpbx 0.4.2

A SIP PBX implementation in Rust
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

use axum::extract::{ConnectInfo, FromRequestParts};
use http::{HeaderMap, StatusCode, Uri, request::Parts};
use std::{
    fmt::{self, Formatter},
    net::{IpAddr, Ipv4Addr, SocketAddr},
};

pub struct ClientAddr {
    pub addr: SocketAddr,
    pub is_secure: bool,
}

impl ClientAddr {
    pub fn new(addr: SocketAddr) -> Self {
        ClientAddr {
            addr,
            is_secure: false,
        }
    }
    pub fn ip(&self) -> IpAddr {
        self.addr.ip()
    }

    pub fn from_http_parts(
        uri: &Uri,
        headers: &HeaderMap,
        connect_info: Option<SocketAddr>,
    ) -> Self {
        let is_secure = match uri.scheme_str() {
            Some("wss") | Some("https") => true,
            _ => headers
                .get("x-forwarded-proto")
                .is_some_and(|v| v == "https"),
        };

        let mut remote_addr = connect_info
            .unwrap_or_else(|| SocketAddr::from((IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 0)));

        for header in [
            "x-client-ip",
            "x-forwarded-for",
            "x-real-ip",
            "cf-connecting-ip",
        ] {
            if let Some(value) = headers.get(header)
                && let Ok(ip) = value.to_str()
            {
                let first_ip = ip.split(',').next().unwrap_or(ip).trim();
                if let Ok(parsed_ip) = first_ip.parse::<IpAddr>() {
                    remote_addr.set_ip(parsed_ip);
                }
                break;
            }
        }

        ClientAddr {
            addr: remote_addr,
            is_secure,
        }
    }
}

impl<S> FromRequestParts<S> for ClientAddr
where
    S: Send + Sync,
{
    type Rejection = StatusCode;

    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
        let connect_info = parts
            .extensions
            .get::<ConnectInfo<SocketAddr>>()
            .map(|ConnectInfo(addr)| *addr);

        Ok(ClientAddr::from_http_parts(
            &parts.uri,
            &parts.headers,
            connect_info,
        ))
    }
}

impl fmt::Display for ClientAddr {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.addr)
    }
}