sergio/takana

1//! netup — configuración de red mínima Rust-nativa para el userland de hammer (Etapa C).
2//!
3//! Reemplaza el `ip` de busybox + la IP estática hardcodeada del driver de rebuild por un binario
4//! propio: levanta la interfaz, negocia un lease DHCPv4 y aplica IP/ruta/DNS vía netlink — todo
5//! síncrono, sin tokio, dependiendo sólo de libc (ABI estable del kernel). Como hammerd/arje, es
6//! código hammer-propio: no hay un cliente DHCP Rust "maduro" para adoptar al estilo ripgrep.
7//!
8//! Uso: `netup [interfaz]`  (sin argumento, autodetecta la primera interfaz no-loopback).
9
10mod dhcp;
11mod netlink;
12
13use std::process::ExitCode;
14
15fn main() -> ExitCode {
16    match run() {
17        Ok(()) => ExitCode::SUCCESS,
18        Err(e) => {
19            eprintln!("netup: {e}");
20            ExitCode::FAILURE
21        }
22    }
23}
24
25fn run() -> Result<(), Box<dyn std::error::Error>> {
26    let iface = match std::env::args().nth(1) {
27        Some(a) => a,
28        None => detect_iface().ok_or("no encuentro ninguna interfaz no-loopback en /sys/class/net")?,
29    };
30    let ifindex = read_sysfs_int(&iface, "ifindex")? as i32;
31    let mac = read_mac(&iface)?;
32    println!("netup: interfaz {iface} (index {ifindex}, mac {})", fmt_mac(mac));
33
34    let mut nl = netlink::Netlink::open()?;
35    nl.link_up(ifindex)?;
36    // Esperar el carrier (virtio/e1000 lo levantan en ms, pero damos margen).
37    wait_carrier(&iface, std::time::Duration::from_secs(5));
38
39    let lease = dhcp::run(&iface, mac)?;
40    println!(
41        "netup: lease {} /{} gw {} dns {} ({}s) de {}",
42        fmt_ip(lease.ip),
43        lease.prefix,
44        lease.router.map(fmt_ip).unwrap_or_else(|| "-".into()),
45        if lease.dns.is_empty() { "-".into() } else { lease.dns.iter().map(|d| fmt_ip(*d)).collect::<Vec<_>>().join(",") },
46        lease.lease_secs,
47        fmt_ip(lease.server),
48    );
49
50    nl.add_addr(ifindex, lease.ip, lease.prefix)?;
51    if let Some(gw) = lease.router {
52        nl.add_default_route(ifindex, gw)?;
53    }
54    if !lease.dns.is_empty() {
55        write_resolv_conf(&lease.dns)?;
56    }
57    println!("netup: red configurada en {iface}");
58    Ok(())
59}
60
61/// Primera interfaz de /sys/class/net que no sea loopback (type 772 = ARPHRD_LOOPBACK).
62fn detect_iface() -> Option<String> {
63    let mut names: Vec<String> = std::fs::read_dir("/sys/class/net")
64        .ok()?
65        .filter_map(|e| e.ok())
66        .map(|e| e.file_name().to_string_lossy().into_owned())
67        .filter(|n| n != "lo")
68        .filter(|n| read_sysfs_int(n, "type").map(|t| t != 772).unwrap_or(true))
69        .collect();
70    names.sort(); // determinismo (eth0 < eth1)
71    names.into_iter().next()
72}
73
74fn read_sysfs_int(iface: &str, attr: &str) -> Result<i64, Box<dyn std::error::Error>> {
75    let s = std::fs::read_to_string(format!("/sys/class/net/{iface}/{attr}"))?;
76    Ok(s.trim().parse()?)
77}
78
79fn read_mac(iface: &str) -> Result<[u8; 6], Box<dyn std::error::Error>> {
80    let s = std::fs::read_to_string(format!("/sys/class/net/{iface}/address"))?;
81    let bytes: Vec<u8> = s
82        .trim()
83        .split(':')
84        .filter_map(|h| u8::from_str_radix(h, 16).ok())
85        .collect();
86    if bytes.len() != 6 {
87        return Err(format!("MAC inesperada para {iface}: {}", s.trim()).into());
88    }
89    Ok([bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5]])
90}
91
92/// Espera hasta `timeout` a que /sys/class/net/<if>/carrier sea 1 (link físico/virtio listo).
93fn wait_carrier(iface: &str, timeout: std::time::Duration) {
94    let start = std::time::Instant::now();
95    while start.elapsed() < timeout {
96        if let Ok(c) = std::fs::read_to_string(format!("/sys/class/net/{iface}/carrier")) {
97            if c.trim() == "1" {
98                return;
99            }
100        }
101        std::thread::sleep(std::time::Duration::from_millis(100));
102    }
103}
104
105fn write_resolv_conf(dns: &[[u8; 4]]) -> std::io::Result<()> {
106    let body: String = dns.iter().map(|d| format!("nameserver {}\n", fmt_ip(*d))).collect();
107    std::fs::write("/etc/resolv.conf", body)
108}
109
110fn fmt_ip(ip: [u8; 4]) -> String {
111    format!("{}.{}.{}.{}", ip[0], ip[1], ip[2], ip[3])
112}
113
114fn fmt_mac(m: [u8; 6]) -> String {
115    format!("{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}", m[0], m[1], m[2], m[3], m[4], m[5])
116}