@willieee802/zigbee-herdsman-converters 15.0.8-4.1

package/lib/ota/salus.js

@@ -0,0 +1,82 @@
+const url = 'https://eu.salusconnect.io/demo/default/status/firmware?timestamp=0';
+const assert = require('assert');
+const common = require('./common');
+const tar = require('tar-stream');
+const axios = common.getAxios();
+
+/**
+ * Helper functions
+ */
+
+async function getImageMeta(current, logger, device) {
+    const modelID = device.modelID;
+    const images = (await axios.get(url)).data.versions;
+    const image = images.find((i) => i.model === modelID);
+    assert(image, `No image available for modelID '${modelID}'`);
+    return {
+        fileVersion: parseInt(image.version, 16),
+        url: image.url.replace(/^http:\/\//, 'https://'),
+    };
+}
+
+async function untar(tarStream) {
+    return new Promise((resolve, reject) => {
+        const extract = tar.extract();
+
+        const result = [];
+
+        extract.on('error', reject);
+
+        extract.on('entry', (headers, stream, next) => {
+            const buffers = [];
+
+            stream.on('data', function(data) {
+                buffers.push(data);
+            });
+
+            stream.on('end', function() {
+                result.push({
+                    headers,
+                    data: Buffer.concat(buffers),
+                });
+
+                next();
+            });
+
+            stream.resume();
+        });
+
+        extract.on('finish', () => {
+            resolve(result);
+        });
+
+        tarStream.pipe(extract);
+    });
+}
+
+async function downloadImage(meta, logger) {
+    const download = await axios.get(meta.url, {responseType: 'stream'});
+
+    const files = await untar(download.data);
+
+    const imageFile = files.find((file) => file.headers.name.endsWith('.ota'));
+
+    return imageFile;
+}
+
+/**
+ * Interface implementation
+ */
+
+async function isUpdateAvailable(device, logger, requestPayload=null) {
+    return common.isUpdateAvailable(device, logger, common.isNewImageAvailable, requestPayload, getImageMeta);
+}
+
+async function updateToLatest(device, logger, onProgress) {
+    return common.updateToLatest(device, logger, onProgress, common.getNewImage, getImageMeta, downloadImage);
+}
+
+module.exports = {
+    isUpdateAvailable,
+    updateToLatest,
+};

package/lib/ota/securifi.js

@@ -0,0 +1,25 @@
+const common = require('./common');
+const zigbeeOTA = require('./zigbeeOTA');
+
+async function isUpdateAvailable(device, logger, requestPayload=null) {
+    if (device.modelID === 'PP-WHT-US') {
+        // see https://github.com/Koenkk/zigbee-OTA/pull/14
+        const scenesEndpoint = device.endpoints.find((e) => e.supportsOutputCluster('genScenes'));
+        await scenesEndpoint.write('genScenes', {currentGroup: 49502});
+    }
+    return common.isUpdateAvailable(device, logger, common.isNewImageAvailable, requestPayload, zigbeeOTA.getImageMeta);
+}
+
+async function updateToLatest(device, logger, onProgress) {
+    if (device.modelID === 'PP-WHT-US') {
+        // see https://github.com/Koenkk/zigbee-OTA/pull/14
+        const scenesEndpoint = device.endpoints.find((e) => e.supportsOutputCluster('genScenes'));
+        await scenesEndpoint.write('genScenes', {currentGroup: 49502});
+    }
+    return common.updateToLatest(device, logger, onProgress, common.getNewImage, zigbeeOTA.getImageMeta);
+}
+
+module.exports = {
+    isUpdateAvailable,
+    updateToLatest,
+};

package/lib/ota/tradfri.js

@@ -0,0 +1,45 @@
+const productionURL = 'http://fw.ota.homesmart.ikea.net/feed/version_info.json';
+const testURL = 'http://fw.test.ota.homesmart.ikea.net/feed/version_info.json';
+const common = require('./common');
+const axios = common.getAxios();
+let useTestURL = false;
+
+/**
+ * Helper functions
+ */
+
+async function getImageMeta(current, logger, device) {
+    const url = useTestURL ? testURL : productionURL;
+    const imageType = current.imageType;
+    const images = (await axios.get(url)).data;
+    const image = images.find((i) => i.fw_image_type === imageType);
+
+    if (!image) {
+        throw new Error(`No image available for imageType '${imageType}'`);
+    }
+
+    return {
+        fileVersion: (image.fw_file_version_MSB << 16) | image.fw_file_version_LSB,
+        url: image.fw_binary_url,
+    };
+}
+
+/**
+ * Interface implementation
+ */
+
+async function isUpdateAvailable(device, logger, requestPayload=null) {
+    return common.isUpdateAvailable(device, logger, common.isNewImageAvailable, requestPayload, getImageMeta);
+}
+
+async function updateToLatest(device, logger, onProgress) {
+    return common.updateToLatest(device, logger, onProgress, common.getNewImage, getImageMeta);
+}
+
+module.exports = {
+    isUpdateAvailable,
+    updateToLatest,
+    useTestURL: () => {
+        useTestURL = true;
+    },
+};

package/lib/ota/ubisys.js

@@ -0,0 +1,61 @@
+const firmwareHtmlPageUrl = 'http://fwu.ubisys.de/smarthome/OTA/release/index';
+const imageRegex = /10F2-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{8})\S*ota1?\.zigbee/gi;
+const assert = require('assert');
+const url = require('url');
+const common = require('./common');
+const axios = common.getAxios();
+
+/**
+ * Helper functions
+ */
+
+async function getImageMeta(current, logger, device) {
+    const imageType = current.imageType;
+    const hardwareVersion = device.hardwareVersion;
+
+    const firmwarePage = await axios.get(firmwareHtmlPageUrl);
+    logger.debug(
+        `OTA ubisys: got firmware page, status: ${firmwarePage.status}, data.length: ${firmwarePage.data.length}`);
+    assert(firmwarePage.status === 200, `HTTP Error getting ubisys firmware page`);
+    const firmwarePageHtml = firmwarePage.data;
+
+    imageRegex.lastIndex = 0; // reset (global) regex for next exec to match from the beginning again
+    let imageMatch = imageRegex.exec(firmwarePageHtml);
+    let highestMatch = null;
+    while (imageMatch != null) {
+        logger.debug(`OTA ubisys: image found: ${imageMatch[0]}`);
+        if (parseInt(imageMatch[1], 16) === imageType &&
+            parseInt(imageMatch[2], 16) <= hardwareVersion && hardwareVersion <= parseInt(imageMatch[3], 16)) {
+            if (highestMatch === null || parseInt(highestMatch[4], 16) < parseInt(imageMatch[4], 16)) {
+                highestMatch = imageMatch;
+            }
+        }
+        imageMatch = imageRegex.exec(firmwarePageHtml);
+    }
+    assert(highestMatch !== null,
+        `No image available for imageType '0x${imageType.toString(16)}' with hardware version ${hardwareVersion}`);
+
+    return {
+        hardwareVersionMin: parseInt(highestMatch[2], 16),
+        hardwareVersionMax: parseInt(highestMatch[3], 16),
+        fileVersion: parseInt(highestMatch[4], 16),
+        url: url.resolve(firmwareHtmlPageUrl, highestMatch[0]),
+    };
+}
+
+/**
+ * Interface implementation
+ */
+
+async function isUpdateAvailable(device, logger, requestPayload=null) {
+    return common.isUpdateAvailable(device, logger, common.isNewImageAvailable, requestPayload, getImageMeta);
+}
+
+async function updateToLatest(device, logger, onProgress) {
+    return common.updateToLatest(device, logger, onProgress, common.getNewImage, getImageMeta);
+}
+
+module.exports = {
+    isUpdateAvailable,
+    updateToLatest,
+};

package/lib/ota/zigbeeOTA.js

@@ -0,0 +1,161 @@
+const url = 'https://raw.githubusercontent.com/Koenkk/zigbee-OTA/master/index.json';
+const common = require('./common');
+const axios = common.getAxios();
+const fs = require('fs');
+const URI = require('uri-js');
+const path = require('path');
+
+let overrideIndexFileName = null;
+let dataDir = null;
+
+/**
+ * Helper functions
+ */
+
+
+function isValidUrl(url) {
+    let parsed;
+    try {
+        parsed = URI.parse(url);
+    } catch (_) {
+        return false;
+    }
+    return parsed.scheme === 'http' || parsed.scheme === 'https';
+}
+
+async function getIndexFile(urlOrName) {
+    if (isValidUrl(urlOrName)) {
+        return (await axios.get(urlOrName)).data;
+    }
+
+    return JSON.parse(fs.readFileSync(urlOrName));
+}
+
+function readLocalFile(fileName, logger) {
+    // If the file name is not a full path, then treat it as a relative to the data directory
+    if (!path.isAbsolute(fileName) && dataDir) {
+        fileName = path.join(dataDir, fileName);
+    }
+
+    logger.debug(`ZigbeeOTA: getting local firmware file ${fileName}`);
+    return fs.readFileSync(fileName);
+}
+
+async function getFirmwareFile(image, logger) {
+    const urlOrName = image.url;
+
+    // First try to download firmware file with the URL provided
+    if (isValidUrl(urlOrName)) {
+        logger.debug(`ZigbeeOTA: downloading firmware image from ${urlOrName}`);
+        return await axios.get(urlOrName, {responseType: 'arraybuffer'});
+    }
+
+    return {data: readLocalFile(urlOrName, logger)};
+}
+
+function fillImageInfo(meta, logger) {
+    // Web-hosted images must come with all fields filled already
+    if (isValidUrl(meta.url)) {
+        return meta;
+    }
+
+    // Nothing to do if needed fields were filled already
+    if (meta.hasOwnProperty('imageType') &&
+        meta.hasOwnProperty('manufacturerCode') &&
+        meta.hasOwnProperty('fileVersion')) {
+        return meta;
+    }
+
+    // If no fields provided - get them from the image file
+    const buffer = readLocalFile(meta.url, logger);
+    const start = buffer.indexOf(common.upgradeFileIdentifier);
+    const image = common.parseImage(buffer.slice(start));
+
+    // Will fill only those fields that were absent
+    if (!meta.hasOwnProperty('imageType')) meta.imageType = image.header.imageType;
+    if (!meta.hasOwnProperty('manufacturerCode')) meta.manufacturerCode = image.header.manufacturerCode;
+    if (!meta.hasOwnProperty('fileVersion')) meta.fileVersion = image.header.fileVersion;
+    return meta;
+}
+
+async function getIndex(logger) {
+    const index = (await axios.get(url)).data;
+
+    logger.debug(`ZigbeeOTA: downloaded main index`);
+
+    if (overrideIndexFileName) {
+        logger.debug(`ZigbeeOTA: Loading override index ${overrideIndexFileName}`);
+        const localIndex = await getIndexFile(overrideIndexFileName);
+
+        // Resulting index will have overriden items first
+        return localIndex.concat(index).map((item) => isValidUrl(item.url) ? item : fillImageInfo(item, logger));
+    }
+
+    return index;
+}
+
+async function getImageMeta(current, logger, device) {
+    const modelId = device.modelID;
+    const imageType = current.imageType;
+    const manufacturerCode = current.manufacturerCode;
+    const manufacturerName = device.manufacturerName;
+    const images = await getIndex(logger);
+
+    // NOTE: Officially an image can be determined with a combination of manufacturerCode and imageType.
+    // However Gledopto pro products use the same imageType (0) for every device while the image is different.
+    // For this case additional identification through the modelId is done.
+    // In the case of Tuya and Moes, additional identification is carried out through the manufacturerName.
+    const image = images.find((i) => i.imageType === imageType && i.manufacturerCode === manufacturerCode &&
+        (!i.minFileVersion || current.fileVersion >= i.minFileVersion) && (!i.maxFileVersion || current.fileVersion <= i.maxFileVersion) &&
+        (!i.modelId || i.modelId === modelId) && (!i.manufacturerName || i.manufacturerName.includes(manufacturerName)));
+
+    if (!image) {
+        throw new Error(`No image available for imageType '${imageType}'`);
+    }
+
+    return {
+        fileVersion: image.fileVersion,
+        fileSize: image.fileSize,
+        url: image.url,
+        sha512: image.sha512,
+        force: image.force,
+    };
+}
+
+async function isNewImageAvailable(current, logger, device, getImageMeta) {
+    if (device.modelID === 'lumi.airrtc.agl001') {
+        // The current.fileVersion which comes from the device is wrong.
+        // Use the `aqaraFileVersion` which comes from the aqaraOpple.attributeReport instead.
+        // https://github.com/Koenkk/zigbee2mqtt/issues/16345#issuecomment-1454835056
+        // https://github.com/Koenkk/zigbee2mqtt/issues/16345 doesn't seem to be needed for all
+        if (device.meta.aqaraFileVersion) {
+            current = {...current, fileVersion: device.meta.aqaraFileVersion};
+        }
+    }
+
+    return common.isNewImageAvailable(current, logger, device, getImageMeta);
+}
+
+/**
+ * Interface implementation
+ */
+
+async function isUpdateAvailable(device, logger, requestPayload=null) {
+    return common.isUpdateAvailable(device, logger, isNewImageAvailable, requestPayload, getImageMeta);
+}
+
+async function updateToLatest(device, logger, onProgress) {
+    return common.updateToLatest(device, logger, onProgress, common.getNewImage, getImageMeta, getFirmwareFile);
+}
+
+module.exports = {
+    getImageMeta,
+    isUpdateAvailable,
+    updateToLatest,
+    useIndexOverride: (indexFileName) => {
+        overrideIndexFileName = indexFileName;
+    },
+    setDataDir: (dir) => {
+        dataDir = dir;
+    },
+};