use crate::error::{Error, Result};
use std::process::Command;
#[derive(Debug, Clone)]
pub struct Bridge {
name: String,
}
impl Bridge {
pub fn create(name: &str) -> Result<Self> {
if Self::exists(name)? {
return Err(Error::BridgeAlreadyExists(name.to_string()));
}
Self::load_modules()?;
let output = Command::new("ifconfig")
.args(["bridge", "create", "name", name])
.output()
.map_err(|e| Error::Network(format!("Failed to create bridge: {}", e)))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err(Error::Network(format!(
"Failed to create bridge {}: {}",
name, stderr
)));
}
let output = Command::new("ifconfig")
.args([name, "up"])
.output()
.map_err(|e| Error::Network(format!("Failed to bring up bridge: {}", e)))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err(Error::Network(format!(
"Failed to bring up bridge {}: {}",
name, stderr
)));
}
Ok(Self {
name: name.to_string(),
})
}
pub fn open(name: &str) -> Result<Self> {
if !Self::exists(name)? {
return Err(Error::InterfaceNotFound(name.to_string()));
}
Ok(Self {
name: name.to_string(),
})
}
pub fn create_or_open(name: &str) -> Result<Self> {
if Self::exists(name)? {
Self::open(name)
} else {
Self::create(name)
}
}
#[allow(dead_code)]
pub fn name(&self) -> &str {
&self.name
}
pub fn exists(name: &str) -> Result<bool> {
let output = Command::new("ifconfig")
.arg(name)
.output()
.map_err(|e| Error::Network(format!("Failed to check interface: {}", e)))?;
Ok(output.status.success())
}
pub fn destroy(&self) -> Result<()> {
let output = Command::new("ifconfig")
.args([&self.name, "destroy"])
.output()
.map_err(|e| Error::Network(format!("Failed to destroy bridge: {}", e)))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err(Error::Network(format!(
"Failed to destroy bridge {}: {}",
self.name, stderr
)));
}
Ok(())
}
#[allow(dead_code)]
pub fn add_member(&self, interface: &str) -> Result<()> {
let output = Command::new("ifconfig")
.args([&self.name, "addm", interface])
.output()
.map_err(|e| Error::Network(format!("Failed to add member: {}", e)))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err(Error::Network(format!(
"Failed to add {} to bridge {}: {}",
interface, self.name, stderr
)));
}
Ok(())
}
#[allow(dead_code)]
pub fn remove_member(&self, interface: &str) -> Result<()> {
let output = Command::new("ifconfig")
.args([&self.name, "deletem", interface])
.output()
.map_err(|e| Error::Network(format!("Failed to remove member: {}", e)))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err(Error::Network(format!(
"Failed to remove {} from bridge {}: {}",
interface, self.name, stderr
)));
}
Ok(())
}
pub fn set_address(&self, addr: &str) -> Result<()> {
let output = Command::new("ifconfig")
.args([&self.name, addr])
.output()
.map_err(|e| Error::Network(format!("Failed to set address: {}", e)))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err(Error::Network(format!(
"Failed to set address on {}: {}",
self.name, stderr
)));
}
Ok(())
}
pub fn members(&self) -> Result<Vec<String>> {
let output = Command::new("ifconfig")
.arg(&self.name)
.output()
.map_err(|e| Error::Network(format!("Failed to get bridge info: {}", e)))?;
if !output.status.success() {
return Ok(Vec::new());
}
let stdout = String::from_utf8_lossy(&output.stdout);
let mut members = Vec::new();
for line in stdout.lines() {
let line = line.trim();
if line.starts_with("member:")
&& let Some(iface) = line.split_whitespace().nth(1) {
members.push(iface.to_string());
}
}
Ok(members)
}
fn load_modules() -> Result<()> {
let modules = ["if_bridge", "bridgestp", "if_epair"];
for module in modules {
let output = Command::new("kldload").arg(module).output().map_err(|e| {
Error::Network(format!("Failed to load module {}: {}", module, e))
})?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
if !stderr.contains("already loaded") && !stderr.contains("module already loaded") {
if stderr.contains("No such file") {
continue;
}
}
}
}
Ok(())
}
}
pub fn destroy_bridge(name: &str, force: bool) -> Result<()> {
if !Bridge::exists(name)? {
return Err(Error::InterfaceNotFound(name.to_string()));
}
let bridge = Bridge::open(name)?;
let members = bridge.members()?;
if !members.is_empty() && !force {
return Err(Error::Network(format!(
"Bridge '{}' has {} member(s) attached: {}. Use --force to destroy anyway.",
name,
members.len(),
members.join(", ")
)));
}
bridge.destroy()
}
pub fn list_bridges() -> Result<Vec<String>> {
let output = Command::new("ifconfig")
.args(["-l", "-g", "bridge"])
.output()
.map_err(|e| Error::Network(format!("Failed to list bridges: {}", e)))?;
if !output.status.success() {
return Ok(Vec::new());
}
let stdout = String::from_utf8_lossy(&output.stdout);
Ok(stdout.split_whitespace().map(String::from).collect())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_bridge_exists_check() {
assert!(Bridge::exists("lo0").unwrap());
assert!(!Bridge::exists("nonexistent12345").unwrap());
}
}