Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
7.9 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

pub(super) use fluxer_common::config::{EnvMap, parse_bool, parse_number};

use super::{BucketStyle, DeploymentMode, PolicyMode, StorageBackend};
use crate::constants::DESKTOP_APP_ORIGIN;
use base64::{Engine as _, engine::general_purpose};
use fluxer_common::secret::SecretBytes;
use http::HeaderValue;

fn parse_mode(raw: &str) -> Option<DeploymentMode> {
    match raw.to_ascii_lowercase().as_str() {
        "mp" => Some(DeploymentMode::Mp),
        "static" => Some(DeploymentMode::Static),
        "upload" => Some(DeploymentMode::Upload),
        "relay" => Some(DeploymentMode::Relay),
        _ => None,
    }
}

pub(super) fn parse_mode_env(raw: Option<&str>) -> anyhow::Result<Option<DeploymentMode>> {
    let Some(raw) = raw else {
        return Ok(None);
    };
    let raw = raw.trim();
    parse_mode(raw).map(Some).ok_or_else(|| {
        anyhow::anyhow!("FLUXER_MEDIA_PROXY_MODE must be one of: mp, static, upload, relay")
    })
}

pub(super) fn parse_policy_mode(var_name: &str, raw: Option<&str>) -> anyhow::Result<PolicyMode> {
    let Some(raw) = raw else {
        return Ok(PolicyMode::Off);
    };
    match raw.trim().to_ascii_lowercase().as_str() {
        "off" => Ok(PolicyMode::Off),
        "report" => Ok(PolicyMode::Report),
        "enforce" => Ok(PolicyMode::Enforce),
        _ => Err(anyhow::anyhow!(
            "{var_name} must be one of: off, report, enforce"
        )),
    }
}

pub(super) fn parse_attachment_url_secrets(
    var_name: &str,
    raw: Option<&str>,
) -> anyhow::Result<Vec<SecretBytes>> {
    let Some(raw) = raw else {
        return Ok(Vec::new());
    };
    let mut out: Vec<SecretBytes> = Vec::new();
    for entry in raw.split(',') {
        let entry = entry.trim();
        if entry.is_empty() {
            continue;
        }
        let decoded = general_purpose::STANDARD
            .decode(entry)
            .map_err(|_| anyhow::anyhow!("{var_name} entries must be standard base64"))?;
        anyhow::ensure!(
            decoded.len() >= 32,
            "{var_name} entries must decode to at least 32 bytes"
        );
        let candidate = SecretBytes::new(decoded);
        if !out
            .iter()
            .any(|existing| existing.expose() == candidate.expose())
        {
            out.push(candidate);
        }
    }
    Ok(out)
}

pub(super) fn parse_allowed_origins(
    var_name: &str,
    raw: Option<&str>,
) -> anyhow::Result<Vec<HeaderValue>> {
    let Some(raw) = raw else {
        return Ok(Vec::new());
    };
    let mut out: Vec<HeaderValue> = Vec::new();
    for entry in raw.split(',') {
        let entry = entry.trim();
        if entry.is_empty() {
            continue;
        }
        let origin = parse_origin(entry)
            .ok_or_else(|| anyhow::anyhow!("{var_name} contains an invalid origin: {entry}"))?;
        if !out.contains(&origin) {
            out.push(origin);
        }
    }
    Ok(out)
}

fn parse_origin(entry: &str) -> Option<HeaderValue> {
    if !entry.is_ascii() {
        return None;
    }
    if entry == DESKTOP_APP_ORIGIN {
        return Some(HeaderValue::from_static(DESKTOP_APP_ORIGIN));
    }
    let url = url::Url::parse(entry).ok()?;
    let bare = matches!(url.scheme(), "http" | "https")
        && url.host().is_some_and(is_origin_host)
        && url.username().is_empty()
        && url.password().is_none()
        && url.path() == "/"
        && url.query().is_none()
        && url.fragment().is_none();
    if !bare {
        return None;
    }
    let serialised = url.origin().ascii_serialization();
    if serialised == "null" {
        return None;
    }
    HeaderValue::from_str(&serialised).ok()
}

fn is_origin_host(host: url::Host<&str>) -> bool {
    match host {
        url::Host::Ipv4(_) | url::Host::Ipv6(_) => true,
        url::Host::Domain(domain) => domain.split('.').all(|label| {
            !label.is_empty()
                && label
                    .bytes()
                    .all(|byte| byte.is_ascii_alphanumeric() || byte == b'-')
        }),
    }
}

pub(super) fn parse_bucket_style(raw: Option<&str>) -> anyhow::Result<Option<BucketStyle>> {
    let Some(raw) = raw.map(str::trim) else {
        return Ok(None);
    };
    match raw.to_ascii_lowercase().as_str() {
        "path" => Ok(Some(BucketStyle::Path)),
        "virtual" => Ok(Some(BucketStyle::VirtualHosted)),
        "root" => Ok(Some(BucketStyle::Rooted)),
        _ => Err(anyhow::anyhow!(
            "FLUXER_S3_READ_BUCKET_STYLE must be one of: path, virtual, root"
        )),
    }
}

pub(super) fn validate_read_endpoint(endpoint: &str) -> anyhow::Result<()> {
    let parsed = url::Url::parse(endpoint)
        .map_err(|err| anyhow::anyhow!("FLUXER_S3_READ_ENDPOINT is not a valid URL: {err}"))?;
    anyhow::ensure!(
        matches!(parsed.scheme(), "http" | "https"),
        "FLUXER_S3_READ_ENDPOINT must be an http or https URL"
    );
    anyhow::ensure!(
        parsed.host_str().is_some_and(|host| !host.is_empty()),
        "FLUXER_S3_READ_ENDPOINT must include a host"
    );
    anyhow::ensure!(
        parsed.username().is_empty() && parsed.password().is_none(),
        "FLUXER_S3_READ_ENDPOINT must not contain credentials"
    );
    anyhow::ensure!(
        parsed.query().is_none() && parsed.fragment().is_none(),
        "FLUXER_S3_READ_ENDPOINT must not contain a query string or fragment"
    );
    Ok(())
}

pub(super) fn parse_storage_backend(raw: Option<&str>) -> anyhow::Result<Option<StorageBackend>> {
    let Some(raw) = raw else {
        return Ok(None);
    };
    let raw = raw.trim();
    match raw.to_ascii_lowercase().as_str() {
        "local" => Ok(Some(StorageBackend::Local)),
        "s3" => Ok(Some(StorageBackend::S3)),
        _ => Err(anyhow::anyhow!(
            "FLUXER_MEDIA_PROXY_STORAGE_BACKEND must be one of: local, s3"
        )),
    }
}

pub(super) fn decode_upload_relay_secret(
    raw: Option<&str>,
    mode: DeploymentMode,
) -> anyhow::Result<SecretBytes> {
    let Some(raw) = raw.map(str::trim) else {
        anyhow::ensure!(
            !mode.serves_upload_relay(),
            "FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SECRET_BASE64 is required in upload and relay modes"
        );
        return Ok(SecretBytes::new(Vec::new()));
    };
    let decoded = general_purpose::STANDARD.decode(raw).map_err(|_| {
        anyhow::anyhow!("FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SECRET_BASE64 must be base64")
    })?;
    anyhow::ensure!(
        decoded.len() >= 32,
        "FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SECRET_BASE64 must decode to at least 32 bytes"
    );
    Ok(SecretBytes::new(decoded))
}

pub(super) fn parse_u16(
    var_name: &str,
    raw: Option<&str>,
    default_value: u16,
) -> anyhow::Result<u16> {
    parse_number(var_name, raw, default_value, u16::MIN, u16::MAX)
}

pub(super) fn parse_u64(
    var_name: &str,
    raw: Option<&str>,
    default_value: u64,
    min_value: u64,
    max_value: u64,
) -> anyhow::Result<u64> {
    parse_number(var_name, raw, default_value, min_value, max_value)
}

pub(super) fn parse_usize(
    var_name: &str,
    raw: Option<&str>,
    default_value: usize,
    min_value: usize,
    max_value: usize,
) -> anyhow::Result<usize> {
    parse_number(var_name, raw, default_value, min_value, max_value)
}

pub(super) fn parse_f32(
    var_name: &str,
    raw: Option<&str>,
    default_value: f32,
    min_value: f32,
    max_value: f32,
) -> anyhow::Result<f32> {
    let Some(raw) = raw else {
        return Ok(default_value);
    };
    let parsed = raw
        .trim()
        .parse::<f32>()
        .map_err(|_| anyhow::anyhow!("{var_name} must be a number"))?;
    anyhow::ensure!(parsed.is_finite(), "{var_name} must be a finite number");
    anyhow::ensure!(
        (min_value..=max_value).contains(&parsed),
        "{var_name} must be between {min_value} and {max_value}"
    );
    Ok(parsed)
}

pub(super) fn default_native_transform_concurrency() -> usize {
    std::thread::available_parallelism()
        .map(usize::from)
        .unwrap_or(4)
        .clamp(2, 8)
}