shohei 2.4.1

Infrastructure diagnostics library: DNS, DNSSEC, TLS certificate inspection, email security, DNS propagation, and MCP-integrated AI agent support
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

//! IP information checker — ASN, geolocation, organization details.

use serde::{Deserialize, Serialize};
use crate::error::Result;

/// Check IP information including ASN, geolocation, and organization.
pub async fn check_ip_info(req: &IpInfoCheckRequest) -> Result<IpInfoCheckResult> {
    // Use ipinfo.io API (free, no API key required)
    let url = format!("https://ipinfo.io/{}/json", crate::api::helpers::percent_encode(&req.ip));

    let client = reqwest::Client::new();
    let response = client
        .get(&url)
        .timeout(std::time::Duration::from_secs(req.timeout_secs))
        .send()
        .await
        .map_err(|e| crate::error::ShoheError::Transport(format!("IP info request failed: {}", e)))?;

    if !response.status().is_success() {
        return Ok(IpInfoCheckResult {
            ip: req.ip.clone(),
            country: None,
            region: None,
            city: None,
            latitude: None,
            longitude: None,
            org: None,
            timezone: None,
            postal: None,
            hostname: None,
            error: Some(format!("API returned {}", response.status())),
        });
    }

    match response.json::<serde_json::Value>().await {
        Ok(data) => {
            Ok(IpInfoCheckResult {
                ip: req.ip.clone(),
                country: data.get("country").and_then(|v| v.as_str()).map(|s| s.to_string()),
                region: data.get("region").and_then(|v| v.as_str()).map(|s| s.to_string()),
                city: data.get("city").and_then(|v| v.as_str()).map(|s| s.to_string()),
                latitude: data.get("loc")
                    .and_then(|v| v.as_str())
                    .and_then(|loc| loc.split(',').next())
                    .and_then(|lat| lat.trim().parse::<f64>().ok()),
                longitude: data.get("loc")
                    .and_then(|v| v.as_str())
                    .and_then(|loc| loc.split(',').nth(1))
                    .and_then(|lon| lon.trim().parse::<f64>().ok()),
                org: data.get("org").and_then(|v| v.as_str()).map(|s| s.to_string()),
                timezone: data.get("timezone").and_then(|v| v.as_str()).map(|s| s.to_string()),
                postal: data.get("postal").and_then(|v| v.as_str()).map(|s| s.to_string()),
                hostname: data.get("hostname").and_then(|v| v.as_str()).map(|s| s.to_string()),
                error: None,
            })
        }
        Err(e) => {
            Ok(IpInfoCheckResult {
                ip: req.ip.clone(),
                country: None,
                region: None,
                city: None,
                latitude: None,
                longitude: None,
                org: None,
                timezone: None,
                postal: None,
                hostname: None,
                error: Some(format!("Failed to parse response: {}", e)),
            })
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IpInfoCheckRequest {
    /// IP address to check (IPv4 or IPv6)
    pub ip: String,
    #[serde(default = "default_timeout")]
    pub timeout_secs: u64,
}

fn default_timeout() -> u64 { 10 }

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IpInfoCheckResult {
    pub ip: String,
    /// ISO 3166-1 alpha-2 country code
    pub country: Option<String>,
    /// State/province name
    pub region: Option<String>,
    /// City name
    pub city: Option<String>,
    /// Latitude (from loc field)
    pub latitude: Option<f64>,
    /// Longitude (from loc field)
    pub longitude: Option<f64>,
    /// Organization / AS number + name (e.g., "AS15169 Google LLC")
    pub org: Option<String>,
    /// IANA timezone
    pub timezone: Option<String>,
    /// Postal code
    pub postal: Option<String>,
    /// Reverse DNS hostname
    pub hostname: Option<String>,
    pub error: Option<String>,
}