diff --git a/crates/common/src/config/server/listener.rs b/crates/common/src/config/server/listener.rs index 0aa0ef07..41febdff 100644 --- a/crates/common/src/config/server/listener.rs +++ b/crates/common/src/config/server/listener.rs @@ -48,7 +48,24 @@ impl Listeners { // Parse servers if !bp.registry.is_recovery_mode() { let system = bp.setting_infallible::().await; + // inbuxa: K-C6: PROXY copies of mail listeners, from the environment + let proxy = match crate::manager::listener_ports::proxy_listeners( + types::branding::env_var("MAIL_PROXY_LISTENERS") + .ok() + .as_deref(), + types::branding::env_var("MAIL_PROXY_TRUSTED_NETWORKS") + .ok() + .as_deref(), + ) { + Ok(proxy) => proxy, + Err(err) => { + bp.build_error(ObjectType::NetworkListener.singleton(), err); + None + } + }; + let mut names = Vec::new(); for listener in bp.list_infallible::().await { + names.push(listener.object.name.clone()); if bp.role.as_ref().is_none_or(|r| match &r.listeners { ClusterListenerGroup::EnableAll => true, ClusterListenerGroup::DisableAll => false, @@ -59,7 +76,39 @@ impl Listeners { !group.listener_ids.iter().any(|id| *id == listener.id.id()) } }) { + let copy = proxy.as_ref().and_then(|proxy| { + let (name, port) = proxy + .ports + .iter() + .find(|(name, _)| *name == listener.object.name)?; + let mut object = listener.object.clone(); + object.name = format!("{name}-proxy"); + object.bind = + Map::new(vec![SocketAddr::from_str(&format!("[::]:{port}")).unwrap()]); + object.override_proxy_trusted_networks = Map::new(proxy.trusted.clone()); + Some(RegistryObject { + id: listener.id, + object, + revision: listener.revision, + }) + }); servers.parse_server(bp, listener, &system); + if let Some(copy) = copy { + servers.parse_server(bp, copy, &system); + } + } + } + if let Some(proxy) = &proxy { + for (name, _) in &proxy.ports { + if !names.iter().any(|n| n == name) { + bp.build_warning( + ObjectType::NetworkListener.singleton(), + format!( + "INBUXA_MAIL_PROXY_LISTENERS names '{name}', but this server \ + has no listener of that name to copy" + ), + ); + } } } } else { diff --git a/crates/common/src/manager/listener_ports.rs b/crates/common/src/manager/listener_ports.rs index 7e4b6e77..ebe04a17 100644 --- a/crates/common/src/manager/listener_ports.rs +++ b/crates/common/src/manager/listener_ports.rs @@ -95,10 +95,152 @@ pub fn default_listeners(spec: Option<&str>) -> Result, + pub trusted: Vec, +} + +/// `None` when neither variable is set. +pub fn proxy_listeners( + spec: Option<&str>, + networks: Option<&str>, +) -> Result, String> { + let spec = spec.map(str::trim).filter(|s| !s.is_empty()); + let networks = networks.map(str::trim).filter(|s| !s.is_empty()); + let (spec, networks) = match (spec, networks) { + (None, None) => return Ok(None), + (Some(_), None) => { + return Err(format!( + "{PROXY_ENV_VAR} is set without {PROXY_NETWORKS_ENV_VAR}: name the load \ + balancer's addresses, the only ones whose PROXY headers are believed" + )); + } + (None, Some(_)) => { + return Err(format!( + "{PROXY_NETWORKS_ENV_VAR} is set without {PROXY_ENV_VAR}, which names the \ + listeners that take PROXY headers" + )); + } + (Some(spec), Some(networks)) => (spec, networks), + }; + + let mut ports: Vec<(&'static str, u16)> = Vec::new(); + for item in spec.split(',').map(str::trim).filter(|i| !i.is_empty()) { + let Some((name, port)) = item.split_once('=') else { + return Err(format!( + "{PROXY_ENV_VAR}: '{item}' is not name=port (for example smtp=10025)" + )); + }; + let (name, port) = (name.trim(), port.trim()); + let Some(name) = MAIL_LISTENERS.iter().copied().find(|n| *n == name) else { + return Err(format!( + "{PROXY_ENV_VAR}: '{name}' is not a mail listener; they are {}", + MAIL_LISTENERS.join(", ") + )); + }; + let port = match port.parse::() { + Ok(port) if port > 0 => port, + _ => { + return Err(format!( + "{PROXY_ENV_VAR}: '{port}' is not a port for '{name}' (1 to 65535)" + )); + } + }; + if ports.iter().any(|(n, _)| *n == name) { + return Err(format!("{PROXY_ENV_VAR}: '{name}' is given twice")); + } + if let Some((other, _)) = ports.iter().find(|(_, p)| *p == port) { + return Err(format!( + "{PROXY_ENV_VAR}: '{other}' and '{name}' would both listen on port {port}" + )); + } + ports.push((name, port)); + } + + let mut trusted = Vec::new(); + for item in networks + .split(|c: char| c == ',' || c.is_whitespace()) + .filter(|i| !i.is_empty()) + { + trusted.push(item.parse().map_err(|_| { + format!( + "{PROXY_NETWORKS_ENV_VAR}: '{item}' is not an address or a network of /8 or \ + narrower" + ) + })?); + } + if ports.is_empty() || trusted.is_empty() { + return Err(format!( + "{PROXY_ENV_VAR} and {PROXY_NETWORKS_ENV_VAR} name nothing" + )); + } + Ok(Some(ProxyListeners { ports, trusted })) +} + #[cfg(test)] mod tests { use super::*; + #[test] + fn proxy_listeners_read() { + assert_eq!(proxy_listeners(None, None), Ok(None)); + assert_eq!(proxy_listeners(Some(" "), Some("")), Ok(None)); + let found = proxy_listeners( + Some("smtp=10025, imaps=10993"), + Some("10.0.0.10 192.168.0.0/16,fd00::/8"), + ) + .unwrap() + .unwrap(); + assert_eq!(found.ports, vec![("smtp", 10025), ("imaps", 10993)]); + assert_eq!(found.trusted.len(), 3); + } + + #[test] + fn proxy_listeners_refused() { + for (spec, networks, said) in [ + ( + "smtp=10025", + "", + "without INBUXA_MAIL_PROXY_TRUSTED_NETWORKS", + ), + ("", "10.0.0.1", "without INBUXA_MAIL_PROXY_LISTENERS"), + ("http=10080", "10.0.0.1", "not a mail listener"), + ("smtp=0", "10.0.0.1", "not a port"), + ("smtp=1,smtp=2", "10.0.0.1", "given twice"), + ("smtp=1,imaps=1", "10.0.0.1", "would both listen"), + ("smtp=10025", "0.0.0.0/0", "narrower"), + ("smtp=10025", "::/0", "narrower"), + ("smtp=10025", "not-an-address", "narrower"), + ] { + let err = proxy_listeners(Some(spec), Some(networks)).unwrap_err(); + assert!(err.contains(said), "{spec} {networks}: {err}"); + } + } + fn ports(spec: &str) -> Vec<(&'static str, u16)> { default_listeners(Some(spec)) .unwrap()