blackship 0.2.1

A FreeBSD jail manager with state machine control
//! Port forwarding commands: expose, ports, unexpose

use std::path::Path;

use crate::bulkhead::PortForward;
use crate::error::Result;
use crate::{bridge, error, manifest};

pub fn handle_expose(
    config_path: &Path,
    verbose: bool,
    jail: &str,
    port: u16,
    internal: Option<u16>,
    proto: &str,
    bind_ip: Option<String>,
) -> Result<()> {
    use std::net::IpAddr;

    let config = manifest::load(config_path)?;
    let mut bridge = bridge::Bridge::open(config, verbose)?;

    let bind_addr: Option<IpAddr> = if let Some(ip_str) = bind_ip {
        Some(
            ip_str
                .parse()
                .map_err(|e| error::Error::Network(format!("Invalid bind IP '{ip_str}': {e}")))?,
        )
    } else {
        None
    };

    let forward = bridge.expose_port(jail, port, internal, proto, bind_addr)?;

    println!("Port forwarding configured:");
    println!(
        "  {}:{}/{} -> {}:{}",
        bind_addr.map_or_else(|| "*".to_string(), |ip| ip.to_string()),
        port,
        proto,
        forward.jail_ip,
        internal.unwrap_or(port)
    );
    println!("\nPF rule applied: {}", forward.to_pf_rule()?);
    println!("\nNote: Ensure these lines are in /etc/pf.conf:");
    println!("  rdr-anchor \"blackship\"");
    println!("  anchor \"blackship\"");

    Ok(())
}

pub fn handle_ports(config_path: &Path, jail: Option<&str>) -> Result<()> {
    let forwards = list_ports(config_path, jail)?;

    println!("Port forwarding status:");
    println!(
        "{:<20} {:<12} {:<18} {:<18}",
        "JAIL", "PROTO", "EXTERNAL", "INTERNAL"
    );
    println!("{}", "-".repeat(70));

    if forwards.is_empty() {
        println!("No port forwards configured.");
    } else {
        for forward in forwards {
            let bind_str = forward
                .bind_ip
                .map_or_else(|| "*".to_string(), |ip| ip.to_string());
            println!(
                "{:<20} {:<12} {:<18} {:<18}",
                forward.jail_name,
                forward.protocol,
                format!("{}:{}", bind_str, forward.external_port),
                format!("{}:{}", forward.jail_ip, forward.internal_port)
            );
        }
    }

    println!("\nTo expose a port:");
    println!("  blackship expose <jail> -p <port> [--bind-ip <ip>]");

    Ok(())
}

/// Return configured port forwards without writing terminal output.
pub fn list_ports(config_path: &Path, jail: Option<&str>) -> Result<Vec<PortForward>> {
    let config = manifest::load(config_path)?;
    let bridge = bridge::Bridge::new(config)?;

    Ok(if let Some(jail_name) = jail {
        bridge
            .get_jail_port_forwards(jail_name)
            .into_iter()
            .cloned()
            .collect()
    } else {
        bridge.list_port_forwards().to_vec()
    })
}

pub fn handle_unexpose(config_path: &Path, verbose: bool, jail: &str) -> Result<()> {
    let config = manifest::load(config_path)?;
    let (_service_name, full_name) = config
        .resolve_jail_names(jail)
        .ok_or_else(|| error::Error::JailNotFound(jail.to_string()))?;
    let mut bridge = bridge::Bridge::open(config, verbose)?;
    bridge.remove_port_forwards(&full_name)?;
    println!("Removed all port forwards for jail '{full_name}'");

    Ok(())
}