zeloxy 0.2.2

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

use serde::Deserialize;
use serde_json::Value;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

use crate::Proxy;

/// Структура информации об IP
#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
pub struct LookupInfo {
  pub ip: String,
  pub hostname: String,
  pub city: String,
  pub region: String,
  pub country: String,
  pub location: String,
  pub organization: String,
  pub postal: String,
  pub timezone: String,
}

/// Функция получения данных об IP адресе, используя `ipinfo.io`
pub async fn lookup_proxy(proxy: &Proxy) -> Option<LookupInfo> {
  let mut stream = match proxy.connect("ipinfo.io", 80).await {
    Ok(s) => s,
    Err(_) => return None,
  };

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

  let mut buf = Vec::new();
  let _ = stream.read_to_end(&mut buf).await;

  let data = match String::from_utf8(buf) {
    Ok(s) => s,
    Err(_) => String::new(),
  };

  let split_data = data.split("\n").collect::<Vec<&str>>();
  let mut pretty_data = String::new();

  for (i, item) in split_data.iter().enumerate() {
    if i < 7 {
      continue;
    }

    pretty_data.push_str(*item);
  }

  let raw: Value = match serde_json::from_str(&pretty_data) {
    Ok(info) => info,
    Err(_) => return None,
  };

  Some(LookupInfo {
    ip: raw["ip"].to_string(),
    hostname: raw["hostname"].to_string(),
    city: raw["city"].to_string(),
    region: raw["region"].to_string(),
    country: raw["country"].to_string(),
    location: raw["loc"].to_string(),
    organization: raw["org"].to_string(),
    postal: raw["postal"].to_string(),
    timezone: raw["timezone"].to_string(),
  })
}