use crate::error::{Error, Result};
use std::process::Command;
use std::sync::atomic::{AtomicU32, Ordering};
static EPAIR_COUNTER: AtomicU32 = AtomicU32::new(0);
#[derive(Debug, Clone)]
pub struct EpairInterface {
host_side: String,
jail_side: String,
}
impl EpairInterface {
pub fn create() -> Result<Self> {
let output = Command::new("ifconfig")
.args(["epair", "create"])
.output()
.map_err(|e| Error::Network(format!("Failed to create epair: {}", e)))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err(Error::Network(format!(
"Failed to create epair: {}",
stderr
)));
}
let host_side = String::from_utf8_lossy(&output.stdout).trim().to_string();
let jail_side = host_side
.strip_suffix('a')
.map(|s| format!("{}b", s))
.ok_or_else(|| {
Error::Network(format!("Unexpected epair name format: {}", host_side))
})?;
let output = Command::new("ifconfig")
.args([&host_side, "up"])
.output()
.map_err(|e| Error::Network(format!("Failed to bring up epair: {}", e)))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err(Error::Network(format!(
"Failed to bring up {}: {}",
host_side, stderr
)));
}
Ok(Self {
host_side,
jail_side,
})
}
pub fn create_for_jail(jail_name: &str) -> Result<Self> {
let epair = Self::create()?;
let counter = EPAIR_COUNTER.fetch_add(1, Ordering::SeqCst);
let new_host_name = format!("e{}a_{}", counter, Self::sanitize_name(jail_name));
let new_jail_name = format!("e{}b_{}", counter, Self::sanitize_name(jail_name));
let output = Command::new("ifconfig")
.args([&epair.host_side, "name", &new_host_name])
.output()
.map_err(|e| Error::Network(format!("Failed to rename epair: {}", e)))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
let _ = Command::new("ifconfig")
.args([&epair.host_side, "destroy"])
.output();
return Err(Error::Network(format!(
"Failed to rename {}: {}",
epair.host_side, stderr
)));
}
let output = Command::new("ifconfig")
.args([&epair.jail_side, "name", &new_jail_name])
.output()
.map_err(|e| Error::Network(format!("Failed to rename epair: {}", e)))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
let _ = Command::new("ifconfig")
.args([&new_host_name, "destroy"])
.output();
return Err(Error::Network(format!(
"Failed to rename {}: {}",
epair.jail_side, stderr
)));
}
Ok(Self {
host_side: new_host_name,
jail_side: new_jail_name,
})
}
pub fn host_side(&self) -> &str {
&self.host_side
}
pub fn jail_side(&self) -> &str {
&self.jail_side
}
pub fn set_mac_address(&self, mac: &str) -> Result<()> {
let output = Command::new("ifconfig")
.args([&self.jail_side, "ether", mac])
.output()
.map_err(|e| Error::Network(format!("Failed to set MAC address: {}", e)))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err(Error::Network(format!(
"Failed to set MAC {} on {}: {}",
mac, self.jail_side, stderr
)));
}
Ok(())
}
pub fn move_to_jail(&self, jid: i32) -> Result<()> {
let output = Command::new("ifconfig")
.args([&self.jail_side, "vnet", &jid.to_string()])
.output()
.map_err(|e| Error::Network(format!("Failed to move interface to jail: {}", e)))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err(Error::Network(format!(
"Failed to move {} to jail {}: {}",
self.jail_side, jid, stderr
)));
}
Ok(())
}
pub fn configure_in_jail(
jid: i32,
interface: &str,
addr: &str,
gateway: Option<&str>,
) -> Result<()> {
let output = Command::new("jexec")
.args([&jid.to_string(), "ifconfig", interface, addr])
.output()
.map_err(|e| Error::Network(format!("Failed to configure interface: {}", e)))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err(Error::Network(format!(
"Failed to configure {} in jail {}: {}",
interface, jid, stderr
)));
}
let output = Command::new("jexec")
.args([&jid.to_string(), "ifconfig", interface, "up"])
.output()
.map_err(|e| Error::Network(format!("Failed to bring up interface: {}", e)))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err(Error::Network(format!(
"Failed to bring up {} in jail {}: {}",
interface, jid, stderr
)));
}
if let Some(gw) = gateway {
let output = Command::new("jexec")
.args([&jid.to_string(), "route", "add", "default", gw])
.output()
.map_err(|e| Error::Network(format!("Failed to add route: {}", e)))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
if !stderr.contains("File exists") {
return Err(Error::Network(format!(
"Failed to add default route in jail {}: {}",
jid, stderr
)));
}
}
}
Ok(())
}
pub fn destroy(&self) -> Result<()> {
let output = Command::new("ifconfig")
.args([&self.host_side, "destroy"])
.output()
.map_err(|e| Error::Network(format!("Failed to destroy epair: {}", e)))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
if !stderr.contains("does not exist") {
return Err(Error::Network(format!(
"Failed to destroy {}: {}",
self.host_side, stderr
)));
}
}
Ok(())
}
fn sanitize_name(name: &str) -> String {
let sanitized: String = name
.chars()
.filter(|c| c.is_ascii_alphanumeric() || *c == '_')
.take(10) .collect();
if sanitized.is_empty() {
"jail".to_string()
} else {
sanitized
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_sanitize_name() {
assert_eq!(EpairInterface::sanitize_name("myjail"), "myjail");
assert_eq!(EpairInterface::sanitize_name("my-jail"), "myjail");
assert_eq!(
EpairInterface::sanitize_name("verylongjailname"),
"verylongja"
);
assert_eq!(EpairInterface::sanitize_name(""), "jail");
}
}