ftr 0.7.0

A fast, parallel ICMP traceroute with ASN lookup, reverse DNS, and ISP detection
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
141
142
143

//! Extract ISP information from traceroute path
//!
//! This module provides functionality to extract ISP information directly
//! from the traceroute path, avoiding expensive external API calls.

use crate::traceroute::{is_cgnat, is_internal_ip, ClassifiedHopInfo, IspInfo};
use std::net::IpAddr;

/// Extract ISP information from the traceroute path
///
/// This function identifies the user's ISP by finding the first public IP
/// in the traceroute path and using its ASN information. This is much faster
/// than making external HTTP requests.
///
/// The logic is:
/// 1. Find the first hop with a public IP (not private, not CGNAT)
/// 2. Use that hop's ASN as the ISP
/// 3. Use that IP as the public IP (or close to it)
pub fn extract_isp_from_path(hops: &[ClassifiedHopInfo]) -> Option<IspInfo> {
    // Find the first hop with a public IP and ASN info
    for hop in hops {
        if let Some(addr) = hop.addr {
            if let IpAddr::V4(ipv4) = addr {
                // Skip private and CGNAT addresses
                if is_internal_ip(&ipv4) || is_cgnat(&ipv4) {
                    continue;
                }

                // This is a public IP - check if we have ASN info
                if let Some(ref asn_info) = hop.asn_info {
                    if asn_info.asn != 0 {
                        return Some(IspInfo {
                            public_ip: addr,
                            asn: asn_info.asn,
                            name: asn_info.name.clone(),
                            hostname: hop.hostname.clone(),
                        });
                    }
                }
            }
        }
    }

    None
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::traceroute::{AsnInfo, SegmentType};
    use std::net::Ipv4Addr;

    #[test]
    fn test_extract_isp_from_path() {
        let hops = vec![
            // LAN hop
            ClassifiedHopInfo {
                ttl: 1,
                segment: SegmentType::Lan,
                hostname: Some("router.local".to_string()),
                addr: Some(IpAddr::V4(Ipv4Addr::new(192, 168, 1, 1))),
                asn_info: None,
                rtt: None,
            },
            // ISP hop - this should be detected
            ClassifiedHopInfo {
                ttl: 2,
                segment: SegmentType::Isp,
                hostname: Some("gateway.isp.com".to_string()),
                addr: Some(IpAddr::V4(Ipv4Addr::new(203, 0, 113, 1))),
                asn_info: Some(AsnInfo {
                    asn: 12345,
                    prefix: "203.0.113.0/24".to_string(),
                    country_code: "US".to_string(),
                    registry: "ARIN".to_string(),
                    name: "TEST-ISP".to_string(),
                }),
                rtt: None,
            },
        ];

        let isp = extract_isp_from_path(&hops);
        assert!(isp.is_some());

        let isp = isp.unwrap();
        assert_eq!(isp.asn, 12345);
        assert_eq!(isp.name, "TEST-ISP");
        assert_eq!(isp.public_ip, IpAddr::V4(Ipv4Addr::new(203, 0, 113, 1)));
        assert_eq!(isp.hostname, Some("gateway.isp.com".to_string()));
    }

    #[test]
    fn test_skip_private_ips() {
        let hops = vec![
            // Private IP - should be skipped
            ClassifiedHopInfo {
                ttl: 1,
                segment: SegmentType::Lan,
                hostname: None,
                addr: Some(IpAddr::V4(Ipv4Addr::new(192, 168, 1, 1))),
                asn_info: None,
                rtt: None,
            },
            // CGNAT IP - should be skipped
            ClassifiedHopInfo {
                ttl: 2,
                segment: SegmentType::Isp,
                hostname: None,
                addr: Some(IpAddr::V4(Ipv4Addr::new(100, 64, 0, 1))),
                asn_info: Some(AsnInfo {
                    asn: 12345,
                    prefix: "100.64.0.0/10".to_string(),
                    country_code: "US".to_string(),
                    registry: "ARIN".to_string(),
                    name: "CGNAT-ISP".to_string(),
                }),
                rtt: None,
            },
            // Public IP - should be used
            ClassifiedHopInfo {
                ttl: 3,
                segment: SegmentType::Isp,
                hostname: None,
                addr: Some(IpAddr::V4(Ipv4Addr::new(8, 8, 8, 8))),
                asn_info: Some(AsnInfo {
                    asn: 15169,
                    prefix: "8.8.8.0/24".to_string(),
                    country_code: "US".to_string(),
                    registry: "ARIN".to_string(),
                    name: "GOOGLE".to_string(),
                }),
                rtt: None,
            },
        ];

        let isp = extract_isp_from_path(&hops);
        assert!(isp.is_some());

        let isp = isp.unwrap();
        assert_eq!(isp.asn, 15169);
        assert_eq!(isp.name, "GOOGLE");
    }
}