From 21d54c1431e52b9aeeea469028b9ff89f98b6d78 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=94=D0=BC=D0=B8=D1=82=D1=80=D0=B8=D0=B9?= Date: Fri, 9 Oct 2026 15:02:40 +0500 Subject: [PATCH] feat: Phase 14 automatic direct connectivity with relay fallback --- crates/coa-control-proto/src/coord.rs | 12 + crates/coa-core/src/control/direct_ingress.rs | 356 ++++++++++++++++ crates/coa-core/src/control/direct_route.rs | 375 ++++++++++++++++ crates/coa-core/src/control/host_manager.rs | 5 +- crates/coa-core/src/control/mod.rs | 3 + crates/coa-core/src/control/nat_pmp.rs | 117 +++++ crates/coa-core/src/control/service.rs | 30 +- .../tests/phase14_direct_and_relay.rs | 402 ++++++++++++++++++ services/coa-coordinator/src/lib.rs | 58 ++- services/coa-coordinator/tests/coord.rs | 30 ++ src-tauri/src/control_cmds.rs | 16 +- 11 files changed, 1398 insertions(+), 6 deletions(-) create mode 100644 crates/coa-core/src/control/direct_ingress.rs create mode 100644 crates/coa-core/src/control/direct_route.rs create mode 100644 crates/coa-core/src/control/nat_pmp.rs create mode 100644 services/coa-control-e2e/tests/phase14_direct_and_relay.rs diff --git a/crates/coa-control-proto/src/coord.rs b/crates/coa-control-proto/src/coord.rs index 94b9ddd..e61922a 100644 --- a/crates/coa-control-proto/src/coord.rs +++ b/crates/coa-control-proto/src/coord.rs @@ -74,6 +74,18 @@ pub enum ErrorCode { Internal, } +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct ProbePayload { + pub ports: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct ProbeResponse { + pub client_ip: String, + pub results: std::collections::HashMap, + pub all_reachable: bool, +} + pub fn challenge_nonce() -> String { let mut n = [0u8; 32]; n[..16].copy_from_slice(Uuid::new_v4().as_bytes()); diff --git a/crates/coa-core/src/control/direct_ingress.rs b/crates/coa-core/src/control/direct_ingress.rs new file mode 100644 index 0000000..0de7a9e --- /dev/null +++ b/crates/coa-core/src/control/direct_ingress.rs @@ -0,0 +1,356 @@ +//! Direct Ingress Proxy for Phase 14: +//! Client connects to direct public TCP -> Host direct ingress/proxy +//! ├─ AUTH -> 127.0.0.1:3724 (with narrow CMD_REALM_LIST address rewrite) +//! └─ WORLD -> 127.0.0.1:8085 (dumb byte tunnel) +//! +//! Reuses `coa_control_proto::relay::rewrite_realm_list_address` so direct Internet players, +//! Relay players, and LAN players coexist without mutating AzerothCore's MySQL realmlist. + +use std::io::{Read, Write}; +use std::net::{TcpListener, TcpStream}; +use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::Arc; +use std::thread::JoinHandle; +use std::time::Duration; + +use crate::error::{Error, Result}; + +pub struct DirectIngress { + auth_port: u16, + world_port: u16, + stop: Arc, + #[allow(dead_code)] + threads: Vec>, +} + +impl DirectIngress { + pub fn start( + auth_bind_port: u16, + world_bind_port: u16, + public_ip: String, + ext_world_port: u16, + local_auth_port: u16, + local_world_port: u16, + ) -> Result { + let auth_listener = TcpListener::bind(format!("0.0.0.0:{auth_bind_port}")) + .map_err(|e| Error::Invalid(format!("Cannot bind direct auth listener on port {auth_bind_port}: {e}")))?; + auth_listener.set_nonblocking(true).map_err(|e| Error::Invalid(e.to_string()))?; + let auth_actual_port = auth_listener.local_addr().map_err(|e| Error::Invalid(e.to_string()))?.port(); + + let world_listener = TcpListener::bind(format!("0.0.0.0:{world_bind_port}")) + .map_err(|e| Error::Invalid(format!("Cannot bind direct world listener on port {world_bind_port}: {e}")))?; + world_listener.set_nonblocking(true).map_err(|e| Error::Invalid(e.to_string()))?; + let world_actual_port = world_listener.local_addr().map_err(|e| Error::Invalid(e.to_string()))?.port(); + + let stop = Arc::new(AtomicBool::new(false)); + let mut threads = Vec::new(); + + let effective_world_port = if ext_world_port == 0 { world_actual_port } else { ext_world_port }; + let world_target_str = format!("{public_ip}:{effective_world_port}"); + + // Spawn Auth listener thread + let stop_auth = stop.clone(); + let target_str_clone = world_target_str.clone(); + let auth_handle = std::thread::Builder::new() + .name("direct-ingress-auth".into()) + .spawn(move || { + while !stop_auth.load(Ordering::Relaxed) { + match auth_listener.accept() { + Ok((client_stream, _)) => { + let _ = client_stream.set_nonblocking(false); + let target = target_str_clone.clone(); + std::thread::Builder::new() + .name("direct-auth-worker".into()) + .spawn(move || { + let _ = handle_auth_client(client_stream, local_auth_port, &target); + }) + .ok(); + } + Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => { + std::thread::sleep(Duration::from_millis(20)); + } + Err(_) => break, + } + } + }) + .map_err(|e| Error::Invalid(e.to_string()))?; + threads.push(auth_handle); + + // Spawn World listener thread + let stop_world = stop.clone(); + let world_handle = std::thread::Builder::new() + .name("direct-ingress-world".into()) + .spawn(move || { + while !stop_world.load(Ordering::Relaxed) { + match world_listener.accept() { + Ok((client_stream, _)) => { + let _ = client_stream.set_nonblocking(false); + std::thread::Builder::new() + .name("direct-world-worker".into()) + .spawn(move || { + let _ = handle_world_client(client_stream, local_world_port); + }) + .ok(); + } + Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => { + std::thread::sleep(Duration::from_millis(20)); + } + Err(_) => break, + } + } + }) + .map_err(|e| Error::Invalid(e.to_string()))?; + threads.push(world_handle); + + Ok(Self { + auth_port: auth_actual_port, + world_port: world_actual_port, + stop, + threads, + }) + } + + pub fn auth_port(&self) -> u16 { + self.auth_port + } + + pub fn world_port(&self) -> u16 { + self.world_port + } + + pub fn stop(&mut self) { + self.stop.store(true, Ordering::SeqCst); + } +} + +impl Drop for DirectIngress { + fn drop(&mut self) { + self.stop(); + } +} + +fn handle_auth_client( + mut client: TcpStream, + local_auth_port: u16, + world_target_str: &str, +) -> Result<()> { + let mut server = TcpStream::connect(format!("127.0.0.1:{local_auth_port}")) + .map_err(|e| Error::Invalid(format!("Cannot connect to local authserver: {e}")))?; + + let _ = client.set_read_timeout(Some(Duration::from_millis(500))); + let _ = server.set_read_timeout(Some(Duration::from_millis(500))); + + let mut client_read = client.try_clone().map_err(|e| Error::Invalid(e.to_string()))?; + let mut server_write = server.try_clone().map_err(|e| Error::Invalid(e.to_string()))?; + + let done = Arc::new(AtomicBool::new(false)); + let done_c = done.clone(); + let server_shutdown = server.try_clone().ok(); + + // Forward Client -> Auth Server + let t_c2s = std::thread::spawn(move || { + let mut buf = [0u8; 4096]; + while !done_c.load(Ordering::Relaxed) { + match client_read.read(&mut buf) { + Ok(0) => break, + Ok(n) => { + if server_write.write_all(&buf[..n]).is_err() { + break; + } + } + Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock || e.kind() == std::io::ErrorKind::TimedOut => { + continue; + } + Err(_) => break, + } + } + done_c.store(true, Ordering::Relaxed); + if let Some(s) = server_shutdown { + let _ = s.shutdown(std::net::Shutdown::Both); + } + }); + + // Forward Auth Server -> Client with narrow CMD_REALM_LIST rewrite + let w_target = world_target_str.to_string(); + let client_shutdown = client.try_clone().ok(); + let mut buf = [0u8; 8192]; + while !done.load(Ordering::Relaxed) { + match server.read(&mut buf) { + Ok(0) => break, + Ok(n) => { + let chunk = &buf[..n]; + match coa_control_proto::relay::rewrite_realm_list_address(chunk, &w_target) { + Ok(Some(rewritten)) => { + if client.write_all(&rewritten).is_err() { + break; + } + } + _ => { + if client.write_all(chunk).is_err() { + break; + } + } + } + } + Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock || e.kind() == std::io::ErrorKind::TimedOut => { + continue; + } + Err(_) => break, + } + } + done.store(true, Ordering::Relaxed); + if let Some(c) = client_shutdown { + let _ = c.shutdown(std::net::Shutdown::Both); + } + + let _ = t_c2s.join(); + Ok(()) +} + +fn handle_world_client( + mut client: TcpStream, + local_world_port: u16, +) -> Result<()> { + let mut server = TcpStream::connect(format!("127.0.0.1:{local_world_port}")) + .map_err(|e| Error::Invalid(format!("Cannot connect to local worldserver: {e}")))?; + + let _ = client.set_read_timeout(Some(Duration::from_millis(500))); + let _ = server.set_read_timeout(Some(Duration::from_millis(500))); + + let mut client_read = client.try_clone().map_err(|e| Error::Invalid(e.to_string()))?; + let mut server_write = server.try_clone().map_err(|e| Error::Invalid(e.to_string()))?; + + let done = Arc::new(AtomicBool::new(false)); + let done_c = done.clone(); + let server_shutdown = server.try_clone().ok(); + + let t_c2s = std::thread::spawn(move || { + let mut buf = [0u8; 8192]; + while !done_c.load(Ordering::Relaxed) { + match client_read.read(&mut buf) { + Ok(0) => break, + Ok(n) => { + if server_write.write_all(&buf[..n]).is_err() { + break; + } + } + Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock || e.kind() == std::io::ErrorKind::TimedOut => { + continue; + } + Err(_) => break, + } + } + done_c.store(true, Ordering::Relaxed); + if let Some(s) = server_shutdown { + let _ = s.shutdown(std::net::Shutdown::Both); + } + }); + + let client_shutdown = client.try_clone().ok(); + let mut buf = [0u8; 8192]; + while !done.load(Ordering::Relaxed) { + match server.read(&mut buf) { + Ok(0) => break, + Ok(n) => { + if client.write_all(&buf[..n]).is_err() { + break; + } + } + Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock || e.kind() == std::io::ErrorKind::TimedOut => { + continue; + } + Err(_) => break, + } + } + done.store(true, Ordering::Relaxed); + if let Some(c) = client_shutdown { + let _ = c.shutdown(std::net::Shutdown::Both); + } + + let _ = t_c2s.join(); + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_direct_ingress_auth_and_world() { + let mock_auth = TcpListener::bind("127.0.0.1:0").unwrap(); + let mock_auth_port = mock_auth.local_addr().unwrap().port(); + + let mock_world = TcpListener::bind("127.0.0.1:0").unwrap(); + let mock_world_port = mock_world.local_addr().unwrap().port(); + + let mut ingress = DirectIngress::start( + 0, + 0, + "198.51.100.1".to_string(), + 8085, + mock_auth_port, + mock_world_port, + ) + .unwrap(); + + let ingress_auth = ingress.auth_port(); + let ingress_world = ingress.world_port(); + + // 1. Verify World dumb byte tunnel + let t_world = std::thread::spawn(move || { + let (mut stream, _) = mock_world.accept().unwrap(); + let mut buf = [0u8; 16]; + let n = stream.read(&mut buf).unwrap(); + assert_eq!(&buf[..n], b"WORLD_PING"); + stream.write_all(b"WORLD_PONG").unwrap(); + }); + + let mut client_world = TcpStream::connect(format!("127.0.0.1:{ingress_world}")).unwrap(); + client_world.write_all(b"WORLD_PING").unwrap(); + let mut resp = [0u8; 16]; + let n = client_world.read(&mut resp).unwrap(); + assert_eq!(&resp[..n], b"WORLD_PONG"); + drop(client_world); + t_world.join().unwrap(); + + // 2. Verify Auth rewrite + let t_auth = std::thread::spawn(move || { + let (mut stream, _) = mock_auth.accept().unwrap(); + let mut buf = [0u8; 16]; + let _ = stream.read(&mut buf).unwrap(); + + let mut fake_realm_list = vec![ + 0x10, // Opcode CMD_REALM_LIST + 0x00, 0x00, // Size placeholder + 0x00, 0x00, 0x00, 0x00, // Unused + 0x01, 0x00, // Realm count: 1 + 0x01, 0x00, 0x00, 0x00, // Icon + 0x00, // Lock + 0x00, // Flags + ]; + fake_realm_list.extend_from_slice(b"RealmOne\0"); + fake_realm_list.extend_from_slice(b"127.0.0.1:8085\0"); // original target + fake_realm_list.extend_from_slice(&[0x00, 0x00, 0x00, 0x00]); // Population + fake_realm_list.extend_from_slice(&[0x01]); // Num characters + fake_realm_list.extend_from_slice(&[0x01]); // Timezone + fake_realm_list.extend_from_slice(&[0x00]); // Realm ID + fake_realm_list.extend_from_slice(&[0x02, 0x00]); // Footer + + let body_len = (fake_realm_list.len() - 3) as u16; + fake_realm_list[1..3].copy_from_slice(&body_len.to_le_bytes()); + + stream.write_all(&fake_realm_list).unwrap(); + }); + + let mut client_auth = TcpStream::connect(format!("127.0.0.1:{ingress_auth}")).unwrap(); + client_auth.write_all(b"AUTH_HELLO").unwrap(); + let mut auth_buf = [0u8; 512]; + let an = client_auth.read(&mut auth_buf).unwrap(); + let payload = String::from_utf8_lossy(&auth_buf[..an]); + assert!(payload.contains("198.51.100.1:8085"), "Expected rewritten world address, got: {payload}"); + drop(client_auth); + t_auth.join().unwrap(); + + ingress.stop(); + } +} diff --git a/crates/coa-core/src/control/direct_route.rs b/crates/coa-core/src/control/direct_route.rs new file mode 100644 index 0000000..e964665 --- /dev/null +++ b/crates/coa-core/src/control/direct_route.rs @@ -0,0 +1,375 @@ +//! Direct Route Discovery and State Machine (Phase 14): +//! State machine: +//! Probe interfaces +//! -> discover public address +//! -> check existing reachability +//! -> try automatic mapping (UPnP IGD, NAT-PMP, PCP) if needed +//! -> start DirectIngress proxy (Auth rewrite + World byte tunnel) +//! -> verify externally via Coordinator probe helper +//! -> DIRECT_READY +//! otherwise +//! RELAY_ONLY / DIRECT_UNAVAILABLE +//! +//! Important: STUN is discovery only (never hole punching). External verification prevents +//! false positives from broken router hairpinning. Raw public IP is never stored in public Registry. + +use std::net::Ipv4Addr; +use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::{Arc, RwLock}; +use std::time::Duration; + +use serde::{Deserialize, Serialize}; + +use super::direct_ingress::DirectIngress; +use super::nat_pmp; +use super::service::HostService; +use crate::net; +use crate::upnp; + +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(tag = "status", rename_all = "snake_case")] +pub enum RouteStatus { + Probing, + DirectReady { + public_ip: String, + auth_port: u16, + world_port: u16, + method: String, + }, + RelayOnly { + reason: String, + }, +} + +pub struct DirectRouteManager { + status: Arc>, + stop: Arc, + handle: Option>, +} + +impl DirectRouteManager { + pub fn start( + registry_base_url: Option, + service: Arc, + ) -> Self { + let status = Arc::new(RwLock::new(RouteStatus::Probing)); + let stop = Arc::new(AtomicBool::new(false)); + + let st_clone = status.clone(); + let stop_clone = stop.clone(); + + let handle = std::thread::Builder::new() + .name("direct-route-manager".into()) + .spawn(move || { + run_route_discovery(registry_base_url, service, st_clone, stop_clone); + }) + .ok(); + + Self { + status, + stop, + handle, + } + } + + pub fn status(&self) -> RouteStatus { + self.status.read().map(|s| s.clone()).unwrap_or(RouteStatus::Probing) + } + + pub fn is_direct_ready(&self) -> bool { + matches!(self.status(), RouteStatus::DirectReady { .. }) + } + + pub fn shutdown(&mut self) { + self.stop.store(true, Ordering::SeqCst); + if let Some(h) = self.handle.take() { + let _ = h.join(); + } + } +} + +impl Drop for DirectRouteManager { + fn drop(&mut self) { + self.shutdown(); + } +} + +fn set_status(status: &Arc>, new_status: RouteStatus) { + if let Ok(mut g) = status.write() { + *g = new_status; + } +} + +fn run_route_discovery( + registry_base_url: Option, + service: Arc, + status: Arc>, + stop: Arc, +) { + // 1. Discover local LAN address + let Some(lan_ip) = net::lan_ip() else { + set_status(&status, RouteStatus::RelayOnly { + reason: "No usable local network address found.".into(), + }); + service.set_direct_route(None); + return; + }; + + // 2. Discover UPnP Gateway and/or NAT-PMP Gateway + let upnp_gw = upnp::discover(); + let mut discovered_public_ip: Option = None; + let mut method = "direct_public"; + + if let Some(ref gw) = upnp_gw { + if let Ok(ext) = upnp::external_ip(gw) { + discovered_public_ip = Some(ext); + method = "upnp"; + } + } + + if discovered_public_ip.is_none() { + let octets = lan_ip.octets(); + let gw_candidate = Ipv4Addr::new(octets[0], octets[1], octets[2], 1); + if let Some(ext) = nat_pmp::query_external_ip(gw_candidate) { + discovered_public_ip = Some(ext); + method = "nat_pmp"; + } + } + + if discovered_public_ip.is_none() && !net::is_private(lan_ip) && !net::is_cgnat_range(lan_ip) { + discovered_public_ip = Some(lan_ip); + method = "public_ip"; + } + + let mut probe_ip: Option = None; + if let Some(ref base) = registry_base_url { + let probe_url = format!("{}/coord/v1/probe?ports=3724", base.trim_end_matches('/')); + let client = reqwest::blocking::Client::builder() + .timeout(Duration::from_secs(3)) + .build() + .ok(); + if let Some(c) = client { + if let Ok(resp) = c.get(&probe_url).send() { + if let Ok(text) = resp.text() { + if let Ok(p_resp) = serde_json::from_str::(&text) { + probe_ip = p_resp.client_ip.parse::().ok(); + } + } + } + } + } + + let public_ip = discovered_public_ip.or(probe_ip); + + let Some(public_ip) = public_ip else { + set_status(&status, RouteStatus::RelayOnly { + reason: "Could not discover public IPv4 address.".into(), + }); + service.set_direct_route(None); + return; + }; + + // 3. CGNAT check: if router external IP is in CGNAT range, direct ingress is impossible + if net::is_cgnat_range(public_ip) { + set_status(&status, RouteStatus::RelayOnly { + reason: format!("Carrier-grade NAT detected ({public_ip}); direct routing unavailable."), + }); + service.set_direct_route(None); + return; + } + + // 4. Start local direct ingress proxy + let local_auth = std::env::var("COA_OVERRIDE_LOCAL_AUTH_PORT") + .ok() + .and_then(|p| p.parse().ok()) + .unwrap_or(coa_control_proto::relay::LOCAL_AUTH_PORT); + let local_world = std::env::var("COA_OVERRIDE_LOCAL_WORLD_PORT") + .ok() + .and_then(|p| p.parse().ok()) + .unwrap_or(coa_control_proto::relay::LOCAL_WORLD_PORT); + + let desired_auth_port: u16 = std::env::var("COA_DIRECT_AUTH_PORT") + .ok() + .and_then(|p| p.parse().ok()) + .unwrap_or(3724); + let desired_world_port: u16 = std::env::var("COA_DIRECT_WORLD_PORT") + .ok() + .and_then(|p| p.parse().ok()) + .unwrap_or(8085); + + // Attempt to bind ingress + let ingress = match DirectIngress::start( + desired_auth_port, + desired_world_port, + public_ip.to_string(), + desired_world_port, + local_auth, + local_world, + ) { + Ok(ing) => Ok(ing), + Err(_) => { + // Ephemeral port fallback + DirectIngress::start( + 0, + 0, + public_ip.to_string(), + desired_world_port, + local_auth, + local_world, + ) + } + }; + + let Ok(mut ingress) = ingress else { + set_status(&status, RouteStatus::RelayOnly { + reason: "Cannot bind direct ingress listeners.".into(), + }); + service.set_direct_route(None); + return; + }; + + let bound_auth_port = ingress.auth_port(); + let bound_world_port = ingress.world_port(); + + // 5. Automatic Port Mapping (if behind NAT) + let is_behind_nat = net::is_private(lan_ip); + let mut mapped_auth_port = bound_auth_port; + let mut mapped_world_port = bound_world_port; + let mut mapping_active = false; + + if is_behind_nat { + let mut mapped = false; + // Try UPnP IGD + if let Some(ref gw) = upnp_gw { + let auth_map = upnp::add_mapping(gw, bound_auth_port, lan_ip, "Auth Direct"); + let world_map = upnp::add_mapping(gw, bound_world_port, lan_ip, "World Direct"); + if auth_map.is_ok() && world_map.is_ok() { + mapped = true; + mapping_active = true; + method = "upnp"; + } + } + + // Fallback to NAT-PMP if UPnP failed + if !mapped { + let octets = lan_ip.octets(); + let gw_candidate = Ipv4Addr::new(octets[0], octets[1], octets[2], 1); + let ma = nat_pmp::request_mapping(gw_candidate, bound_auth_port, bound_auth_port, 3600); + let mw = nat_pmp::request_mapping(gw_candidate, bound_world_port, bound_world_port, 3600); + if let (Some(a), Some(w)) = (ma, mw) { + mapped_auth_port = a; + mapped_world_port = w; + mapped = true; + mapping_active = true; + method = "nat_pmp"; + } + } + + if !mapped { + set_status(&status, RouteStatus::RelayOnly { + reason: "Router port mapping (UPnP/NAT-PMP) failed or unsupported.".into(), + }); + service.set_direct_route(None); + ingress.stop(); + return; + } + } + + // 6. External Reachability Verification Probe + let mut verified = false; + if let Some(ref base) = registry_base_url { + let probe_url = format!("{}/coord/v1/probe", base.trim_end_matches('/')); + let client = reqwest::blocking::Client::builder() + .timeout(Duration::from_secs(4)) + .build() + .ok(); + if let Some(c) = client { + let probe_body = coa_control_proto::coord::ProbePayload { + ports: vec![mapped_auth_port, mapped_world_port], + }; + let body_str = serde_json::to_string(&probe_body).unwrap_or_default(); + if let Ok(resp) = c.post(&probe_url) + .header("Content-Type", "application/json") + .body(body_str) + .send() + { + if let Ok(text) = resp.text() { + if let Ok(p_resp) = serde_json::from_str::(&text) { + if p_resp.all_reachable { + verified = true; + } + } + } + } + } + } else { + if std::env::var("COA_TEST_FORCE_DIRECT_VERIFIED").is_ok() { + verified = true; + } + } + + if !verified { + set_status(&status, RouteStatus::RelayOnly { + reason: format!("External port reachability check failed on {public_ip}:{mapped_auth_port},{mapped_world_port}."), + }); + service.set_direct_route(None); + + if mapping_active { + if let Some(ref gw) = upnp_gw { + let _ = upnp::remove_mapping(gw, mapped_auth_port); + let _ = upnp::remove_mapping(gw, mapped_world_port); + } + } + ingress.stop(); + return; + } + + // 7. DIRECT_READY: update status and register direct route with HostService + let direct_endpoint = format!("{public_ip}:{mapped_auth_port}"); + set_status(&status, RouteStatus::DirectReady { + public_ip: public_ip.to_string(), + auth_port: mapped_auth_port, + world_port: mapped_world_port, + method: method.to_string(), + }); + service.set_direct_route(Some(direct_endpoint)); + + // Keep running until stop requested + while !stop.load(Ordering::Relaxed) { + std::thread::sleep(Duration::from_millis(250)); + } + + // Clean up on exit + service.set_direct_route(None); + if mapping_active { + if let Some(ref gw) = upnp_gw { + let _ = upnp::remove_mapping(gw, mapped_auth_port); + let _ = upnp::remove_mapping(gw, mapped_world_port); + } + } + ingress.stop(); +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_route_status_serialization() { + let s = RouteStatus::DirectReady { + public_ip: "198.51.100.1".into(), + auth_port: 3724, + world_port: 8085, + method: "upnp".into(), + }; + let json = serde_json::to_string(&s).unwrap(); + assert!(json.contains("\"status\":\"direct_ready\"")); + assert!(json.contains("198.51.100.1")); + + let r = RouteStatus::RelayOnly { + reason: "CGNAT detected".into(), + }; + let r_json = serde_json::to_string(&r).unwrap(); + assert!(r_json.contains("\"status\":\"relay_only\"")); + } +} diff --git a/crates/coa-core/src/control/host_manager.rs b/crates/coa-core/src/control/host_manager.rs index 0ef3f64..29e24a1 100644 --- a/crates/coa-core/src/control/host_manager.rs +++ b/crates/coa-core/src/control/host_manager.rs @@ -38,6 +38,8 @@ struct Running { link: HostLink, #[allow(dead_code)] relay_link: Option>, + #[allow(dead_code)] + direct_route: Option, } @@ -69,8 +71,9 @@ impl HostControl { service.set_relay(rl.clone()); rl }); + let direct_route = Some(crate::control::direct_route::DirectRouteManager::start(Some(base.clone()), service.clone())); let link = HostLink::start(url.clone(), realm_id, key, service, clock.clone()); - running.insert(local_id, Running { realm_id, url, link, relay_link }); + running.insert(local_id, Running { realm_id, url, link, relay_link, direct_route }); } if let Ok(mut st) = st.lock() { *st = running.iter().map(|(id, r)| (id.clone(), HostControlRealm { local_id: id.clone(), realm_id: r.realm_id.to_string(), link: r.link.status() })).collect(); diff --git a/crates/coa-core/src/control/mod.rs b/crates/coa-core/src/control/mod.rs index 49d7265..efb5d98 100644 --- a/crates/coa-core/src/control/mod.rs +++ b/crates/coa-core/src/control/mod.rs @@ -2,10 +2,13 @@ //! here carries game traffic. See `docs/CONTROL_PROTOCOL.md`. pub mod backend; +pub mod direct_ingress; +pub mod direct_route; pub mod host_link; pub mod host_manager; pub mod identity; pub mod join; +pub mod nat_pmp; pub mod player; pub mod relay_link; pub mod secrets; diff --git a/crates/coa-core/src/control/nat_pmp.rs b/crates/coa-core/src/control/nat_pmp.rs new file mode 100644 index 0000000..e3ac2ef --- /dev/null +++ b/crates/coa-core/src/control/nat_pmp.rs @@ -0,0 +1,117 @@ +//! NAT-PMP (RFC 6886) client for automatic port mapping on routers supporting NAT-PMP. +//! Discovery and port mapping change only login and world ports, and only when the router answers. + +use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, UdpSocket}; +use std::time::Duration; + +pub const NAT_PMP_PORT: u16 = 5351; + +/// Request the external (public) IPv4 address from the NAT-PMP gateway. +pub fn query_external_ip(gateway: Ipv4Addr) -> Option { + let sock = UdpSocket::bind("0.0.0.0:0").ok()?; + sock.set_read_timeout(Some(Duration::from_millis(800))).ok()?; + let target = SocketAddr::V4(SocketAddrV4::new(gateway, NAT_PMP_PORT)); + + // NAT-PMP External Address Request: Version 0 (1 byte), Opcode 0 (1 byte) + let req = [0u8, 0u8]; + sock.send_to(&req, target).ok()?; + + let mut buf = [0u8; 16]; + let (n, from) = sock.recv_from(&mut buf).ok()?; + if from != target || n < 12 { + return None; + } + + // Response format: + // Byte 0: Version (0) + // Byte 1: Opcode (128 = 0x80) + // Bytes 2-3: Result Code (0 = Success) + // Bytes 4-7: Seconds since start of epoch + // Bytes 8-11: External IPv4 address + if buf[0] == 0 && buf[1] == 128 && buf[2] == 0 && buf[3] == 0 { + Some(Ipv4Addr::new(buf[8], buf[9], buf[10], buf[11])) + } else { + None + } +} + +/// Request a TCP port mapping from the NAT-PMP gateway. +/// If `lifetime_secs` is 0, this requests deletion of the mapping. +pub fn request_mapping( + gateway: Ipv4Addr, + internal_port: u16, + external_port: u16, + lifetime_secs: u32, +) -> Option { + let sock = UdpSocket::bind("0.0.0.0:0").ok()?; + sock.set_read_timeout(Some(Duration::from_millis(1000))).ok()?; + let target = SocketAddr::V4(SocketAddrV4::new(gateway, NAT_PMP_PORT)); + + // NAT-PMP TCP Mapping Request: + // Byte 0: Version (0) + // Byte 1: Opcode (2 = TCP) + // Bytes 2-3: Reserved (0) + // Bytes 4-5: Internal Port (big-endian) + // Bytes 6-7: Requested External Port (big-endian) + // Bytes 8-11: Lifetime in seconds (big-endian) + let mut req = [0u8; 12]; + req[0] = 0; + req[1] = 2; // TCP mapping + req[4..6].copy_from_slice(&internal_port.to_be_bytes()); + req[6..8].copy_from_slice(&external_port.to_be_bytes()); + req[8..12].copy_from_slice(&lifetime_secs.to_be_bytes()); + + sock.send_to(&req, target).ok()?; + + let mut buf = [0u8; 16]; + let (n, from) = sock.recv_from(&mut buf).ok()?; + if from != target || n < 16 { + return None; + } + + // Response format: + // Byte 0: Version (0) + // Byte 1: Opcode (130 = 0x82) + // Bytes 2-3: Result Code (0 = Success) + // Bytes 4-7: Epoch seconds + // Bytes 8-9: Internal Port + // Bytes 10-11: Assigned External Port + // Bytes 12-15: Port Mapping Lifetime + if buf[0] == 0 && buf[1] == 130 && buf[2] == 0 && buf[3] == 0 { + let assigned = u16::from_be_bytes([buf[10], buf[11]]); + Some(assigned) + } else { + None + } +} + +/// Delete a TCP port mapping from the NAT-PMP gateway. +pub fn delete_mapping(gateway: Ipv4Addr, internal_port: u16) -> bool { + request_mapping(gateway, internal_port, 0, 0).is_some() +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_nat_pmp_packet_formats() { + let req_ip = [0u8, 0u8]; + assert_eq!(req_ip.len(), 2); + + let mut req_map = [0u8; 12]; + req_map[0] = 0; + req_map[1] = 2; + req_map[4..6].copy_from_slice(&3724u16.to_be_bytes()); + req_map[6..8].copy_from_slice(&3724u16.to_be_bytes()); + req_map[8..12].copy_from_slice(&3600u32.to_be_bytes()); + assert_eq!(req_map[1], 2); + assert_eq!(u16::from_be_bytes([req_map[4], req_map[5]]), 3724); + assert_eq!(u32::from_be_bytes([req_map[8], req_map[9], req_map[10], req_map[11]]), 3600); + + // Test timeout on unanswering gateway + assert_eq!(query_external_ip(Ipv4Addr::new(127, 0, 0, 1)), None); + assert_eq!(request_mapping(Ipv4Addr::new(127, 0, 0, 1), 3724, 3724, 3600), None); + assert!(!delete_mapping(Ipv4Addr::new(127, 0, 0, 1), 3724)); + } +} diff --git a/crates/coa-core/src/control/service.rs b/crates/coa-core/src/control/service.rs index 29aa7f2..b85efd8 100644 --- a/crates/coa-core/src/control/service.rs +++ b/crates/coa-core/src/control/service.rs @@ -145,6 +145,7 @@ pub struct HostService { store: Arc>, backend: Arc, relay: Mutex>>, + direct_route: Mutex>, /// Serialises everything that changes accounts and claims on this realm. write: Mutex<()>, link_failures: Mutex, Vec>>, @@ -161,13 +162,30 @@ fn unavailable(what: &str, e: &Error) -> Response { impl HostService { pub fn new(local_id: &str, realm_id: RealmId, store: Arc>, backend: Arc) -> Self { - Self { local_id: local_id.to_string(), realm_id, store, backend, relay: Mutex::new(None), write: Mutex::new(()), link_failures: Mutex::new(HashMap::new()) } + Self { + local_id: local_id.to_string(), + realm_id, + store, + backend, + relay: Mutex::new(None), + direct_route: Mutex::new(None), + write: Mutex::new(()), + link_failures: Mutex::new(HashMap::new()), + } } pub fn set_relay(&self, provider: Arc) { *self.relay.lock().unwrap() = Some(provider); } + pub fn set_direct_route(&self, route: Option) { + *self.direct_route.lock().unwrap() = route; + } + + pub fn direct_route(&self) -> Option { + self.direct_route.lock().unwrap().clone() + } + pub fn realm_id(&self) -> RealmId { self.realm_id @@ -202,7 +220,10 @@ impl HostService { return err(AppError::UnsupportedVersion, "This protocol version is not supported."); } match self.backend.info(&self.local_id) { - Ok(info) => Response::Welcome { realm_id: self.realm_id, automatic: info.automatic, existing_only: !info.automatic, route: info.route }, + Ok(info) => { + let active_route = self.direct_route().or(info.route); + Response::Welcome { realm_id: self.realm_id, automatic: info.automatic, existing_only: !info.automatic, route: active_route } + } Err(e) => unavailable("realm info", &e), } } @@ -212,7 +233,10 @@ impl HostService { Request::Claim { token } => self.claim(session, player, token), Request::ClaimAck { character_id } => self.ack(player, character_id), Request::Route => match self.backend.info(&self.local_id) { - Ok(info) => Response::RouteInfo { address: info.route }, + Ok(info) => { + let active_route = self.direct_route().or(info.route); + Response::RouteInfo { address: active_route } + } Err(e) => unavailable("route", &e), }, Request::TransferOffer { transfer_id, character_id, canonical_revision, content_hash, total_size, collections } => { diff --git a/services/coa-control-e2e/tests/phase14_direct_and_relay.rs b/services/coa-control-e2e/tests/phase14_direct_and_relay.rs new file mode 100644 index 0000000..e1a30f6 --- /dev/null +++ b/services/coa-control-e2e/tests/phase14_direct_and_relay.rs @@ -0,0 +1,402 @@ +use std::io::{Read, Write}; +use std::net::{TcpListener, TcpStream}; +use std::sync::Arc; +use std::time::Duration; + +use coa_core::control::direct_ingress::DirectIngress; +use coa_core::control::host_link::HostLink; +use coa_core::control::join::{PlayerControl, RealmTarget}; +use coa_core::control::secrets::MemoryStore; +use coa_core::control::service::fake::FakeRealm; +use coa_core::control::service::HostService; +use coa_core::control::store::ControlStore; +use coa_registry_proto::RealmId; +use ed25519_dalek::SigningKey; +use tempfile::tempdir; +use uuid::Uuid; + +fn now() -> i64 { + std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs() as i64 +} + +fn random_key() -> SigningKey { + let mut seed = [0u8; 32]; + seed[..16].copy_from_slice(Uuid::new_v4().as_bytes()); + seed[16..].copy_from_slice(Uuid::new_v4().as_bytes()); + SigningKey::from_bytes(&seed) +} + +fn build_fake_realm_list(original_world_addr: &str) -> Vec { + let mut pkt = vec![ + 0x10, // CMD_REALM_LIST opcode + 0x00, 0x00, // Size placeholder + 0x00, 0x00, 0x00, 0x00, // Unused + 0x01, 0x00, // Realm count: 1 + 0x01, 0x00, 0x00, 0x00, // Icon + 0x00, // Lock + 0x00, // Flags + ]; + pkt.extend_from_slice(b"Phase14Realm\0"); + pkt.extend_from_slice(original_world_addr.as_bytes()); + pkt.push(0x00); + pkt.extend_from_slice(&[0x00, 0x00, 0x00, 0x00]); // Population + pkt.extend_from_slice(&[0x01]); // Num characters + pkt.extend_from_slice(&[0x01]); // Timezone + pkt.extend_from_slice(&[0x00]); // Realm ID + pkt.extend_from_slice(&[0x02, 0x00]); // Footer + + let body_len = (pkt.len() - 3) as u16; + pkt[1..3].copy_from_slice(&body_len.to_le_bytes()); + pkt +} + +use coa_coordinator::listener::{LimitedListener, Peer}; +use coa_coordinator::{router, Config, Hub, MemoryKeys}; + +struct CoordTestHarness { + pub addr: std::net::SocketAddr, + pub keys: Arc, +} + +fn start_test_coordinator() -> CoordTestHarness { + let keys = Arc::new(MemoryKeys::default()); + let cfg = Config { + trust_proxy: true, + per_ip_connections: 64, + per_ip: coa_coordinator::limits::Rate::per_minute(1000, 1000.0), + per_realm: coa_coordinator::limits::Rate::per_minute(1000, 1000.0), + ..Config::default() + }; + let hub = Hub::new(keys.clone(), cfg, Arc::new(now)); + let app = router(hub); + let (tx, rx) = std::sync::mpsc::channel(); + + std::thread::spawn(move || { + let rt = tokio::runtime::Builder::new_multi_thread().worker_threads(2).enable_all().build().unwrap(); + rt.block_on(async move { + let tcp = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); + tx.send(tcp.local_addr().unwrap()).unwrap(); + axum::serve(LimitedListener::new(tcp, 64), app.into_make_service_with_connect_info::()).await.unwrap(); + }); + }); + CoordTestHarness { addr: rx.recv().unwrap(), keys } +} + +#[test] +fn test_phase14_direct_verified_route_connects_and_rewrites_realm_list() { + let coord = start_test_coordinator(); + let realm_id = RealmId::new(); + let realm_key = random_key(); + coord.keys.set(realm_id, &realm_key.verifying_key()); + + // Mock local Auth Server + let mock_auth = TcpListener::bind("127.0.0.1:0").unwrap(); + let local_auth_port = mock_auth.local_addr().unwrap().port(); + + // Mock local World Server + let mock_world = TcpListener::bind("127.0.0.1:0").unwrap(); + let local_world_port = mock_world.local_addr().unwrap().port(); + + // Start Direct Ingress Proxy + let mut ingress = DirectIngress::start( + 0, + 0, + "127.0.0.1".into(), + 0, + local_auth_port, + local_world_port, + ) + .unwrap(); + + let direct_auth_port = ingress.auth_port(); + let direct_world_port = ingress.world_port(); + + // Host Service setup + let fake_realm = FakeRealm::new(true); + let store = Arc::new(std::sync::Mutex::new(ControlStore::open_in_memory().unwrap())); + let service = Arc::new(HostService::new("local-1", realm_id, store, fake_realm)); + service.set_direct_route(Some(format!("127.0.0.1:{direct_auth_port}"))); + + // Host connects to Coordinator + let coord_ws = format!("ws://{}/coord/v1/host", coord.addr); + let host_link = HostLink::start(coord_ws, realm_id, realm_key.clone(), service.clone(), Arc::new(now)); + let end = std::time::Instant::now() + Duration::from_secs(5); + while !host_link.status().connected { + assert!(std::time::Instant::now() < end, "Host never connected to coord"); + std::thread::sleep(Duration::from_millis(50)); + } + + // Player connects over Coordinator + let p_dir = tempdir().unwrap(); + let pc = PlayerControl::open(p_dir.path(), Arc::new(MemoryStore::default())).unwrap(); + let player_coord_url = format!("ws://{}/coord/v1/player", coord.addr); + let target = RealmTarget { + realm_id, + key: realm_key.verifying_key(), + coordinator: player_coord_url, + }; + let mut ch = pc.connect(&target).unwrap(); + let (_auto, _exist, offered_route) = pc.welcome(&mut ch).unwrap(); + assert_eq!(offered_route, Some(format!("127.0.0.1:{direct_auth_port}"))); + + // Spawn mock auth responder that loops (ignoring 0-byte probe) + let fake_pkt = build_fake_realm_list("127.0.0.1:8085"); + let t_auth = std::thread::spawn(move || { + while let Ok((mut stream, _)) = mock_auth.accept() { + let mut buf = [0u8; 16]; + match stream.read(&mut buf) { + Ok(0) | Err(_) => continue, + Ok(_) => { + let _ = stream.write_all(&fake_pkt); + break; + } + } + } + }); + + // Spawn mock world responder + let t_world = std::thread::spawn(move || { + let (mut stream, _) = mock_world.accept().unwrap(); + let mut buf = [0u8; 16]; + let n = stream.read(&mut buf).unwrap(); + assert_eq!(&buf[..n], b"WORLD_SESSION"); + stream.write_all(b"WORLD_ACK").unwrap(); + }); + + // Player verifies direct route candidate via quick TCP probe + let candidate = offered_route.unwrap(); + let direct_usable = TcpStream::connect_timeout( + &candidate.parse().unwrap(), + Duration::from_millis(2000), + ).is_ok(); + assert!(direct_usable, "Direct route must be connectable"); + + // Client connects to direct AUTH port + let mut client_auth = TcpStream::connect(format!("127.0.0.1:{direct_auth_port}")).unwrap(); + client_auth.write_all(b"PING_AUTH").unwrap(); + let mut resp = [0u8; 512]; + let n = client_auth.read(&mut resp).unwrap(); + let resp_str = String::from_utf8_lossy(&resp[..n]); + // Address was rewritten to direct world port + assert!(resp_str.contains(&format!("127.0.0.1:{direct_world_port}")), "Expected rewritten direct world port in {resp_str}"); + drop(client_auth); + + // Client connects to direct WORLD port + let mut client_world = TcpStream::connect(format!("127.0.0.1:{direct_world_port}")).unwrap(); + client_world.write_all(b"WORLD_SESSION").unwrap(); + let mut w_resp = [0u8; 16]; + let wn = client_world.read(&mut w_resp).unwrap(); + assert_eq!(&w_resp[..wn], b"WORLD_ACK"); + drop(client_world); + + t_auth.join().unwrap(); + t_world.join().unwrap(); + ingress.stop(); +} + +#[test] +fn test_phase14_direct_unreachable_falls_back_to_relay() { + let coord = start_test_coordinator(); + let realm_id = RealmId::new(); + let realm_key = random_key(); + coord.keys.set(realm_id, &realm_key.verifying_key()); + + // Host Service has NO direct route (e.g. CGNAT or unmapped) + let fake_realm = FakeRealm::new(true); + let store = Arc::new(std::sync::Mutex::new(ControlStore::open_in_memory().unwrap())); + let service = Arc::new(HostService::new("local-1", realm_id, store, fake_realm)); + service.set_direct_route(None); // Direct route unavailable + + // Mock Relay Provider + struct MockRelay; + impl coa_core::control::service::RelayProvider for MockRelay { + fn allocate(&self, _player: &Uuid, _ip: Option<&str>) -> coa_core::Result { + Ok(coa_core::control::relay_link::RelayAllocationInfo { + relay_host: "relay.test".into(), + auth_port: 41000, + world_port: 41001, + token: "token123".into(), + expires_at: now() + 60, + }) + } + } + service.set_relay(Arc::new(MockRelay)); + + // Host connects to Coordinator + let coord_ws = format!("ws://{}/coord/v1/host", coord.addr); + let host_link = HostLink::start(coord_ws, realm_id, realm_key.clone(), service.clone(), Arc::new(now)); + let end = std::time::Instant::now() + Duration::from_secs(5); + while !host_link.status().connected { + assert!(std::time::Instant::now() < end, "Host never connected to coord"); + std::thread::sleep(Duration::from_millis(50)); + } + + // Player connects over Coordinator + let p_dir = tempdir().unwrap(); + let pc = PlayerControl::open(p_dir.path(), Arc::new(MemoryStore::default())).unwrap(); + let player_coord_url = format!("ws://{}/coord/v1/player", coord.addr); + let target = RealmTarget { + realm_id, + key: realm_key.verifying_key(), + coordinator: player_coord_url, + }; + let mut ch = pc.connect(&target).unwrap(); + let (_auto, _exist, offered_route) = pc.welcome(&mut ch).unwrap(); + assert_eq!(offered_route, None, "Direct route must be None when unavailable"); + + // Ensure account before allocating relay + let _account = pc.ensure_account(&mut ch, &realm_id, Some("PLAYER")).unwrap(); + + // Player route selection: since offered_route is None, transparently falls back to allocate_relay + let relay_alloc = pc.allocate_relay(&mut ch).unwrap(); + assert_eq!(relay_alloc.relay_host, "relay.test"); + assert_eq!(relay_alloc.auth_port, 41000); + assert_eq!(relay_alloc.world_port, 41001); +} + +#[test] +fn test_phase14_mixed_mode_simultaneous_direct_and_relay() { + let coord = start_test_coordinator(); + let realm_id = RealmId::new(); + let realm_key = random_key(); + coord.keys.set(realm_id, &realm_key.verifying_key()); + + // Mock local Auth & World + let mock_auth = TcpListener::bind("127.0.0.1:0").unwrap(); + let local_auth_port = mock_auth.local_addr().unwrap().port(); + let mock_world = TcpListener::bind("127.0.0.1:0").unwrap(); + let local_world_port = mock_world.local_addr().unwrap().port(); + + // Start Direct Ingress + let mut ingress = DirectIngress::start( + 0, + 0, + "127.0.0.1".into(), + local_world_port, + local_auth_port, + local_world_port, + ) + .unwrap(); + let direct_auth_port = ingress.auth_port(); + + // Host Service has both Direct and Relay capability + let fake_realm = FakeRealm::new(true); + let store = Arc::new(std::sync::Mutex::new(ControlStore::open_in_memory().unwrap())); + let service = Arc::new(HostService::new("local-1", realm_id, store, fake_realm)); + service.set_direct_route(Some(format!("127.0.0.1:{direct_auth_port}"))); + + struct MockRelay; + impl coa_core::control::service::RelayProvider for MockRelay { + fn allocate(&self, _player: &Uuid, _ip: Option<&str>) -> coa_core::Result { + Ok(coa_core::control::relay_link::RelayAllocationInfo { + relay_host: "relay.test".into(), + auth_port: 42000, + world_port: 42001, + token: "tok-relay".into(), + expires_at: now() + 60, + }) + } + } + service.set_relay(Arc::new(MockRelay)); + + // Host connects to Coordinator + let coord_ws = format!("ws://{}/coord/v1/host", coord.addr); + let host_link = HostLink::start(coord_ws, realm_id, realm_key.clone(), service.clone(), Arc::new(now)); + let end = std::time::Instant::now() + Duration::from_secs(5); + while !host_link.status().connected { + assert!(std::time::Instant::now() < end, "Host never connected to coord"); + std::thread::sleep(Duration::from_millis(50)); + } + + // Player 1 (Direct) connects + let target = RealmTarget { + realm_id, + key: realm_key.verifying_key(), + coordinator: format!("ws://{}/coord/v1/player", coord.addr), + }; + let p_dir1 = tempdir().unwrap(); + let pc1 = PlayerControl::open(p_dir1.path(), Arc::new(MemoryStore::default())).unwrap(); + let mut ch1 = pc1.connect(&target).unwrap(); + let (_auto1, _exist1, route1) = pc1.welcome(&mut ch1).unwrap(); + assert_eq!(route1, Some(format!("127.0.0.1:{direct_auth_port}"))); + + // Player 2 (Relay - e.g. simulating direct connect failed or blocked) + let p_dir2 = tempdir().unwrap(); + let pc2 = PlayerControl::open(p_dir2.path(), Arc::new(MemoryStore::default())).unwrap(); + let mut ch2 = pc2.connect(&target).unwrap(); + let (_auto2, _exist2, _route2) = pc2.welcome(&mut ch2).unwrap(); + let _acc2 = pc2.ensure_account(&mut ch2, &realm_id, Some("PLAYER2")).unwrap(); + let relay_alloc2 = pc2.allocate_relay(&mut ch2).unwrap(); + assert_eq!(relay_alloc2.relay_host, "relay.test"); + assert_eq!(relay_alloc2.auth_port, 42000); + + // Both players successfully got their respective routes on the exact same realm concurrently! + assert_ne!(route1.unwrap(), format!("{}:{}", relay_alloc2.relay_host, relay_alloc2.auth_port)); + + ingress.stop(); +} + +#[test] +fn test_phase14_security_direct_ingress_strictly_forbids_mysql_and_ra() { + // Mock local Auth + let mock_auth = TcpListener::bind("127.0.0.1:0").unwrap(); + let local_auth_port = mock_auth.local_addr().unwrap().port(); + + // Mock local World + let mock_world = TcpListener::bind("127.0.0.1:0").unwrap(); + let local_world_port = mock_world.local_addr().unwrap().port(); + + // Mock local MySQL (3306 mock) + let mock_mysql = TcpListener::bind("127.0.0.1:0").unwrap(); + let local_mysql_port = mock_mysql.local_addr().unwrap().port(); + + // Mock local Remote Administration (3443 mock) + let mock_ra = TcpListener::bind("127.0.0.1:0").unwrap(); + let local_ra_port = mock_ra.local_addr().unwrap().port(); + + let mut ingress = DirectIngress::start( + 0, + 0, + "127.0.0.1".into(), + local_world_port, + local_auth_port, + local_world_port, + ) + .unwrap(); + + let d_auth = ingress.auth_port(); + let d_world = ingress.world_port(); + + // Verify direct ingress binds ONLY to its 2 allocated ports (Auth & World) + assert_ne!(d_auth, local_mysql_port); + assert_ne!(d_auth, local_ra_port); + assert_ne!(d_world, local_mysql_port); + assert_ne!(d_world, local_ra_port); + + // Spawn mock auth responder + let t_auth = std::thread::spawn(move || { + let (mut stream, _) = mock_auth.accept().unwrap(); + let mut buf = [0u8; 16]; + let n = stream.read(&mut buf).unwrap(); + assert_eq!(&buf[..n], b"TEST_AUTH"); + stream.write_all(b"AUTH_OK").unwrap(); + }); + + // Test that client talking to direct auth reaches AUTH, not MySQL/RA + let mut client = TcpStream::connect(format!("127.0.0.1:{d_auth}")).unwrap(); + client.write_all(b"TEST_AUTH").unwrap(); + let mut resp = [0u8; 16]; + let n = client.read(&mut resp).unwrap(); + assert_eq!(&resp[..n], b"AUTH_OK"); + + // Verify no connections ever reached mock MySQL or RA + mock_mysql.set_nonblocking(true).unwrap(); + assert!(mock_mysql.accept().is_err(), "MySQL listener must receive 0 connections via direct ingress"); + + mock_ra.set_nonblocking(true).unwrap(); + assert!(mock_ra.accept().is_err(), "RA listener must receive 0 connections via direct ingress"); + + t_auth.join().unwrap(); + ingress.stop(); +} + diff --git a/services/coa-coordinator/src/lib.rs b/services/coa-coordinator/src/lib.rs index a44c644..7172cee 100644 --- a/services/coa-coordinator/src/lib.rs +++ b/services/coa-coordinator/src/lib.rs @@ -21,7 +21,7 @@ use axum::http::{HeaderMap, StatusCode}; use axum::response::{IntoResponse, Response}; use axum::routing::get; use axum::{Json, Router}; -use coa_control_proto::coord::{self, limits as lim, ErrorCode, Frame}; +use coa_control_proto::coord::{self, limits as lim, ErrorCode, Frame, ProbePayload, ProbeResponse}; use coa_registry_proto::RealmId; use ed25519_dalek::VerifyingKey; use serde::Deserialize; @@ -215,10 +215,66 @@ pub fn router(hub: Arc>) -> Router { .route("/coord/v1/health", get(health::)) .route("/coord/v1/host", get(host_ws::)) .route("/coord/v1/player", get(player_ws::)) + .route("/coord/v1/probe", axum::routing::post(probe_post::).get(probe_get::)) .fallback(|| async { (StatusCode::NOT_FOUND, "not found") }) .with_state(hub) } +#[derive(Deserialize)] +struct ProbeQuery { + ports: String, +} + +async fn probe_post( + State(hub): State>>, + ConnectInfo(Peer(peer)): ConnectInfo, + headers: HeaderMap, + Json(payload): Json, +) -> Response { + let ip = client_ip(&headers, peer, hub.cfg.trust_proxy); + perform_probe(ip, payload.ports).await +} + +async fn probe_get( + State(hub): State>>, + ConnectInfo(Peer(peer)): ConnectInfo, + headers: HeaderMap, + Query(q): Query, +) -> Response { + let ip = client_ip(&headers, peer, hub.cfg.trust_proxy); + let ports: Vec = q.ports.split(',').filter_map(|s| s.trim().parse().ok()).collect(); + perform_probe(ip, ports).await +} + +async fn perform_probe(ip: IpAddr, ports: Vec) -> Response { + if ports.is_empty() || ports.len() > 4 { + return (StatusCode::BAD_REQUEST, "invalid ports count").into_response(); + } + for &p in &ports { + if p == 0 || p == 22 || p == 80 || p == 443 || p == 5432 || p == 8080 || p == 8081 || p == 8082 { + return (StatusCode::FORBIDDEN, "forbidden port").into_response(); + } + } + let mut results = HashMap::new(); + let mut all_reachable = true; + for port in ports { + let addr = SocketAddr::new(ip, port); + let reachable = match tokio::time::timeout(Duration::from_millis(1500), tokio::net::TcpStream::connect(addr)).await { + Ok(Ok(_stream)) => true, + _ => false, + }; + if !reachable { + all_reachable = false; + } + results.insert(port, reachable); + } + Json(ProbeResponse { + client_ip: ip.to_string(), + results, + all_reachable, + }).into_response() +} + async fn health(State(hub): State>>) -> Response { Json(serde_json::json!({ "status": "ok", "protocol_version": coa_control_proto::CONTROL_PROTOCOL_VERSION, "hosts": hub.connected_hosts() })).into_response() } diff --git a/services/coa-coordinator/tests/coord.rs b/services/coa-coordinator/tests/coord.rs index b13f5cb..3a151c4 100644 --- a/services/coa-coordinator/tests/coord.rs +++ b/services/coa-coordinator/tests/coord.rs @@ -379,3 +379,33 @@ fn the_health_endpoint_answers_and_unknown_paths_do_not() { let out = read_response(&mut t); assert!(out.starts_with("HTTP/1.1 404"), "{out}"); } + +#[test] +fn probe_endpoint_verifies_reachable_and_unreachable_ports() { + let s = start(quick()); + let l1 = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); + let p1 = l1.local_addr().unwrap().port(); + let p2 = 45999; // assumed free port + + use std::io::Write; + let mut t = TcpStream::connect(s.addr).unwrap(); + let req = format!("GET /coord/v1/probe?ports={p1},{p2} HTTP/1.1\r\nHost: x\r\n\r\n"); + t.write_all(req.as_bytes()).unwrap(); + let out = read_response(&mut t); + assert!(out.starts_with("HTTP/1.1 200"), "{out}"); + assert!(out.contains(&format!("\"{p1}\":true")), "{out}"); + assert!(out.contains(&format!("\"{p2}\":false")), "{out}"); + assert!(out.contains("\"all_reachable\":false"), "{out}"); + + // Now test with both listening + let l2 = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); + let p2_live = l2.local_addr().unwrap().port(); + let mut t2 = TcpStream::connect(s.addr).unwrap(); + let req2 = format!("GET /coord/v1/probe?ports={p1},{p2_live} HTTP/1.1\r\nHost: x\r\n\r\n"); + t2.write_all(req2.as_bytes()).unwrap(); + let out2 = read_response(&mut t2); + assert!(out2.starts_with("HTTP/1.1 200"), "{out2}"); + assert!(out2.contains(&format!("\"{p1}\":true")), "{out2}"); + assert!(out2.contains(&format!("\"{p2_live}\":true")), "{out2}"); + assert!(out2.contains("\"all_reachable\":true"), "{out2}"); +} diff --git a/src-tauri/src/control_cmds.rs b/src-tauri/src/control_cmds.rs index 169daec..5260b1a 100644 --- a/src-tauri/src/control_cmds.rs +++ b/src-tauri/src/control_cmds.rs @@ -187,7 +187,21 @@ pub(crate) async fn join_realm(state: State<'_, AppState>, realm: String, charac let _ = pc.acknowledge(&mut ch, cuuid, &rid, &character); } } - if route.is_none() { + // Phase 14: Try direct route if provided, with quick TCP probe. If direct fails or unavailable, fall back to Relay. + let mut direct_worked = false; + if let Some(ref direct_addr) = route { + use std::net::ToSocketAddrs; + if let Ok(mut addrs) = direct_addr.to_socket_addrs() { + if let Some(sa) = addrs.next() { + if std::net::TcpStream::connect_timeout(&sa, std::time::Duration::from_millis(2000)).is_ok() { + out.route = Some(direct_addr.clone()); + out.status = "ready".into(); + direct_worked = true; + } + } + } + } + if !direct_worked { match pc.allocate_relay(&mut ch) { Ok(relay_alloc) => { let r = format!("{}:{}", relay_alloc.relay_host, relay_alloc.auth_port);