archy/core/openwrt/src/tollgate/install.rs

use anyhow::Result;
use tracing::info;

use crate::Router;

/// The OpenWrt package name for the TollGate reference implementation.
const TOLLGATE_PACKAGE: &str = "tollgate-module-basic-go";

/// Direct-download fallback URLs by opkg architecture string.
/// Used when the package is not in any configured feed.
/// Source: https://github.com/OpenTollGate/tollgate-module-basic-go/releases/tag/v0.2.0
fn ipk_url(arch: &str) -> Option<&'static str> {
    match arch {
        "mips_24kc"          => Some("https://github.com/OpenTollGate/tollgate-module-basic-go/releases/download/v0.2.0/mips_24kc.ipk"),
        "mipsel_24kc"        => Some("https://github.com/OpenTollGate/tollgate-module-basic-go/releases/download/v0.2.0/mipsel_24kc.ipk"),
        "aarch64_cortex-a53" => Some("https://github.com/OpenTollGate/tollgate-module-basic-go/releases/download/v0.2.0/aarch64_cortex-a53.ipk"),
        "aarch64_cortex-a72" => Some("https://github.com/OpenTollGate/tollgate-module-basic-go/releases/download/v0.2.0/aarch64_cortex-a72.ipk"),
        "arm_cortex-a7"      => Some("https://github.com/OpenTollGate/tollgate-module-basic-go/releases/download/v0.2.0/arm_cortex-a7.ipk"),
        _ => None,
    }
}

/// Install tollgate-module-basic-go via opkg (OpenWrt ≤24.x).
///
/// Tries opkg first (works if a custom feed is configured). Falls back to
/// downloading the .ipk directly from GitHub releases if opkg can't find it.
/// Caller is responsible for running `opkg_update` first.
pub fn install_tollgate(router: &Router) -> Result<()> {
    info!("[{}] Installing {}", router.host, TOLLGATE_PACKAGE);

    // Fast path: standard opkg install (or already installed).
    if router.opkg_install(TOLLGATE_PACKAGE).is_ok() {
        return Ok(());
    }

    // Package not in any feed — download the .ipk directly.
    let arch = router
        .run_ok("/usr/bin/opkg print-architecture | grep -v all | grep -v noarch | tail -1 | awk '{print $2}'")?;
    let arch = arch.trim();

    let url = ipk_url(arch).ok_or_else(|| {
        anyhow::anyhow!(
            "No pre-built TollGate package for architecture '{}'. \
             Add a custom opkg feed or build from source.",
            arch
        )
    })?;

    info!("[{}] Downloading TollGate for {} from GitHub releases", router.host, arch);
    router.run_ok(&format!("wget --no-check-certificate -O /tmp/tollgate.ipk '{}' 2>&1", url))?;
    install_ipk(router, "/tmp/tollgate.ipk")
}

/// Install tollgate-module-basic-go on OpenWrt 25.x where opkg is not available.
///
/// Downloads the .ipk from GitHub releases and extracts it manually using
/// BusyBox `ar` and `tar` (both present on all OpenWrt images).
pub fn install_tollgate_apk_native(router: &Router) -> Result<()> {
    info!("[{}] Installing {} (apk-native mode)", router.host, TOLLGATE_PACKAGE);

    // Already installed?
    let (_, code) = router.run(&format!(
        "apk list --installed 2>/dev/null | grep -q '^{}' || \
         test -f /usr/bin/{} 2>/dev/null",
        TOLLGATE_PACKAGE, TOLLGATE_PACKAGE
    ))?;
    if code == 0 {
        info!("[{}] {} already installed", router.host, TOLLGATE_PACKAGE);
        return Ok(());
    }

    // Get architecture from /etc/openwrt_release.
    // The variable is DISTRIB_ARCH on most builds; OPENWRT_ARCH on some.
    // Fall back to apk --print-arch, then uname -m.
    let arch_raw = router.run_ok(
        ". /etc/openwrt_release 2>/dev/null \
         && a=\"${DISTRIB_ARCH:-${OPENWRT_ARCH:-}}\" \
         && [ -n \"$a\" ] && echo \"$a\" \
         || /usr/bin/apk --print-arch 2>/dev/null \
         || uname -m"
    )?;
    // Normalise: uname -m returns bare "mipsel"/"mips"; map to 24kc variant
    // which is the standard for home-router MIPS builds.
    let arch = match arch_raw.trim() {
        "mipsel" => "mipsel_24kc",
        "mips"   => "mips_24kc",
        other    => other,
    };
    info!("[{}] detected arch: {:?}", router.host, arch);
    if arch.is_empty() {
        anyhow::bail!("Could not determine router architecture");
    }

    let url = ipk_url(arch).ok_or_else(|| {
        anyhow::anyhow!(
            "No pre-built TollGate package for architecture '{}'. \
             Add a custom feed or build from source.",
            arch
        )
    })?;

    info!("[{}] Downloading TollGate for {} from GitHub releases", router.host, arch);
    // --no-check-certificate: fresh OpenWrt 25.x images ship without a CA bundle;
    // GitHub serves releases over HTTPS so wget would otherwise reject the cert.
    let (dl_out, dl_code) = router.run(&format!(
        "wget --no-check-certificate -O /tmp/tollgate.ipk '{}' 2>&1", url
    ))?;
    if dl_code != 0 {
        anyhow::bail!("TollGate download failed: {}", dl_out.trim());
    }
    // Sanity-check: a real .ipk is at least 50 KB.
    // If wget captured an HTML error page it will be tiny.
    let (size_out, _) = router.run("wc -c < /tmp/tollgate.ipk 2>/dev/null")?;
    let size: u64 = size_out.trim().parse().unwrap_or(0);
    if size < 50_000 {
        anyhow::bail!(
            "Downloaded TollGate package is only {}B — wget likely captured an error page. \
             Check router internet access and that the release URL is reachable.",
            size
        );
    }
    install_ipk(router, "/tmp/tollgate.ipk")
}

/// Extract and install an .ipk file without opkg.
///
/// An .ipk is an `ar` archive containing `data.tar.gz` (package files) and
/// `control.tar.gz` (metadata + postinst script).
fn install_ipk(router: &Router, ipk_path: &str) -> Result<()> {
    // Check for disk space first (rough: need at least ~1 MB free on /overlay).
    // TollGate is a Go binary — typically 5–8 MB on flash.
    let (df_out, _) = router.run("df /overlay 2>/dev/null | awk 'NR==2{print $4}'")?;
    let free_kb: u64 = df_out.trim().parse().unwrap_or(u64::MAX);
    if free_kb < 5120 {
        anyhow::bail!(
            "Not enough flash space for TollGate: only {}kB free on /overlay \
             (need ≥5MB). Free up space first or use a router with more storage.",
            free_kb
        );
    }

    router.run_ok("rm -rf /tmp/_tg_install && mkdir -p /tmp/_tg_install")?;

    // OpenWrt 25.x BusyBox does not include `ar` — install binutils via
    // whichever package manager is available before trying to unpack the ipk.
    let (_, ar_found) = router.run("command -v ar >/dev/null 2>&1")?;
    if ar_found != 0 {
        info!("[{}] ar not found, installing binutils", router.host);
        let (pkg_out, pkg_code) = router.run(
            "apk add binutils 2>&1 || opkg install binutils 2>&1"
        )?;
        if pkg_code != 0 {
            anyhow::bail!(
                "TollGate installation failed: ar not available and binutils install failed: {}",
                pkg_out.trim()
            );
        }
    }

    // Try standard opkg ar format first (ar archive → data.tar.gz inside).
    let (ar_out, ar_code) = router.run(&format!(
        "cd /tmp/_tg_install && ar x {} 2>&1", ipk_path
    ))?;

    if ar_code == 0 {
        // ar succeeded: unpack data.tar.gz from the inner archive.
        let (tar_out, tar_code) = router.run(
            "tar -xzf /tmp/_tg_install/data.tar.gz -C / 2>&1"
        )?;
        if tar_code != 0 {
            anyhow::bail!("TollGate installation failed: data extract failed: {}", tar_out.trim());
        }
        // Run postinst if present (optional — failures are non-fatal).
        router.run_ok(
            "if tar -xzf /tmp/_tg_install/control.tar.gz -C /tmp/_tg_install 2>/dev/null; then \
                 chmod +x /tmp/_tg_install/postinst 2>/dev/null; \
                 /tmp/_tg_install/postinst configure 2>/dev/null || true; \
             fi"
        )?;
    } else {
        // Fallback: some packages ship .ipk as a plain gzip tarball.
        info!("[{}] ar failed ({}), trying tar -xzf", router.host, ar_out.trim());

        // List contents first — validates format without writing anything.
        let (list_out, list_code) = router.run(&format!(
            "tar -tzf {} 2>&1 | head -30", ipk_path
        ))?;
        if list_code != 0 {
            anyhow::bail!(
                "TollGate installation failed: file is not an ar archive or gzip tar.\n\
                 ar: {}\ntar -t: {}",
                ar_out.trim(), list_out.trim()
            );
        }
        info!("[{}] ipk contents:\n{}", router.host, list_out.trim());

        // Check free space on the root overlay before writing.
        let (ov_df, _) = router.run("df / 2>/dev/null | awk 'NR==2{print $4}'")?;
        let overlay_free_kb: u64 = ov_df.trim().parse().unwrap_or(0);
        if overlay_free_kb < 5120 {
            anyhow::bail!(
                "Not enough space to install TollGate: only {}kB free on /. \
                 Need at least 5MB. Free up flash space on the router first \
                 (e.g. remove unused packages with `apk del …`).",
                overlay_free_kb
            );
        }

        let (tar_out, tar_code) = router.run(&format!(
            "tar -xzf {} -C / 2>&1", ipk_path
        ))?;
        if tar_code != 0 {
            anyhow::bail!(
                "TollGate installation failed: tar extract failed: {}",
                tar_out.trim()
            );
        }
    }

    router.run_ok(&format!("rm -rf /tmp/_tg_install {}", ipk_path))?;
    Ok(())
}