proxied 1.1.0

Asynchronous client connector for proxies
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126

/*!
# `Proxied`
Asynchronous proxy TCP connector

Includes:
- No `unsafe` code
- SOCKS4/5 and HTTP(s) proxies support
- Single structure for both types of proxies
- [`TCPStream`](tokio::net::TcpStream)-like connection (see [`TCPConnection`])
- Password authentication

## How-to
Main entrypoint is [`Proxy`] structure.
It contains connection data about proxy like protocol, address port and credentials.
Additionally it supports IP refreshment link, although user is expected to manually request it.

To create a TCP connection, call [`Proxy::connect_tcp`]. After it is created, it can be used
just like regural TCP stream, as it implements [`AsyncRead`](tokio::io::AsyncRead) and [`AsyncWrite`](tokio::io::AsyncRead).
*/

/** Proxy protocol

Backend protocol of proxy server. Doesn't affect developer experience, except:
- SOCKS4/5 proxies are fully and always supported
- HTTP(s) proxy servers are expected to implement `CONNECT` method (see [RFC7232](https://datatracker.ietf.org/doc/html/rfc7231#section-4.3.6))
*/
#[derive(serde::Deserialize, serde::Serialize, Debug, Clone, PartialEq, Eq, Hash)]
pub enum ProxyKind {
    Socks5,
    Socks4,
    Http,
    Https,
}

/**
Proxy connection data

Support mobile proxies by including `refresh_link`, although `connect` method won't
automatically refresh proxy on each connect

 ## [`FromStr`] Format

 `<protocol>://(login:password)@ip:port`

 Credentials are optional.

 Example:
```rust
use std::str::FromStr;

let socks = "socks4://hello:world@127.0.0.1:1234";
let proxy = proxied::Proxy::from_str(socks).unwrap();
assert_eq!(&proxy.addr, "127.0.0.1");
```
*/
#[derive(serde::Deserialize, serde::Serialize, Debug, Clone, PartialEq, Eq, Hash)]
pub struct Proxy {
    pub kind: ProxyKind,
    pub addr: String,
    pub port: u16,
    pub creds: Option<(String, String)>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub refresh_url: Option<String>,
}

impl Proxy {
    pub fn is_dns_addr(&self) -> bool {
        self.addr.chars().any(char::is_alphabetic)
    }

    pub fn is_ip_addr(&self) -> bool {
        !self.is_dns_addr()
    }

    /// Create TCP tunnel through this proxy to the target
    pub async fn connect_tcp(&self, target: NetworkTarget) -> Result<TcpStream, ConnectError> {
        connect::connect(self, target).await
    }
}

#[cfg(feature = "reqwest")]
mod reqwest_helpers {
    use super::Proxy;
    pub trait ProxifyClient {
        fn proxify(self, client: reqwest::ClientBuilder) -> reqwest::ClientBuilder;
    }
    #[cfg(feature = "reqwest")]
    impl Into<reqwest::Proxy> for Proxy {
        fn into(self) -> reqwest::Proxy {
            let url = format!("{}://{}:{}", self.kind.to_string(), &self.addr, self.port);

            let mut proxy =
                reqwest::Proxy::all(url).expect("Structure provides fixed format, never crashed");

            if let Some((username, password)) = self.creds {
                proxy = proxy.basic_auth(&username, &password);
            }

            proxy
        }
    }

    impl ProxifyClient for Proxy {
        fn proxify(self, client: reqwest::ClientBuilder) -> reqwest::ClientBuilder {
            client.proxy(self.into())
        }
    }

    impl ProxifyClient for Option<Proxy> {
        fn proxify(self, client: reqwest::ClientBuilder) -> reqwest::ClientBuilder {
            match self {
                Some(proxy) => proxy.proxify(client),
                None => client,
            }
        }
    }
}
#[cfg(feature = "reqwest")]
pub use reqwest_helpers::*;

pub mod parse;

mod connect;

pub use connect::{ConnectError, NetworkTarget};
use tokio::net::TcpStream;