use crate::error::{Error, Result};
use serde::{Deserialize, Serialize};
use std::fmt::Write as _;
use std::net::IpAddr;
use std::path::{Path, PathBuf};
use std::process::Command;
const PF_ANCHOR: &str = "blackship";
const DRAIN_ANCHOR_REFERENCE: &str = "anchor \"drain/*\"";
pub fn enable_pf() -> Result<()> {
if pf_enabled() {
return Ok(());
}
let pf_conf = Path::new("/etc/pf.conf");
if !pf_conf.exists() {
let conf = format!(
"# Generated by blackship setup --enable-pf\n\
set skip on lo0\n\
nat-anchor \"{PF_ANCHOR}\"\n\
rdr-anchor \"{PF_ANCHOR}\"\n\
anchor \"{PF_ANCHOR}\"\n\
anchor \"{PF_ANCHOR}/*\"\n\
pass all\n"
);
std::fs::write(pf_conf, conf)
.map_err(|e| Error::Network(format!("Failed to write /etc/pf.conf: {e}")))?;
println!("Wrote minimal /etc/pf.conf with blackship anchors (default: pass all)");
}
let status = Command::new("/usr/sbin/sysrc")
.arg("pf_enable=YES")
.status()
.map_err(|e| Error::Network(format!("Failed to run sysrc: {e}")))?;
if !status.success() {
return Err(Error::Network("sysrc pf_enable=YES failed".to_string()));
}
let status = Command::new("/usr/sbin/service")
.args(["pf", "start"])
.status()
.map_err(|e| Error::Network(format!("Failed to start pf: {e}")))?;
if !status.success() {
return Err(Error::Network(
"service pf start failed; check /etc/pf.conf".to_string(),
));
}
println!("PF enabled and started.");
Ok(())
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct PortForward {
pub external_port: u16,
pub internal_port: u16,
pub protocol: String,
pub jail_ip: IpAddr,
pub bind_ip: Option<IpAddr>,
pub jail_name: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct PortForwardFile {
forwards: Vec<PortForward>,
}
impl PortForward {
pub fn new(
external_port: u16,
internal_port: u16,
protocol: &str,
jail_ip: IpAddr,
jail_name: &str,
) -> Self {
Self {
external_port,
internal_port,
protocol: protocol.to_string(),
jail_ip,
bind_ip: None,
jail_name: jail_name.to_string(),
}
}
pub const fn with_bind_ip(mut self, ip: IpAddr) -> Self {
self.bind_ip = Some(ip);
self
}
pub fn to_pf_rule(&self) -> Result<String> {
match self.protocol.as_str() {
"tcp" | "udp" => {}
other => {
return Err(Error::ConfigValidation(format!(
"invalid protocol {other:?}: must be \"tcp\" or \"udp\""
)));
}
}
let destination = self
.bind_ip
.map_or_else(|| "any".to_string(), |ip| ip.to_string());
let safe_name = sanitize_jail_name(&self.jail_name);
Ok(format!(
"rdr proto {} from any to {} port {} -> {} port {} # jail:{}",
self.protocol,
destination,
self.external_port,
self.jail_ip,
self.internal_port,
safe_name
))
}
}
pub fn sanitize_jail_name(name: &str) -> String {
name.chars()
.map(|c| {
if c.is_alphanumeric() || c == '-' || c == '_' || c == '.' {
c
} else {
'_'
}
})
.collect()
}
pub fn drain_anchor_path(jail_name: &str) -> String {
format!("{}/drain/{}", PF_ANCHOR, sanitize_jail_name(jail_name))
}
pub fn load_drain_anchor(data_dir: &Path, jail_name: &str, ips: &[IpAddr]) -> Result<String> {
if ips.is_empty() {
return Err(Error::InvalidArgument(format!(
"jail '{jail_name}' has no recorded IP to drain"
)));
}
BulkheadManager::from_data_dir(data_dir)?.apply_rules()?;
let anchor = drain_anchor_path(jail_name);
pfctl_stdin(&anchor, &drain_rules(ips))?;
Ok(anchor)
}
fn drain_rules(ips: &[IpAddr]) -> String {
let mut rules = String::new();
for ip in ips {
if !rules.is_empty() {
rules.push('\n');
}
let _ = write!(rules, "block drop in quick proto tcp to {ip} flags S/SA"); }
rules
}
pub fn flush_drain_anchor(anchor: &str) {
let _ = Command::new("/sbin/pfctl")
.args(["-a", anchor, "-F", "rules"])
.output();
}
pub fn list_drain_anchors() -> Vec<String> {
let prefix = format!("{PF_ANCHOR}/drain/");
Command::new("/sbin/pfctl")
.args(["-a", &format!("{PF_ANCHOR}/drain"), "-s", "Anchors"])
.output()
.ok()
.filter(|o| o.status.success())
.map(|o| {
String::from_utf8_lossy(&o.stdout)
.lines()
.map(str::trim)
.filter(|line| line.starts_with(&prefix))
.map(str::to_string)
.collect()
})
.unwrap_or_default()
}
pub fn tcp_state_count(ip: IpAddr) -> usize {
let needle = ip.to_string();
Command::new("/sbin/pfctl")
.args(["-s", "state"])
.output()
.ok()
.filter(|o| o.status.success())
.map_or(0, |o| {
String::from_utf8_lossy(&o.stdout)
.lines()
.filter(|line| line.contains("tcp") && line.contains(&needle))
.count()
})
}
pub fn pf_enabled() -> bool {
Command::new("/sbin/pfctl")
.args(["-s", "info"])
.output()
.ok()
.filter(|o| o.status.success())
.is_some_and(|o| String::from_utf8_lossy(&o.stdout).contains("Status: Enabled"))
}
fn pfctl_stdin(anchor: &str, rules: &str) -> Result<()> {
let mut child = Command::new("/sbin/pfctl")
.args(["-a", anchor, "-f", "-"])
.stdin(std::process::Stdio::piped())
.spawn()
.map_err(|e| Error::Network(format!("Failed to run pfctl: {e}")))?;
if let Some(stdin) = child.stdin.as_mut() {
use std::io::Write;
stdin
.write_all(rules.as_bytes())
.map_err(|e| Error::Network(format!("Failed to write rules: {e}")))?;
}
let output = child
.wait_with_output()
.map_err(|e| Error::Network(format!("Failed to wait for pfctl: {e}")))?;
if !output.status.success() {
return Err(Error::Network(format!(
"pfctl failed for anchor '{}': {}",
anchor,
String::from_utf8_lossy(&output.stderr)
)));
}
Ok(())
}
#[derive(Debug, Default)]
pub struct BulkheadManager {
forwards: Vec<PortForward>,
state_path: Option<PathBuf>,
}
impl BulkheadManager {
pub fn from_data_dir(data_dir: &Path) -> Result<Self> {
let state_path = data_dir.join("port-forwards.toml");
let forwards = read_forwards(&state_path)?;
Ok(Self {
forwards,
state_path: Some(state_path),
})
}
pub fn init() -> Result<()> {
if !pf_enabled() {
return Err(Error::Network(
"PF is not running. Enable it with: service pf start".to_string(),
));
}
let output = Command::new("/sbin/pfctl")
.args(["-a", PF_ANCHOR, "-s", "rules"])
.output()
.map_err(|e| Error::Network(format!("Failed to check anchor: {e}")))?;
if !output.status.success() {
eprintln!("Warning: PF anchor '{PF_ANCHOR}' may not be configured.");
eprintln!("Add these lines to /etc/pf.conf:");
eprintln!(" rdr-anchor \"{PF_ANCHOR}\"");
eprintln!(" anchor \"{PF_ANCHOR}\"");
}
Ok(())
}
pub fn sync_rules(&self) -> Result<()> {
Self::init()?;
self.apply_rules()
}
pub fn add_forward(&mut self, forward: PortForward) -> Result<()> {
Self::init()?;
if self.forwards.iter().any(|existing| existing == &forward) {
return Ok(());
}
if let Some(existing) = self.forwards.iter().find(|existing| {
existing.bind_ip == forward.bind_ip
&& existing.protocol == forward.protocol
&& existing.external_port == forward.external_port
}) {
return Err(Error::Network(format!(
"Port {} {}/{} is already exposed for jail '{}'",
existing.external_port,
existing
.bind_ip
.map_or_else(|| "*".into(), |ip| ip.to_string()),
existing.protocol,
existing.jail_name
)));
}
self.forwards.push(forward);
self.forwards.sort_by(|a, b| {
a.jail_name
.cmp(&b.jail_name)
.then_with(|| a.protocol.cmp(&b.protocol))
.then_with(|| a.external_port.cmp(&b.external_port))
});
self.persist()?;
self.apply_rules()
}
pub fn remove_jail_forwards(&mut self, jail_name: &str) -> Result<()> {
if !self.forwards.iter().any(|f| f.jail_name == jail_name) {
return Ok(());
}
Self::init()?;
self.forwards
.retain(|forward| forward.jail_name != jail_name);
self.persist()?;
self.apply_rules()
}
pub fn list_forwards(&self) -> &[PortForward] {
&self.forwards
}
pub fn get_jail_forwards(&self, jail_name: &str) -> Vec<&PortForward> {
self.forwards
.iter()
.filter(|forward| forward.jail_name == jail_name)
.collect()
}
fn persist(&self) -> Result<()> {
let Some(path) = self.state_path.as_ref() else {
return Ok(());
};
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent).map_err(|e| {
Error::Network(format!("Failed to create port-forward state dir: {e}"))
})?;
}
write_forwards(path, &self.forwards)
}
fn apply_rules(&self) -> Result<()> {
pfctl_stdin(PF_ANCHOR, &self.anchor_ruleset()?)
}
fn anchor_ruleset(&self) -> Result<String> {
let mut rules = String::new();
for forward in &self.forwards {
rules.push_str(&forward.to_pf_rule()?);
rules.push('\n');
}
rules.push_str(DRAIN_ANCHOR_REFERENCE);
rules.push('\n');
Ok(rules)
}
}
fn read_forwards(path: &Path) -> Result<Vec<PortForward>> {
if !path.exists() {
return Ok(Vec::new());
}
let state: PortForwardFile = crate::atomic::read_toml(path, "port-forward state")?;
Ok(state.forwards)
}
fn write_forwards(path: &Path, forwards: &[PortForward]) -> Result<()> {
crate::atomic::write_toml_atomic(
path,
&PortForwardFile {
forwards: forwards.to_vec(),
},
"port-forward state",
)
}
#[cfg(test)]
impl BulkheadManager {
pub fn new() -> Self {
Self::default()
}
}
#[cfg(test)]
mod tests;