rns_net/common/

config.rs

//! ConfigObj parser for RNS config files.
//!
//! Python RNS uses ConfigObj format — NOT TOML, NOT standard INI.
//! Key differences: nested `[[sections]]`, booleans `Yes`/`No`/`True`/`False`,
//! comments with `#`, unquoted string values.

use std::collections::HashMap;
use std::fmt;
use std::io;
use std::path::Path;

use rns_core::stamp::StampCost;

/// Parsed RNS configuration.
#[derive(Debug, Clone)]
pub struct RnsConfig {
    pub reticulum: ReticulumSection,
    pub logging: LoggingSection,
    pub stamps: StampsSection,
    pub filter: FilterSection,
    pub interfaces: Vec<ParsedInterface>,
    pub hooks: Vec<ParsedHook>,
}

/// A parsed hook from `[[subsection]]` within `[hooks]`.
#[derive(Debug, Clone)]
pub struct ParsedHook {
    pub name: String,
    pub path: String,
    pub hook_type: String,
    pub builtin_id: Option<String>,
    pub attach_point: String,
    pub priority: i32,
    pub enabled: bool,
}

/// The `[reticulum]` section.
#[derive(Debug, Clone)]
pub struct ReticulumSection {
    pub enable_transport: bool,
    /// Inbound packets whose hop count reaches this limit are dropped and
    /// counted as `hop_limiter_hits` (upstream `hop_limiter`, clamped to
    /// `1..=PATHFINDER_M`).
    pub hop_limiter: u8,
    pub static_transport_identity: bool,
    pub local_hops_delta: bool,
    pub share_instance: bool,
    /// Allow local shared-instance clients to attach, detach, and reload interfaces.
    pub enable_interface_management: bool,
    pub instance_name: String,
    pub shared_instance_port: u16,
    pub instance_control_port: u16,
    pub panic_on_interface_error: bool,
    pub use_implicit_proof: bool,
    pub network_identity: Option<String>,
    pub respond_to_probes: bool,
    pub enable_remote_management: bool,
    pub remote_management_allowed: Vec<String>,
    pub publish_blackhole: bool,
    pub probe_port: Option<u16>,
    pub probe_addr: Option<String>,
    /// Protocol for endpoint discovery: "rnsp" (default) or "stun".
    pub probe_protocol: Option<String>,
    /// Policy for incoming direct-connect proposals.
    pub direct_connect_policy: crate::event::HolePunchPolicy,
    /// Accept direct-connect endpoints in private, shared, link-local,
    /// and unique-local ranges (LAN-only deployments).
    pub direct_connect_allow_private_endpoints: bool,
    /// Network interface to bind outbound sockets to (e.g. "usb0").
    pub device: Option<String>,
    /// Linux `SO_MARK` value applied to Reticulum IP underlay sockets.
    pub underlay_mark: Option<u32>,
    /// Enable interface discovery (advertise discoverable interfaces and
    /// listen for discovery announces from the network).
    pub discover_interfaces: bool,
    /// Global gravity used by interfaces without an explicit override.
    pub default_gravity: i64,
    /// Mode assigned to auto-connected interfaces.
    pub autoconnect_interface_mode: Option<String>,
    /// Gravity assigned to auto-connected interfaces.
    pub autoconnect_interface_gravity: i64,
    /// Allow auto-connected interfaces to propagate announces to internal interfaces.
    pub autoconnect_announces_to_internal: bool,
    /// Allow auto-connecting discovered interfaces from unverified implementations.
    pub autoconnect_unverified_implementations: bool,
    /// Minimum stamp value for accepting discovered interfaces, fractional
    /// since upstream 796ef2d4. A value of 0 or less leaves the default.
    pub required_discovery_value: Option<StampCost>,
    /// Accept an announce with strictly fewer hops even when the random_blob
    /// is a duplicate of the existing path entry.
    pub prefer_shorter_path: bool,
    /// Maximum number of alternative paths stored per destination.
    /// Default 1 (single path, backward-compatible).
    pub max_paths_per_destination: usize,
    /// Maximum number of packet hashes retained for duplicate suppression.
    pub packet_hashlist_max_entries: usize,
    /// Startup allocation policy for the packet hashlist payload pages.
    pub packet_hashlist_allocation: rns_core::transport::types::PacketHashlistAllocation,
    /// Maximum number of discovery path-request tags remembered.
    pub max_discovery_pr_tags: usize,
    /// Maximum number of destinations retained in the live path table.
    pub max_path_destinations: usize,
    /// Maximum number of destinations retained across tunnel-known paths.
    pub max_tunnel_destinations_total: usize,
    /// TTL for recalled known destinations without an active path, in seconds.
    pub known_destinations_ttl: u64,
    /// Maximum number of recalled known destinations retained.
    pub known_destinations_max_entries: usize,
    /// TTL for received ratchets, in seconds.
    pub ratchet_expiry: u64,
    /// TTL for announce retransmission state, in seconds.
    pub announce_table_ttl: u64,
    /// Maximum retained bytes for announce retransmission state.
    pub announce_table_max_bytes: usize,
    /// Whether the announce signature verification cache is enabled.
    pub announce_sig_cache_enabled: bool,
    /// Maximum entries in the announce signature verification cache.
    pub announce_sig_cache_max_entries: usize,
    /// TTL for announce signature cache entries, in seconds.
    pub announce_sig_cache_ttl: u64,
    /// Maximum entries in the async announce verification queue.
    pub announce_queue_max_entries: usize,
    /// Maximum interface-scoped announce queues retained.
    pub announce_queue_max_interfaces: usize,
    /// Default announce-rate target for transport-node interfaces, in seconds.
    pub default_ar_target: Option<f64>,
    /// Default announce-rate penalty for transport-node interfaces, in seconds.
    pub default_ar_penalty: f64,
    /// Default announce-rate grace count for transport-node interfaces.
    pub default_ar_grace: u32,
    /// Default maximum held announces for ingress control.
    pub default_ic_max_held_announces: usize,
    /// Default announce burst hold time for ingress control.
    pub default_ic_burst_hold: f64,
    /// Default new-interface announce burst threshold.
    pub default_ic_burst_freq_new: f64,
    /// Default mature-interface announce burst threshold.
    pub default_ic_burst_freq: f64,
    /// Default new-interface path request burst threshold.
    pub default_ic_pr_burst_freq_new: f64,
    /// Default mature-interface path request burst threshold.
    pub default_ic_pr_burst_freq: f64,
    /// Default new-interface age window for ingress control.
    pub default_ic_new_time: f64,
    /// Default burst penalty before releasing held announces.
    pub default_ic_burst_penalty: f64,
    /// Default interval between released held announces.
    pub default_ic_held_release_interval: f64,
    /// Default egress path request limiting state.
    pub default_egress_control: bool,
    /// Default egress path request frequency threshold.
    pub default_ec_pr_freq: f64,
    /// Maximum retained bytes in the async announce verification queue.
    pub announce_queue_max_bytes: usize,
    /// TTL for queued async announce verification entries, in seconds.
    pub announce_queue_ttl: u64,
    /// Overflow policy for the async announce verification queue.
    pub announce_queue_overflow_policy: String,
    /// Maximum queued events awaiting driver processing.
    pub driver_event_queue_capacity: usize,
    /// Independently bounded inbound traffic-class queues.
    pub inbound_queue_capacities: crate::event::InboundQueueCapacities,
    /// Maximum queued outbound frames per interface writer worker.
    pub interface_writer_queue_capacity: usize,
    /// Maximum active outbound Backbone peer-pool connections. Zero disables pooling.
    pub backbone_peer_pool_max_connected: usize,
    /// Failures within the failure window before a discovered pooled Backbone
    /// peer enters cooldown. Configured peers never enter cooldown: they retry
    /// with the Backbone client backoff (reconnect wait doubled per failure,
    /// capped at 64x, i.e. 320 s by default, with ±25 % jitter).
    pub backbone_peer_pool_failure_threshold: usize,
    /// Failure accounting window for pooled Backbone peers, in seconds.
    pub backbone_peer_pool_failure_window: u64,
    /// Cooldown duration for failed discovered pooled Backbone peers, in seconds.
    pub backbone_peer_pool_cooldown: u64,
    #[cfg(feature = "hooks")]
    pub provider_bridge: bool,
    #[cfg(feature = "hooks")]
    pub provider_socket_path: Option<String>,
    #[cfg(feature = "hooks")]
    pub provider_queue_max_events: usize,
    #[cfg(feature = "hooks")]
    pub provider_queue_max_bytes: usize,
    #[cfg(feature = "hooks")]
    pub provider_overflow_policy: String,
}

impl Default for ReticulumSection {
    fn default() -> Self {
        ReticulumSection {
            enable_transport: false,
            hop_limiter: rns_core::constants::HOP_LIMITER,
            static_transport_identity: false,
            local_hops_delta: false,
            share_instance: true,
            enable_interface_management: true,
            instance_name: "default".into(),
            shared_instance_port: 37428,
            instance_control_port: 37429,
            panic_on_interface_error: false,
            use_implicit_proof: true,
            network_identity: None,
            respond_to_probes: false,
            enable_remote_management: false,
            remote_management_allowed: Vec::new(),
            publish_blackhole: false,
            probe_port: None,
            probe_addr: None,
            probe_protocol: None,
            direct_connect_policy: crate::event::HolePunchPolicy::IdentifiedOnly,
            direct_connect_allow_private_endpoints: false,
            device: None,
            underlay_mark: None,
            discover_interfaces: false,
            default_gravity: 0,
            autoconnect_interface_mode: None,
            autoconnect_interface_gravity: 0,
            autoconnect_announces_to_internal: false,
            autoconnect_unverified_implementations: false,
            required_discovery_value: None,
            prefer_shorter_path: false,
            max_paths_per_destination: 1,
            packet_hashlist_max_entries: rns_core::constants::HASHLIST_MAXSIZE,
            packet_hashlist_allocation: rns_core::transport::types::PacketHashlistAllocation::Lazy,
            max_discovery_pr_tags: rns_core::constants::MAX_PR_TAGS,
            max_path_destinations: rns_core::transport::types::DEFAULT_MAX_PATH_DESTINATIONS,
            max_tunnel_destinations_total: usize::MAX,
            known_destinations_ttl: 48 * 60 * 60,
            known_destinations_max_entries: 8192,
            ratchet_expiry: rns_core::constants::RATCHET_EXPIRY,
            announce_table_ttl: rns_core::constants::ANNOUNCE_TABLE_TTL as u64,
            announce_table_max_bytes: rns_core::constants::ANNOUNCE_TABLE_MAX_BYTES,
            announce_sig_cache_enabled: true,
            announce_sig_cache_max_entries: rns_core::constants::ANNOUNCE_SIG_CACHE_MAXSIZE,
            announce_sig_cache_ttl: rns_core::constants::ANNOUNCE_SIG_CACHE_TTL as u64,
            announce_queue_max_entries: 256,
            announce_queue_max_interfaces: 1024,
            default_ar_target: Some(3600.0),
            default_ar_penalty: 0.0,
            default_ar_grace: 5,
            default_ic_max_held_announces: rns_core::constants::IC_MAX_HELD_ANNOUNCES,
            default_ic_burst_hold: rns_core::constants::IC_BURST_HOLD,
            default_ic_burst_freq_new: rns_core::constants::IC_BURST_FREQ_NEW,
            default_ic_burst_freq: rns_core::constants::IC_BURST_FREQ,
            default_ic_pr_burst_freq_new: rns_core::constants::IC_PR_BURST_FREQ_NEW,
            default_ic_pr_burst_freq: rns_core::constants::IC_PR_BURST_FREQ,
            default_ic_new_time: rns_core::constants::IC_NEW_TIME,
            default_ic_burst_penalty: rns_core::constants::IC_BURST_PENALTY,
            default_ic_held_release_interval: rns_core::constants::IC_HELD_RELEASE_INTERVAL,
            default_egress_control: false,
            default_ec_pr_freq: rns_core::constants::EC_PR_FREQ,
            announce_queue_max_bytes: 256 * 1024,
            announce_queue_ttl: 30,
            announce_queue_overflow_policy: "drop_worst".into(),
            driver_event_queue_capacity: crate::event::DEFAULT_EVENT_QUEUE_CAPACITY,
            inbound_queue_capacities: crate::event::InboundQueueCapacities::default(),
            interface_writer_queue_capacity: crate::interface::DEFAULT_ASYNC_WRITER_QUEUE_CAPACITY,
            backbone_peer_pool_max_connected: 0,
            backbone_peer_pool_failure_threshold: 3,
            backbone_peer_pool_failure_window: 600,
            backbone_peer_pool_cooldown: 900,
            #[cfg(feature = "hooks")]
            provider_bridge: false,
            #[cfg(feature = "hooks")]
            provider_socket_path: None,
            #[cfg(feature = "hooks")]
            provider_queue_max_events: 16384,
            #[cfg(feature = "hooks")]
            provider_queue_max_bytes: 8 * 1024 * 1024,
            #[cfg(feature = "hooks")]
            provider_overflow_policy: "drop_newest".into(),
        }
    }
}

/// The `[stamps]` section (upstream d7749b0b, Reticulum.py `__apply_config`).
///
/// The boolean options can only enable a feature: upstream applies them as
/// `if value == True: Transport.X = True`, so `no` leaves the built-in
/// default in place. Costs and values are read as floats (`as_float`, since
/// upstream 796ef2d4) and clamped to `0..=STAMP_COST_CAP` (`lr_cost` to
/// `0..=LINK_COST_CAP`). The timeouts are floored at 20 ms.
#[derive(Debug, Clone, PartialEq)]
pub struct StampsSection {
    /// `Transport.STAMPS_ENFORCED`, set by `enforce_stamps`.
    pub stamps_enforced: bool,
    /// `Transport.LR_STAMPS_ENFORCED`, also set by `enforce_stamps`.
    pub lr_stamps_enforced: bool,
    /// `Transport.STAMP_DESTINATIONS` (`stamp_destinations`).
    pub stamp_destinations: bool,
    /// `Transport.STAMP_PRS` (`stamp_prs`).
    pub stamp_prs: bool,
    /// `Transport.STAMP_LRS`. Upstream a8cc6cb2 turned it back on and
    /// removed its `stamp_lrs` option; it stays switchable at runtime through
    /// `global.stamp_link_requests`.
    pub stamp_lrs: bool,
    /// `Transport.ALWAYS_STAMP_LRS` (`always_stamp_lrs`).
    pub always_stamp_lrs: bool,
    /// `Transport.DESTINATION_COST` (`destination_cost`).
    pub destination_cost: StampCost,
    /// `Transport.DESTINATION_VALUE` (`destination_value`).
    pub destination_value: StampCost,
    /// `Transport.PR_COST` (`pr_cost`).
    pub pr_cost: StampCost,
    /// `Transport.PR_VALUE` (`pr_value`).
    pub pr_value: StampCost,
    /// `Transport.LR_COST` (`lr_cost`).
    pub lr_cost: StampCost,
    /// `Transport.LINK_STAMP_TIMEOUT` in seconds (`lr_stamp_timeout`).
    pub lr_stamp_timeout: f64,
    /// `Transport.PR_STAMP_TIMEOUT` in seconds (`pr_stamp_timeout`).
    pub pr_stamp_timeout: f64,
}

/// The `[filter]` section (upstream 825c2e19): announce filtering by
/// destination type. `required_only` is read with `as_bool` and assigned,
/// and the two type lists with `as_list`, as full destination names such as
/// `lxmf.delivery`.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct FilterSection {
    /// `Transport.required_destinations_only` (`required_only`).
    pub required_only: bool,
    /// Types blocked with `Transport.block_destination_type`
    /// (`ignored_types`).
    pub ignored_types: Vec<String>,
    /// Types allowed with `Transport.allow_destination_type`
    /// (`allowed_types`).
    pub allowed_types: Vec<String>,
}

impl FilterSection {
    /// The engine filter this section configures.
    pub fn destination_filter(
        &self,
    ) -> rns_core::transport::destination_filter::DestinationTypeFilter {
        use rns_core::transport::destination_filter::{destination_type, DestinationTypeFilter};
        let mut filter = DestinationTypeFilter::default();
        filter.set_required_only(self.required_only);
        for name in &self.ignored_types {
            filter.block(destination_type(name));
        }
        for name in &self.allowed_types {
            filter.allow(destination_type(name));
        }
        filter
    }
}

impl Default for StampsSection {
    fn default() -> Self {
        use rns_core::constants;
        StampsSection {
            stamps_enforced: constants::STAMPS_ENFORCED,
            lr_stamps_enforced: constants::LR_STAMPS_ENFORCED,
            stamp_destinations: constants::STAMP_DESTINATIONS,
            stamp_prs: constants::STAMP_PRS,
            stamp_lrs: constants::STAMP_LRS,
            always_stamp_lrs: constants::ALWAYS_STAMP_LRS,
            destination_cost: constants::DESTINATION_STAMP_COST,
            destination_value: constants::DESTINATION_STAMP_VALUE,
            pr_cost: constants::PATH_REQUEST_STAMP_COST,
            pr_value: constants::PATH_REQUEST_STAMP_VALUE,
            lr_cost: constants::LINK_REQUEST_STAMP_COST,
            lr_stamp_timeout: constants::LINK_STAMP_TIMEOUT as f64,
            pr_stamp_timeout: constants::PATH_REQUEST_STAMP_TIMEOUT as f64,
        }
    }
}

impl StampsSection {
    /// The announce and path request requirements for the transport engine.
    pub fn requirements(&self) -> rns_core::transport::types::StampRequirements {
        rns_core::transport::types::StampRequirements {
            enforced: self.stamps_enforced,
            destination_cost: self.destination_cost,
            path_request_cost: self.pr_cost,
        }
    }

    /// The link request stamp timeout as a duration.
    pub fn link_stamp_timeout(&self) -> std::time::Duration {
        stamp_timeout_duration(self.lr_stamp_timeout)
    }

    /// The path request stamp timeout as a duration.
    pub fn path_request_stamp_timeout(&self) -> std::time::Duration {
        stamp_timeout_duration(self.pr_stamp_timeout)
    }
}

/// An infinite timeout means no deadline in practice.
fn stamp_timeout_duration(seconds: f64) -> std::time::Duration {
    std::time::Duration::try_from_secs_f64(seconds).unwrap_or(std::time::Duration::MAX)
}

/// The `[logging]` section.
#[derive(Debug, Clone)]
pub struct LoggingSection {
    pub loglevel: u8,
    pub logtimestamps: bool,
}

impl Default for LoggingSection {
    fn default() -> Self {
        LoggingSection {
            loglevel: 4,
            logtimestamps: true,
        }
    }
}

/// A parsed interface from `[[subsection]]` within `[interfaces]`.
#[derive(Debug, Clone)]
pub struct ParsedInterface {
    pub name: String,
    pub interface_type: String,
    pub enabled: bool,
    pub mode: String,
    pub params: HashMap<String, String>,
    pub subinterfaces: Vec<ParsedSubinterface>,
}

/// A `[[[subinterface]]]` nested under an interface section.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ParsedSubinterface {
    pub name: String,
    pub params: HashMap<String, String>,
}

/// Configuration parse error.
#[derive(Debug, Clone)]
pub enum ConfigError {
    Io(String),
    Parse(String),
    InvalidValue { key: String, value: String },
}

impl fmt::Display for ConfigError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ConfigError::Io(msg) => write!(f, "Config I/O error: {}", msg),
            ConfigError::Parse(msg) => write!(f, "Config parse error: {}", msg),
            ConfigError::InvalidValue { key, value } => {
                write!(f, "Invalid value for '{}': '{}'", key, value)
            }
        }
    }
}

impl From<io::Error> for ConfigError {
    fn from(e: io::Error) -> Self {
        ConfigError::Io(e.to_string())
    }
}

/// Parse a config string into an `RnsConfig`.
pub fn parse(input: &str) -> Result<RnsConfig, ConfigError> {
    let mut current_section: Option<String> = None;
    let mut current_subsection: Option<String> = None;

    let mut reticulum_kvs: HashMap<String, String> = HashMap::new();
    let mut logging_kvs: HashMap<String, String> = HashMap::new();
    let mut stamps_kvs: HashMap<String, String> = HashMap::new();
    let mut filter_kvs: HashMap<String, String> = HashMap::new();
    let mut interfaces: Vec<ParsedInterface> = Vec::new();
    let mut current_iface_kvs: Option<HashMap<String, String>> = None;
    let mut current_iface_name: Option<String> = None;
    let mut current_iface_subinterfaces: Vec<ParsedSubinterface> = Vec::new();
    let mut current_subiface_name: Option<String> = None;
    let mut current_subiface_kvs: Option<HashMap<String, String>> = None;
    let mut hooks: Vec<ParsedHook> = Vec::new();
    let mut current_hook_kvs: Option<HashMap<String, String>> = None;
    let mut current_hook_name: Option<String> = None;

    for line in input.lines() {
        // Strip comments (# to end of line, unless inside quotes)
        let line = strip_comment(line);
        let trimmed = line.trim();

        // Skip empty lines
        if trimmed.is_empty() {
            continue;
        }

        // Check for third-level subsection [[[name]]] before [[name]].
        if trimmed.starts_with("[[[") && trimmed.ends_with("]]]") {
            if current_iface_kvs.is_none() {
                return Err(ConfigError::Parse(
                    "third-level section outside an interface".into(),
                ));
            }
            if let (Some(name), Some(params)) =
                (current_subiface_name.take(), current_subiface_kvs.take())
            {
                current_iface_subinterfaces.push(ParsedSubinterface { name, params });
            }
            current_subiface_name = Some(trimmed[3..trimmed.len() - 3].trim().to_string());
            current_subiface_kvs = Some(HashMap::new());
            continue;
        }

        // Check for subsection [[name]]
        if trimmed.starts_with("[[") && trimmed.ends_with("]]") {
            let name = trimmed[2..trimmed.len() - 2].trim().to_string();
            if let (Some(name), Some(params)) =
                (current_subiface_name.take(), current_subiface_kvs.take())
            {
                current_iface_subinterfaces.push(ParsedSubinterface { name, params });
            }
            // Finalize previous interface subsection if any
            if let (Some(iface_name), Some(kvs)) =
                (current_iface_name.take(), current_iface_kvs.take())
            {
                interfaces.push(build_parsed_interface(
                    iface_name,
                    kvs,
                    std::mem::take(&mut current_iface_subinterfaces),
                ));
            }
            // Finalize previous hook subsection if any
            if let (Some(hook_name), Some(kvs)) =
                (current_hook_name.take(), current_hook_kvs.take())
            {
                hooks.push(build_parsed_hook(hook_name, kvs));
            }
            current_subsection = Some(name.clone());
            // Determine which section we're in to know subsection type
            if current_section.as_deref() == Some("hooks") {
                current_hook_name = Some(name);
                current_hook_kvs = Some(HashMap::new());
            } else {
                current_iface_name = Some(name);
                current_iface_kvs = Some(HashMap::new());
            }
            continue;
        }

        // Check for section [name]
        if trimmed.starts_with('[') && trimmed.ends_with(']') {
            if let (Some(name), Some(params)) =
                (current_subiface_name.take(), current_subiface_kvs.take())
            {
                current_iface_subinterfaces.push(ParsedSubinterface { name, params });
            }
            // Finalize previous interface subsection if any
            if let (Some(iface_name), Some(kvs)) =
                (current_iface_name.take(), current_iface_kvs.take())
            {
                interfaces.push(build_parsed_interface(
                    iface_name,
                    kvs,
                    std::mem::take(&mut current_iface_subinterfaces),
                ));
            }
            // Finalize previous hook subsection if any
            if let (Some(hook_name), Some(kvs)) =
                (current_hook_name.take(), current_hook_kvs.take())
            {
                hooks.push(build_parsed_hook(hook_name, kvs));
            }
            current_subsection = None;

            let name = trimmed[1..trimmed.len() - 1].trim().to_lowercase();
            current_section = Some(name);
            continue;
        }

        // Parse key = value
        if let Some(eq_pos) = trimmed.find('=') {
            let key = trimmed[..eq_pos].trim().to_string();
            let value = trimmed[eq_pos + 1..].trim().to_string();

            if current_subsection.is_some() {
                // Inside a [[subsection]] — exactly one of these should be Some
                debug_assert!(
                    !(current_hook_kvs.is_some() && current_iface_kvs.is_some()),
                    "hook and interface subsections should never be active simultaneously"
                );
                if let Some(ref mut kvs) = current_subiface_kvs {
                    kvs.insert(key, value);
                } else if let Some(ref mut kvs) = current_hook_kvs {
                    kvs.insert(key, value);
                } else if let Some(ref mut kvs) = current_iface_kvs {
                    kvs.insert(key, value);
                }
            } else if let Some(ref section) = current_section {
                match section.as_str() {
                    "reticulum" => {
                        reticulum_kvs.insert(key, value);
                    }
                    "logging" => {
                        logging_kvs.insert(key, value);
                    }
                    "stamps" => {
                        stamps_kvs.insert(key, value);
                    }
                    "filter" => {
                        filter_kvs.insert(key, value);
                    }
                    _ => {} // ignore unknown sections
                }
            }
        }
    }

    // Finalize last subsections
    if let (Some(name), Some(params)) = (current_subiface_name.take(), current_subiface_kvs.take())
    {
        current_iface_subinterfaces.push(ParsedSubinterface { name, params });
    }
    if let (Some(iface_name), Some(kvs)) = (current_iface_name.take(), current_iface_kvs.take()) {
        interfaces.push(build_parsed_interface(
            iface_name,
            kvs,
            current_iface_subinterfaces,
        ));
    }
    if let (Some(hook_name), Some(kvs)) = (current_hook_name.take(), current_hook_kvs.take()) {
        hooks.push(build_parsed_hook(hook_name, kvs));
    }

    // Build typed sections
    let reticulum = build_reticulum_section(&reticulum_kvs)?;
    let logging = build_logging_section(&logging_kvs)?;
    let stamps = build_stamps_section(&stamps_kvs)?;
    let filter = build_filter_section(&filter_kvs)?;

    Ok(RnsConfig {
        reticulum,
        logging,
        stamps,
        filter,
        interfaces,
        hooks,
    })
}

/// Parse a config file from disk.
pub fn parse_file(path: &Path) -> Result<RnsConfig, ConfigError> {
    let content = std::fs::read_to_string(path)?;
    parse(&content)
}

pub(crate) fn parse_link_mtu_discovery(input: &str) -> Result<bool, ConfigError> {
    let mut in_reticulum = false;
    for line in input.lines() {
        let trimmed = strip_comment(line).trim();
        if trimmed.starts_with('[') && trimmed.ends_with(']') {
            in_reticulum = trimmed.eq_ignore_ascii_case("[reticulum]");
            continue;
        }
        if !in_reticulum {
            continue;
        }
        let Some((key, value)) = trimmed.split_once('=') else {
            continue;
        };
        if key.trim() == "link_mtu_discovery" {
            let value = value.trim();
            return parse_bool(value).ok_or_else(|| ConfigError::InvalidValue {
                key: "link_mtu_discovery".into(),
                value: value.into(),
            });
        }
    }
    Ok(true)
}

/// Strip `#` comments from a line (simple: not inside quotes).
fn strip_comment(line: &str) -> &str {
    // Find # that is not inside quotes
    let mut in_quote = false;
    let mut quote_char = '"';
    for (i, ch) in line.char_indices() {
        if !in_quote && (ch == '"' || ch == '\'') {
            in_quote = true;
            quote_char = ch;
        } else if in_quote && ch == quote_char {
            in_quote = false;
        } else if !in_quote && ch == '#' {
            return &line[..i];
        }
    }
    line
}

/// Parse a string as a boolean (ConfigObj style). Public API for use by node.rs.
pub fn parse_bool_pub(value: &str) -> Option<bool> {
    parse_bool(value)
}

/// Parse a string as a boolean (ConfigObj style).
fn parse_bool(value: &str) -> Option<bool> {
    match value.to_lowercase().as_str() {
        "yes" | "true" | "1" | "on" => Some(true),
        "no" | "false" | "0" | "off" => Some(false),
        _ => None,
    }
}

fn parse_nonnegative_f64_option(
    kvs: &HashMap<String, String>,
    key: &str,
) -> Result<Option<f64>, ConfigError> {
    let Some(v) = kvs.get(key) else {
        return Ok(None);
    };
    let parsed = v.parse::<f64>().map_err(|_| ConfigError::InvalidValue {
        key: key.into(),
        value: v.clone(),
    })?;
    if !parsed.is_finite() || parsed < 0.0 {
        return Err(ConfigError::InvalidValue {
            key: key.into(),
            value: v.clone(),
        });
    }
    Ok(Some(parsed))
}

fn parse_usize_option(
    kvs: &HashMap<String, String>,
    key: &str,
) -> Result<Option<usize>, ConfigError> {
    let Some(v) = kvs.get(key) else {
        return Ok(None);
    };
    let parsed = v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
        key: key.into(),
        value: v.clone(),
    })?;
    Ok(Some(parsed))
}

fn build_parsed_interface(
    name: String,
    mut kvs: HashMap<String, String>,
    subinterfaces: Vec<ParsedSubinterface>,
) -> ParsedInterface {
    let interface_type = kvs.remove("type").unwrap_or_default();
    let enabled = kvs
        .remove("enabled")
        .and_then(|v| parse_bool(&v))
        .unwrap_or(true);
    // Python checks `interface_mode` first, then falls back to `mode`
    let mode = kvs
        .remove("interface_mode")
        .or_else(|| kvs.remove("mode"))
        .unwrap_or_else(|| "full".into());

    ParsedInterface {
        name,
        interface_type,
        enabled,
        mode,
        params: kvs,
        subinterfaces,
    }
}

fn build_parsed_hook(name: String, mut kvs: HashMap<String, String>) -> ParsedHook {
    let path = kvs.remove("path").unwrap_or_default();
    let hook_type = kvs
        .remove("type")
        .or_else(|| kvs.remove("backend"))
        .unwrap_or_else(|| default_hook_type().into());
    let builtin_id = kvs
        .remove("builtin")
        .or_else(|| kvs.remove("builtin_id"))
        .or_else(|| kvs.remove("id"));
    let attach_point = kvs.remove("attach_point").unwrap_or_default();
    let priority = kvs
        .remove("priority")
        .and_then(|v| v.parse::<i32>().ok())
        .unwrap_or(0);
    let enabled = kvs
        .remove("enabled")
        .and_then(|v| parse_bool(&v))
        .unwrap_or(true);

    ParsedHook {
        name,
        path,
        hook_type,
        builtin_id,
        attach_point,
        priority,
        enabled,
    }
}

fn default_hook_type() -> &'static str {
    #[cfg(feature = "rns-hooks-native")]
    {
        "native"
    }
    #[cfg(all(not(feature = "rns-hooks-native"), feature = "rns-hooks-wasm"))]
    {
        return "wasm";
    }
    #[cfg(all(not(feature = "rns-hooks-native"), not(feature = "rns-hooks-wasm")))]
    {
        "wasm"
    }
}

/// Map a hook point name string to its index. Returns None for unknown names.
pub fn parse_hook_point(s: &str) -> Option<usize> {
    match s {
        "PreIngress" => Some(0),
        "PreDispatch" => Some(1),
        "AnnounceReceived" => Some(2),
        "PathUpdated" => Some(3),
        "AnnounceRetransmit" => Some(4),
        "LinkRequestReceived" => Some(5),
        "LinkEstablished" => Some(6),
        "LinkClosed" => Some(7),
        "InterfaceUp" => Some(8),
        "InterfaceDown" => Some(9),
        "InterfaceConfigChanged" => Some(10),
        "BackbonePeerConnected" => Some(11),
        "BackbonePeerDisconnected" => Some(12),
        "BackbonePeerIdleTimeout" => Some(13),
        "BackbonePeerWriteStall" => Some(14),
        "BackbonePeerPenalty" => Some(15),
        "SendOnInterface" => Some(16),
        "BroadcastOnAllInterfaces" => Some(17),
        "DeliverLocal" => Some(18),
        "TunnelSynthesize" => Some(19),
        "Tick" => Some(20),
        _ => None,
    }
}

#[cfg(feature = "hooks")]
pub fn parse_hook_backend(s: &str) -> Result<rns_hooks::HookBackend, String> {
    s.parse()
}

fn build_reticulum_section(kvs: &HashMap<String, String>) -> Result<ReticulumSection, ConfigError> {
    let mut section = ReticulumSection::default();

    if let Some(v) = kvs.get("enable_transport") {
        section.enable_transport = parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
            key: "enable_transport".into(),
            value: v.clone(),
        })?;
    }
    if let Some(v) = kvs.get("static_transport_identity") {
        section.static_transport_identity =
            parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
                key: "static_transport_identity".into(),
                value: v.clone(),
            })?;
    }
    if let Some(v) = kvs.get("local_hops_delta") {
        section.local_hops_delta = parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
            key: "local_hops_delta".into(),
            value: v.clone(),
        })?;
    }
    if let Some(v) = kvs.get("share_instance") {
        section.share_instance = parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
            key: "share_instance".into(),
            value: v.clone(),
        })?;
    }
    if let Some(v) = kvs.get("enable_interface_management") {
        section.enable_interface_management =
            parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
                key: "enable_interface_management".into(),
                value: v.clone(),
            })?;
    }
    if let Some(v) = kvs.get("instance_name") {
        section.instance_name = v.clone();
    }
    if let Some(v) = kvs.get("shared_instance_port") {
        section.shared_instance_port = v.parse::<u16>().map_err(|_| ConfigError::InvalidValue {
            key: "shared_instance_port".into(),
            value: v.clone(),
        })?;
    }
    if let Some(v) = kvs.get("instance_control_port") {
        section.instance_control_port =
            v.parse::<u16>().map_err(|_| ConfigError::InvalidValue {
                key: "instance_control_port".into(),
                value: v.clone(),
            })?;
    }
    if let Some(v) = kvs.get("panic_on_interface_error") {
        section.panic_on_interface_error =
            parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
                key: "panic_on_interface_error".into(),
                value: v.clone(),
            })?;
    }
    if let Some(v) = kvs.get("use_implicit_proof") {
        section.use_implicit_proof = parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
            key: "use_implicit_proof".into(),
            value: v.clone(),
        })?;
    }
    if let Some(v) = kvs.get("network_identity") {
        section.network_identity = Some(v.clone());
    }
    if let Some(v) = kvs.get("respond_to_probes") {
        section.respond_to_probes = parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
            key: "respond_to_probes".into(),
            value: v.clone(),
        })?;
    }
    if let Some(v) = kvs.get("enable_remote_management") {
        section.enable_remote_management =
            parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
                key: "enable_remote_management".into(),
                value: v.clone(),
            })?;
    }
    if let Some(v) = kvs.get("remote_management_allowed") {
        // Value is a comma-separated list of hex identity hashes
        for item in v.split(',') {
            let trimmed = item.trim();
            if !trimmed.is_empty() {
                section.remote_management_allowed.push(trimmed.to_string());
            }
        }
    }
    if let Some(v) = kvs.get("publish_blackhole") {
        section.publish_blackhole = parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
            key: "publish_blackhole".into(),
            value: v.clone(),
        })?;
    }
    if let Some(v) = kvs.get("probe_port") {
        section.probe_port = Some(v.parse::<u16>().map_err(|_| ConfigError::InvalidValue {
            key: "probe_port".into(),
            value: v.clone(),
        })?);
    }
    if let Some(v) = kvs.get("probe_addr") {
        section.probe_addr = Some(v.clone());
    }
    if let Some(v) = kvs.get("probe_protocol") {
        section.probe_protocol = Some(v.clone());
    }
    if let Some(v) = kvs.get("direct_connect_policy") {
        section.direct_connect_policy = match v.to_ascii_lowercase().as_str() {
            "reject" => crate::event::HolePunchPolicy::Reject,
            "accept_all" => crate::event::HolePunchPolicy::AcceptAll,
            "identified_only" => crate::event::HolePunchPolicy::IdentifiedOnly,
            "ask_app" => crate::event::HolePunchPolicy::AskApp,
            _ => {
                return Err(ConfigError::InvalidValue {
                    key: "direct_connect_policy".into(),
                    value: v.clone(),
                })
            }
        };
    }
    if let Some(v) = kvs.get("direct_connect_allow_private_endpoints") {
        section.direct_connect_allow_private_endpoints =
            parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
                key: "direct_connect_allow_private_endpoints".into(),
                value: v.clone(),
            })?;
    }
    if let Some(v) = kvs.get("device") {
        section.device = Some(v.clone());
    }
    if let Some(v) = kvs.get("underlay_mark") {
        let mark = v.parse::<u32>().map_err(|_| ConfigError::InvalidValue {
            key: "underlay_mark".into(),
            value: v.clone(),
        })?;
        if mark == 0 {
            return Err(ConfigError::InvalidValue {
                key: "underlay_mark".into(),
                value: v.clone(),
            });
        }
        section.underlay_mark = Some(mark);
    }
    if let Some(v) = kvs.get("discover_interfaces") {
        section.discover_interfaces = parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
            key: "discover_interfaces".into(),
            value: v.clone(),
        })?;
    }
    if let Some(v) = kvs.get("default_gravity") {
        section.default_gravity = v.parse::<i64>().map_err(|_| ConfigError::InvalidValue {
            key: "default_gravity".into(),
            value: v.clone(),
        })?;
    }
    // Retain the short-lived pre-release name as a compatibility alias. The
    // final upstream option takes precedence when both are present.
    if let Some(v) = kvs.get("autoconnect_discovered_mode") {
        section.autoconnect_interface_mode = Some(v.to_lowercase());
    }
    if let Some(v) = kvs.get("autoconnect_interface_mode") {
        section.autoconnect_interface_mode = Some(v.to_lowercase());
    }
    if let Some(v) = kvs.get("autoconnect_interface_gravity") {
        section.autoconnect_interface_gravity =
            v.parse::<i64>().map_err(|_| ConfigError::InvalidValue {
                key: "autoconnect_interface_gravity".into(),
                value: v.clone(),
            })?;
    }
    if let Some(v) = kvs.get("autoconnect_announces_to_internal") {
        section.autoconnect_announces_to_internal =
            parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
                key: "autoconnect_announces_to_internal".into(),
                value: v.clone(),
            })?;
    }
    if let Some(v) = kvs.get("autoconnect_unverified_implementations") {
        section.autoconnect_unverified_implementations =
            parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
                key: "autoconnect_unverified_implementations".into(),
                value: v.clone(),
            })?;
    }
    if let Some(v) = kvs.get("required_discovery_value") {
        // Reticulum.py: `v = as_float(option)`, used only when `v > 0`.
        let v = parse_config_float(v).ok_or_else(|| ConfigError::InvalidValue {
            key: "required_discovery_value".into(),
            value: v.clone(),
        })?;
        section.required_discovery_value =
            (v > 0.0).then(|| rns_core::stamp::clamp_cost(v, rns_core::constants::STAMP_COST_CAP));
    }
    if let Some(v) = kvs.get("hop_limiter") {
        // Reticulum.py: `max(1, min(as_int(v), PATHFINDER_M))`.
        let n = parse_config_int(v).ok_or_else(|| ConfigError::InvalidValue {
            key: "hop_limiter".into(),
            value: v.clone(),
        })?;
        section.hop_limiter = n.clamp(1, i64::from(rns_core::constants::PATHFINDER_M)) as u8;
    }
    if let Some(v) = kvs.get("prefer_shorter_path") {
        section.prefer_shorter_path = parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
            key: "prefer_shorter_path".into(),
            value: v.clone(),
        })?;
    }
    if let Some(v) = kvs.get("max_paths_per_destination") {
        let n = v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
            key: "max_paths_per_destination".into(),
            value: v.clone(),
        })?;
        section.max_paths_per_destination = n.max(1);
    }
    if let Some(v) = kvs.get("packet_hashlist_max_entries") {
        let n = v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
            key: "packet_hashlist_max_entries".into(),
            value: v.clone(),
        })?;
        section.packet_hashlist_max_entries = n.max(1);
    }
    if let Some(v) = kvs.get("packet_hashlist_allocation") {
        section.packet_hashlist_allocation = match v.to_ascii_lowercase().as_str() {
            "eager" => rns_core::transport::types::PacketHashlistAllocation::Eager,
            "lazy" => rns_core::transport::types::PacketHashlistAllocation::Lazy,
            _ => {
                return Err(ConfigError::InvalidValue {
                    key: "packet_hashlist_allocation".into(),
                    value: v.clone(),
                });
            }
        };
    }
    if let Some(v) = kvs.get("max_discovery_pr_tags") {
        let n = v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
            key: "max_discovery_pr_tags".into(),
            value: v.clone(),
        })?;
        section.max_discovery_pr_tags = n.max(1);
    }
    if let Some(v) = kvs.get("max_path_destinations") {
        let n = v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
            key: "max_path_destinations".into(),
            value: v.clone(),
        })?;
        section.max_path_destinations = n.max(1);
    }
    if let Some(v) = kvs.get("max_tunnel_destinations_total") {
        let n = v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
            key: "max_tunnel_destinations_total".into(),
            value: v.clone(),
        })?;
        section.max_tunnel_destinations_total = n.max(1);
    }
    if let Some(v) = kvs.get("known_destinations_ttl") {
        section.known_destinations_ttl =
            v.parse::<u64>().map_err(|_| ConfigError::InvalidValue {
                key: "known_destinations_ttl".into(),
                value: v.clone(),
            })?;
    }
    if let Some(v) = kvs.get("known_destinations_max_entries") {
        let n = v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
            key: "known_destinations_max_entries".into(),
            value: v.clone(),
        })?;
        if n == 0 {
            return Err(ConfigError::InvalidValue {
                key: "known_destinations_max_entries".into(),
                value: v.clone(),
            });
        }
        section.known_destinations_max_entries = n;
    }
    if let Some(v) = kvs.get("ratchet_expiry") {
        let expiry = v.parse::<u64>().map_err(|_| ConfigError::InvalidValue {
            key: "ratchet_expiry".into(),
            value: v.clone(),
        })?;
        if expiry == 0 {
            return Err(ConfigError::InvalidValue {
                key: "ratchet_expiry".into(),
                value: v.clone(),
            });
        }
        section.ratchet_expiry = expiry;
    }
    if let Some(v) = kvs.get("destination_timeout_secs") {
        section.known_destinations_ttl =
            v.parse::<u64>().map_err(|_| ConfigError::InvalidValue {
                key: "destination_timeout_secs".into(),
                value: v.clone(),
            })?;
    }
    if let Some(v) = kvs.get("announce_table_ttl") {
        let ttl = v.parse::<u64>().map_err(|_| ConfigError::InvalidValue {
            key: "announce_table_ttl".into(),
            value: v.clone(),
        })?;
        if ttl == 0 {
            return Err(ConfigError::InvalidValue {
                key: "announce_table_ttl".into(),
                value: v.clone(),
            });
        }
        section.announce_table_ttl = ttl;
    }
    if let Some(v) = kvs.get("announce_table_max_bytes") {
        let max_bytes = v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
            key: "announce_table_max_bytes".into(),
            value: v.clone(),
        })?;
        if max_bytes == 0 {
            return Err(ConfigError::InvalidValue {
                key: "announce_table_max_bytes".into(),
                value: v.clone(),
            });
        }
        section.announce_table_max_bytes = max_bytes;
    }
    if let Some(v) = kvs.get("announce_signature_cache_enabled") {
        section.announce_sig_cache_enabled = match v.as_str() {
            "true" | "yes" | "True" | "Yes" => true,
            "false" | "no" | "False" | "No" => false,
            _ => {
                return Err(ConfigError::InvalidValue {
                    key: "announce_signature_cache_enabled".into(),
                    value: v.clone(),
                })
            }
        };
    }
    if let Some(v) = kvs.get("announce_signature_cache_max_entries") {
        let n = v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
            key: "announce_signature_cache_max_entries".into(),
            value: v.clone(),
        })?;
        section.announce_sig_cache_max_entries = n;
    }
    if let Some(v) = kvs.get("announce_signature_cache_ttl") {
        let ttl = v.parse::<u64>().map_err(|_| ConfigError::InvalidValue {
            key: "announce_signature_cache_ttl".into(),
            value: v.clone(),
        })?;
        section.announce_sig_cache_ttl = ttl;
    }
    if let Some(v) = kvs.get("announce_queue_max_entries") {
        let n = v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
            key: "announce_queue_max_entries".into(),
            value: v.clone(),
        })?;
        if n == 0 {
            return Err(ConfigError::InvalidValue {
                key: "announce_queue_max_entries".into(),
                value: v.clone(),
            });
        }
        section.announce_queue_max_entries = n;
    }
    if let Some(v) = kvs.get("announce_queue_max_interfaces") {
        let n = v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
            key: "announce_queue_max_interfaces".into(),
            value: v.clone(),
        })?;
        if n == 0 {
            return Err(ConfigError::InvalidValue {
                key: "announce_queue_max_interfaces".into(),
                value: v.clone(),
            });
        }
        section.announce_queue_max_interfaces = n;
    }
    if let Some(v) = kvs.get("default_ar_target") {
        let target = v.parse::<f64>().map_err(|_| ConfigError::InvalidValue {
            key: "default_ar_target".into(),
            value: v.clone(),
        })?;
        if !target.is_finite() || target < 0.0 {
            return Err(ConfigError::InvalidValue {
                key: "default_ar_target".into(),
                value: v.clone(),
            });
        }
        section.default_ar_target = if target == 0.0 { None } else { Some(target) };
    }
    if let Some(v) = kvs.get("default_ar_penalty") {
        let penalty = v.parse::<f64>().map_err(|_| ConfigError::InvalidValue {
            key: "default_ar_penalty".into(),
            value: v.clone(),
        })?;
        if !penalty.is_finite() || penalty < 0.0 {
            return Err(ConfigError::InvalidValue {
                key: "default_ar_penalty".into(),
                value: v.clone(),
            });
        }
        section.default_ar_penalty = penalty;
    }
    if let Some(v) = kvs.get("default_ar_grace") {
        let grace = v.parse::<u32>().map_err(|_| ConfigError::InvalidValue {
            key: "default_ar_grace".into(),
            value: v.clone(),
        })?;
        section.default_ar_grace = grace;
    }
    if let Some(v) = parse_usize_option(kvs, "ic_max_held_announces")? {
        section.default_ic_max_held_announces = v;
    }
    if let Some(v) = parse_nonnegative_f64_option(kvs, "ic_burst_hold")? {
        section.default_ic_burst_hold = v;
    }
    if let Some(v) = parse_nonnegative_f64_option(kvs, "ic_burst_freq_new")? {
        section.default_ic_burst_freq_new = v;
    }
    if let Some(v) = parse_nonnegative_f64_option(kvs, "ic_burst_freq")? {
        section.default_ic_burst_freq = v;
    }
    if let Some(v) = parse_nonnegative_f64_option(kvs, "ic_pr_burst_freq_new")? {
        section.default_ic_pr_burst_freq_new = v;
    }
    if let Some(v) = parse_nonnegative_f64_option(kvs, "ic_pr_burst_freq")? {
        section.default_ic_pr_burst_freq = v;
    }
    if let Some(v) = parse_nonnegative_f64_option(kvs, "ic_new_time")? {
        section.default_ic_new_time = v;
    }
    if let Some(v) = parse_nonnegative_f64_option(kvs, "ic_burst_penalty")? {
        section.default_ic_burst_penalty = v;
    }
    if let Some(v) = parse_nonnegative_f64_option(kvs, "ic_held_release_interval")? {
        section.default_ic_held_release_interval = v;
    }
    if let Some(v) = kvs.get("egress_control") {
        section.default_egress_control =
            parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
                key: "egress_control".into(),
                value: v.clone(),
            })?;
    }
    if let Some(v) = parse_nonnegative_f64_option(kvs, "ec_pr_freq")? {
        section.default_ec_pr_freq = v;
    }
    if let Some(v) = kvs.get("announce_queue_max_bytes") {
        let n = v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
            key: "announce_queue_max_bytes".into(),
            value: v.clone(),
        })?;
        if n == 0 {
            return Err(ConfigError::InvalidValue {
                key: "announce_queue_max_bytes".into(),
                value: v.clone(),
            });
        }
        section.announce_queue_max_bytes = n;
    }
    if let Some(v) = kvs.get("announce_queue_ttl") {
        let ttl = v.parse::<u64>().map_err(|_| ConfigError::InvalidValue {
            key: "announce_queue_ttl".into(),
            value: v.clone(),
        })?;
        if ttl == 0 {
            return Err(ConfigError::InvalidValue {
                key: "announce_queue_ttl".into(),
                value: v.clone(),
            });
        }
        section.announce_queue_ttl = ttl;
    }
    if let Some(v) = kvs.get("announce_queue_overflow_policy") {
        let normalized = v.to_lowercase();
        if normalized != "drop_newest" && normalized != "drop_oldest" && normalized != "drop_worst"
        {
            return Err(ConfigError::InvalidValue {
                key: "announce_queue_overflow_policy".into(),
                value: v.clone(),
            });
        }
        section.announce_queue_overflow_policy = normalized;
    }
    if let Some(v) = kvs.get("driver_event_queue_capacity") {
        let n = v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
            key: "driver_event_queue_capacity".into(),
            value: v.clone(),
        })?;
        if n == 0 {
            return Err(ConfigError::InvalidValue {
                key: "driver_event_queue_capacity".into(),
                value: v.clone(),
            });
        }
        section.driver_event_queue_capacity = n;
        section.inbound_queue_capacities =
            crate::event::InboundQueueCapacities::from_shared_capacity(n);
    }
    for (key, queue) in [
        ("qlen_in_data", 0),
        ("qlen_in_announce", 1),
        ("qlen_in_pr", 2),
        ("qlen_in_il", 3),
    ] {
        let Some(v) = kvs.get(key) else {
            continue;
        };
        let n = v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
            key: key.into(),
            value: v.clone(),
        })?;
        if n == 0 {
            return Err(ConfigError::InvalidValue {
                key: key.into(),
                value: v.clone(),
            });
        }
        match queue {
            0 => section.inbound_queue_capacities.data = n,
            1 => section.inbound_queue_capacities.announce = n,
            2 => section.inbound_queue_capacities.path_request = n,
            _ => section.inbound_queue_capacities.ingress_limited = n,
        }
    }
    if let Some(v) = kvs.get("interface_writer_queue_capacity") {
        let n = v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
            key: "interface_writer_queue_capacity".into(),
            value: v.clone(),
        })?;
        if n == 0 {
            return Err(ConfigError::InvalidValue {
                key: "interface_writer_queue_capacity".into(),
                value: v.clone(),
            });
        }
        section.interface_writer_queue_capacity = n;
    }
    if let Some(v) = kvs.get("backbone_peer_pool_max_connected") {
        section.backbone_peer_pool_max_connected =
            v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
                key: "backbone_peer_pool_max_connected".into(),
                value: v.clone(),
            })?;
    }
    if let Some(v) = kvs.get("backbone_peer_pool_failure_threshold") {
        let n = v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
            key: "backbone_peer_pool_failure_threshold".into(),
            value: v.clone(),
        })?;
        if n == 0 {
            return Err(ConfigError::InvalidValue {
                key: "backbone_peer_pool_failure_threshold".into(),
                value: v.clone(),
            });
        }
        section.backbone_peer_pool_failure_threshold = n;
    }
    if let Some(v) = kvs.get("backbone_peer_pool_failure_window") {
        section.backbone_peer_pool_failure_window =
            v.parse::<u64>().map_err(|_| ConfigError::InvalidValue {
                key: "backbone_peer_pool_failure_window".into(),
                value: v.clone(),
            })?;
    }
    if let Some(v) = kvs.get("backbone_peer_pool_cooldown") {
        section.backbone_peer_pool_cooldown =
            v.parse::<u64>().map_err(|_| ConfigError::InvalidValue {
                key: "backbone_peer_pool_cooldown".into(),
                value: v.clone(),
            })?;
    }
    #[cfg(feature = "hooks")]
    if let Some(v) = kvs.get("provider_bridge") {
        section.provider_bridge = parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
            key: "provider_bridge".into(),
            value: v.clone(),
        })?;
    }
    #[cfg(feature = "hooks")]
    if let Some(v) = kvs.get("provider_socket_path") {
        section.provider_socket_path = Some(v.clone());
    }
    #[cfg(feature = "hooks")]
    if let Some(v) = kvs.get("provider_queue_max_events") {
        section.provider_queue_max_events =
            v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
                key: "provider_queue_max_events".into(),
                value: v.clone(),
            })?;
    }
    #[cfg(feature = "hooks")]
    if let Some(v) = kvs.get("provider_queue_max_bytes") {
        section.provider_queue_max_bytes =
            v.parse::<usize>().map_err(|_| ConfigError::InvalidValue {
                key: "provider_queue_max_bytes".into(),
                value: v.clone(),
            })?;
    }
    #[cfg(feature = "hooks")]
    if let Some(v) = kvs.get("provider_overflow_policy") {
        let normalized = v.to_lowercase();
        if normalized != "drop_newest" && normalized != "drop_oldest" {
            return Err(ConfigError::InvalidValue {
                key: "provider_overflow_policy".into(),
                value: v.clone(),
            });
        }
        section.provider_overflow_policy = normalized;
    }

    Ok(section)
}

/// Parse an integer as ConfigObj's `as_int` does, saturating values beyond
/// the `i64` range instead of rejecting them, since every caller clamps.
fn parse_config_int(value: &str) -> Option<i64> {
    let value = value.trim();
    if let Ok(n) = value.parse::<i64>() {
        return Some(n);
    }
    let digits = value.strip_prefix(['+', '-']).unwrap_or(value);
    if digits.is_empty() || !digits.bytes().all(|b| b.is_ascii_digit()) {
        return None;
    }
    Some(if value.starts_with('-') {
        i64::MIN
    } else {
        i64::MAX
    })
}

/// Parse a float as ConfigObj's `as_float` (Python `float()`) does,
/// including `inf` and `nan`, which callers clamp.
pub(crate) fn parse_config_float(value: &str) -> Option<f64> {
    value.trim().parse::<f64>().ok()
}

fn build_filter_section(kvs: &HashMap<String, String>) -> Result<FilterSection, ConfigError> {
    let mut section = FilterSection::default();
    if let Some(v) = kvs.get("required_only") {
        section.required_only = parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
            key: "required_only".into(),
            value: v.clone(),
        })?;
    }
    let list = |key: &str| -> Vec<String> {
        kvs.get(key)
            .map(|v| {
                v.split(',')
                    .map(str::trim)
                    .filter(|item| !item.is_empty())
                    .map(str::to_string)
                    .collect()
            })
            .unwrap_or_default()
    };
    section.ignored_types = list("ignored_types");
    section.allowed_types = list("allowed_types");
    Ok(section)
}

fn build_stamps_section(kvs: &HashMap<String, String>) -> Result<StampsSection, ConfigError> {
    use rns_core::constants::{LINK_COST_CAP, STAMP_COST_CAP, STAMP_TIMEOUT_MIN};

    let mut section = StampsSection::default();
    let flag = |key: &str| -> Result<bool, ConfigError> {
        match kvs.get(key) {
            None => Ok(false),
            Some(v) => parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
                key: key.into(),
                value: v.clone(),
            }),
        }
    };
    let cost = |key: &str, cap: u8| -> Result<Option<StampCost>, ConfigError> {
        let Some(v) = kvs.get(key) else {
            return Ok(None);
        };
        let n = parse_config_float(v).ok_or_else(|| ConfigError::InvalidValue {
            key: key.into(),
            value: v.clone(),
        })?;
        Ok(Some(rns_core::stamp::clamp_cost(n, cap)))
    };
    let timeout = |key: &str| -> Result<Option<f64>, ConfigError> {
        let Some(v) = kvs.get(key) else {
            return Ok(None);
        };
        let n = v
            .trim()
            .parse::<f64>()
            .map_err(|_| ConfigError::InvalidValue {
                key: key.into(),
                value: v.clone(),
            })?;
        // `max(0.020, v)`; Python's `max` also keeps 0.020 for NaN.
        Ok(Some(if n.is_nan() {
            STAMP_TIMEOUT_MIN
        } else {
            n.max(STAMP_TIMEOUT_MIN)
        }))
    };

    // Enable-only booleans (Reticulum.py: `if value == True: ... = True`).
    if flag("enforce_stamps")? {
        section.stamps_enforced = true;
        section.lr_stamps_enforced = true;
    }
    if flag("stamp_destinations")? {
        section.stamp_destinations = true;
    }
    if flag("stamp_prs")? {
        section.stamp_prs = true;
    }
    // a8cc6cb2 replaced `stamp_lrs` with `always_stamp_lrs`; like other
    // unknown options, a leftover `stamp_lrs` is ignored.
    if flag("always_stamp_lrs")? {
        section.always_stamp_lrs = true;
    }
    if let Some(v) = cost("destination_cost", STAMP_COST_CAP)? {
        section.destination_cost = v;
    }
    if let Some(v) = cost("destination_value", STAMP_COST_CAP)? {
        section.destination_value = v;
    }
    if let Some(v) = cost("pr_cost", STAMP_COST_CAP)? {
        section.pr_cost = v;
    }
    if let Some(v) = cost("pr_value", STAMP_COST_CAP)? {
        section.pr_value = v;
    }
    if let Some(v) = cost("lr_cost", LINK_COST_CAP)? {
        section.lr_cost = v;
    }
    if let Some(v) = timeout("lr_stamp_timeout")? {
        section.lr_stamp_timeout = v;
    }
    if let Some(v) = timeout("pr_stamp_timeout")? {
        section.pr_stamp_timeout = v;
    }
    Ok(section)
}

fn build_logging_section(kvs: &HashMap<String, String>) -> Result<LoggingSection, ConfigError> {
    let mut section = LoggingSection::default();

    if let Some(v) = kvs.get("loglevel") {
        section.loglevel = v.parse::<u8>().map_err(|_| ConfigError::InvalidValue {
            key: "loglevel".into(),
            value: v.clone(),
        })?;
        if section.loglevel > crate::logging::LOG_EXTREME {
            return Err(ConfigError::InvalidValue {
                key: "loglevel".into(),
                value: v.clone(),
            });
        }
    }
    if let Some(v) = kvs.get("logtimestamps") {
        section.logtimestamps = parse_bool(v).ok_or_else(|| ConfigError::InvalidValue {
            key: "logtimestamps".into(),
            value: v.clone(),
        })?;
    }

    Ok(section)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parse_empty() {
        let config = parse("").unwrap();
        assert!(!config.reticulum.enable_transport);
        assert!(!config.reticulum.static_transport_identity);
        assert!(!config.reticulum.local_hops_delta);
        assert!(config.reticulum.share_instance);
        assert_eq!(config.reticulum.instance_name, "default");
        assert_eq!(config.logging.loglevel, 4);
        assert!(config.logging.logtimestamps);
        assert!(config.interfaces.is_empty());
        assert_eq!(
            config.reticulum.packet_hashlist_max_entries,
            rns_core::constants::HASHLIST_MAXSIZE
        );
        assert_eq!(
            config.reticulum.packet_hashlist_allocation,
            rns_core::transport::types::PacketHashlistAllocation::Lazy
        );
        assert_eq!(
            config.reticulum.announce_table_ttl,
            rns_core::constants::ANNOUNCE_TABLE_TTL as u64
        );
        assert_eq!(
            config.reticulum.announce_table_max_bytes,
            rns_core::constants::ANNOUNCE_TABLE_MAX_BYTES
        );
        assert_eq!(
            config.reticulum.ratchet_expiry,
            rns_core::constants::RATCHET_EXPIRY
        );
        assert_eq!(
            config.reticulum.inbound_queue_capacities,
            crate::event::InboundQueueCapacities::default()
        );
    }

    #[test]
    fn parse_reticulum_inbound_queue_lengths() {
        let config = parse(
            r#"
[reticulum]
qlen_in_data = 101
qlen_in_announce = 102
qlen_in_pr = 103
qlen_in_il = 104
"#,
        )
        .unwrap();

        assert_eq!(
            config.reticulum.inbound_queue_capacities,
            crate::event::InboundQueueCapacities {
                data: 101,
                announce: 102,
                path_request: 103,
                ingress_limited: 104,
            }
        );
    }

    #[test]
    fn inbound_queue_lengths_must_be_positive_integers() {
        for key in [
            "qlen_in_data",
            "qlen_in_announce",
            "qlen_in_pr",
            "qlen_in_il",
        ] {
            for value in ["0", "-1", "many"] {
                let input = format!("[reticulum]\n{key} = {value}\n");
                assert!(matches!(
                    parse(&input),
                    Err(ConfigError::InvalidValue { key: invalid_key, .. })
                        if invalid_key == key
                ));
            }
        }
    }

    #[test]
    fn legacy_event_capacity_still_scales_class_defaults() {
        let config = parse("[reticulum]\ndriver_event_queue_capacity = 64\n").unwrap();
        assert_eq!(
            config.reticulum.inbound_queue_capacities,
            crate::event::InboundQueueCapacities {
                data: 64,
                announce: 64,
                path_request: 64,
                ingress_limited: 8,
            }
        );
    }

    #[cfg(feature = "hooks")]
    #[test]
    fn parse_provider_bridge_config() {
        let config = parse(
            r#"
[reticulum]
provider_bridge = yes
provider_socket_path = /tmp/rns-provider.sock
provider_queue_max_events = 42
provider_queue_max_bytes = 8192
provider_overflow_policy = drop_oldest
"#,
        )
        .unwrap();

        assert!(config.reticulum.provider_bridge);
        assert_eq!(
            config.reticulum.provider_socket_path.as_deref(),
            Some("/tmp/rns-provider.sock")
        );
        assert_eq!(config.reticulum.provider_queue_max_events, 42);
        assert_eq!(config.reticulum.provider_queue_max_bytes, 8192);
        assert_eq!(config.reticulum.provider_overflow_policy, "drop_oldest");
    }

    #[test]
    fn parse_default_config() {
        // The default config from Python's __default_rns_config__, with the
        // commented-out [stamps] section added in upstream f57fa265.
        let input = r#"
[reticulum]
enable_transport = False
share_instance = Yes
instance_name = default

[stamps]

# destination_cost = 23.5
# destination_value = 25.0
# pr_cost = 15.8
# pr_value = 15.8
# lr_cost = 12.5
# lr_stamp_timeout = 15
# pr_stamp_timeout = 15

[logging]
loglevel = 4

[interfaces]

  [[Default Interface]]
    type = AutoInterface
    enabled = Yes
"#;
        let config = parse(input).unwrap();
        assert!(!config.reticulum.enable_transport);
        assert!(config.reticulum.share_instance);
        assert_eq!(config.reticulum.instance_name, "default");
        assert_eq!(config.logging.loglevel, 4);
        assert_eq!(config.interfaces.len(), 1);
        assert_eq!(config.interfaces[0].name, "Default Interface");
        assert_eq!(config.interfaces[0].interface_type, "AutoInterface");
        assert!(config.interfaces[0].enabled);
        assert_eq!(config.stamps, StampsSection::default());
    }

    #[test]
    fn parse_reticulum_section() {
        let input = r#"
[reticulum]
enable_transport = True
share_instance = No
instance_name = mynode
shared_instance_port = 12345
instance_control_port = 12346
panic_on_interface_error = Yes
use_implicit_proof = False
respond_to_probes = True
network_identity = /home/user/.reticulum/identity
known_destinations_ttl = 1234
known_destinations_max_entries = 4321
ratchet_expiry = 9876
announce_table_ttl = 45
announce_table_max_bytes = 65536
packet_hashlist_max_entries = 321
max_discovery_pr_tags = 222
max_path_destinations = 111
max_tunnel_destinations_total = 99
announce_signature_cache_enabled = false
announce_signature_cache_max_entries = 500
announce_signature_cache_ttl = 300
announce_queue_max_entries = 123
announce_queue_max_interfaces = 321
announce_queue_max_bytes = 4567
announce_queue_ttl = 89
announce_queue_overflow_policy = drop_oldest
driver_event_queue_capacity = 6543
interface_writer_queue_capacity = 210
underlay_mark = 51820
backbone_peer_pool_max_connected = 6
backbone_peer_pool_failure_threshold = 4
backbone_peer_pool_failure_window = 120
backbone_peer_pool_cooldown = 300
"#;
        let config = parse(input).unwrap();
        assert!(config.reticulum.enable_transport);
        assert!(!config.reticulum.share_instance);
        assert_eq!(config.reticulum.instance_name, "mynode");
        assert_eq!(config.reticulum.shared_instance_port, 12345);
        assert_eq!(config.reticulum.instance_control_port, 12346);
        assert!(config.reticulum.panic_on_interface_error);
        assert!(!config.reticulum.use_implicit_proof);
        assert!(config.reticulum.respond_to_probes);
        assert_eq!(config.reticulum.underlay_mark, Some(51820));
        assert_eq!(
            config.reticulum.network_identity.as_deref(),
            Some("/home/user/.reticulum/identity")
        );
        assert_eq!(config.reticulum.known_destinations_ttl, 1234);
        assert_eq!(config.reticulum.known_destinations_max_entries, 4321);
        assert_eq!(config.reticulum.ratchet_expiry, 9876);
        assert_eq!(config.reticulum.announce_table_ttl, 45);
        assert_eq!(config.reticulum.announce_table_max_bytes, 65536);
        assert_eq!(config.reticulum.packet_hashlist_max_entries, 321);
        assert_eq!(config.reticulum.max_discovery_pr_tags, 222);
        assert_eq!(config.reticulum.max_path_destinations, 111);
        assert_eq!(config.reticulum.max_tunnel_destinations_total, 99);
        assert!(!config.reticulum.announce_sig_cache_enabled);
        assert_eq!(config.reticulum.announce_sig_cache_max_entries, 500);
        assert_eq!(config.reticulum.announce_sig_cache_ttl, 300);
        assert_eq!(config.reticulum.announce_queue_max_entries, 123);
        assert_eq!(config.reticulum.announce_queue_max_interfaces, 321);
        assert_eq!(config.reticulum.announce_queue_max_bytes, 4567);
        assert_eq!(config.reticulum.announce_queue_ttl, 89);
        assert_eq!(
            config.reticulum.announce_queue_overflow_policy,
            "drop_oldest"
        );
        assert_eq!(config.reticulum.driver_event_queue_capacity, 6543);
        assert_eq!(config.reticulum.interface_writer_queue_capacity, 210);
        assert_eq!(config.reticulum.backbone_peer_pool_max_connected, 6);
        assert_eq!(config.reticulum.backbone_peer_pool_failure_threshold, 4);
        assert_eq!(config.reticulum.backbone_peer_pool_failure_window, 120);
        assert_eq!(config.reticulum.backbone_peer_pool_cooldown, 300);
    }

    #[test]
    fn underlay_mark_defaults_to_disabled() {
        let config = parse("[reticulum]\n").unwrap();
        assert_eq!(config.reticulum.underlay_mark, None);
    }

    #[test]
    fn underlay_mark_rejects_zero_and_non_numeric_values() {
        for value in ["0", "-1", "not-a-mark", "4294967296"] {
            let error = parse(&format!("[reticulum]\nunderlay_mark = {value}\n"))
                .expect_err("invalid underlay mark must be rejected");
            assert!(matches!(
                error,
                ConfigError::InvalidValue { ref key, .. } if key == "underlay_mark"
            ));
        }
    }

    #[test]
    fn parse_reticulum_announce_rate_defaults() {
        let input = r#"
[reticulum]
default_ar_target = 7200
default_ar_penalty = 15
default_ar_grace = 7
"#;
        let config = parse(input).unwrap();

        assert_eq!(config.reticulum.default_ar_target, Some(7200.0));
        assert_eq!(config.reticulum.default_ar_penalty, 15.0);
        assert_eq!(config.reticulum.default_ar_grace, 7);
    }

    #[test]
    fn parse_interface_gravity_defaults_and_autoconnect_options() {
        let config = parse(
            r#"
[reticulum]
default_gravity = -3
autoconnect_discovered_mode = full
autoconnect_interface_mode = boundary
autoconnect_interface_gravity = 7
autoconnect_announces_to_internal = yes
autoconnect_unverified_implementations = yes
"#,
        )
        .unwrap();

        assert_eq!(
            config.reticulum.autoconnect_interface_mode.as_deref(),
            Some("boundary")
        );
        assert_eq!(config.reticulum.default_gravity, -3);
        assert_eq!(config.reticulum.autoconnect_interface_gravity, 7);
        assert!(config.reticulum.autoconnect_announces_to_internal);
        assert!(config.reticulum.autoconnect_unverified_implementations);
    }

    #[test]
    fn autoconnect_unverified_implementations_defaults_to_false() {
        let config = parse("[reticulum]\n").unwrap();
        assert!(!config.reticulum.autoconnect_unverified_implementations);
    }

    #[test]
    fn interface_gravity_options_default_to_zero() {
        let config = parse("[reticulum]\n").unwrap();
        assert_eq!(config.reticulum.default_gravity, 0);
        assert_eq!(config.reticulum.autoconnect_interface_gravity, 0);
    }

    #[test]
    fn parses_packet_hashlist_allocation_case_insensitively() {
        for (value, expected) in [
            (
                "eager",
                rns_core::transport::types::PacketHashlistAllocation::Eager,
            ),
            (
                "LAZY",
                rns_core::transport::types::PacketHashlistAllocation::Lazy,
            ),
            (
                "LaZy",
                rns_core::transport::types::PacketHashlistAllocation::Lazy,
            ),
        ] {
            let input = format!("[reticulum]\npacket_hashlist_allocation = {value}\n");
            assert_eq!(
                parse(&input).unwrap().reticulum.packet_hashlist_allocation,
                expected
            );
        }
    }

    #[test]
    fn rejects_invalid_packet_hashlist_allocation() {
        assert!(parse("[reticulum]\npacket_hashlist_allocation = dynamic\n").is_err());
    }

    #[test]
    fn rejects_non_integer_global_gravity_options() {
        assert!(parse("[reticulum]\ndefault_gravity = heavy\n").is_err());
        assert!(parse("[reticulum]\nautoconnect_interface_gravity = light\n").is_err());
    }

    #[test]
    fn parse_reticulum_announce_rate_target_zero_disables_default() {
        let input = r#"
[reticulum]
default_ar_target = 0
default_ar_penalty = 0
default_ar_grace = 0
"#;
        let config = parse(input).unwrap();

        assert_eq!(config.reticulum.default_ar_target, None);
        assert_eq!(config.reticulum.default_ar_penalty, 0.0);
        assert_eq!(config.reticulum.default_ar_grace, 0);
    }

    #[test]
    fn parse_reticulum_announce_rate_defaults_reject_negative_values() {
        for (key, value) in [
            ("default_ar_target", "-1"),
            ("default_ar_target", "NaN"),
            ("default_ar_target", "inf"),
            ("default_ar_penalty", "-1"),
            ("default_ar_penalty", "NaN"),
            ("default_ar_penalty", "inf"),
            ("default_ar_grace", "-1"),
        ] {
            let input = format!("[reticulum]\n{key} = {value}\n");
            let err = parse(&input).unwrap_err();
            assert!(
                err.to_string().contains(key),
                "error {err:?} should mention {key}"
            );
        }
    }

    #[test]
    fn parse_reticulum_ingress_and_egress_control_defaults() {
        let input = r#"[reticulum]
ic_max_held_announces = 17
ic_burst_hold = 1.5
ic_burst_freq_new = 2.5
ic_burst_freq = 3.5
ic_pr_burst_freq_new = 4.5
ic_pr_burst_freq = 5.5
ic_new_time = 6.5
ic_burst_penalty = 7.5
ic_held_release_interval = 8.5
egress_control = Yes
ec_pr_freq = 9.5
"#;

        let config = parse(input).unwrap();

        assert_eq!(config.reticulum.default_ic_max_held_announces, 17);
        assert_eq!(config.reticulum.default_ic_burst_hold, 1.5);
        assert_eq!(config.reticulum.default_ic_burst_freq_new, 2.5);
        assert_eq!(config.reticulum.default_ic_burst_freq, 3.5);
        assert_eq!(config.reticulum.default_ic_pr_burst_freq_new, 4.5);
        assert_eq!(config.reticulum.default_ic_pr_burst_freq, 5.5);
        assert_eq!(config.reticulum.default_ic_new_time, 6.5);
        assert_eq!(config.reticulum.default_ic_burst_penalty, 7.5);
        assert_eq!(config.reticulum.default_ic_held_release_interval, 8.5);
        assert!(config.reticulum.default_egress_control);
        assert_eq!(config.reticulum.default_ec_pr_freq, 9.5);
    }

    #[test]
    fn parse_reticulum_ingress_and_egress_defaults_reject_invalid_values() {
        for (key, value) in [
            ("ic_max_held_announces", "-1"),
            ("ic_burst_hold", "-1"),
            ("ic_burst_hold", "NaN"),
            ("ic_burst_freq_new", "-1"),
            ("ic_burst_freq", "inf"),
            ("ic_pr_burst_freq_new", "-1"),
            ("ic_pr_burst_freq", "NaN"),
            ("ic_new_time", "-1"),
            ("ic_burst_penalty", "-1"),
            ("ic_held_release_interval", "-1"),
            ("ec_pr_freq", "-1"),
            ("ec_pr_freq", "inf"),
        ] {
            let input = format!("[reticulum]\n{key} = {value}\n");
            let err = parse(&input).unwrap_err();
            assert!(
                format!("{err}").contains(key),
                "error {err} should mention {key}"
            );
        }
    }

    #[test]
    fn parse_backbone_peer_pool_defaults_disabled() {
        let config = parse("[reticulum]\n").unwrap();
        assert_eq!(config.reticulum.backbone_peer_pool_max_connected, 0);
        assert_eq!(config.reticulum.backbone_peer_pool_failure_threshold, 3);
        assert_eq!(config.reticulum.backbone_peer_pool_failure_window, 600);
        assert_eq!(config.reticulum.backbone_peer_pool_cooldown, 900);
    }

    #[test]
    fn parse_announce_table_limits_reject_zero() {
        let err = parse(
            r#"
[reticulum]
announce_table_ttl = 0
"#,
        )
        .unwrap_err();
        assert!(matches!(
            err,
            ConfigError::InvalidValue { key, .. } if key == "announce_table_ttl"
        ));

        let err = parse(
            r#"
[reticulum]
known_destinations_max_entries = 0
"#,
        )
        .unwrap_err();
        assert!(matches!(
            err,
            ConfigError::InvalidValue { key, .. } if key == "known_destinations_max_entries"
        ));

        let err = parse(
            r#"
[reticulum]
ratchet_expiry = 0
"#,
        )
        .unwrap_err();
        assert!(matches!(
            err,
            ConfigError::InvalidValue { key, .. } if key == "ratchet_expiry"
        ));

        let err = parse(
            r#"
[reticulum]
announce_table_max_bytes = 0
"#,
        )
        .unwrap_err();
        assert!(matches!(
            err,
            ConfigError::InvalidValue { key, .. } if key == "announce_table_max_bytes"
        ));

        let err = parse(
            r#"
[reticulum]
announce_queue_max_entries = 0
"#,
        )
        .unwrap_err();
        assert!(matches!(
            err,
            ConfigError::InvalidValue { key, .. } if key == "announce_queue_max_entries"
        ));

        let err = parse(
            r#"
[reticulum]
announce_queue_max_interfaces = 0
"#,
        )
        .unwrap_err();
        assert!(matches!(
            err,
            ConfigError::InvalidValue { key, .. } if key == "announce_queue_max_interfaces"
        ));

        let err = parse(
            r#"
[reticulum]
announce_queue_max_bytes = 0
"#,
        )
        .unwrap_err();
        assert!(matches!(
            err,
            ConfigError::InvalidValue { key, .. } if key == "announce_queue_max_bytes"
        ));

        let err = parse(
            r#"
[reticulum]
driver_event_queue_capacity = 0
"#,
        )
        .unwrap_err();
        assert!(matches!(
            err,
            ConfigError::InvalidValue { key, .. } if key == "driver_event_queue_capacity"
        ));

        let err = parse(
            r#"
[reticulum]
interface_writer_queue_capacity = 0
"#,
        )
        .unwrap_err();
        assert!(matches!(
            err,
            ConfigError::InvalidValue { key, .. } if key == "interface_writer_queue_capacity"
        ));

        let err = parse(
            r#"
[reticulum]
announce_queue_ttl = 0
"#,
        )
        .unwrap_err();
        assert!(matches!(
            err,
            ConfigError::InvalidValue { key, .. } if key == "announce_queue_ttl"
        ));
    }

    #[test]
    fn parse_announce_queue_overflow_policy_rejects_invalid() {
        let err = parse(
            r#"
[reticulum]
announce_queue_overflow_policy = keep_everything
"#,
        )
        .unwrap_err();
        assert!(matches!(
            err,
            ConfigError::InvalidValue { key, .. } if key == "announce_queue_overflow_policy"
        ));
    }

    #[test]
    fn parse_destination_timeout_secs_alias() {
        let config = parse(
            r#"
[reticulum]
destination_timeout_secs = 777
"#,
        )
        .unwrap();

        assert_eq!(config.reticulum.known_destinations_ttl, 777);
    }

    #[test]
    fn parse_logging_section() {
        let input = "[logging]\nloglevel = 6\nlogtimestamps = no\n";
        let config = parse(input).unwrap();
        assert_eq!(config.logging.loglevel, 6);
        assert!(!config.logging.logtimestamps);
    }

    #[test]
    fn parse_logging_accepts_pathing_and_extreme_levels() {
        for level in [7, 8] {
            let config = parse(&format!("[logging]\nloglevel = {level}\n")).unwrap();
            assert_eq!(config.logging.loglevel, level);
        }
    }

    #[test]
    fn parse_logging_rejects_levels_above_extreme() {
        for value in ["9", "255", "256", "-1"] {
            let err = parse(&format!("[logging]\nloglevel = {value}\n")).unwrap_err();
            assert!(matches!(
                err,
                ConfigError::InvalidValue { key, .. } if key == "loglevel"
            ));
        }
    }

    #[test]
    fn parse_logging_rejects_invalid_logtimestamps() {
        let err = parse("[logging]\nlogtimestamps = maybe\n").unwrap_err();
        assert!(matches!(
            err,
            ConfigError::InvalidValue { key, .. } if key == "logtimestamps"
        ));
    }

    #[test]
    fn parse_interface_tcp_client() {
        let input = r#"
[interfaces]
  [[TCP Client]]
    type = TCPClientInterface
    enabled = Yes
    target_host = 87.106.8.245
    target_port = 4242
"#;
        let config = parse(input).unwrap();
        assert_eq!(config.interfaces.len(), 1);
        let iface = &config.interfaces[0];
        assert_eq!(iface.name, "TCP Client");
        assert_eq!(iface.interface_type, "TCPClientInterface");
        assert!(iface.enabled);
        assert_eq!(iface.params.get("target_host").unwrap(), "87.106.8.245");
        assert_eq!(iface.params.get("target_port").unwrap(), "4242");
    }

    #[test]
    fn parse_interface_tcp_server() {
        let input = r#"
[interfaces]
  [[TCP Server]]
    type = TCPServerInterface
    enabled = Yes
    listen_ip = 0.0.0.0
    listen_port = 4242
"#;
        let config = parse(input).unwrap();
        assert_eq!(config.interfaces.len(), 1);
        let iface = &config.interfaces[0];
        assert_eq!(iface.name, "TCP Server");
        assert_eq!(iface.interface_type, "TCPServerInterface");
        assert_eq!(iface.params.get("listen_ip").unwrap(), "0.0.0.0");
        assert_eq!(iface.params.get("listen_port").unwrap(), "4242");
    }

    #[test]
    fn parse_interface_udp() {
        let input = r#"
[interfaces]
  [[UDP Interface]]
    type = UDPInterface
    enabled = Yes
    listen_ip = 0.0.0.0
    listen_port = 4242
    forward_ip = 255.255.255.255
    forward_port = 4242
"#;
        let config = parse(input).unwrap();
        assert_eq!(config.interfaces.len(), 1);
        let iface = &config.interfaces[0];
        assert_eq!(iface.name, "UDP Interface");
        assert_eq!(iface.interface_type, "UDPInterface");
        assert_eq!(iface.params.get("listen_ip").unwrap(), "0.0.0.0");
        assert_eq!(iface.params.get("forward_ip").unwrap(), "255.255.255.255");
    }

    #[test]
    fn parse_multiple_interfaces() {
        let input = r#"
[interfaces]
  [[TCP Client]]
    type = TCPClientInterface
    target_host = 10.0.0.1
    target_port = 4242

  [[UDP Broadcast]]
    type = UDPInterface
    listen_ip = 0.0.0.0
    listen_port = 5555
    forward_ip = 255.255.255.255
    forward_port = 5555
"#;
        let config = parse(input).unwrap();
        assert_eq!(config.interfaces.len(), 2);
        assert_eq!(config.interfaces[0].name, "TCP Client");
        assert_eq!(config.interfaces[0].interface_type, "TCPClientInterface");
        assert_eq!(config.interfaces[1].name, "UDP Broadcast");
        assert_eq!(config.interfaces[1].interface_type, "UDPInterface");
    }

    #[test]
    fn parse_third_level_interface_sections() {
        let config = parse(
            "[interfaces]\n[[radio]]\n  type = RNodeMultiInterface\n  port = /dev/ttyUSB0\n  [[[fast]]]\n    enabled = yes\n    vport = 7\n    frequency = 915000000\n  [[[disabled]]]\n    enabled = no\n    vport = 2\n",
        )
        .unwrap();
        assert_eq!(config.interfaces.len(), 1);
        let interface = &config.interfaces[0];
        assert_eq!(interface.params["port"], "/dev/ttyUSB0");
        assert_eq!(interface.subinterfaces.len(), 2);
        assert_eq!(interface.subinterfaces[0].name, "fast");
        assert_eq!(interface.subinterfaces[0].params["vport"], "7");
    }

    #[test]
    fn parse_booleans() {
        // Test all boolean variants
        for (input, expected) in &[
            ("Yes", true),
            ("No", false),
            ("True", true),
            ("False", false),
            ("true", true),
            ("false", false),
            ("1", true),
            ("0", false),
            ("on", true),
            ("off", false),
        ] {
            let result = parse_bool(input);
            assert_eq!(result, Some(*expected), "parse_bool({}) failed", input);
        }
    }

    #[test]
    fn parse_comments() {
        let input = r#"
# This is a comment
[reticulum]
enable_transport = True  # inline comment
# share_instance = No
instance_name = test
"#;
        let config = parse(input).unwrap();
        assert!(config.reticulum.enable_transport);
        assert!(config.reticulum.share_instance); // commented out line should be ignored
        assert_eq!(config.reticulum.instance_name, "test");
    }

    #[test]
    fn parse_interface_mode_field() {
        let input = r#"
[interfaces]
  [[TCP Client]]
    type = TCPClientInterface
    interface_mode = access_point
    target_host = 10.0.0.1
    target_port = 4242
"#;
        let config = parse(input).unwrap();
        assert_eq!(config.interfaces[0].mode, "access_point");
    }

    #[test]
    fn parse_mode_fallback() {
        // Python also accepts "mode" as fallback for "interface_mode"
        let input = r#"
[interfaces]
  [[TCP Client]]
    type = TCPClientInterface
    mode = gateway
    target_host = 10.0.0.1
    target_port = 4242
"#;
        let config = parse(input).unwrap();
        assert_eq!(config.interfaces[0].mode, "gateway");
    }

    #[test]
    fn parse_interface_mode_takes_precedence() {
        // If both interface_mode and mode are set, interface_mode wins
        let input = r#"
[interfaces]
  [[TCP Client]]
    type = TCPClientInterface
    interface_mode = roaming
    mode = boundary
    target_host = 10.0.0.1
    target_port = 4242
"#;
        let config = parse(input).unwrap();
        assert_eq!(config.interfaces[0].mode, "roaming");
    }

    #[test]
    fn parse_disabled_interface() {
        let input = r#"
[interfaces]
  [[Disabled TCP]]
    type = TCPClientInterface
    enabled = No
    target_host = 10.0.0.1
    target_port = 4242
"#;
        let config = parse(input).unwrap();
        assert_eq!(config.interfaces.len(), 1);
        assert!(!config.interfaces[0].enabled);
    }

    #[test]
    fn parse_serial_interface() {
        let input = r#"
[interfaces]
  [[Serial Port]]
    type = SerialInterface
    enabled = Yes
    port = /dev/ttyUSB0
    speed = 115200
    databits = 8
    parity = N
    stopbits = 1
"#;
        let config = parse(input).unwrap();
        assert_eq!(config.interfaces.len(), 1);
        let iface = &config.interfaces[0];
        assert_eq!(iface.name, "Serial Port");
        assert_eq!(iface.interface_type, "SerialInterface");
        assert!(iface.enabled);
        assert_eq!(iface.params.get("port").unwrap(), "/dev/ttyUSB0");
        assert_eq!(iface.params.get("speed").unwrap(), "115200");
        assert_eq!(iface.params.get("databits").unwrap(), "8");
        assert_eq!(iface.params.get("parity").unwrap(), "N");
        assert_eq!(iface.params.get("stopbits").unwrap(), "1");
    }

    #[test]
    fn parse_kiss_interface() {
        let input = r#"
[interfaces]
  [[KISS TNC]]
    type = KISSInterface
    enabled = Yes
    port = /dev/ttyUSB1
    speed = 9600
    preamble = 350
    txtail = 20
    persistence = 64
    slottime = 20
    flow_control = True
    id_interval = 600
    id_callsign = MYCALL
"#;
        let config = parse(input).unwrap();
        assert_eq!(config.interfaces.len(), 1);
        let iface = &config.interfaces[0];
        assert_eq!(iface.name, "KISS TNC");
        assert_eq!(iface.interface_type, "KISSInterface");
        assert_eq!(iface.params.get("port").unwrap(), "/dev/ttyUSB1");
        assert_eq!(iface.params.get("speed").unwrap(), "9600");
        assert_eq!(iface.params.get("preamble").unwrap(), "350");
        assert_eq!(iface.params.get("txtail").unwrap(), "20");
        assert_eq!(iface.params.get("persistence").unwrap(), "64");
        assert_eq!(iface.params.get("slottime").unwrap(), "20");
        assert_eq!(iface.params.get("flow_control").unwrap(), "True");
        assert_eq!(iface.params.get("id_interval").unwrap(), "600");
        assert_eq!(iface.params.get("id_callsign").unwrap(), "MYCALL");
    }

    #[test]
    fn parse_ifac_networkname() {
        let input = r#"
[interfaces]
  [[TCP Client]]
    type = TCPClientInterface
    target_host = 10.0.0.1
    target_port = 4242
    networkname = testnet
"#;
        let config = parse(input).unwrap();
        assert_eq!(
            config.interfaces[0].params.get("networkname").unwrap(),
            "testnet"
        );
    }

    #[test]
    fn parse_ifac_passphrase() {
        let input = r#"
[interfaces]
  [[TCP Client]]
    type = TCPClientInterface
    target_host = 10.0.0.1
    target_port = 4242
    passphrase = secret123
    ifac_size = 64
"#;
        let config = parse(input).unwrap();
        assert_eq!(
            config.interfaces[0].params.get("passphrase").unwrap(),
            "secret123"
        );
        assert_eq!(config.interfaces[0].params.get("ifac_size").unwrap(), "64");
    }

    #[test]
    fn parse_remote_management_config() {
        let input = r#"
[reticulum]
enable_transport = True
enable_remote_management = Yes
remote_management_allowed = aabbccdd00112233aabbccdd00112233, 11223344556677881122334455667788
publish_blackhole = Yes
"#;
        let config = parse(input).unwrap();
        assert!(config.reticulum.enable_remote_management);
        assert!(config.reticulum.publish_blackhole);
        assert_eq!(config.reticulum.remote_management_allowed.len(), 2);
        assert_eq!(
            config.reticulum.remote_management_allowed[0],
            "aabbccdd00112233aabbccdd00112233"
        );
        assert_eq!(
            config.reticulum.remote_management_allowed[1],
            "11223344556677881122334455667788"
        );
    }

    #[test]
    fn parse_remote_management_defaults() {
        let input = "[reticulum]\n";
        let config = parse(input).unwrap();
        assert!(!config.reticulum.enable_remote_management);
        assert!(!config.reticulum.publish_blackhole);
        assert!(config.reticulum.remote_management_allowed.is_empty());
    }

    #[test]
    fn parse_hooks_section() {
        let input = r#"
[hooks]
  [[drop_tick]]
    path = /tmp/drop_tick.wasm
    attach_point = Tick
    priority = 10
    enabled = Yes

  [[log_announce]]
    path = /tmp/log_announce.wasm
    type = native
    attach_point = AnnounceReceived
    priority = 5
    enabled = No

  [[builtin_tick]]
    builtin = example.tick
    type = builtin
    attach_point = Tick
"#;
        let config = parse(input).unwrap();
        assert_eq!(config.hooks.len(), 3);
        assert_eq!(config.hooks[0].name, "drop_tick");
        assert_eq!(config.hooks[0].path, "/tmp/drop_tick.wasm");
        assert_eq!(config.hooks[0].hook_type, default_hook_type());
        assert_eq!(config.hooks[0].attach_point, "Tick");
        assert_eq!(config.hooks[0].priority, 10);
        assert!(config.hooks[0].enabled);
        assert_eq!(config.hooks[1].name, "log_announce");
        assert_eq!(config.hooks[1].hook_type, "native");
        assert_eq!(config.hooks[1].attach_point, "AnnounceReceived");
        assert!(!config.hooks[1].enabled);
        assert_eq!(config.hooks[2].hook_type, "builtin");
        assert_eq!(config.hooks[2].builtin_id.as_deref(), Some("example.tick"));
    }

    #[test]
    fn parse_empty_hooks() {
        let input = "[hooks]\n";
        let config = parse(input).unwrap();
        assert!(config.hooks.is_empty());
    }

    #[test]
    fn parse_hook_point_names() {
        assert_eq!(parse_hook_point("PreIngress"), Some(0));
        assert_eq!(parse_hook_point("PreDispatch"), Some(1));
        assert_eq!(parse_hook_point("AnnounceReceived"), Some(2));
        assert_eq!(parse_hook_point("PathUpdated"), Some(3));
        assert_eq!(parse_hook_point("AnnounceRetransmit"), Some(4));
        assert_eq!(parse_hook_point("LinkRequestReceived"), Some(5));
        assert_eq!(parse_hook_point("LinkEstablished"), Some(6));
        assert_eq!(parse_hook_point("LinkClosed"), Some(7));
        assert_eq!(parse_hook_point("InterfaceUp"), Some(8));
        assert_eq!(parse_hook_point("InterfaceDown"), Some(9));
        assert_eq!(parse_hook_point("InterfaceConfigChanged"), Some(10));
        assert_eq!(parse_hook_point("BackbonePeerConnected"), Some(11));
        assert_eq!(parse_hook_point("BackbonePeerDisconnected"), Some(12));
        assert_eq!(parse_hook_point("BackbonePeerIdleTimeout"), Some(13));
        assert_eq!(parse_hook_point("BackbonePeerWriteStall"), Some(14));
        assert_eq!(parse_hook_point("BackbonePeerPenalty"), Some(15));
        assert_eq!(parse_hook_point("SendOnInterface"), Some(16));
        assert_eq!(parse_hook_point("BroadcastOnAllInterfaces"), Some(17));
        assert_eq!(parse_hook_point("DeliverLocal"), Some(18));
        assert_eq!(parse_hook_point("TunnelSynthesize"), Some(19));
        assert_eq!(parse_hook_point("Tick"), Some(20));
        assert_eq!(parse_hook_point("Unknown"), None);
    }

    #[test]
    fn backbone_extra_params_preserved() {
        let config = r#"
[reticulum]
enable_transport = True

[interfaces]
  [[Public Entrypoint]]
    type = BackboneInterface
    enabled = yes
    listen_ip = 0.0.0.0
    listen_port = 4242
    interface_mode = gateway
    discoverable = Yes
    discovery_name = PizzaSpaghettiMandolino
    announce_interval = 600
    discovery_stamp_value = 24
    reachable_on = 87.106.8.245
"#;
        let parsed = parse(config).unwrap();
        assert_eq!(parsed.interfaces.len(), 1);
        let iface = &parsed.interfaces[0];
        assert_eq!(iface.name, "Public Entrypoint");
        assert_eq!(iface.interface_type, "BackboneInterface");
        // After removing type, enabled, interface_mode, remaining params should include discovery keys
        assert_eq!(
            iface.params.get("discoverable").map(|s| s.as_str()),
            Some("Yes")
        );
        assert_eq!(
            iface.params.get("discovery_name").map(|s| s.as_str()),
            Some("PizzaSpaghettiMandolino")
        );
        assert_eq!(
            iface.params.get("announce_interval").map(|s| s.as_str()),
            Some("600")
        );
        assert_eq!(
            iface
                .params
                .get("discovery_stamp_value")
                .map(|s| s.as_str()),
            Some("24")
        );
        assert_eq!(
            iface.params.get("reachable_on").map(|s| s.as_str()),
            Some("87.106.8.245")
        );
        assert_eq!(
            iface.params.get("listen_ip").map(|s| s.as_str()),
            Some("0.0.0.0")
        );
        assert_eq!(
            iface.params.get("listen_port").map(|s| s.as_str()),
            Some("4242")
        );
    }

    #[test]
    fn parse_probe_protocol() {
        let input = r#"
[reticulum]
probe_addr = 1.2.3.4:19302
probe_protocol = stun
"#;
        let config = parse(input).unwrap();
        assert_eq!(
            config.reticulum.probe_addr.as_deref(),
            Some("1.2.3.4:19302")
        );
        assert_eq!(config.reticulum.probe_protocol.as_deref(), Some("stun"));
    }

    #[test]
    fn parse_probe_protocol_defaults_to_none() {
        let input = r#"
[reticulum]
probe_addr = 1.2.3.4:4343
"#;
        let config = parse(input).unwrap();
        assert_eq!(config.reticulum.probe_addr.as_deref(), Some("1.2.3.4:4343"));
        assert!(config.reticulum.probe_protocol.is_none());
    }

    #[test]
    fn parse_direct_connect_policy() {
        let config = parse(
            r#"
[reticulum]
direct_connect_policy = identified_only
"#,
        )
        .unwrap();
        assert_eq!(
            config.reticulum.direct_connect_policy,
            crate::event::HolePunchPolicy::IdentifiedOnly
        );
    }

    #[test]
    fn direct_connect_policy_defaults_to_identified_only_and_rejects_invalid() {
        let config = parse("[reticulum]\n").unwrap();
        assert_eq!(
            config.reticulum.direct_connect_policy,
            crate::event::HolePunchPolicy::IdentifiedOnly
        );
        let config = parse("[reticulum]\ndirect_connect_policy = accept_all\n").unwrap();
        assert_eq!(
            config.reticulum.direct_connect_policy,
            crate::event::HolePunchPolicy::AcceptAll
        );
        assert!(parse("[reticulum]\ndirect_connect_policy = sometimes\n").is_err());
    }

    #[test]
    fn direct_connect_allow_private_endpoints_parses_and_defaults_false() {
        let config = parse("[reticulum]\n").unwrap();
        assert!(!config.reticulum.direct_connect_allow_private_endpoints);
        let config = parse("[reticulum]\ndirect_connect_allow_private_endpoints = yes\n").unwrap();
        assert!(config.reticulum.direct_connect_allow_private_endpoints);
        let config =
            parse("[reticulum]\ndirect_connect_allow_private_endpoints = False\n").unwrap();
        assert!(!config.reticulum.direct_connect_allow_private_endpoints);
        assert!(parse("[reticulum]\ndirect_connect_allow_private_endpoints = maybe\n").is_err());
    }

    #[test]
    fn link_mtu_discovery_defaults_true_and_honors_both_boolean_values() {
        assert!(parse_link_mtu_discovery("").unwrap());
        assert!(parse_link_mtu_discovery("[reticulum]\nlink_mtu_discovery = Yes\n").unwrap());
        assert!(!parse_link_mtu_discovery("[reticulum]\nlink_mtu_discovery = False\n").unwrap());
        assert!(parse_link_mtu_discovery("[logging]\nlink_mtu_discovery = No\n").unwrap());
        assert!(parse_link_mtu_discovery("[reticulum]\nlink_mtu_discovery = maybe\n").is_err());
    }

    #[test]
    fn filter_section_defaults_to_no_filtering() {
        let config = parse("").unwrap();
        assert_eq!(config.filter, FilterSection::default());
        assert!(!config.filter.required_only);
    }

    #[test]
    fn filter_section_parses_every_option() {
        let config = parse(
            "[filter]\n\
             required_only = Yes\n\
             ignored_types = nomadnetwork.node, lxmf.propagation\n\
             allowed_types = lxmf.delivery\n",
        )
        .unwrap();
        assert_eq!(
            config.filter,
            FilterSection {
                required_only: true,
                ignored_types: vec!["nomadnetwork.node".into(), "lxmf.propagation".into()],
                allowed_types: vec!["lxmf.delivery".into()],
            }
        );

        use rns_core::transport::destination_filter::destination_type;
        let filter = config.filter.destination_filter();
        assert!(filter.required_only());
        assert!(!filter.allows(&destination_type("nomadnetwork.node"), true));
        assert!(filter.allows(&destination_type("lxmf.delivery"), false));
        assert!(!filter.allows(&destination_type("rncp.receive"), false));
    }

    #[test]
    fn filter_section_rejects_an_invalid_boolean() {
        assert!(parse("[filter]\nrequired_only = maybe\n").is_err());
    }

    #[test]
    fn stamps_section_defaults_to_the_protocol_constants() {
        use rns_core::constants;
        let config = parse("").unwrap();
        assert_eq!(config.stamps, StampsSection::default());
        let stamps = config.stamps;
        let flags = [
            stamps.stamps_enforced,
            stamps.lr_stamps_enforced,
            stamps.stamp_destinations,
            stamps.stamp_prs,
            stamps.always_stamp_lrs,
        ];
        assert_eq!(flags, [false; 5]);
        // a8cc6cb2: link requests are stamped when a cost is announced.
        assert!(stamps.stamp_lrs);
        assert_eq!(stamps.destination_cost, constants::DESTINATION_STAMP_COST);
        assert_eq!(stamps.destination_value, StampCost::from_whole(25));
        assert_eq!(stamps.pr_cost, constants::PATH_REQUEST_STAMP_COST);
        assert_eq!(stamps.pr_value, constants::PATH_REQUEST_STAMP_VALUE);
        assert_eq!(stamps.lr_cost, constants::LINK_REQUEST_STAMP_COST);
        assert_eq!(
            stamps.link_stamp_timeout(),
            std::time::Duration::from_secs(15)
        );
        assert_eq!(
            stamps.path_request_stamp_timeout(),
            std::time::Duration::from_secs(15)
        );
        assert_eq!(config.reticulum.hop_limiter, constants::PATHFINDER_M);
    }

    #[test]
    fn stamps_section_parses_every_option() {
        let config = parse(
            "[stamps]\n\
             enforce_stamps = yes\n\
             stamp_destinations = Yes\n\
             stamp_prs = true\n\
             always_stamp_lrs = on\n\
             destination_cost = 20\n\
             destination_value = 30\n\
             pr_cost = 12\n\
             pr_value = 14\n\
             lr_cost = 9\n\
             lr_stamp_timeout = 2.5\n\
             pr_stamp_timeout = 7\n",
        )
        .unwrap();
        let stamps = config.stamps;
        // `enforce_stamps` sets both STAMPS_ENFORCED and LR_STAMPS_ENFORCED.
        assert!(stamps.stamps_enforced);
        assert!(stamps.lr_stamps_enforced);
        assert!(stamps.stamp_destinations);
        assert!(stamps.stamp_prs);
        assert!(stamps.always_stamp_lrs);
        assert_eq!(stamps.destination_cost, StampCost::from_whole(20));
        assert_eq!(stamps.destination_value, StampCost::from_whole(30));
        assert_eq!(stamps.pr_cost, StampCost::from_whole(12));
        assert_eq!(stamps.pr_value, StampCost::from_whole(14));
        assert_eq!(stamps.lr_cost, StampCost::from_whole(9));
        assert_eq!(
            stamps.link_stamp_timeout(),
            std::time::Duration::from_millis(2500)
        );
        assert_eq!(
            stamps.path_request_stamp_timeout(),
            std::time::Duration::from_secs(7)
        );
    }

    #[test]
    fn stamps_section_booleans_can_only_enable() {
        // Reticulum.py applies each option as `if value == True: X = True`,
        // so `no` keeps the built-in default instead of forcing it off.
        let config = parse(
            "[stamps]\n\
             enforce_stamps = no\n\
             stamp_destinations = False\n\
             stamp_prs = off\n\
             always_stamp_lrs = 0\n",
        )
        .unwrap();
        assert_eq!(config.stamps, StampsSection::default());
        assert!(parse("[stamps]\nstamp_prs = maybe\n").is_err());
        assert!(parse("[stamps]\nenforce_stamps = 2\n").is_err());
    }

    #[test]
    fn stamps_section_ignores_the_removed_stamp_lrs_option() {
        // a8cc6cb2 dropped `stamp_lrs`; `no` no longer turns stamping off.
        let config = parse("[stamps]\nstamp_lrs = no\n").unwrap();
        assert_eq!(config.stamps, StampsSection::default());
        assert!(config.stamps.stamp_lrs);
    }

    #[test]
    fn stamps_section_costs_are_fractional() {
        // Reticulum.py reads them with `as_float` since 796ef2d4.
        let config = parse(
            "[stamps]\n\
             destination_cost = 23.5\n\
             pr_value = 15.8\n\
             lr_cost = 12\n\
             pr_cost = inf\n\
             destination_value = nan\n",
        )
        .unwrap();
        let stamps = config.stamps;
        assert_eq!(stamps.destination_cost, StampCost::from_fp(6016));
        assert_eq!(stamps.pr_value, StampCost::from_f64(15.8));
        assert_eq!(stamps.lr_cost, StampCost::from_whole(12));
        // `max(0, min(v, cap))` in Python: infinity clamps to the cap, NaN to 0.
        assert_eq!(stamps.pr_cost, StampCost::from_whole(100));
        assert_eq!(stamps.destination_value, StampCost::ZERO);
        assert!(parse("[stamps]\npr_cost = high\n").is_err());
    }

    #[test]
    fn stamps_section_clamps_costs_and_timeouts() {
        use rns_core::constants;
        let config = parse(
            "[stamps]\n\
             destination_cost = 500\n\
             destination_value = -3\n\
             pr_cost = 101\n\
             pr_value = 99999999999999999999999\n\
             lr_cost = 41\n\
             lr_stamp_timeout = 0\n\
             pr_stamp_timeout = -10\n",
        )
        .unwrap();
        let stamps = config.stamps;
        let cap = StampCost::from_whole(u32::from(constants::STAMP_COST_CAP));
        assert_eq!(stamps.destination_cost, cap);
        assert_eq!(stamps.destination_value, StampCost::ZERO);
        assert_eq!(stamps.pr_cost, cap);
        assert_eq!(stamps.pr_value, cap);
        // `lr_cost` has its own, lower cap.
        assert_eq!(
            stamps.lr_cost,
            StampCost::from_whole(u32::from(constants::LINK_COST_CAP))
        );
        assert_eq!(
            stamps.link_stamp_timeout(),
            std::time::Duration::from_millis(20)
        );
        assert_eq!(
            stamps.path_request_stamp_timeout(),
            std::time::Duration::from_millis(20)
        );

        let config = parse("[stamps]\nlr_cost = -1\npr_stamp_timeout = nan\n").unwrap();
        assert_eq!(config.stamps.lr_cost, StampCost::ZERO);
        assert_eq!(
            config.stamps.path_request_stamp_timeout(),
            std::time::Duration::from_millis(20)
        );
        let config = parse("[stamps]\nlr_stamp_timeout = inf\n").unwrap();
        assert_eq!(config.stamps.link_stamp_timeout(), std::time::Duration::MAX);

        // `as_float` rejects non-numbers.
        assert!(parse("[stamps]\npr_cost = lots\n").is_err());
        assert!(parse("[stamps]\npr_stamp_timeout = soon\n").is_err());
    }

    #[test]
    fn stamps_options_outside_the_stamps_section_are_ignored() {
        let config = parse("[reticulum]\nstamp_prs = yes\ndestination_cost = 5\n").unwrap();
        assert_eq!(config.stamps, StampsSection::default());
    }

    #[test]
    fn hop_limiter_parses_and_clamps_to_pathfinder_range() {
        use rns_core::constants::PATHFINDER_M;
        let limiter = |value: &str| {
            parse(&format!("[reticulum]\nhop_limiter = {value}\n"))
                .unwrap()
                .reticulum
                .hop_limiter
        };
        assert_eq!(limiter("16"), 16);
        assert_eq!(limiter("1"), 1);
        assert_eq!(limiter("0"), 1);
        assert_eq!(limiter("-5"), 1);
        assert_eq!(limiter("128"), PATHFINDER_M);
        assert_eq!(limiter("1000"), PATHFINDER_M);
        assert!(parse("[reticulum]\nhop_limiter = many\n").is_err());
        assert!(parse("[reticulum]\nhop_limiter = 4.5\n").is_err());
    }
}