use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GeoLocation {
pub ip: String,
pub country_code: String,
pub country_name: String,
pub region: Option<String>,
pub city: Option<String>,
pub latitude: Option<f64>,
pub longitude: Option<f64>,
pub isp: Option<String>,
pub org: Option<String>,
}
impl Default for GeoLocation {
fn default() -> Self {
Self {
ip: String::new(),
country_code: "UNKNOWN".to_string(),
country_name: "Unknown".to_string(),
region: None,
city: None,
latitude: None,
longitude: None,
isp: None,
org: None,
}
}
}
#[async_trait::async_trait]
pub trait GeoLocationService: Send + Sync {
async fn get_location(&self, ip: &IpAddr) -> Result<GeoLocation>;
}
pub fn is_ip_in_cidr(ip: &IpAddr, cidr: &str) -> bool {
let (network_str, prefix_str) = match cidr.split_once('/') {
Some(pair) => pair,
None => return false,
};
let prefix_length = match prefix_str.parse::<u8>() {
Ok(p) => p,
Err(_) => {
log::warn!(
"Invalid CIDR prefix length in '{}', treating as non-match",
cidr
);
return false;
}
};
match (ip, network_str.parse::<IpAddr>()) {
(IpAddr::V4(ip_v4), Ok(IpAddr::V4(network_v4))) => {
is_ipv4_in_cidr(ip_v4, &network_v4, prefix_length)
}
(IpAddr::V6(ip_v6), Ok(IpAddr::V6(network_v6))) => {
is_ipv6_in_cidr(ip_v6, &network_v6, prefix_length)
}
_ => false,
}
}
fn is_ipv4_in_cidr(ip: &Ipv4Addr, network: &Ipv4Addr, prefix_length: u8) -> bool {
if prefix_length > 32 {
return false;
}
let ip_int = u32::from_be_bytes(ip.octets());
let network_int = u32::from_be_bytes(network.octets());
let mask = if prefix_length == 0 {
0
} else {
(!0u32) << (32 - prefix_length)
};
(ip_int & mask) == (network_int & mask)
}
fn is_ipv6_in_cidr(ip: &Ipv6Addr, network: &Ipv6Addr, prefix_length: u8) -> bool {
if prefix_length > 128 {
return false;
}
let ip_segments = ip.segments();
let network_segments = network.segments();
let full_segments = prefix_length / 16;
let remaining_bits = prefix_length % 16;
for i in 0..full_segments.min(8) {
if ip_segments[i as usize] != network_segments[i as usize] {
return false;
}
}
if remaining_bits > 0 && full_segments < 8 {
let mask = (!0u16) << (16 - remaining_bits);
if (ip_segments[full_segments as usize] & mask)
!= (network_segments[full_segments as usize] & mask)
{
return false;
}
}
true
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::{Ipv4Addr, Ipv6Addr};
#[test]
fn test_is_ipv4_in_cidr() {
let ip = Ipv4Addr::new(192, 168, 1, 100);
let network = Ipv4Addr::new(192, 168, 1, 0);
assert!(is_ipv4_in_cidr(&ip, &network, 24));
let ip = Ipv4Addr::new(10, 0, 0, 5);
let network = Ipv4Addr::new(10, 0, 0, 0);
assert!(is_ipv4_in_cidr(&ip, &network, 8));
let ip = Ipv4Addr::new(172, 16, 0, 1);
let network = Ipv4Addr::new(172, 16, 0, 0);
assert!(is_ipv4_in_cidr(&ip, &network, 16));
let ip = Ipv4Addr::new(192, 168, 2, 100);
let network = Ipv4Addr::new(192, 168, 1, 0);
assert!(!is_ipv4_in_cidr(&ip, &network, 24));
}
#[test]
fn test_is_ipv6_in_cidr() {
let ip = Ipv6Addr::new(0x2001, 0x0db8, 0x85a3, 0, 0, 0x8a2e, 0x370, 0x7334);
let network = Ipv6Addr::new(0x2001, 0x0db8, 0x85a3, 0, 0, 0, 0, 0);
assert!(is_ipv6_in_cidr(&ip, &network, 48));
let ip = Ipv6Addr::new(0x2001, 0x0db9, 0x85a3, 0, 0, 0x8a2e, 0x370, 0x7334);
let network = Ipv6Addr::new(0x2001, 0x0db8, 0x85a3, 0, 0, 0, 0, 0);
assert!(!is_ipv6_in_cidr(&ip, &network, 48));
}
#[test]
fn test_is_ip_in_cidr() {
let ip: IpAddr = "192.168.1.100".parse().unwrap();
assert!(is_ip_in_cidr(&ip, "192.168.1.0/24"));
assert!(!is_ip_in_cidr(&ip, "192.168.2.0/24"));
let ip: IpAddr = "2001:db8::1".parse().unwrap();
assert!(is_ip_in_cidr(&ip, "2001:db8::/32"));
assert!(!is_ip_in_cidr(&ip, "2001:db9::/32"));
}
#[test]
fn test_is_ip_in_cidr_invalid_format_returns_false() {
let ip: IpAddr = "192.168.1.1".parse().unwrap();
assert!(!is_ip_in_cidr(&ip, "192.168.1.0"));
assert!(!is_ip_in_cidr(&ip, "not-an-ip/24"));
}
#[test]
fn test_is_ip_in_cidr_invalid_prefix_is_fail_closed() {
let ip: IpAddr = "192.168.1.1".parse().unwrap();
assert!(!is_ip_in_cidr(&ip, "0.0.0.0/abc"));
assert!(!is_ip_in_cidr(&ip, "0.0.0.0/999"));
assert!(!is_ip_in_cidr(&ip, "0.0.0.0/-1"));
}
#[test]
fn test_is_ip_in_cidr_mismatched_ip_version_returns_false() {
let ip: IpAddr = "192.168.1.1".parse().unwrap();
assert!(!is_ip_in_cidr(&ip, "::1/128"));
let ip: IpAddr = "::1".parse().unwrap();
assert!(!is_ip_in_cidr(&ip, "192.168.1.0/24"));
}
#[test]
fn test_is_ipv4_in_cidr_prefix_length_edge_cases() {
let ip = Ipv4Addr::new(192, 168, 1, 1);
let network = Ipv4Addr::new(0, 0, 0, 0);
assert!(is_ipv4_in_cidr(&ip, &network, 0));
assert!(!is_ipv4_in_cidr(&ip, &network, 33));
}
#[test]
fn test_is_ipv6_in_cidr_prefix_length_edge_cases() {
let ip = Ipv6Addr::new(0x2001, 0x0db8, 0x85a3, 0, 0, 0x8a2e, 0x370, 0x7334);
let network = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0);
assert!(!is_ipv6_in_cidr(&ip, &network, 129));
let network_diff = Ipv6Addr::new(0x2001, 0x0db8, 0x85a3, 0, 0, 0x8a2e, 0x370, 0xff34);
assert!(!is_ipv6_in_cidr(&ip, &network_diff, 120));
let network_match = Ipv6Addr::new(0x2001, 0x0db8, 0x85a3, 0, 0, 0x8a2e, 0x370, 0x7300);
assert!(is_ipv6_in_cidr(&ip, &network_match, 120));
}
}