rewrite: initialize local interfaces

2 files changed, 41 insertions, 163 deletions

diff --git a/src/error.rs b/src/error.rs
index 269c957..26e2444 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -18,8 +18,6 @@ pub enum Error {
     IpnetPrefixLen(#[from] ipnet::PrefixLenError),
     #[error("net: parse ip address: {0}")]
     NetAddrParseError(#[from] net::AddrParseError),
-    #[error("notify: {0}")]
-    Notify(#[from] notify::Error),
     #[error("rtnetlink: {0}")]
     RtNetlink(#[from] rtnetlink::Error),
     #[error("serde_json: {0}")]
diff --git a/src/main.rs b/src/main.rs
index 3d4123c..4e681de 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,115 +3,54 @@ use rsdsl_netlinkd::{Error, Result};
 
 use std::fs::{self, File};
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
-use std::path::Path;
 use std::thread;
 use std::time::Duration;
 
 use ipnet::Ipv6Net;
-use notify::event::{CreateKind, ModifyKind};
-use notify::{Event, EventKind, RecursiveMode, Watcher};
 use rsdsl_ip_config::DsConfig;
 use rsdsl_pd_config::PdConfig;
+use signal_hook::{consts::SIGUSR1, iterator::Signals};
 
 const LINK_LOCAL: Ipv6Addr = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 1);
 
 fn main() -> Result<()> {
-    println!("wait for eth0");
+    println!("[info] wait for eth0");
     link::wait_exists("eth0".into())?;
-    println!("detect eth0");
+    println!("[info] detect eth0");
 
     link::up("eth0".into())?;
 
-    match configure_eth0() {
-        Ok(_) => println!("configure eth0 statically (10.128.0.254/24, fe80::1/64)"),
-        Err(e) => {
-            println!("can't configure eth0: {}", e);
-            return Err(e);
-        }
-    }
+    configure_lan()?;
+    println!("[info] config eth0 10.128.0.254/24 fe80::1/64");
 
-    match setup_vlans("eth0") {
-        Ok(_) => println!("setup vlans"),
-        Err(e) => {
-            println!("can't setup vlans: {}", e);
-            return Err(e);
-        }
-    }
+    create_vlans()?;
+    configure_vlans()?;
 
     fs::write("/proc/sys/net/ipv4/ip_forward", "1")?;
-    println!("enable ipv4 routing");
+    println!("[info] enable ipv4 routing");
 
     fs::write("/proc/sys/net/ipv6/conf/all/forwarding", "1")?;
     fs::write("/proc/sys/net/ipv6/conf/default/forwarding", "1")?;
-    println!("enable ipv6 routing");
+    println!("[info] enable ipv6 routing");
 
-    println!("wait for eth1");
+    println!("[info] wait for eth1");
     link::wait_exists("eth1".into())?;
-    println!("detect eth1");
+    println!("[info] detect eth1");
 
     link::up("eth1".into())?;
 
-    match enable_modem_access() {
-        Ok(_) => println!("configure eth1 modem (192.168.1.2/24)"),
-        Err(e) => {
-            println!("can't configure eth1 modem: {}", e);
-            return Err(e);
-        }
-    }
-
-    let ip_config = Path::new(rsdsl_ip_config::LOCATION);
-    while !ip_config.exists() {
-        println!("wait for pppoe");
-        thread::sleep(Duration::from_secs(8));
-    }
-
-    configure_wan();
-
-    let mut watcher = notify::recommended_watcher(|res: notify::Result<Event>| match res {
-        Ok(event) => match event.kind {
-            EventKind::Create(kind) if kind == CreateKind::File => {
-                configure_wan();
-            }
-            EventKind::Modify(kind) if matches!(kind, ModifyKind::Data(_)) => {
-                configure_wan();
-            }
-            _ => {}
-        },
-        Err(e) => println!("watch error: {:?}", e),
-    })?;
+    configure_modem()?;
+    println!("[info] config eth1 192.168.1.2/24 (modem)");
 
-    watcher.watch(ip_config, RecursiveMode::NonRecursive)?;
-
-    let pd_config = Path::new(rsdsl_pd_config::LOCATION);
-
-    println!("wait for dhcp6");
-    while !pd_config.exists() {
-        thread::sleep(Duration::from_secs(8));
+    let mut signals = Signals::new([SIGUSR1])?;
+    for _ in signals.forever() {
+        configure_wan_logged();
     }
 
-    configure_ipv6();
-
-    let mut watcher = notify::recommended_watcher(|res: notify::Result<Event>| match res {
-        Ok(event) => match event.kind {
-            EventKind::Create(kind) if kind == CreateKind::File => {
-                configure_ipv6();
-            }
-            EventKind::Modify(kind) if matches!(kind, ModifyKind::Data(_)) => {
-                configure_ipv6();
-            }
-            _ => {}
-        },
-        Err(e) => println!("watch error: {:?}", e),
-    })?;
-
-    watcher.watch(pd_config, RecursiveMode::NonRecursive)?;
-
-    loop {
-        thread::sleep(Duration::MAX)
-    }
+    Ok(()) // unreachable
 }
 
-fn configure_eth0() -> Result<()> {
+fn configure_lan() -> Result<()> {
     addr::flush("eth0".into())?;
     addr::add_link_local("eth0".into(), LINK_LOCAL.into(), 64)?;
     addr::add("eth0".into(), "10.128.0.254".parse()?, 24)?;
@@ -119,113 +58,54 @@ fn configure_eth0() -> Result<()> {
     Ok(())
 }
 
-fn setup_vlans(base: &str) -> Result<()> {
+fn create_vlans() -> Result<()> {
     let zones = ["trusted", "untrusted", "isolated", "exposed"];
 
     for (i, zone) in zones.iter().enumerate() {
         let vlan_id = 10 * (i + 1);
-        let vlan_name = format!("{}.{}", base, vlan_id);
+        let vlan_name = format!("eth0.{}", vlan_id);
         let vlan_addr = IpAddr::V4(Ipv4Addr::new(10, 128, vlan_id as u8, 254));
 
-        link::add_vlan(vlan_name.clone(), base.to_owned(), vlan_id as u16)?;
-
-        addr::add_link_local(vlan_name.clone(), LINK_LOCAL.into(), 64)?;
-        addr::add(vlan_name.clone(), vlan_addr, 24)?;
-
+        link::add_vlan(vlan_name.clone(), "eth0".to_string(), vlan_id as u16)?;
         link::up(vlan_name.clone())?;
 
-        println!(
-            "configure {} ({}/24, fe80::1/64) zone {}",
-            vlan_name, vlan_addr, zone
-        );
+        addr::flush(vlan_name.clone())?;
     }
 
     Ok(())
 }
 
-fn enable_modem_access() -> Result<()> {
-    addr::flush("eth1".into())?;
-    addr::add("eth1".into(), "192.168.1.2".parse()?, 24)?;
+fn configure_vlans() -> Result<()> {
+    let zones = ["trusted", "untrusted", "isolated", "exposed"];
 
-    Ok(())
-}
+    for (i, zone) in zones.iter().enumerate() {
+        let vlan_id = 10 * (i + 1);
+        let vlan_name = format!("eth0.{}", vlan_id);
+        let vlan_addr = IpAddr::V4(Ipv4Addr::new(10, 128, vlan_id as u8, 254));
 
-fn configure_wan() {
-    match configure_ppp0() {
-        Ok(_) => println!("configure ppp0 with pppoe data"),
-        Err(e) => println!("can't configure ppp0: {:?}", e),
+        addr::add_link_local(vlan_name.clone(), LINK_LOCAL.into(), 64)?;
+        addr::add(vlan_name.clone(), vlan_addr, 24)?;
     }
-}
 
-fn configure_ppp0() -> Result<()> {
-    link::set_mtu("ppp0".into(), 1492)?;
-    link::up("ppp0".into())?;
-
-    let mut file = File::open(rsdsl_ip_config::LOCATION)?;
-    let ip_config: DsConfig = serde_json::from_reader(&mut file)?;
-
-    addr::flush("ppp0".into())?;
-    route::flush("ppp0".into())?;
-
-    if let Some(v4) = ip_config.v4 {
-        addr::add("ppp0".into(), IpAddr::V4(v4.addr), 32)?;
-        route::add4(Ipv4Addr::UNSPECIFIED, 0, None, "ppp0".into())?;
-    }
+    Ok(())
+}
 
-    if let Some(v6) = ip_config.v6 {
-        addr::add("ppp0".into(), IpAddr::V6(v6.laddr), 64)?;
-        route::add6(Ipv6Addr::UNSPECIFIED, 0, None, "ppp0".into())?;
-    }
+fn configure_modem() -> Result<()> {
+    addr::flush("eth1".into())?;
+    addr::add("eth1".into(), "192.168.1.2".parse()?, 24)?;
 
     Ok(())
 }
 
-fn configure_ipv6() {
-    match configure_all_v6() {
-        Ok(_) => println!("configure ipv6"),
-        Err(e) => println!("can't configure ipv6: {:?}", e),
+fn configure_wan_logged() {
+    match configure_wan() {
+        Ok(_) => {}
+        Err(e) => println!("[warn] config wan: {}", e),
     }
 }
 
-fn configure_all_v6() -> Result<()> {
-    let mut file = File::open(rsdsl_pd_config::LOCATION)?;
-    let pdconfig: PdConfig = serde_json::from_reader(&mut file)?;
-
-    let prefix = Ipv6Net::new(pdconfig.prefix, pdconfig.len)?.trunc();
-    let mut subnets = prefix.subnets(64)?;
-
-    addr::flush6_global()?;
-    addr::add("ppp0".into(), IpAddr::V6(next_ifid1(&mut subnets)?), 64)?;
-
-    let addr = next_ifid1(&mut subnets)?;
-
-    fs::write("/proc/sys/net/ipv6/conf/eth0/accept_ra", "0")?;
-
-    addr::flush6("eth0".into())?;
-    addr::add_link_local("eth0".into(), LINK_LOCAL.into(), 64)?;
-    addr::add("eth0".into(), addr.into(), 64)?;
-
-    println!("configure eth0 ({}/64)", addr);
-
-    let zones = ["trusted", "untrusted", "isolated", "exposed"];
-    for (i, zone) in zones.iter().enumerate() {
-        let vlan_id = 10 * (i + 1);
-        let vlan_name = format!("eth0.{}", vlan_id);
-        let vlan_addr = next_ifid1(&mut subnets)?;
-
-        fs::write(
-            format!("/proc/sys/net/ipv6/conf/{}/accept_ra", vlan_name),
-            "0",
-        )?;
-
-        addr::flush6(vlan_name.clone())?;
-        addr::add(vlan_name.clone(), LINK_LOCAL.into(), 64)?;
-        addr::add(vlan_name.clone(), vlan_addr.into(), 64)?;
-
-        println!("configure {} ({}/64) zone {}", vlan_name, vlan_addr, zone);
-    }
-
-    Ok(())
+fn configure_wan() -> Result<()> {
+    todo!()
 }
 
 fn next_ifid1<T: Iterator<Item = Ipv6Net>>(subnets: &mut T) -> Result<Ipv6Addr> {