A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
// 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)
}