homebridge-openwrt-control 0.4.2 → 0.4.4

package/CHANGELOG.md

@@ -9,6 +9,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - After update to v0.1.0 the plugin need to be reconfigured!
 
+## [0.4.4] - (15.10.2026)
+
+### Changes
+
+- fixed: after a restart of the router the plugin could report `Access denied` for up to 4 minutes. A call that was refused twice in a row (the router was still starting) was remembered as denied by the ACL and the plugin did not log in again. Only optional calls (`iwinfo`) are remembered now, and only when the session was created for that call, a required call is read again on the next poll
+- changed: what the ACL refused is forgotten after the session was renewed, so a changed ACL on the router is picked up without a restart of the plugin
+
+## [0.4.3] - (15.10.2026)
+
+### Changes
+
+- fixed: Home Assistant discovery on current OpenWrt, `network.wireless status` is refused over HTTP with invalid argument, so channel, TX power and clients per SSID were always empty. The interfaces are now matched to the SSIDs with `iwinfo` by SSID and band, `network.wireless status` is still used first where it works
+- fixed: after a router restart the cached session was unknown to the router and every call failed with `Access denied` until the session expired (up to 4 minutes), the plugin now logs in again once
+- changed: the request timeout is 10 s (was 5 s) and a read is repeated once after a network error (timeout, reset, host unreachable), commands that change the router are never repeated
+- changed: a call that the ACL of the user denies even with a fresh session is remembered, the plugin does not log in again on every poll for it
+
 ## [0.4.2] - (29.09.2026)
 
 ### Changes

package/package.json

@@ -1,7 +1,7 @@
 {
     "displayName": "OpenWrt Control",
     "name": "homebridge-openwrt-control",
-    "version": "0.4.2",
+    "version": "0.4.4",
     "description": "Homebridge plugin to control OpenWrt flashed devices.",
     "license": "MIT",
     "author": "grzegorz914",

package/src/openwrt.js

@@ -14,6 +14,10 @@ export function redactWireless(wirelessInfo) {
     return { ...wirelessInfo, values };
 }
 
+// Small routers answer slowly now and then (5 s was too short for some), network errors that may pass on a second try
+const RequestTimeout = 10_000;
+const TransientErrors = new Set(['ECONNABORTED', 'ETIMEDOUT', 'ECONNRESET', 'EHOSTUNREACH', 'ENETUNREACH', 'EPIPE']);
+
 class OpenWrt extends EventEmitter {
     constructor(config) {
         super();
@@ -32,10 +36,13 @@ class OpenWrt extends EventEmitter {
         this.extendedInfoAt = 0;
         this.sessionExpiresAt = 0;
 
+        // Calls the ACL of the user denies even with a fresh session, skipped instead of logging in again every time
+        this.aclDenied = new Set();
+
         const baseUrl = `http://${config.host}/ubus`;
         this.axiosInstance = axios.create({
             baseURL: baseUrl,
-            timeout: 5000,
+            timeout: RequestTimeout,
             headers: {
                 "Content-Type": "application/json"
             }
@@ -108,18 +115,53 @@ class OpenWrt extends EventEmitter {
         return this.sessionId;
     }
 
-    async ubusCall(service, method, params = {}) {
-        const session = await this.login();
-        const response = await this.axiosInstance.post('', {
-            jsonrpc: '2.0',
-            id: 2,
-            method: 'call',
-            params: [session, service, method, params]
-        });
+    // retry is only for reads. One more try after a network hiccup, and one new login when the router no longer knows
+    // the cached session (a restarted router answers every call with Access denied until the cached session expires).
+    // optional marks a call a router may refuse by ACL, only such a call is remembered as denied, a required call is
+    // never given up on so a router that is still starting is read again on the next poll
+    async ubusCall(service, method, params = {}, retry = false, optional = false) {
+        const key = `${service}.${method}`;
+        let renewed = false;
+
+        for (let attempt = 0; ; attempt++) {
+            const cached = this.sessionId !== null && Date.now() < this.sessionExpiresAt;
+            const session = await this.login();
+
+            let response;
+            try {
+                response = await this.axiosInstance.post('', {
+                    jsonrpc: '2.0',
+                    id: 2,
+                    method: 'call',
+                    params: [session, service, method, params]
+                });
+            } catch (error) {
+                if (retry && attempt === 0 && TransientErrors.has(error.code)) continue;
+                throw error;
+            }
+
+            const error = response.data?.error;
+            if (error) {
+                const denied = error.code === -32002 || /access denied/i.test(error.message ?? '');
+
+                // A cached session may be one the router forgot, log in again once. A call the ACL is known to refuse is skipped
+                if (denied && retry && attempt === 0 && cached && !(optional && this.aclDenied.has(key))) {
+                    this.sessionId = null;
+                    this.sessionExpiresAt = 0;
+                    renewed = true;
+                    continue;
+                }
+
+                // Refused with a session that was just created is the ACL, not asked again with a new login on every poll
+                if (denied && optional && !cached) this.aclDenied.add(key);
+                throw new Error(error.message || 'Ubus call error');
+            }
 
-        if (response.data?.error) throw new Error(response.data.error.message || 'Ubus call error');
+            // The router had forgotten the session, what it refused before may be allowed again
+            if (renewed) this.aclDenied.clear();
 
-        return response.data.result[1];
+            return response.data.result[1];
+        }
     }
 
     async connect() {
@@ -127,11 +169,11 @@ class OpenWrt extends EventEmitter {
             const openWrtInfo = { state: false, info: '', linkUp: false, wan: null, systemInfo: {}, networkInfo: {}, wirelessInfo: {}, wirelessRadios: [], wirelessSsids: [], switchPorts: [], extendedInfo: null };
 
             // System info
-            const systemInfo = await this.ubusCall('system', 'board');
+            const systemInfo = await this.ubusCall('system', 'board', {}, true);
             if (this.logDebug) this.emit('debug', `System info data: ${JSON.stringify(systemInfo, null, 2)}`);
 
             // Link status
-            const networkInterfaces = await this.ubusCall('network.interface', 'dump');
+            const networkInterfaces = await this.ubusCall('network.interface', 'dump', {}, true);
             if (this.logDebug) this.emit('debug', `Network interfaces data: ${JSON.stringify(networkInterfaces, null, 2)}`);
             const interfaces = networkInterfaces?.interface || [];
             const linkUp = interfaces.some(iface => {
@@ -144,7 +186,7 @@ class OpenWrt extends EventEmitter {
             const wan = wanIface ? { up: wanIface.up === true, ipv4: wanIface['ipv4-address']?.[0]?.address ?? null } : null;
 
             // Wireless info
-            const wirelessInfo = await this.ubusCall('uci', 'get', { config: 'wireless' });
+            const wirelessInfo = await this.ubusCall('uci', 'get', { config: 'wireless' }, true);
             if (this.logDebug) this.emit('debug', `Wireless status data: ${JSON.stringify(redactWireless(wirelessInfo), null, 2)}`);
 
             // Radios list
@@ -195,7 +237,7 @@ class OpenWrt extends EventEmitter {
             openWrtInfo.wirelessInfo = wirelessInfo;
             openWrtInfo.wirelessRadios = radios;
             openWrtInfo.wirelessSsids = ssids;
-            if (this.haDiscovery) openWrtInfo.extendedInfo = await this.getExtendedInfo();
+            if (this.haDiscovery) openWrtInfo.extendedInfo = await this.getExtendedInfo(ssids);
             
             this.emit('openWrtInfo', openWrtInfo);
 
@@ -207,13 +249,38 @@ class OpenWrt extends EventEmitter {
 
     // System info, radio channel and power, clients per SSID. Every call is optional, a router without iwinfo or
     // without the ACL for it still reports the rest. Cached for 30 s, the calls per interface are not needed every poll
-    async getExtendedInfo() {
+    // Radio interfaces (phy0-ap0) matched to the SSID sections, by SSID and band. An SSID that two interfaces of one
+    // band share is assigned in the order of the interfaces, so every section gets one interface
+    async matchInterfaces(optional, ssids) {
+        const bandOf = (frequency) => frequency < 3000 ? '2' : frequency < 5925 ? '5' : '6';
+        const devices = await optional('iwinfo', 'devices');
+        const used = new Set();
+        const matches = [];
+
+        for (const ifname of devices?.devices ?? []) {
+            const details = await optional('iwinfo', 'info', { device: ifname });
+            if (!details?.ssid) continue;
+
+            const candidates = ssids.filter(ssid => ssid.section && ssid.name === details.ssid && !used.has(ssid.section));
+            const band = bandOf(details.frequency);
+            const sameBand = candidates.filter(ssid => String(ssid.band ?? '').replace(/\D.*$/, '') === band);
+            const ssid = sameBand[0] ?? candidates.find(candidate => !candidate.band) ?? null;
+            if (!ssid) continue;
+
+            used.add(ssid.section);
+            matches.push({ radio: ssid.radio, section: ssid.section, ifname, up: true, details });
+        }
+
+        return matches;
+    }
+
+    async getExtendedInfo(ssids = []) {
         const now = Date.now();
         if (this.extendedInfo && now - this.extendedInfoAt < 30_000) return this.extendedInfo;
 
         const optional = async (service, method, params) => {
             try {
-                return await this.ubusCall(service, method, params);
+                return await this.ubusCall(service, method, params, true, true);
             } catch (error) {
                 if (this.logDebug) this.emit('debug', `Optional ubus call ${service} ${method} failed: ${error.message}`);
                 return null;
@@ -233,23 +300,29 @@ class OpenWrt extends EventEmitter {
             };
         }
 
-        // Interface names of the SSID sections, from the runtime wireless status
+        // Interface names of the SSID sections from the runtime wireless status. Current OpenWrt answers it with
+        // invalid argument over HTTP, then the interfaces are matched to the SSID sections by SSID and band
         const status = await optional('network.wireless', 'status');
+        const found = [];
         for (const [radio, radioStatus] of Object.entries(status ?? {})) {
-            const radioInfo = { up: radioStatus?.up === true, channel: null, txpower: null };
             for (const iface of radioStatus?.interfaces ?? []) {
-                if (!iface?.section || !iface?.ifname) continue;
-                const clients = await optional('iwinfo', 'assoclist', { device: iface.ifname });
-                info.ifaces[iface.section] = { ifname: iface.ifname, clients: Array.isArray(clients?.results) ? clients.results.length : null };
-
-                // Channel and power of the radio from its first interface
-                if (radioInfo.channel === null) {
-                    const ifaceInfo = await optional('iwinfo', 'info', { device: iface.ifname });
-                    radioInfo.channel = ifaceInfo?.channel ?? null;
-                    radioInfo.txpower = ifaceInfo?.txpower ?? null;
-                }
+                if (iface?.section && iface?.ifname) found.push({ radio, section: iface.section, ifname: iface.ifname, up: radioStatus?.up === true });
+            }
+        }
+        if (found.length === 0) found.push(...await this.matchInterfaces(optional, ssids));
+
+        for (const { radio, section, ifname, up, details } of found) {
+            const radioInfo = info.radios[radio] ?? (info.radios[radio] = { up, channel: null, txpower: null });
+
+            const clients = await optional('iwinfo', 'assoclist', { device: ifname });
+            info.ifaces[section] = { ifname, clients: Array.isArray(clients?.results) ? clients.results.length : null };
+
+            // Channel and power of the radio from its first interface
+            if (radioInfo.channel === null) {
+                const ifaceInfo = details ?? await optional('iwinfo', 'info', { device: ifname });
+                radioInfo.channel = ifaceInfo?.channel ?? null;
+                radioInfo.txpower = ifaceInfo?.txpower ?? null;
             }
-            info.radios[radio] = radioInfo;
         }
 
         if (this.logDebug) this.emit('debug', `Extended info: ${JSON.stringify(info)}`);