zeloxy 0.2.0

A library for creating lightweight, asynchronous, and lag-free proxy connections.
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use tokio::net::TcpStream;

use crate::{ErrorKind, Proxy, ProxyError, ProxyResult};

/// Цепочка прокси.
///
/// ## Примеры
///
/// ```rust, ignore
/// use tokio::io::{AsyncReadExt, AsyncWriteExt};
/// use zeloxy::{Proxy, ProxyChain, ProxyResult};
///
/// #[tokio::main]
/// async fn main() -> ProxyResult<()> {
///   // Создаём список из 3 прокси
///   let proxies = vec![
///     Proxy::from("socks4://98.181.137.83:4145"),
///     Proxy::from("socks4://98.170.57.249:4145"),
///     Proxy::from("socks5://212.58.132.5:1080"),
///   ];
///
///   // Создаём цепочку прокси
///   let chain = ProxyChain::new().with_proxies(proxies);
///
///   // Подключаемся к целевому серверу через цепочку
///   let mut stream = chain.connect("ipinfo.io", 80).await?;
///
///   // Отправляем GET-запрос
///   stream.write_all(b"GET / HTTP/1.0\r\nHost: ipinfo.io\r\n\r\n").await?;
///
///   // Читаем ответ (в данном случае информация об IP)
///   let mut resp = Vec::new();
///   stream.read_to_end(&mut resp).await?;
///
///   // Логгируем выходной IP (здесь должно быть { "ip": "212.58.132.5:1080" })
///   println!("Выход: {}", String::from_utf8_lossy(&resp));
///
///   Ok(())
/// }
/// ```
///
/// Больше актуальных примеров: [смотреть](https://github.com/nullclyze/zeloxy/tree/main/examples)
pub struct ProxyChain {
  chain: Vec<Proxy>,
}

impl ProxyChain {
  /// Метод создания пустой цепочки прокси
  pub fn new() -> Self {
    Self { chain: Vec::new() }
  }

  /// Метод добавления прокси в цепочку
  pub fn add_proxy(&mut self, proxy: Proxy) {
    self.chain.push(proxy);
  }

  /// Метод добавления нескольких прокси в цепочку
  pub fn add_proxies(&mut self, proxies: Vec<Proxy>) {
    self.chain.extend(proxies);
  }

  /// Метод добавления прокси в цепочку (возвращает `Self`)
  pub fn with_proxy(mut self, proxy: Proxy) -> Self {
    self.chain.push(proxy);
    self
  }

  /// Метод добавления нескольких прокси в цепочку (возвращает `Self`)
  pub fn with_proxies(mut self, proxies: Vec<Proxy>) -> Self {
    self.chain.extend(proxies);
    self
  }

  /// Метод очистки цепочки прокси
  pub fn clear(&mut self) {
    self.chain.clear();
  }

  /// Метод получения цепочки прокси
  pub fn get_chain(&self) -> &Vec<Proxy> {
    &self.chain
  }

  /// Метод подключения к целевому серверу через цепочку прокси
  pub async fn connect(&self, target_host: impl Into<String>, target_port: u16) -> ProxyResult<TcpStream> {
    let first_proxy = &self.chain[0];
    let first_addr = first_proxy.get_address();

    let mut stream = TcpStream::connect(first_addr).await?;

    for proxy in &self.chain[1..] {
      let proxy_ip = proxy
        .get_ip()
        .ok_or(ProxyError::new(ErrorKind::InvalidData, "failed to obtain proxy IP address"))?;

      let proxy_port = proxy
        .get_port()
        .ok_or(ProxyError::new(ErrorKind::InvalidData, "failed to obtain proxy port"))?;

      stream = proxy.connect_with_stream(stream, proxy_ip, proxy_port).await?;
    }

    let last_proxy = &self.chain[self.chain.len() - 1];

    stream = last_proxy.connect_with_stream(stream, target_host, target_port).await?;

    Ok(stream)
  }
}

#[cfg(test)]
mod tests {
  use tokio::io::{AsyncReadExt, AsyncWriteExt};

  use crate::{Proxy, ProxyChain, ProxyResult};

  #[tokio::test]
  async fn test_mini_chain() -> ProxyResult<()> {
    let proxies = vec![
      Proxy::from("socks4://98.181.137.83:4145"),
      Proxy::from("socks4://98.170.57.249:4145"),
      Proxy::from("socks5://212.58.132.5:1080"),
      // Proxy::from("socks4://68.71.242.118:4145"),
    ];

    let chain = ProxyChain::new().with_proxies(proxies);

    let mut stream = chain.connect("ipinfo.io", 80).await?;

    stream.write_all(b"GET / HTTP/1.0\r\nHost: ipinfo.io\r\n\r\n").await?;

    let mut resp = Vec::new();
    stream.read_to_end(&mut resp).await?;

    println!("{}", String::from_utf8_lossy(&resp));

    Ok(())
  }
}