use serde::{Deserialize, Serialize};
use crate::{
config::{ConfigIssues, ConfigValidationError},
http::{TrustedProxyConfig, trusted_proxy::ForwardedHeadersPolicy},
net::IpNetworkSet,
};
use super::super::error::HttpLayerError;
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct ForwardedHeadersSettings {
#[serde(default)]
pub mode: ForwardedHeadersMode,
#[serde(default)]
pub trusted_proxy_cidrs: Vec<String>,
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum ForwardedHeadersMode {
#[default]
Disabled,
TrustedProxies,
Always,
}
impl Default for ForwardedHeadersSettings {
fn default() -> Self {
Self {
mode: ForwardedHeadersMode::Disabled,
trusted_proxy_cidrs: Vec::new(),
}
}
}
impl ForwardedHeadersSettings {
#[must_use]
pub fn disabled() -> Self {
Self::default()
}
#[must_use]
pub fn trusted_proxies(cidrs: impl IntoIterator<Item = impl Into<String>>) -> Self {
Self {
mode: ForwardedHeadersMode::TrustedProxies,
trusted_proxy_cidrs: cidrs.into_iter().map(Into::into).collect(),
}
}
#[must_use]
pub fn always() -> Self {
Self {
mode: ForwardedHeadersMode::Always,
trusted_proxy_cidrs: Vec::new(),
}
}
pub(crate) fn validate_at(&self, path: &str) -> Result<(), ConfigValidationError> {
let mut issues = ConfigIssues::new();
match self.mode {
ForwardedHeadersMode::TrustedProxies => {
issues.require(
!self.trusted_proxy_cidrs.is_empty(),
format!("{path}.trusted_proxy_cidrs"),
"must not be empty when mode is trusted_proxies",
);
}
ForwardedHeadersMode::Disabled | ForwardedHeadersMode::Always => {
issues.require(
self.trusted_proxy_cidrs.is_empty(),
format!("{path}.trusted_proxy_cidrs"),
"must be empty unless mode is trusted_proxies",
);
}
}
if let Err(error) = IpNetworkSet::from_cidrs(&self.trusted_proxy_cidrs) {
issues.push(
format!("{path}.trusted_proxy_cidrs"),
format!("contains invalid CIDR: {error}"),
);
}
issues.into_result()
}
}
impl TryFrom<&ForwardedHeadersSettings> for ForwardedHeadersPolicy {
type Error = HttpLayerError;
fn try_from(value: &ForwardedHeadersSettings) -> Result<Self, Self::Error> {
match value.mode {
ForwardedHeadersMode::Disabled => Ok(Self::Never),
ForwardedHeadersMode::Always => Ok(Self::Always),
ForwardedHeadersMode::TrustedProxies => {
let networks =
IpNetworkSet::from_cidrs(&value.trusted_proxy_cidrs).map_err(|source| {
HttpLayerError::InvalidTrustedProxyCidr {
reason: source.to_string(),
}
})?;
Ok(Self::trusted_proxies(TrustedProxyConfig::from_network_set(
networks,
)))
}
}
}
}