Merge pull request #34 from Corfirean/fix/lan-address-selector

Choose and remember the LAN address friends connect to
This commit is contained in:
Corfirean authored and GitHub committed 2026-10-07 06:53:22 +05:00
commit f3fc14b55a
14 files changed
+292 -17

No files matched your search

+1
View File
@@ -25,6 +25,7 @@ zip = { version = "2", default-features = false, features = ["deflate"] }
sha1 = "0.10"
tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt", "std"] }
tempfile = "3"
if-addrs = "0.15"
[dev-dependencies]
rand_core = { version = "0.6", features = ["getrandom"] }
+64 -3
View File
@@ -31,11 +31,25 @@ pub struct Settings {
pub mode: Mode,
/// The address friends type into their client for this mode.
pub host: Option<String>,
/// Independent of the effective host of the current mode. None means automatic LAN detection.
#[serde(default)]
pub lan_address_override: Option<String>,
}
impl Default for Settings {
fn default() -> Self {
Settings { mode: Mode::Local, host: None }
Settings { mode: Mode::Local, host: None, lan_address_override: None }
}
}
impl Settings {
/// Only LAN application changes the LAN preference. Other modes keep it for the next LAN session.
pub fn select_mode(&mut self, mode: Mode, host: String, lan_override: Option<String>) {
if mode == Mode::Lan {
self.lan_address_override = lan_override;
}
self.mode = mode;
self.host = Some(host);
}
}
@@ -233,7 +247,7 @@ CoA.AllowRemoteClients = 0
fn a_shared_server_gets_its_bind_address_back_before_start_and_a_local_one_is_left_alone() {
let (_d, root, meta) = setup();
assert!(!ensure_bind(&root, &meta).unwrap(), "local mode: nothing to do");
save(&meta, &Settings { mode: Mode::Private, host: Some("100.64.1.2".into()) }).unwrap();
save(&meta, &Settings { mode: Mode::Private, host: Some("100.64.1.2".into()), ..Settings::default() }).unwrap();
assert!(ensure_bind(&root, &meta).unwrap(), "templates were reset to 127.0.0.1 -> reopened");
assert!(bind_is_open(&root));
assert!(!ensure_bind(&root, &meta).unwrap(), "already open: idempotent");
@@ -243,11 +257,39 @@ CoA.AllowRemoteClients = 0
fn settings_round_trip_and_default_to_local() {
let d = tempfile::tempdir().unwrap();
assert_eq!(load(d.path()).mode, Mode::Local);
save(d.path(), &Settings { mode: Mode::Private, host: Some("100.64.1.2".into()) }).unwrap();
save(d.path(), &Settings { mode: Mode::Private, host: Some("100.64.1.2".into()), ..Settings::default() }).unwrap();
let s = load(d.path());
assert_eq!((s.mode, s.host.as_deref()), (Mode::Private, Some("100.64.1.2")));
}
#[test]
fn old_settings_load_without_migrating_effective_host_to_override() {
let s: Settings = serde_json::from_str(r#"{"mode":"lan","host":"192.168.1.50"}"#).unwrap();
assert_eq!(s.mode, Mode::Lan);
assert_eq!(s.host.as_deref(), Some("192.168.1.50"));
assert_eq!(s.lan_address_override, None);
}
#[test]
fn lan_preference_survives_save_load_and_every_other_mode_and_can_be_cleared() {
let d = tempfile::tempdir().unwrap();
let mut s = Settings::default();
s.select_mode(Mode::Lan, "192.168.1.50".into(), Some("192.168.1.50".into()));
for (mode, host) in [(Mode::Private, "100.101.20.5"), (Mode::Direct, "203.0.113.9"), (Mode::Local, "127.0.0.1")] {
s.select_mode(mode, host.into(), None);
save(d.path(), &s).unwrap();
s = load(d.path());
assert_eq!(s.lan_address_override.as_deref(), Some("192.168.1.50"));
assert_eq!(s.host.as_deref(), Some(host));
let lan = crate::net::resolve_lan_host(s.lan_address_override.as_deref(), Some("192.168.0.169".parse().unwrap())).unwrap();
s.select_mode(Mode::Lan, lan, s.lan_address_override.clone());
assert_eq!(s.host.as_deref(), Some("192.168.1.50"));
}
s.select_mode(Mode::Lan, "192.168.0.169".into(), None);
save(d.path(), &s).unwrap();
assert_eq!(load(d.path()).lan_address_override, None);
}
#[test]
fn friend_package_contains_only_whitelisted_files() {
let (d, root, _m) = setup();
@@ -274,4 +316,23 @@ CoA.AllowRemoteClients = 0
}
assert!(make_friend_package(&root, "bad host; x", false, &d.path().join("x.zip")).is_err());
}
#[test]
fn manual_lan_host_survives_startup_bind_restoration_and_drives_friend_package() {
let (d, root, meta) = setup();
let mut s = Settings::default();
s.select_mode(Mode::Lan, "192.168.1.50".into(), Some("192.168.1.50".into()));
save(&meta, &s).unwrap();
assert!(ensure_bind(&root, &meta).unwrap());
assert!(bind_is_open(&root));
let restored = load(&meta);
assert_eq!(restored.host.as_deref(), Some("192.168.1.50"));
assert_eq!(restored.lan_address_override.as_deref(), Some("192.168.1.50"));
let package = d.path().join("manual-lan.zip");
make_friend_package(&root, restored.host.as_deref().unwrap(), false, &package).unwrap();
let mut zip = zip::ZipArchive::new(fs::File::open(package).unwrap()).unwrap();
let mut realm = String::new();
std::io::Read::read_to_string(&mut zip.by_name("realmlist.wtf").unwrap(), &mut realm).unwrap();
assert_eq!(realm, "set realmlist 192.168.1.50\r\n");
}
}
+81
View File
@@ -19,6 +19,51 @@ pub fn lan_ip() -> Option<Ipv4Addr> {
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct LanAddress {
pub interface: String,
pub address: String,
pub is_default: bool,
}
/// Suitable unicast IPv4 addresses; shared carrier/Tailscale space belongs to Private mode.
pub fn is_lan_address(ip: Ipv4Addr) -> bool {
!ip.is_unspecified() && !ip.is_loopback() && !ip.is_link_local()
&& !ip.is_multicast() && !ip.is_broadcast() && ip.octets()[0] != 0
&& ip.octets()[0] < 240 && !is_cgnat_range(ip)
}
pub fn validate_lan_address(address: &str) -> Result<Ipv4Addr> {
address.parse::<Ipv4Addr>().ok().filter(|ip| is_lan_address(*ip))
.ok_or_else(|| Error::Invalid("Invalid IPv4 address for local network.".into()))
}
/// An absent/disconnected manual address is intentional: never fall back to another adapter.
pub fn resolve_lan_host(manual: Option<&str>, automatic: Option<Ipv4Addr>) -> Result<String> {
match manual {
Some(address) => validate_lan_address(address).map(|ip| ip.to_string()),
None => automatic.filter(|ip| is_lan_address(*ip)).map(|ip| ip.to_string())
.ok_or_else(|| Error::Invalid("This computer has no usable local network address.".into())),
}
}
fn lan_candidates(rows: impl IntoIterator<Item = (String, Ipv4Addr)>, automatic: Option<Ipv4Addr>) -> Vec<LanAddress> {
let mut rows: Vec<_> = rows.into_iter().filter(|(_, ip)| is_lan_address(*ip)).collect();
rows.sort_by(|a, b| a.0.cmp(&b.0).then(a.1.cmp(&b.1)));
let mut seen = std::collections::HashSet::new();
rows.into_iter().filter(|(_, ip)| seen.insert(*ip)).map(|(interface, ip)| LanAddress {
interface, address: ip.to_string(), is_default: Some(ip) == automatic,
}).collect()
}
/// Native OS enumeration (GetAdaptersAddresses on Windows, getifaddrs on Unix).
pub fn lan_addresses(automatic: Option<Ipv4Addr>) -> Result<Vec<LanAddress>> {
let interfaces = if_addrs::get_if_addrs()?;
Ok(lan_candidates(interfaces.into_iter().filter(|i| i.is_oper_up()).filter_map(|i| {
match i.ip() { IpAddr::V4(ip) => Some((i.name, ip)), _ => None }
}), automatic))
}
pub fn is_private(ip: Ipv4Addr) -> bool {
ip.is_private() || ip.is_loopback() || ip.is_link_local()
}
@@ -132,6 +177,42 @@ mod tests {
s.parse().unwrap()
}
#[test]
fn lan_validation_and_resolution_never_replace_manual_addresses() {
for good in ["192.168.1.20", "10.0.0.5", "172.16.2.4"] {
assert!(validate_lan_address(good).is_ok());
}
for bad in ["abc", "999.1.1.1", "0.0.0.0", "0.1.2.3", "127.0.0.1", "127.9.1.2", "169.254.10.20", "100.101.20.5", "224.0.0.1", "255.255.255.255", "240.0.0.1", "192.168.1.1'; DROP TABLE realmlist"] {
assert!(validate_lan_address(bad).is_err(), "{bad}");
}
let automatic = Some(ip("192.168.0.169"));
assert_eq!(resolve_lan_host(None, automatic).unwrap(), "192.168.0.169");
assert_eq!(resolve_lan_host(Some("192.168.1.50"), automatic).unwrap(), "192.168.1.50");
assert_eq!(resolve_lan_host(Some("192.168.1.50"), None).unwrap(), "192.168.1.50");
assert!(resolve_lan_host(Some("invalid"), automatic).is_err());
assert!(resolve_lan_host(None, None).is_err());
assert!(resolve_lan_host(None, Some(ip("169.254.1.2"))).is_err());
assert!(resolve_lan_host(None, Some(ip("100.100.1.2"))).is_err());
}
#[test]
fn candidates_are_filtered_deduplicated_deterministic_and_default_marked() {
let rows = vec![
("Wi-Fi", "192.168.0.25"), ("Ethernet 2", "192.168.1.50"),
("Ethernet", "192.168.0.169"), ("Duplicate", "192.168.1.50"),
("Loopback", "127.0.0.2"), ("APIPA", "169.254.1.2"),
("Tailscale", "100.101.20.5"), ("Empty", "0.0.0.0"),
("Hyper-V Virtual", "10.0.0.5"),
];
let make = |rows: Vec<(&str, &str)>| lan_candidates(rows.into_iter().map(|(name, address)| (name.into(), ip(address))), Some(ip("192.168.0.169")));
let result = make(rows.clone());
assert_eq!(result.len(), 4);
assert_eq!(result.iter().filter(|a| a.is_default).count(), 1);
assert!(result.iter().any(|a| a.interface == "Hyper-V Virtual"));
assert!(result.iter().any(|a| a.is_default && a.address == "192.168.0.169"));
assert_eq!(result, make(rows.into_iter().rev().collect()));
}
#[test]
fn address_classes() {
assert!(is_private(ip("192.168.1.5")) && is_private(ip("10.0.0.2")) && is_private(ip("172.16.4.4")) && is_private(ip("127.0.0.1")));