Luigit
repositories / dotfiles

dotfiles

bugabingas dorkfiles

owned by admin

quickshell/nuguland/features/connectivity/Network.qml

Raw
import QtQuick
import Quickshell.Io
import "network.js" as Network

// Service / native boundary for iwd WiFi management, plus the wired link state
// the bar's offline needs (read-only: `ip -j -d link show`, sysfs uevent).
//
// iwd exposes a full D-Bus API (net.connman.iwd). We talk to it via
// `busctl --json=short`, which emits structured JSON — so there is NO text/ANSI
// parsing. Native objects (Process) stay here; all JSON shaping lives in
// network.js. Two reads drive the model:
//   ObjectManager.GetManagedObjects -> devices / stations / networks / known
//   Station.GetOrderedNetworks      -> [path, signal] strongest-first
//
// Writes are D-Bus method calls (Scan / Connect / Forget / Disconnect) and a
// set-property (Powered) — except connecting to a NEW secured network, which
// needs iwd to call back to an agent for the passphrase; for that one case we
// use `iwctl --passphrase` (a registered agent), as a DISCRETE ARGV array.
//
// SECURITY: every external call uses a discrete argv array — never sh -c with
// interpolation, because SSIDs may contain spaces / quotes / shell metachars.
// The passphrase is a transient argument to the connect call only; it NEVER
// enters stateJson / lastAction / error / any log line.
Item {
    id: root

    // --- reactive state, fed by the read Processes ---
    property bool autoRefresh: true
    property string deviceName: ""
    property string devicePath: ""
    property bool wifiEnabled: true
    property bool scanning: false
    property bool actionPending: false
    property string lastError: ""
    property string actionError: ""
    // Parsed GetManagedObjects payload (device/station/networks/knownBySsid).
    property var managed: ({})
    property var mergedModel: []
    property var lastAction: ({})
    property int scanRetriesLeft: 0
    // StationDiagnostic.GetDiagnostics detail for the CONNECTED BSS only
    // (bssid/band/channel/rssi/rates/mode), fetched lazily on expand. {} = none.
    property var connectionDetail: ({})
    // Whether iwd answered with a station device, and that station's state.
    // `loaded` stays false until the first reply, so startup never flags offline.
    property bool loaded: false
    property bool deviceAvailable: false
    property string stationState: ""
    // Wired Ethernet: "connected" while a port has carrier, "unplugged" while
    // ports exist without one, "" without a port. `linksLoaded` stays false
    // until the first read, so startup never flags offline.
    property string wiredState: ""
    property bool linksLoaded: false
    property var wiredPortList: []
    // A wireless network joined or being joined.
    readonly property bool wifiJoined: deviceAvailable && wifiEnabled && ["connected", "connecting", "roaming"].indexOf(stationState) >= 0
    // The bar's attention: no working link of any kind, neither a joined
    // wireless network nor a wired one. Every iwd signal (iwdWatch) and every
    // link change (linkWatch) re-reads it.
    readonly property bool offline: loaded && linksLoaded && !wifiJoined && wiredState !== "connected"
    // The panel binds these with the state above; stateObject() reports the
    // same values over IPC. networks: rows from buildModel(), strongest first.
    readonly property var networks: mergedModel
    readonly property string error: actionError || lastError

    // D-Bus constants.
    readonly property string svc: "net.connman.iwd"
    readonly property string ifaceStation: "net.connman.iwd.Station"
    readonly property string ifaceDevice: "net.connman.iwd.Device"
    readonly property string ifaceNetwork: "net.connman.iwd.Network"
    readonly property string ifaceKnown: "net.connman.iwd.KnownNetwork"
    readonly property string ifaceDiag: "net.connman.iwd.StationDiagnostic"

    function busctlCall(objectPath, iface, method) {
        return ["busctl", "--json=short", "call", svc, objectPath, iface, method];
    }

    function activeRow() {
        for (let i = 0; i < mergedModel.length; i++)
            if (mergedModel[i].connected) {
                return mergedModel[i];
            }
        return null;
    }

    function rowForId(id) {
        const name = String(id);
        for (let i = 0; i < mergedModel.length; i++)
            if (mergedModel[i].id === name || mergedModel[i].ssid === name) {
                return mergedModel[i];
            }
        return null;
    }

    function role() {
        if (actionError.length > 0 || lastError.length > 0)
            return "error";

        if (!wifiEnabled)
            return "ui.minor";

        const active = activeRow();
        if (active && active.state === "connecting")
            return "warning";

        return active ? "ui.accent" : "ui.minor";
    }

    // Build the view model from parsed managed objects + ordered list. Decorates
    // the pure network.js rows with label/percent/glyph/role/state view fields.
    function buildModel(ordered) {
        const rows = Network.networkRows(managed, ordered);
        const station = managed.station || {};
        const connecting = station.state === "connecting";
        const out = [];
        for (let i = 0; i < rows.length; i++) {
            const n = rows[i];
            const isConnecting = connecting && station.connectedNetwork === n.path;
            out.push({
                "id": n.id,
                "ssid": n.ssid,
                "security": n.security,
                "securityLabel": Network.securityLabel(n.security),
                "signalLabel": Network.signalLabel(n.signal),
                "signal": n.signal,
                "signalDbm": n.signalDbm,
                "signalPercent": n.signal * 25,
                "signalRole": Network.signalRole(n.signal),
                "signalGlyph": Network.signalGlyph(n.signal),
                "known": n.known,
                "connected": n.connected,
                "needsPassphrase": n.needsPassphrase,
                "path": n.path,
                "state": n.connected ? "connected" : (isConnecting ? "connecting" : "available")
            });
        }
        mergedModel = out;
        // Drop stale per-BSS detail if nothing is connected anymore.
        if (!activeRow())
            connectionDetail = ({});
    }

    function stateObject() {
        const active = activeRow();
        const compactSignal = wifiEnabled && active ? active.signal * 25 : 0;
        return {
            "scanning": scanning,
            "pending": actionPending,
            "error": error,
            "device": deviceName,
            "deviceAvailable": deviceAvailable,
            "loaded": loaded,
            "offline": offline,
            "wired": wiredState,
            "wifi": {
                "enabled": wifiEnabled
            },
            "active": active,
            "connectionDetail": connectionDetail,
            "networks": networks,
            "knownNetworks": networks,
            "compact": {
                "label": "network",
                "role": role(),
                "signal": compactSignal
            },
            "lastAction": lastAction
        };
    }

    function stateJson() {
        return JSON.stringify(stateObject());
    }

    // --- read cadence ------------------------------------------------------

    // refresh(): one call returns every iwd object + properties; its handler
    // then reads the ordered list (which needs the discovered device path).
    function refresh() {
        gmoProc.exec(busctlCall("/", "org.freedesktop.DBus.ObjectManager", "GetManagedObjects"));
    }

    // readLinks(): the physical Ethernet-type links, then their sysfs DEVTYPE,
    // which tells a wireless device from a cable port.
    function readLinks() {
        linkProc.exec(["ip", "-j", "-d", "link", "show"]);
    }

    function settleLinks(typed) {
        wiredState = Network.wiredState(wiredPortList, typed);
        linksLoaded = true;
    }

    // --- actions -----------------------------------------------------------

    function actionFailure(exitCode) {
        return Number(exitCode) === 0 ? "" : "action-failed";
    }

    function executeAction(command) {
        actionError = "";
        actionPending = true;
        actionProc.exec(command);
    }

    function unavailableAction() {
        actionPending = false;
        actionError = "action-unavailable";
    }

    function scan() {
        if (!devicePath) {
            refresh();
            return stateJson();
        }
        scanning = true;
        lastError = "";
        actionError = "";
        scanRetriesLeft = 2;
        scanProc.exec(busctlCall(devicePath, ifaceStation, "Scan"));
        scanTimer.start();
        return stateJson();
    }

    // connect(ssid, passphrase) — in-process secured/open/known connect. NOT an
    // IPC handler. open/known go over D-Bus Network.Connect (no agent needed).
    // A NEW secured network needs the passphrase handed to iwd via an agent, so
    // it uses `iwctl --passphrase`. The passphrase is a transient argv only.
    function connect(ssid, passphrase) {
        const name = String(ssid);
        const pp = (passphrase === undefined || passphrase === null) ? "" : String(passphrase);
        const row = rowForId(name);
        lastError = "";
        actionError = "";
        lastAction = {
            "kind": "connect",
            "ssid": name
        };
        if (pp.length > 0) {
            // New secured network: iwctl registers an agent and supplies the key.
            if (deviceName)
                executeAction(["iwctl", "--passphrase", pp, "station", deviceName, "connect", name]);
            else
                unavailableAction();
        } else if (row && row.path) {
            executeAction(busctlCall(row.path, ifaceNetwork, "Connect"));
        } else {
            unavailableAction();
        }
        return stateJson();
    }

    // select(id) — IPC entry: connect a known/open network by id (= ssid).
    function select(id) {
        return connect(String(id), "");
    }

    function forget(id) {
        const name = String(id);
        lastAction = {
            "kind": "forget",
            "id": name
        };
        const knownPath = (managed.knownBySsid || {})[name];
        if (knownPath)
            executeAction(busctlCall(knownPath, ifaceKnown, "Forget"));
        else
            unavailableAction();

        return stateJson();
    }

    function toggleWifi(enabled) {
        const on = !!enabled;
        lastAction = {
            "kind": "toggle-wifi",
            "enabled": on
        };
        if (devicePath) {
            wifiEnabled = on;
            executeAction(["busctl", "set-property", svc, devicePath, ifaceDevice, "Powered", "b", on ? "true" : "false"]);
        } else {
            unavailableAction();
        }
        return stateJson();
    }

    function disconnect() {
        lastAction = {
            "kind": "disconnect"
        };
        if (devicePath)
            executeAction(busctlCall(devicePath, ifaceStation, "Disconnect"));
        else
            unavailableAction();

        return stateJson();
    }

    // diagnostics() — lazy fetch of the connected BSS detail. The view calls
    // this when the connected row is expanded; diagProc.onStreamFinished folds
    // the result into connectionDetail, which the open drawer binds.
    function diagnostics() {
        if (devicePath && activeRow())
            diagProc.exec(busctlCall(devicePath, ifaceDiag, "GetDiagnostics"));

        return stateJson();
    }

    function checkConnectivity() {
        lastAction = {
            "kind": "check-connectivity"
        };
        refresh();
        readLinks();
        return stateJson();
    }

    Component.onCompleted: if (autoRefresh) {
        refresh();
        readLinks();
    }

    // --- read Processes ----------------------------------------------------

    Process {
        id: gmoProc

        running: false

        stdout: StdioCollector {
            waitForEnd: true
            onStreamFinished: {
                root.managed = Network.parseManaged(this.text);
                const m = root.managed;
                root.loaded = true;
                root.stationState = m.station ? m.station.state : "";
                if (!m.device || !m.devicePath) {
                    root.lastError = "no-wifi-device";
                    root.deviceAvailable = false;
                    root.deviceName = "";
                    root.devicePath = "";
                    root.buildModel([]);
                    return;
                }
                root.deviceAvailable = true;
                root.deviceName = m.device.name;
                root.devicePath = m.devicePath;
                root.wifiEnabled = m.device.powered;
                root.lastError = "";
                if (m.device.powered) {
                    gonProc.exec(root.busctlCall(m.devicePath, root.ifaceStation, "GetOrderedNetworks"));
                } else {
                    root.buildModel([]);
                }
            }
        }
    }

    Process {
        id: gonProc

        running: false

        stdout: StdioCollector {
            waitForEnd: true
            onStreamFinished: {
                root.buildModel(Network.parseOrdered(this.text));
            }
        }
    }

    // Lazy StationDiagnostic read (connected BSS only). On reply, shape via
    // network.js#connectionDetail; the open drawer binds it.
    Process {
        id: diagProc

        running: false

        stdout: StdioCollector {
            waitForEnd: true
            onStreamFinished: {
                root.connectionDetail = Network.connectionDetail(this.text) || ({});
            }
        }
    }

    // --- action Processes --------------------------------------------------

    Process {
        id: scanProc

        running: false

        stderr: StdioCollector {
            id: scanErr

            waitForEnd: true
        }

        // "Operation already in progress" = scan already running, NOT a hard
        // error: keep scanning, let the retry timer re-read the list.
        onExited: exitCode => {
            const err = String(scanErr.text || "");
            if (exitCode !== 0 && err.indexOf("already in progress") < 0)
                root.lastError = "scan-failed";
        }
    }

    // Shared action runner. Re-reads state when done so the model reflects the
    // effect. stderr is intentionally NOT surfaced verbatim (belt-and-suspenders:
    // a connect arg must never leak via an error string).
    Process {
        id: actionProc

        running: false

        onExited: exitCode => {
            actionProc.command = [];
            root.actionPending = false;
            root.actionError = root.actionFailure(exitCode);
            root.refresh();
        }
    }

    // Event-driven liveness for the bar's offline state, without polling: one
    // idle `gdbus monitor` prints a line per iwd signal (a joined or lost
    // network, a powered device, iwd starting or stopping) and each burst of
    // lines re-reads the managed objects once. glib2 ships gdbus with qt6-base.
    Process {
        id: iwdWatch

        running: root.autoRefresh
        command: ["gdbus", "monitor", "--system", "--dest", root.svc]

        stdout: SplitParser {
            onRead: watchSettle.restart()
        }
    }

    Timer {
        id: watchSettle

        interval: 500
        onTriggered: root.refresh()
    }

    Process {
        id: linkProc

        running: false

        stdout: StdioCollector {
            waitForEnd: true
            onStreamFinished: {
                root.wiredPortList = Network.wiredPorts(this.text);
                if (root.wiredPortList.length === 0)
                    root.settleLinks({});
                else
                    typeProc.exec(["grep", "-sH", "^DEVTYPE="].concat(root.wiredPortList.map(port => "/sys/class/net/" + port.name + "/uevent")));
            }
        }
    }

    Process {
        id: typeProc

        running: false

        stdout: StdioCollector {
            waitForEnd: true
            onStreamFinished: root.settleLinks(Network.typedLinks(this.text))
        }
    }

    // Event-driven wired state, without polling: one idle `ip monitor link`
    // prints a record per link change (carrier, up, down, added, removed) and
    // each burst re-reads the links once.
    Process {
        id: linkWatch

        running: root.autoRefresh
        command: ["ip", "monitor", "link"]

        stdout: SplitParser {
            onRead: linkSettle.restart()
        }
    }

    Timer {
        id: linkSettle

        interval: 500
        onTriggered: root.readLinks()
    }

    // Delayed/polled re-read after an async scan (results lag ~1-4 s).
    Timer {
        id: scanTimer

        interval: 2000
        repeat: true
        running: false
        onTriggered: {
            root.refresh();
            root.scanRetriesLeft -= 1;
            if (root.scanRetriesLeft <= 0) {
                root.scanning = false;
                running = false;
            }
        }
    }
}