summaryrefslogtreecommitdiff
path: root/services/Nmcli.qml
diff options
context:
space:
mode:
Diffstat (limited to 'services/Nmcli.qml')
-rw-r--r--services/Nmcli.qml1352
1 files changed, 1352 insertions, 0 deletions
diff --git a/services/Nmcli.qml b/services/Nmcli.qml
new file mode 100644
index 0000000..36bd3e6
--- /dev/null
+++ b/services/Nmcli.qml
@@ -0,0 +1,1352 @@
+pragma Singleton
+pragma ComponentBehavior: Bound
+
+import Quickshell
+import Quickshell.Io
+import QtQuick
+
+Singleton {
+ id: root
+
+ property var deviceStatus: null
+ property var wirelessInterfaces: []
+ property var ethernetInterfaces: []
+ property bool isConnected: false
+ property string activeInterface: ""
+ property string activeConnection: ""
+ property bool wifiEnabled: true
+ readonly property bool scanning: rescanProc.running
+ readonly property list<AccessPoint> networks: []
+ readonly property AccessPoint active: networks.find(n => n.active) ?? null
+ property list<string> savedConnections: []
+ property list<string> savedConnectionSsids: []
+
+ property var wifiConnectionQueue: []
+ property int currentSsidQueryIndex: 0
+ property var pendingConnection: null
+ signal connectionFailed(string ssid)
+ property var wirelessDeviceDetails: null
+ property var ethernetDeviceDetails: null
+ property list<var> ethernetDevices: []
+ readonly property var activeEthernet: ethernetDevices.find(d => d.connected) ?? null
+
+ property list<var> activeProcesses: []
+
+ // Constants
+ readonly property string deviceTypeWifi: "wifi"
+ readonly property string deviceTypeEthernet: "ethernet"
+ readonly property string connectionTypeWireless: "802-11-wireless"
+ readonly property string nmcliCommandDevice: "device"
+ readonly property string nmcliCommandConnection: "connection"
+ readonly property string nmcliCommandWifi: "wifi"
+ readonly property string nmcliCommandRadio: "radio"
+ readonly property string deviceStatusFields: "DEVICE,TYPE,STATE,CONNECTION"
+ readonly property string connectionListFields: "NAME,TYPE"
+ readonly property string wirelessSsidField: "802-11-wireless.ssid"
+ readonly property string networkListFields: "SSID,SIGNAL,SECURITY"
+ readonly property string networkDetailFields: "ACTIVE,SIGNAL,FREQ,SSID,BSSID,SECURITY"
+ readonly property string securityKeyMgmt: "802-11-wireless-security.key-mgmt"
+ readonly property string securityPsk: "802-11-wireless-security.psk"
+ readonly property string keyMgmtWpaPsk: "wpa-psk"
+ readonly property string connectionParamType: "type"
+ readonly property string connectionParamConName: "con-name"
+ readonly property string connectionParamIfname: "ifname"
+ readonly property string connectionParamSsid: "ssid"
+ readonly property string connectionParamPassword: "password"
+ readonly property string connectionParamBssid: "802-11-wireless.bssid"
+
+ function detectPasswordRequired(error: string): bool {
+ if (!error || error.length === 0) {
+ return false;
+ }
+
+ return (error.includes("Secrets were required") || error.includes("Secrets were required, but not provided") || error.includes("No secrets provided") || error.includes("802-11-wireless-security.psk") || error.includes("password for") || (error.includes("password") && !error.includes("Connection activated") && !error.includes("successfully")) || (error.includes("Secrets") && !error.includes("Connection activated") && !error.includes("successfully")) || (error.includes("802.11") && !error.includes("Connection activated") && !error.includes("successfully"))) && !error.includes("Connection activated") && !error.includes("successfully");
+ }
+
+ function parseNetworkOutput(output: string): list<var> {
+ if (!output || output.length === 0) {
+ return [];
+ }
+
+ const PLACEHOLDER = "STRINGWHICHHOPEFULLYWONTBEUSED";
+ const rep = new RegExp("\\\\:", "g");
+ const rep2 = new RegExp(PLACEHOLDER, "g");
+
+ const allNetworks = output.trim().split("\n").filter(line => line && line.length > 0).map(n => {
+ const net = n.replace(rep, PLACEHOLDER).split(":");
+ return {
+ active: net[0] === "yes",
+ strength: parseInt(net[1] || "0", 10) || 0,
+ frequency: parseInt(net[2] || "0", 10) || 0,
+ ssid: (net[3]?.replace(rep2, ":") ?? "").trim(),
+ bssid: (net[4]?.replace(rep2, ":") ?? "").trim(),
+ security: (net[5] ?? "").trim()
+ };
+ }).filter(n => n.ssid && n.ssid.length > 0);
+
+ return allNetworks;
+ }
+
+ function deduplicateNetworks(networks: list<var>): list<var> {
+ if (!networks || networks.length === 0) {
+ return [];
+ }
+
+ const networkMap = new Map();
+ for (const network of networks) {
+ const existing = networkMap.get(network.ssid);
+ if (!existing) {
+ networkMap.set(network.ssid, network);
+ } else {
+ if (network.active && !existing.active) {
+ networkMap.set(network.ssid, network);
+ } else if (!network.active && !existing.active) {
+ if (network.strength > existing.strength) {
+ networkMap.set(network.ssid, network);
+ }
+ }
+ }
+ }
+
+ return Array.from(networkMap.values());
+ }
+
+ function isConnectionCommand(command: list<string>): bool {
+ if (!command || command.length === 0) {
+ return false;
+ }
+
+ return command.includes(root.nmcliCommandWifi) || command.includes(root.nmcliCommandConnection);
+ }
+
+ function parseDeviceStatusOutput(output: string, filterType: string): list<var> {
+ if (!output || output.length === 0) {
+ return [];
+ }
+
+ const interfaces = [];
+ const lines = output.trim().split("\n");
+
+ for (const line of lines) {
+ const parts = line.split(":");
+ if (parts.length >= 2) {
+ const deviceType = parts[1];
+ let shouldInclude = false;
+
+ if (filterType === root.deviceTypeWifi && deviceType === root.deviceTypeWifi) {
+ shouldInclude = true;
+ } else if (filterType === root.deviceTypeEthernet && deviceType === root.deviceTypeEthernet) {
+ shouldInclude = true;
+ } else if (filterType === "both" && (deviceType === root.deviceTypeWifi || deviceType === root.deviceTypeEthernet)) {
+ shouldInclude = true;
+ }
+
+ if (shouldInclude) {
+ interfaces.push({
+ device: parts[0] || "",
+ type: parts[1] || "",
+ state: parts[2] || "",
+ connection: parts[3] || ""
+ });
+ }
+ }
+ }
+
+ return interfaces;
+ }
+
+ function isConnectedState(state: string): bool {
+ if (!state || state.length === 0) {
+ return false;
+ }
+
+ return state === "100 (connected)" || state === "connected" || state.startsWith("connected");
+ }
+
+ function executeCommand(args: list<string>, callback: var): void {
+ const proc = commandProc.createObject(root);
+ proc.command = ["nmcli", ...args];
+ proc.callback = callback;
+
+ activeProcesses.push(proc);
+
+ proc.processFinished.connect(() => {
+ const index = activeProcesses.indexOf(proc);
+ if (index >= 0) {
+ activeProcesses.splice(index, 1);
+ }
+ });
+
+ Qt.callLater(() => {
+ proc.exec(proc.command);
+ });
+ }
+
+ function getDeviceStatus(callback: var): void {
+ executeCommand(["-t", "-f", root.deviceStatusFields, root.nmcliCommandDevice, "status"], result => {
+ if (callback)
+ callback(result.output);
+ });
+ }
+
+ function getWirelessInterfaces(callback: var): void {
+ executeCommand(["-t", "-f", root.deviceStatusFields, root.nmcliCommandDevice, "status"], result => {
+ const interfaces = parseDeviceStatusOutput(result.output, root.deviceTypeWifi);
+ root.wirelessInterfaces = interfaces;
+ if (callback)
+ callback(interfaces);
+ });
+ }
+
+ function getEthernetInterfaces(callback: var): void {
+ executeCommand(["-t", "-f", root.deviceStatusFields, root.nmcliCommandDevice, "status"], result => {
+ const interfaces = parseDeviceStatusOutput(result.output, root.deviceTypeEthernet);
+ const devices = [];
+
+ for (const iface of interfaces) {
+ const connected = isConnectedState(iface.state);
+
+ devices.push({
+ interface: iface.device,
+ type: iface.type,
+ state: iface.state,
+ connection: iface.connection,
+ connected: connected,
+ ipAddress: "",
+ gateway: "",
+ dns: [],
+ subnet: "",
+ macAddress: "",
+ speed: ""
+ });
+ }
+
+ root.ethernetInterfaces = interfaces;
+ root.ethernetDevices = devices;
+ if (callback)
+ callback(interfaces);
+ });
+ }
+
+ function connectEthernet(connectionName: string, interfaceName: string, callback: var): void {
+ if (connectionName && connectionName.length > 0) {
+ executeCommand([root.nmcliCommandConnection, "up", connectionName], result => {
+ if (result.success) {
+ Qt.callLater(() => {
+ getEthernetInterfaces(() => {});
+ if (interfaceName && interfaceName.length > 0) {
+ Qt.callLater(() => {
+ getEthernetDeviceDetails(interfaceName, () => {});
+ }, 1000);
+ }
+ }, 500);
+ }
+ if (callback)
+ callback(result);
+ });
+ } else if (interfaceName && interfaceName.length > 0) {
+ executeCommand([root.nmcliCommandDevice, "connect", interfaceName], result => {
+ if (result.success) {
+ Qt.callLater(() => {
+ getEthernetInterfaces(() => {});
+ Qt.callLater(() => {
+ getEthernetDeviceDetails(interfaceName, () => {});
+ }, 1000);
+ }, 500);
+ }
+ if (callback)
+ callback(result);
+ });
+ } else {
+ if (callback)
+ callback({
+ success: false,
+ output: "",
+ error: "No connection name or interface specified",
+ exitCode: -1
+ });
+ }
+ }
+
+ function disconnectEthernet(connectionName: string, callback: var): void {
+ if (!connectionName || connectionName.length === 0) {
+ if (callback)
+ callback({
+ success: false,
+ output: "",
+ error: "No connection name specified",
+ exitCode: -1
+ });
+ return;
+ }
+
+ executeCommand([root.nmcliCommandConnection, "down", connectionName], result => {
+ if (result.success) {
+ root.ethernetDeviceDetails = null;
+ Qt.callLater(() => {
+ getEthernetInterfaces(() => {});
+ }, 500);
+ }
+ if (callback)
+ callback(result);
+ });
+ }
+
+ function getAllInterfaces(callback: var): void {
+ executeCommand(["-t", "-f", root.deviceStatusFields, root.nmcliCommandDevice, "status"], result => {
+ const interfaces = parseDeviceStatusOutput(result.output, "both");
+ if (callback)
+ callback(interfaces);
+ });
+ }
+
+ function isInterfaceConnected(interfaceName: string, callback: var): void {
+ executeCommand([root.nmcliCommandDevice, "status"], result => {
+ const lines = result.output.trim().split("\n");
+ for (const line of lines) {
+ const parts = line.split(/\s+/);
+ if (parts.length >= 3 && parts[0] === interfaceName) {
+ const connected = isConnectedState(parts[2]);
+ if (callback)
+ callback(connected);
+ return;
+ }
+ }
+ if (callback)
+ callback(false);
+ });
+ }
+
+ function connectToNetworkWithPasswordCheck(ssid: string, isSecure: bool, callback: var, bssid: string): void {
+ if (isSecure) {
+ const hasBssid = bssid !== undefined && bssid !== null && bssid.length > 0;
+ connectWireless(ssid, "", bssid, result => {
+ if (result.success) {
+ if (callback)
+ callback({
+ success: true,
+ usedSavedPassword: true,
+ output: result.output,
+ error: "",
+ exitCode: 0
+ });
+ } else if (result.needsPassword) {
+ if (callback)
+ callback({
+ success: false,
+ needsPassword: true,
+ output: result.output,
+ error: result.error,
+ exitCode: result.exitCode
+ });
+ } else {
+ if (callback)
+ callback(result);
+ }
+ });
+ } else {
+ connectWireless(ssid, "", bssid, callback);
+ }
+ }
+
+ function connectToNetwork(ssid: string, password: string, bssid: string, callback: var): void {
+ connectWireless(ssid, password, bssid, callback);
+ }
+
+ function connectWireless(ssid: string, password: string, bssid: string, callback: var, retryCount: int): void {
+ const hasBssid = bssid !== undefined && bssid !== null && bssid.length > 0;
+ const retries = retryCount !== undefined ? retryCount : 0;
+ const maxRetries = 2;
+
+ if (callback) {
+ root.pendingConnection = {
+ ssid: ssid,
+ bssid: hasBssid ? bssid : "",
+ callback: callback,
+ retryCount: retries
+ };
+ connectionCheckTimer.start();
+ immediateCheckTimer.checkCount = 0;
+ immediateCheckTimer.start();
+ }
+
+ if (password && password.length > 0 && hasBssid) {
+ const bssidUpper = bssid.toUpperCase();
+ createConnectionWithPassword(ssid, bssidUpper, password, callback);
+ return;
+ }
+
+ let cmd = [root.nmcliCommandDevice, root.nmcliCommandWifi, "connect", ssid];
+ if (password && password.length > 0) {
+ cmd.push(root.connectionParamPassword, password);
+ }
+ executeCommand(cmd, result => {
+ if (result.needsPassword && callback) {
+ if (callback)
+ callback(result);
+ return;
+ }
+
+ if (!result.success && root.pendingConnection && retries < maxRetries) {
+ console.warn("[NMCLI] Connection failed, retrying... (attempt " + (retries + 1) + "/" + maxRetries + ")");
+ Qt.callLater(() => {
+ connectWireless(ssid, password, bssid, callback, retries + 1);
+ }, 1000);
+ } else if (!result.success && root.pendingConnection) {} else if (result.success && callback) {} else if (!result.success && !root.pendingConnection) {
+ if (callback)
+ callback(result);
+ }
+ });
+ }
+
+ function createConnectionWithPassword(ssid: string, bssidUpper: string, password: string, callback: var): void {
+ checkAndDeleteConnection(ssid, () => {
+ const cmd = [root.nmcliCommandConnection, "add", root.connectionParamType, root.deviceTypeWifi, root.connectionParamConName, ssid, root.connectionParamIfname, "*", root.connectionParamSsid, ssid, root.connectionParamBssid, bssidUpper, root.securityKeyMgmt, root.keyMgmtWpaPsk, root.securityPsk, password];
+
+ executeCommand(cmd, result => {
+ if (result.success) {
+ loadSavedConnections(() => {});
+ activateConnection(ssid, callback);
+ } else {
+ const hasDuplicateWarning = result.error && (result.error.includes("another connection with the name") || result.error.includes("Reference the connection by its uuid"));
+
+ if (hasDuplicateWarning || (result.exitCode > 0 && result.exitCode < 10)) {
+ loadSavedConnections(() => {});
+ activateConnection(ssid, callback);
+ } else {
+ console.warn("[NMCLI] Connection profile creation failed, trying fallback...");
+ let fallbackCmd = [root.nmcliCommandDevice, root.nmcliCommandWifi, "connect", ssid, root.connectionParamPassword, password];
+ executeCommand(fallbackCmd, fallbackResult => {
+ if (callback)
+ callback(fallbackResult);
+ });
+ }
+ }
+ });
+ });
+ }
+
+ function checkAndDeleteConnection(ssid: string, callback: var): void {
+ executeCommand([root.nmcliCommandConnection, "show", ssid], result => {
+ if (result.success) {
+ executeCommand([root.nmcliCommandConnection, "delete", ssid], deleteResult => {
+ Qt.callLater(() => {
+ if (callback)
+ callback();
+ }, 300);
+ });
+ } else {
+ if (callback)
+ callback();
+ }
+ });
+ }
+
+ function activateConnection(connectionName: string, callback: var): void {
+ executeCommand([root.nmcliCommandConnection, "up", connectionName], result => {
+ if (callback)
+ callback(result);
+ });
+ }
+
+ function loadSavedConnections(callback: var): void {
+ executeCommand(["-t", "-f", root.connectionListFields, root.nmcliCommandConnection, "show"], result => {
+ if (!result.success) {
+ root.savedConnections = [];
+ root.savedConnectionSsids = [];
+ if (callback)
+ callback([]);
+ return;
+ }
+
+ parseConnectionList(result.output, callback);
+ });
+ }
+
+ function parseConnectionList(output: string, callback: var): void {
+ const lines = output.trim().split("\n").filter(line => line.length > 0);
+ const wifiConnections = [];
+ const connections = [];
+
+ for (const line of lines) {
+ const parts = line.split(":");
+ if (parts.length >= 2) {
+ const name = parts[0];
+ const type = parts[1];
+ connections.push(name);
+
+ if (type === root.connectionTypeWireless) {
+ wifiConnections.push(name);
+ }
+ }
+ }
+
+ root.savedConnections = connections;
+
+ if (wifiConnections.length > 0) {
+ root.wifiConnectionQueue = wifiConnections;
+ root.currentSsidQueryIndex = 0;
+ root.savedConnectionSsids = [];
+ queryNextSsid(callback);
+ } else {
+ root.savedConnectionSsids = [];
+ root.wifiConnectionQueue = [];
+ if (callback)
+ callback(root.savedConnectionSsids);
+ }
+ }
+
+ function queryNextSsid(callback: var): void {
+ if (root.currentSsidQueryIndex < root.wifiConnectionQueue.length) {
+ const connectionName = root.wifiConnectionQueue[root.currentSsidQueryIndex];
+ root.currentSsidQueryIndex++;
+
+ executeCommand(["-t", "-f", root.wirelessSsidField, root.nmcliCommandConnection, "show", connectionName], result => {
+ if (result.success) {
+ processSsidOutput(result.output);
+ }
+ queryNextSsid(callback);
+ });
+ } else {
+ root.wifiConnectionQueue = [];
+ root.currentSsidQueryIndex = 0;
+ if (callback)
+ callback(root.savedConnectionSsids);
+ }
+ }
+
+ function processSsidOutput(output: string): void {
+ const lines = output.trim().split("\n");
+ for (const line of lines) {
+ if (line.startsWith("802-11-wireless.ssid:")) {
+ const ssid = line.substring("802-11-wireless.ssid:".length).trim();
+ if (ssid && ssid.length > 0) {
+ const ssidLower = ssid.toLowerCase();
+ const exists = root.savedConnectionSsids.some(s => s && s.toLowerCase() === ssidLower);
+ if (!exists) {
+ const newList = root.savedConnectionSsids.slice();
+ newList.push(ssid);
+ root.savedConnectionSsids = newList;
+ }
+ }
+ }
+ }
+ }
+
+ function hasSavedProfile(ssid: string): bool {
+ if (!ssid || ssid.length === 0) {
+ return false;
+ }
+ const ssidLower = ssid.toLowerCase().trim();
+
+ if (root.active && root.active.ssid) {
+ const activeSsidLower = root.active.ssid.toLowerCase().trim();
+ if (activeSsidLower === ssidLower) {
+ return true;
+ }
+ }
+
+ const hasSsid = root.savedConnectionSsids.some(savedSsid => savedSsid && savedSsid.toLowerCase().trim() === ssidLower);
+
+ if (hasSsid) {
+ return true;
+ }
+
+ const hasConnectionName = root.savedConnections.some(connName => connName && connName.toLowerCase().trim() === ssidLower);
+
+ return hasConnectionName;
+ }
+
+ function forgetNetwork(ssid: string, callback: var): void {
+ if (!ssid || ssid.length === 0) {
+ if (callback)
+ callback({
+ success: false,
+ output: "",
+ error: "No SSID specified",
+ exitCode: -1
+ });
+ return;
+ }
+
+ const connectionName = root.savedConnections.find(conn => conn && conn.toLowerCase().trim() === ssid.toLowerCase().trim()) || ssid;
+
+ executeCommand([root.nmcliCommandConnection, "delete", connectionName], result => {
+ if (result.success) {
+ Qt.callLater(() => {
+ loadSavedConnections(() => {});
+ }, 500);
+ }
+ if (callback)
+ callback(result);
+ });
+ }
+
+ function disconnect(interfaceName: string, callback: var): void {
+ if (interfaceName && interfaceName.length > 0) {
+ executeCommand([root.nmcliCommandDevice, "disconnect", interfaceName], result => {
+ if (callback)
+ callback(result.success ? result.output : "");
+ });
+ } else {
+ executeCommand([root.nmcliCommandDevice, "disconnect", root.deviceTypeWifi], result => {
+ if (callback)
+ callback(result.success ? result.output : "");
+ });
+ }
+ }
+
+ function disconnectFromNetwork(): void {
+ if (active && active.ssid) {
+ executeCommand([root.nmcliCommandConnection, "down", active.ssid], result => {
+ if (result.success) {
+ getNetworks(() => {});
+ }
+ });
+ } else {
+ executeCommand([root.nmcliCommandDevice, "disconnect", root.deviceTypeWifi], result => {
+ if (result.success) {
+ getNetworks(() => {});
+ }
+ });
+ }
+ }
+
+ function getDeviceDetails(interfaceName: string, callback: var): void {
+ executeCommand([root.nmcliCommandDevice, "show", interfaceName], result => {
+ if (callback)
+ callback(result.output);
+ });
+ }
+
+ function refreshStatus(callback: var): void {
+ getDeviceStatus(output => {
+ const lines = output.trim().split("\n");
+ let connected = false;
+ let activeIf = "";
+ let activeConn = "";
+
+ for (const line of lines) {
+ const parts = line.split(":");
+ if (parts.length >= 4) {
+ const state = parts[2] || "";
+ if (isConnectedState(state)) {
+ connected = true;
+ activeIf = parts[0] || "";
+ activeConn = parts[3] || "";
+ break;
+ }
+ }
+ }
+
+ root.isConnected = connected;
+ root.activeInterface = activeIf;
+ root.activeConnection = activeConn;
+
+ if (callback)
+ callback({
+ connected,
+ interface: activeIf,
+ connection: activeConn
+ });
+ });
+ }
+
+ function bringInterfaceUp(interfaceName: string, callback: var): void {
+ if (interfaceName && interfaceName.length > 0) {
+ executeCommand([root.nmcliCommandDevice, "connect", interfaceName], result => {
+ if (callback) {
+ callback(result);
+ }
+ });
+ } else {
+ if (callback)
+ callback({
+ success: false,
+ output: "",
+ error: "No interface specified",
+ exitCode: -1
+ });
+ }
+ }
+
+ function bringInterfaceDown(interfaceName: string, callback: var): void {
+ if (interfaceName && interfaceName.length > 0) {
+ executeCommand([root.nmcliCommandDevice, "disconnect", interfaceName], result => {
+ if (callback) {
+ callback(result);
+ }
+ });
+ } else {
+ if (callback)
+ callback({
+ success: false,
+ output: "",
+ error: "No interface specified",
+ exitCode: -1
+ });
+ }
+ }
+
+ function scanWirelessNetworks(interfaceName: string, callback: var): void {
+ let cmd = [root.nmcliCommandDevice, root.nmcliCommandWifi, "rescan"];
+ if (interfaceName && interfaceName.length > 0) {
+ cmd.push(root.connectionParamIfname, interfaceName);
+ }
+ executeCommand(cmd, result => {
+ if (callback) {
+ callback(result);
+ }
+ });
+ }
+
+ function rescanWifi(): void {
+ rescanProc.running = true;
+ }
+
+ function enableWifi(enabled: bool, callback: var): void {
+ const cmd = enabled ? "on" : "off";
+ executeCommand([root.nmcliCommandRadio, root.nmcliCommandWifi, cmd], result => {
+ if (result.success) {
+ getWifiStatus(status => {
+ root.wifiEnabled = status;
+ if (callback)
+ callback(result);
+ });
+ } else {
+ if (callback)
+ callback(result);
+ }
+ });
+ }
+
+ function toggleWifi(callback: var): void {
+ const newState = !root.wifiEnabled;
+ enableWifi(newState, callback);
+ }
+
+ function getWifiStatus(callback: var): void {
+ executeCommand([root.nmcliCommandRadio, root.nmcliCommandWifi], result => {
+ if (result.success) {
+ const enabled = result.output.trim() === "enabled";
+ root.wifiEnabled = enabled;
+ if (callback)
+ callback(enabled);
+ } else {
+ if (callback)
+ callback(root.wifiEnabled);
+ }
+ });
+ }
+
+ function getNetworks(callback: var): void {
+ executeCommand(["-g", root.networkDetailFields, "d", "w"], result => {
+ if (!result.success) {
+ if (callback)
+ callback([]);
+ return;
+ }
+
+ const allNetworks = parseNetworkOutput(result.output);
+ const networks = deduplicateNetworks(allNetworks);
+ const rNetworks = root.networks;
+
+ const destroyed = rNetworks.filter(rn => !networks.find(n => n.frequency === rn.frequency && n.ssid === rn.ssid && n.bssid === rn.bssid));
+ for (const network of destroyed) {
+ const index = rNetworks.indexOf(network);
+ if (index >= 0) {
+ rNetworks.splice(index, 1);
+ network.destroy();
+ }
+ }
+
+ for (const network of networks) {
+ const match = rNetworks.find(n => n.frequency === network.frequency && n.ssid === network.ssid && n.bssid === network.bssid);
+ if (match) {
+ match.lastIpcObject = network;
+ } else {
+ rNetworks.push(apComp.createObject(root, {
+ lastIpcObject: network
+ }));
+ }
+ }
+
+ if (callback)
+ callback(root.networks);
+ checkPendingConnection();
+ });
+ }
+
+ function getWirelessSSIDs(interfaceName: string, callback: var): void {
+ let cmd = ["-t", "-f", root.networkListFields, root.nmcliCommandDevice, root.nmcliCommandWifi, "list"];
+ if (interfaceName && interfaceName.length > 0) {
+ cmd.push(root.connectionParamIfname, interfaceName);
+ }
+ executeCommand(cmd, result => {
+ if (!result.success) {
+ if (callback)
+ callback([]);
+ return;
+ }
+
+ const ssids = [];
+ const lines = result.output.trim().split("\n");
+ const seenSSIDs = new Set();
+
+ for (const line of lines) {
+ if (!line || line.length === 0)
+ continue;
+
+ const parts = line.split(":");
+ if (parts.length >= 1) {
+ const ssid = parts[0].trim();
+ if (ssid && ssid.length > 0 && !seenSSIDs.has(ssid)) {
+ seenSSIDs.add(ssid);
+ const signalStr = parts.length >= 2 ? parts[1].trim() : "";
+ const signal = signalStr ? parseInt(signalStr, 10) : 0;
+ const security = parts.length >= 3 ? parts[2].trim() : "";
+ ssids.push({
+ ssid: ssid,
+ signal: signalStr,
+ signalValue: isNaN(signal) ? 0 : signal,
+ security: security
+ });
+ }
+ }
+ }
+
+ ssids.sort((a, b) => {
+ return b.signalValue - a.signalValue;
+ });
+
+ if (callback)
+ callback(ssids);
+ });
+ }
+
+ function handlePasswordRequired(proc: var, error: string, output: string, exitCode: int): bool {
+ if (!proc || !error || error.length === 0) {
+ return false;
+ }
+
+ if (!isConnectionCommand(proc.command) || !root.pendingConnection || !root.pendingConnection.callback) {
+ return false;
+ }
+
+ const needsPassword = detectPasswordRequired(error);
+
+ if (needsPassword && !proc.callbackCalled && root.pendingConnection) {
+ connectionCheckTimer.stop();
+ immediateCheckTimer.stop();
+ immediateCheckTimer.checkCount = 0;
+ const pending = root.pendingConnection;
+ root.pendingConnection = null;
+ proc.callbackCalled = true;
+ const result = {
+ success: false,
+ output: output || "",
+ error: error,
+ exitCode: exitCode,
+ needsPassword: true
+ };
+ if (pending.callback) {
+ pending.callback(result);
+ }
+ if (proc.callback && proc.callback !== pending.callback) {
+ proc.callback(result);
+ }
+ return true;
+ }
+
+ return false;
+ }
+
+ component CommandProcess: Process {
+ id: proc
+
+ property var callback: null
+ property list<string> command: []
+ property bool callbackCalled: false
+ property int exitCode: 0
+
+ signal processFinished
+
+ environment: ({
+ LANG: "C.UTF-8",
+ LC_ALL: "C.UTF-8"
+ })
+
+ stdout: StdioCollector {
+ id: stdoutCollector
+ }
+
+ stderr: StdioCollector {
+ id: stderrCollector
+
+ onStreamFinished: {
+ const error = text.trim();
+ if (error && error.length > 0) {
+ const output = (stdoutCollector && stdoutCollector.text) ? stdoutCollector.text : "";
+ root.handlePasswordRequired(proc, error, output, -1);
+ }
+ }
+ }
+
+ onExited: code => {
+ exitCode = code;
+
+ Qt.callLater(() => {
+ if (callbackCalled) {
+ processFinished();
+ return;
+ }
+
+ if (proc.callback) {
+ const output = (stdoutCollector && stdoutCollector.text) ? stdoutCollector.text : "";
+ const error = (stderrCollector && stderrCollector.text) ? stderrCollector.text : "";
+ const success = exitCode === 0;
+ const cmdIsConnection = isConnectionCommand(proc.command);
+
+ if (root.handlePasswordRequired(proc, error, output, exitCode)) {
+ processFinished();
+ return;
+ }
+
+ const needsPassword = cmdIsConnection && root.detectPasswordRequired(error);
+
+ if (!success && cmdIsConnection && root.pendingConnection) {
+ const failedSsid = root.pendingConnection.ssid;
+ root.connectionFailed(failedSsid);
+ }
+
+ callbackCalled = true;
+ callback({
+ success: success,
+ output: output,
+ error: error,
+ exitCode: proc.exitCode,
+ needsPassword: needsPassword || false
+ });
+ processFinished();
+ } else {
+ processFinished();
+ }
+ });
+ }
+ }
+
+ Component {
+ id: commandProc
+
+ CommandProcess {}
+ }
+
+ component AccessPoint: QtObject {
+ required property var lastIpcObject
+ readonly property string ssid: lastIpcObject.ssid
+ readonly property string bssid: lastIpcObject.bssid
+ readonly property int strength: lastIpcObject.strength
+ readonly property int frequency: lastIpcObject.frequency
+ readonly property bool active: lastIpcObject.active
+ readonly property string security: lastIpcObject.security
+ readonly property bool isSecure: security.length > 0
+ }
+
+ Component {
+ id: apComp
+
+ AccessPoint {}
+ }
+
+ Timer {
+ id: connectionCheckTimer
+
+ interval: 4000
+ onTriggered: {
+ if (root.pendingConnection) {
+ const connected = root.active && root.active.ssid === root.pendingConnection.ssid;
+
+ if (!connected && root.pendingConnection.callback) {
+ let foundPasswordError = false;
+ for (let i = 0; i < root.activeProcesses.length; i++) {
+ const proc = root.activeProcesses[i];
+ if (proc && proc.stderr && proc.stderr.text) {
+ const error = proc.stderr.text.trim();
+ if (error && error.length > 0) {
+ if (root.isConnectionCommand(proc.command)) {
+ const needsPassword = root.detectPasswordRequired(error);
+
+ if (needsPassword && !proc.callbackCalled && root.pendingConnection) {
+ const pending = root.pendingConnection;
+ root.pendingConnection = null;
+ immediateCheckTimer.stop();
+ immediateCheckTimer.checkCount = 0;
+ proc.callbackCalled = true;
+ const result = {
+ success: false,
+ output: (proc.stdout && proc.stdout.text) ? proc.stdout.text : "",
+ error: error,
+ exitCode: -1,
+ needsPassword: true
+ };
+ if (pending.callback) {
+ pending.callback(result);
+ }
+ if (proc.callback && proc.callback !== pending.callback) {
+ proc.callback(result);
+ }
+ foundPasswordError = true;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ if (!foundPasswordError) {
+ const pending = root.pendingConnection;
+ const failedSsid = pending.ssid;
+ root.pendingConnection = null;
+ immediateCheckTimer.stop();
+ immediateCheckTimer.checkCount = 0;
+ root.connectionFailed(failedSsid);
+ pending.callback({
+ success: false,
+ output: "",
+ error: "Connection timeout",
+ exitCode: -1,
+ needsPassword: false
+ });
+ }
+ } else if (connected) {
+ root.pendingConnection = null;
+ immediateCheckTimer.stop();
+ immediateCheckTimer.checkCount = 0;
+ }
+ }
+ }
+ }
+
+ Timer {
+ id: immediateCheckTimer
+
+ property int checkCount: 0
+
+ interval: 500
+ repeat: true
+ triggeredOnStart: false
+
+ onTriggered: {
+ if (root.pendingConnection) {
+ checkCount++;
+ const connected = root.active && root.active.ssid === root.pendingConnection.ssid;
+
+ if (connected) {
+ connectionCheckTimer.stop();
+ immediateCheckTimer.stop();
+ immediateCheckTimer.checkCount = 0;
+ if (root.pendingConnection.callback) {
+ root.pendingConnection.callback({
+ success: true,
+ output: "Connected",
+ error: "",
+ exitCode: 0
+ });
+ }
+ root.pendingConnection = null;
+ } else {
+ for (let i = 0; i < root.activeProcesses.length; i++) {
+ const proc = root.activeProcesses[i];
+ if (proc && proc.stderr && proc.stderr.text) {
+ const error = proc.stderr.text.trim();
+ if (error && error.length > 0) {
+ if (root.isConnectionCommand(proc.command)) {
+ const needsPassword = root.detectPasswordRequired(error);
+
+ if (needsPassword && !proc.callbackCalled && root.pendingConnection && root.pendingConnection.callback) {
+ connectionCheckTimer.stop();
+ immediateCheckTimer.stop();
+ immediateCheckTimer.checkCount = 0;
+ const pending = root.pendingConnection;
+ root.pendingConnection = null;
+ proc.callbackCalled = true;
+ const result = {
+ success: false,
+ output: (proc.stdout && proc.stdout.text) ? proc.stdout.text : "",
+ error: error,
+ exitCode: -1,
+ needsPassword: true
+ };
+ if (pending.callback) {
+ pending.callback(result);
+ }
+ if (proc.callback && proc.callback !== pending.callback) {
+ proc.callback(result);
+ }
+ return;
+ }
+ }
+ }
+ }
+ }
+
+ if (checkCount >= 6) {
+ immediateCheckTimer.stop();
+ immediateCheckTimer.checkCount = 0;
+ }
+ }
+ } else {
+ immediateCheckTimer.stop();
+ immediateCheckTimer.checkCount = 0;
+ }
+ }
+ }
+
+ function checkPendingConnection(): void {
+ if (root.pendingConnection) {
+ Qt.callLater(() => {
+ const connected = root.active && root.active.ssid === root.pendingConnection.ssid;
+ if (connected) {
+ connectionCheckTimer.stop();
+ immediateCheckTimer.stop();
+ immediateCheckTimer.checkCount = 0;
+ if (root.pendingConnection.callback) {
+ root.pendingConnection.callback({
+ success: true,
+ output: "Connected",
+ error: "",
+ exitCode: 0
+ });
+ }
+ root.pendingConnection = null;
+ } else {
+ if (!immediateCheckTimer.running) {
+ immediateCheckTimer.start();
+ }
+ }
+ });
+ }
+ }
+
+ function cidrToSubnetMask(cidr: string): string {
+ const cidrNum = parseInt(cidr, 10);
+ if (isNaN(cidrNum) || cidrNum < 0 || cidrNum > 32) {
+ return "";
+ }
+
+ const mask = (0xffffffff << (32 - cidrNum)) >>> 0;
+ const octet1 = (mask >>> 24) & 0xff;
+ const octet2 = (mask >>> 16) & 0xff;
+ const octet3 = (mask >>> 8) & 0xff;
+ const octet4 = mask & 0xff;
+
+ return `${octet1}.${octet2}.${octet3}.${octet4}`;
+ }
+
+ function getWirelessDeviceDetails(interfaceName: string, callback: var): void {
+ if (!interfaceName || interfaceName.length === 0) {
+ const activeInterface = root.wirelessInterfaces.find(iface => {
+ return isConnectedState(iface.state);
+ });
+ if (activeInterface && activeInterface.device) {
+ interfaceName = activeInterface.device;
+ } else {
+ if (callback)
+ callback(null);
+ return;
+ }
+ }
+
+ executeCommand(["device", "show", interfaceName], result => {
+ if (!result.success || !result.output) {
+ root.wirelessDeviceDetails = null;
+ if (callback)
+ callback(null);
+ return;
+ }
+
+ const details = parseDeviceDetails(result.output, false);
+ root.wirelessDeviceDetails = details;
+ if (callback)
+ callback(details);
+ });
+ }
+
+ function getEthernetDeviceDetails(interfaceName: string, callback: var): void {
+ if (!interfaceName || interfaceName.length === 0) {
+ const activeInterface = root.ethernetInterfaces.find(iface => {
+ return isConnectedState(iface.state);
+ });
+ if (activeInterface && activeInterface.device) {
+ interfaceName = activeInterface.device;
+ } else {
+ if (callback)
+ callback(null);
+ return;
+ }
+ }
+
+ executeCommand(["device", "show", interfaceName], result => {
+ if (!result.success || !result.output) {
+ root.ethernetDeviceDetails = null;
+ if (callback)
+ callback(null);
+ return;
+ }
+
+ const details = parseDeviceDetails(result.output, true);
+ root.ethernetDeviceDetails = details;
+ if (callback)
+ callback(details);
+ });
+ }
+
+ function parseDeviceDetails(output: string, isEthernet: bool): var {
+ const details = {
+ ipAddress: "",
+ gateway: "",
+ dns: [],
+ subnet: "",
+ macAddress: "",
+ speed: ""
+ };
+
+ if (!output || output.length === 0) {
+ return details;
+ }
+
+ const lines = output.trim().split("\n");
+
+ for (let i = 0; i < lines.length; i++) {
+ const line = lines[i];
+ const parts = line.split(":");
+ if (parts.length >= 2) {
+ const key = parts[0].trim();
+ const value = parts.slice(1).join(":").trim();
+
+ if (key.startsWith("IP4.ADDRESS")) {
+ const ipParts = value.split("/");
+ details.ipAddress = ipParts[0] || "";
+ if (ipParts[1]) {
+ details.subnet = cidrToSubnetMask(ipParts[1]);
+ } else {
+ details.subnet = "";
+ }
+ } else if (key === "IP4.GATEWAY") {
+ if (value !== "--") {
+ details.gateway = value;
+ }
+ } else if (key.startsWith("IP4.DNS")) {
+ if (value !== "--" && value.length > 0) {
+ details.dns.push(value);
+ }
+ } else if (isEthernet && key === "WIRED-PROPERTIES.MAC") {
+ details.macAddress = value;
+ } else if (isEthernet && key === "WIRED-PROPERTIES.SPEED") {
+ details.speed = value;
+ } else if (!isEthernet && key === "GENERAL.HWADDR") {
+ details.macAddress = value;
+ }
+ }
+ }
+
+ return details;
+ }
+
+ Process {
+ id: rescanProc
+
+ command: ["nmcli", "dev", root.nmcliCommandWifi, "list", "--rescan", "yes"]
+ onExited: root.getNetworks()
+ }
+
+ Process {
+ id: monitorProc
+
+ running: true
+ command: ["nmcli", "monitor"]
+ environment: ({
+ LANG: "C.UTF-8",
+ LC_ALL: "C.UTF-8"
+ })
+ stdout: SplitParser {
+ onRead: root.refreshOnConnectionChange()
+ }
+ onExited: monitorRestartTimer.start()
+ }
+
+ Timer {
+ id: monitorRestartTimer
+ interval: 2000
+ onTriggered: {
+ monitorProc.running = true;
+ }
+ }
+
+ function refreshOnConnectionChange(): void {
+ getNetworks(networks => {
+ const newActive = root.active;
+
+ if (newActive && newActive.active) {
+ Qt.callLater(() => {
+ if (root.wirelessInterfaces.length > 0) {
+ const activeWireless = root.wirelessInterfaces.find(iface => {
+ return isConnectedState(iface.state);
+ });
+ if (activeWireless && activeWireless.device) {
+ getWirelessDeviceDetails(activeWireless.device, () => {});
+ }
+ }
+
+ if (root.ethernetInterfaces.length > 0) {
+ const activeEthernet = root.ethernetInterfaces.find(iface => {
+ return isConnectedState(iface.state);
+ });
+ if (activeEthernet && activeEthernet.device) {
+ getEthernetDeviceDetails(activeEthernet.device, () => {});
+ }
+ }
+ }, 500);
+ } else {
+ root.wirelessDeviceDetails = null;
+ root.ethernetDeviceDetails = null;
+ }
+
+ getWirelessInterfaces(() => {});
+ getEthernetInterfaces(() => {
+ if (root.activeEthernet && root.activeEthernet.connected) {
+ Qt.callLater(() => {
+ getEthernetDeviceDetails(root.activeEthernet.interface, () => {});
+ }, 500);
+ }
+ });
+ });
+ }
+
+ Component.onCompleted: {
+ getWifiStatus(() => {});
+ getNetworks(() => {});
+ loadSavedConnections(() => {});
+ getEthernetInterfaces(() => {});
+
+ Qt.callLater(() => {
+ if (root.wirelessInterfaces.length > 0) {
+ const activeWireless = root.wirelessInterfaces.find(iface => {
+ return isConnectedState(iface.state);
+ });
+ if (activeWireless && activeWireless.device) {
+ getWirelessDeviceDetails(activeWireless.device, () => {});
+ }
+ }
+
+ if (root.ethernetInterfaces.length > 0) {
+ const activeEthernet = root.ethernetInterfaces.find(iface => {
+ return isConnectedState(iface.state);
+ });
+ if (activeEthernet && activeEthernet.device) {
+ getEthernetDeviceDetails(activeEthernet.device, () => {});
+ }
+ }
+ }, 2000);
+ }
+}
generated by cgit v1.2.3-freya (git 2.51.1) at 2026-01-20 06:54:54 +0000