footing 0.1.7

Feature-gated foundations for Rust backend services
Documentation
use serde::{Deserialize, Serialize};

use crate::{
    http::{TrustedProxyConfig, trusted_proxy::ForwardedHeadersPolicy},
    net::IpNetworkSet,
    settings::{SettingsIssues, SettingsValidationError},
};

use super::super::error::HttpLayerError;

#[cfg_attr(feature = "tier", derive(tier::TierConfig))]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
/// Serializable settings for forwarded headers.
pub struct ForwardedHeadersSettings {
    #[serde(default)]
    /// Forwarded-header trust mode.
    pub mode: ForwardedHeadersMode,
    #[serde(default)]
    /// Proxy networks trusted to supply forwarded headers.
    pub trusted_proxy_cidrs: Vec<String>,
}

#[cfg_attr(feature = "tier", derive(tier::TierConfig))]
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
/// Enumerates the supported forwarded headers mode values.
pub enum ForwardedHeadersMode {
    #[default]
    /// The capability is disabled.
    Disabled,
    /// Indicates trusted proxies.
    TrustedProxies,
    /// Indicates always.
    Always,
}

impl Default for ForwardedHeadersSettings {
    fn default() -> Self {
        Self {
            mode: ForwardedHeadersMode::Disabled,
            trusted_proxy_cidrs: Vec::new(),
        }
    }
}

impl ForwardedHeadersSettings {
    #[must_use]
    /// Creates disabled.
    pub fn disabled() -> Self {
        Self::default()
    }

    #[must_use]
    /// Creates trusted proxies.
    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]
    /// Creates always.
    pub fn always() -> Self {
        Self {
            mode: ForwardedHeadersMode::Always,
            trusted_proxy_cidrs: Vec::new(),
        }
    }

    pub(crate) fn validate_at(&self, path: &str) -> Result<(), SettingsValidationError> {
        let mut issues = SettingsIssues::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,
                )))
            }
        }
    }
}