sergio/takana

1//! netup — configuración de red mínima Rust-nativa para el userland de takana (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 takana-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        // La puerta puede NO estar dentro del prefijo (Hetzner Cloud da /32 + gw 172.31.1.1). En ese
53        // caso el default falla con ENETUNREACH salvo que antes exista una ruta on-link a la puerta.
54        // Se intenta siempre: si ya era alcanzable, es una ruta más específica y no molesta. No es
55        // fatal —un EEXIST no debe tumbar la red— pero el default SÍ lo es.
56        if let Err(e) = nl.add_onlink_host_route(ifindex, gw) {
57            eprintln!("netup: aviso, no pude crear la ruta on-link a {}: {e}", fmt_ip(gw));
58        }
59        nl.add_default_route(ifindex, gw)?;
60    }
61    if !lease.dns.is_empty() {
62        write_resolv_conf(&lease.dns)?;
63    }
64    println!("netup: red configurada en {iface}");
65    Ok(())
66}
67
68/// Primera interfaz de /sys/class/net que no sea loopback (type 772 = ARPHRD_LOOPBACK).
69fn detect_iface() -> Option<String> {
70    let mut names: Vec<String> = std::fs::read_dir("/sys/class/net")
71        .ok()?
72        .filter_map(|e| e.ok())
73        .map(|e| e.file_name().to_string_lossy().into_owned())
74        .filter(|n| n != "lo")
75        .filter(|n| read_sysfs_int(n, "type").map(|t| t != 772).unwrap_or(true))
76        .collect();
77    names.sort(); // determinismo (eth0 < eth1)
78    names.into_iter().next()
79}
80
81fn read_sysfs_int(iface: &str, attr: &str) -> Result<i64, Box<dyn std::error::Error>> {
82    let s = std::fs::read_to_string(format!("/sys/class/net/{iface}/{attr}"))?;
83    Ok(s.trim().parse()?)
84}
85
86fn read_mac(iface: &str) -> Result<[u8; 6], Box<dyn std::error::Error>> {
87    let s = std::fs::read_to_string(format!("/sys/class/net/{iface}/address"))?;
88    let bytes: Vec<u8> = s
89        .trim()
90        .split(':')
91        .filter_map(|h| u8::from_str_radix(h, 16).ok())
92        .collect();
93    if bytes.len() != 6 {
94        return Err(format!("MAC inesperada para {iface}: {}", s.trim()).into());
95    }
96    Ok([bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5]])
97}
98
99/// Espera hasta `timeout` a que /sys/class/net/<if>/carrier sea 1 (link físico/virtio listo).
100fn wait_carrier(iface: &str, timeout: std::time::Duration) {
101    let start = std::time::Instant::now();
102    while start.elapsed() < timeout {
103        if let Ok(c) = std::fs::read_to_string(format!("/sys/class/net/{iface}/carrier")) {
104            if c.trim() == "1" {
105                return;
106            }
107        }
108        std::thread::sleep(std::time::Duration::from_millis(100));
109    }
110}
111
112fn write_resolv_conf(dns: &[[u8; 4]]) -> std::io::Result<()> {
113    let body: String = dns.iter().map(|d| format!("nameserver {}\n", fmt_ip(*d))).collect();
114    std::fs::write("/etc/resolv.conf", body)
115}
116
117fn fmt_ip(ip: [u8; 4]) -> String {
118    format!("{}.{}.{}.{}", ip[0], ip[1], ip[2], ip[3])
119}
120
121fn fmt_mac(m: [u8; 6]) -> String {
122    format!("{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}", m[0], m[1], m[2], m[3], m[4], m[5])
123}