initial commit

src/http_config.rs

@@ -0,0 +1,395 @@
+//! Prosody-compatible HTTP app mount and advertised URL configuration.
+use crate::config::{Config, Options};
+use anyhow::{Context, Result, ensure};
+use std::collections::{BTreeMap, BTreeSet};
+
+#[derive(Clone, Debug)]
+pub struct HttpConfig {
+    pub host: String,
+    pub default_host: Option<String>,
+    pub websocket_path: String,
+    pub bosh_path: String,
+    pub file_share_path: String,
+    pub altconnect_path: String,
+    pub consider_websocket_secure: bool,
+    pub consider_bosh_secure: bool,
+    pub websocket_origins: Vec<String>,
+    pub bosh_origins: Vec<String>,
+    known_hosts: BTreeSet<String>,
+    external: Option<String>,
+}
+fn string(options: &Options, key: &str) -> Result<Option<String>> {
+    options
+        .get(key)
+        .map(|v| {
+            v.as_str()
+                .map(str::to_owned)
+                .with_context(|| format!("{key} must be a string"))
+        })
+        .transpose()
+}
+fn valid_authority(authority: &axum::http::uri::Authority) -> bool {
+    let raw = authority.as_str();
+    if raw.contains('@') {
+        return false;
+    }
+    let suffix = if raw.starts_with('[') {
+        let Some(end) = raw.find(']') else {
+            return false;
+        };
+        &raw[end + 1..]
+    } else {
+        raw.find(':').map(|i| &raw[i..]).unwrap_or("")
+    };
+    if suffix.is_empty() {
+        return true;
+    }
+    suffix.strip_prefix(':').is_some_and(|port| {
+        !port.is_empty() && port.bytes().all(|c| c.is_ascii_digit()) && port.parse::<u16>().is_ok()
+    })
+}
+fn host(value: &str) -> Result<String> {
+    ensure!(
+        !value.is_empty()
+            && value.is_ascii()
+            && value
+                .bytes()
+                .all(|c| c.is_ascii_alphanumeric() || matches!(c, b'.' | b'-')),
+        "invalid HTTP host: {value}"
+    );
+    Ok(value.to_ascii_lowercase())
+}
+/// Mount paths are literals, never axum route patterns. Reject ambiguous or unsafe forms.
+pub fn normalize_path(value: &str) -> Result<String> {
+    ensure!(
+        value.is_ascii(),
+        "HTTP paths must use percent encoding for non-ASCII characters"
+    );
+    // Validate pchars directly. No value is passed to a route-pattern parser.
+    let bytes = value.as_bytes();
+    let mut decoded = Vec::with_capacity(bytes.len());
+    let mut offset = 0;
+    while offset < bytes.len() {
+        let byte = bytes[offset];
+        if byte == b'%' {
+            ensure!(
+                offset + 2 < bytes.len()
+                    && bytes[offset + 1].is_ascii_hexdigit()
+                    && bytes[offset + 2].is_ascii_hexdigit(),
+                "malformed percent escape in HTTP path"
+            );
+            let byte = u8::from_str_radix(&value[offset + 1..offset + 3], 16)?;
+            ensure!(
+                byte != b'/' && byte != b'\\' && !byte.is_ascii_control(),
+                "ambiguous percent escape in HTTP path"
+            );
+            decoded.push(byte);
+            offset += 3;
+        } else {
+            ensure!(
+                byte.is_ascii_alphanumeric() || b"/-._~!&'()*+,;=:@".contains(&byte),
+                "HTTP path must contain only literal URL path characters"
+            );
+            decoded.push(byte);
+            offset += 1;
+        }
+    }
+    ensure!(
+        !value.contains("//")
+            && !decoded
+                .split(|b| *b == b'/')
+                .any(|s| s == b"." || s == b".."),
+        "invalid HTTP path"
+    );
+    let value = if value.starts_with('/') {
+        value.to_owned()
+    } else {
+        format!("/{value}")
+    };
+    let value = value.trim_end_matches('/');
+    Ok(if value.is_empty() {
+        "/".into()
+    } else {
+        value.to_owned()
+    })
+}
+
+fn paths(options: &Options) -> Result<BTreeMap<String, String>> {
+    let Some(value) = options.get("http_paths") else {
+        return Ok(BTreeMap::new());
+    };
+    let table = value.as_object().context("http_paths must be a table")?;
+    table
+        .iter()
+        .map(|(k, v)| {
+            Ok((
+                k.clone(),
+                v.as_str()
+                    .context("http_paths entries must be strings")?
+                    .to_owned(),
+            ))
+        })
+        .collect()
+}
+impl HttpConfig {
+    pub fn for_host(config: &Config, domain: &str) -> Result<Self> {
+        let local = &config
+            .hosts
+            .get(domain)
+            .context("unknown HTTP virtual host")?
+            .options;
+        let global_paths = paths(&config.global)?;
+        let local_paths = paths(local)?;
+        let mount = |name: &str, default: &str| -> Result<String> {
+            normalize_path(
+                &local_paths
+                    .get(name)
+                    .or_else(|| global_paths.get(name))
+                    .map(String::as_str)
+                    .unwrap_or(default)
+                    .replace("$host", domain),
+            )
+        };
+        let effective_host = |name: &str| -> Result<String> {
+            let h = &config.hosts.get(name).context("unknown HTTP host")?.options;
+            host(
+                &string(h, "http_host")?
+                    .or(string(&config.global, "http_host")?)
+                    .unwrap_or_else(|| name.into()),
+            )
+        };
+        let mut known_hosts = BTreeSet::new();
+        for name in config.hosts.keys() {
+            known_hosts.insert(effective_host(name)?);
+        }
+        let default_host = string(&config.global, "http_default_host")?
+            .map(|s| host(&s))
+            .transpose()?;
+        let origins = |module: &str| -> Result<Vec<String>> {
+            let value = config
+                .option(domain, "http_cors_override")
+                .and_then(|v| v.get(module))
+                .and_then(|v| v.get("origins"))
+                .or_else(|| config.option(domain, "access_control_allow_origins"));
+            match value {
+                None => Ok(vec![]),
+                Some(v) if v.as_object().is_some_and(|m| m.is_empty()) => Ok(vec![]),
+                Some(v) if v.as_str() == Some("*") => Ok(vec!["*".into()]),
+                Some(v) => v
+                    .as_array()
+                    .context("HTTP origins must be a list")?
+                    .iter()
+                    .map(|v| {
+                        v.as_str()
+                            .map(str::to_owned)
+                            .context("HTTP origins entries must be strings")
+                    })
+                    .collect(),
+            }
+        };
+        let boolean = |key: &str| -> Result<bool> {
+            config
+                .option(domain, key)
+                .map(|v| {
+                    v.as_bool()
+                        .with_context(|| format!("{key} must be boolean"))
+                })
+                .unwrap_or(Ok(false))
+        };
+        let external =
+            string(local, "http_external_url")?.or(string(&config.global, "http_external_url")?);
+        if let Some(url) = &external {
+            parse_external(url)?;
+        }
+        Ok(Self {
+            host: effective_host(domain)?,
+            default_host,
+            websocket_path: mount("websocket", "/xmpp-websocket")?,
+            bosh_path: mount("bosh", "/http-bind")?,
+            file_share_path: mount("file_share", "/file_share")?,
+            altconnect_path: mount("altconnect", "/.well-known")?,
+            consider_websocket_secure: boolean("consider_websocket_secure")?,
+            consider_bosh_secure: boolean("consider_bosh_secure")?,
+            websocket_origins: origins("websocket")?,
+            bosh_origins: origins("bosh")?,
+            known_hosts,
+            external,
+        })
+    }
+    pub fn accepts_host(&self, authority: &str) -> bool {
+        let Ok(authority) = authority.parse::<axum::http::uri::Authority>() else {
+            return false;
+        };
+        if !valid_authority(&authority) {
+            return false;
+        }
+        let requested = authority.host().to_ascii_lowercase();
+        requested == self.host
+            || (!self.known_hosts.contains(&requested)
+                && self.default_host.as_deref() == Some(self.host.as_str()))
+    }
+    /// External reverse-proxy prefixes affect discovery only, never local mounts.
+    pub fn external_url(&self, app: &str, secure: bool, port: u16) -> Result<String> {
+        let path = match app {
+            "websocket" => &self.websocket_path,
+            "bosh" => &self.bosh_path,
+            "file_share" => &self.file_share_path,
+            "altconnect" => &self.altconnect_path,
+            _ => anyhow::bail!("unknown HTTP app"),
+        };
+        if let Some(external) = &self.external {
+            let uri = parse_external(external)?;
+            let scheme = uri.scheme_str().unwrap();
+            let authority = uri.authority().unwrap();
+            let authority =
+                if authority.port_u16() == Some(if scheme == "https" { 443 } else { 80 }) {
+                    authority.host().to_owned()
+                } else {
+                    authority.to_string()
+                };
+            return Ok(format!(
+                "{scheme}://{authority}{}{path}",
+                uri.path().trim_end_matches('/')
+            ));
+        }
+        let scheme = if secure { "https" } else { "http" };
+        let port = if port == if secure { 443 } else { 80 } {
+            String::new()
+        } else {
+            format!(":{port}")
+        };
+        Ok(format!("{scheme}://{}{port}{path}", self.host))
+    }
+}
+fn parse_external(value: &str) -> Result<axum::http::Uri> {
+    let uri: axum::http::Uri = value.parse().context("invalid http_external_url")?;
+    ensure!(
+        matches!(uri.scheme_str(), Some("http" | "https"))
+            && uri.authority().is_some()
+            && !uri.authority().unwrap().as_str().contains('@')
+            && uri.query().is_none()
+            && !value.contains('#'),
+        "http_external_url must be an absolute HTTP(S) URL without credentials, query or fragment"
+    );
+    ensure!(
+        valid_authority(uri.authority().unwrap()),
+        "http_external_url port must be in 0..65535"
+    );
+    Ok(uri)
+}
+pub fn validate(config: &Config) -> Result<()> {
+    for options in std::iter::once(&config.global).chain(config.hosts.values().map(|h| &h.options))
+    {
+        for value in paths(options)?.values() {
+            normalize_path(&value.replace("$host", "example.test"))?;
+        }
+    }
+    for domain in config.hosts.keys() {
+        let http = HttpConfig::for_host(config, domain)?;
+        let modules = config.modules(domain)?;
+        ensure!(
+            !(modules.contains("websocket")
+                && modules.contains("bosh")
+                && http.websocket_path == http.bosh_path),
+            "websocket and bosh HTTP paths conflict for {domain}"
+        );
+        if modules.contains("http_altconnect") {
+            for suffix in ["host-meta", "host-meta.json"] {
+                let path = format!("{}/{suffix}", http.altconnect_path.trim_end_matches('/'));
+                ensure!(
+                    !(modules.contains("websocket") && http.websocket_path == path
+                        || modules.contains("bosh") && http.bosh_path == path),
+                    "http_altconnect path conflicts with XMPP transport for {domain}"
+                );
+            }
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn config(value: serde_json::Value) -> Config {
+        serde_json::from_value(value).unwrap()
+    }
+    #[test]
+    fn mounts_inherit_per_app_and_expand_virtual_host() {
+        let c = config(
+            serde_json::json!({"global":{"http_paths":{"websocket":"global/$host/","bosh":"bind/"}},"hosts":{"a.test":{"options":{"http_paths":{"websocket":"custom/$host"}}}}}),
+        );
+        let h = HttpConfig::for_host(&c, "a.test").unwrap();
+        assert_eq!(h.websocket_path, "/custom/a.test");
+        assert_eq!(h.bosh_path, "/bind");
+    }
+    #[test]
+    fn routes_hosts_and_default_without_overriding_known_hosts() {
+        let c = config(
+            serde_json::json!({"global":{"http_default_host":"web.test"},"hosts":{"a.test":{"options":{"http_host":"web.test"}},"b.test":{"options":{}}}}),
+        );
+        let h = HttpConfig::for_host(&c, "a.test").unwrap();
+        assert!(h.accepts_host("WEB.TEST:5280"));
+        assert!(h.accepts_host("unknown.test"));
+        assert!(!h.accepts_host("b.test"));
+        assert!(!h.accepts_host("bad host"));
+    }
+    #[test]
+    fn external_prefix_and_standard_port() {
+        let c = config(
+            serde_json::json!({"global":{"http_external_url":"https://proxy.test:443/prefix/"},"hosts":{"a.test":{"options":{}}}}),
+        );
+        assert_eq!(
+            HttpConfig::for_host(&c, "a.test")
+                .unwrap()
+                .external_url("bosh", false, 5280)
+                .unwrap(),
+            "https://proxy.test/prefix/http-bind"
+        );
+    }
+    #[test]
+    fn literal_pchars_and_percent_encoding_are_supported() {
+        for path in [
+            "/chat/v1:ws",
+            "/bind%20endpoint",
+            "/a/*",
+            "/a@b!&'()+,;=:_~-.%41",
+        ] {
+            assert_eq!(normalize_path(path).unwrap(), path);
+        }
+    }
+    #[test]
+    fn invalid_paths_types_urls_and_conflicts_are_errors() {
+        for path in [
+            "/a/{capture}",
+            "/../b",
+            "/a?x",
+            "/a#b",
+            "/a//b",
+            "/$unknown",
+            "/a%2fb",
+            "/a%5cb",
+            "/a%00b",
+            "/%2e%2E/b",
+            "/a%",
+            "/a%xx",
+            "/a b",
+            "/a\\b",
+        ] {
+            assert!(normalize_path(path).is_err(), "{path}");
+        }
+        for global in [
+            serde_json::json!({"http_paths":false}),
+            serde_json::json!({"http_paths":{"bosh":false}}),
+            serde_json::json!({"http_external_url":"https://u:p@a.test"}),
+            serde_json::json!({"http_external_url":"relative/path"}),
+            serde_json::json!({"modules_enabled":["websocket","bosh"],"http_paths":{"websocket":"same/","bosh":"/same"}}),
+        ] {
+            assert!(
+                validate(&config(
+                    serde_json::json!({"global":global,"hosts":{"a.test":{"options":{}}}})
+                ))
+                .is_err()
+            );
+        }
+    }
+}