zigbee-herdsman 6.0.1 → 6.0.3

package/src/adapter/ember/utils/math.ts

@@ -1,73 +0,0 @@
-/* v8 ignore start */
-//--------------------------------------------------------------
-// Define macros for handling 3-bit frame numbers modulo 8
-
-/** mask to frame number modulus */
-export const mod8 = (n: number): number => n & 7;
-/** increment in frame number modulus */
-export const inc8 = (n: number): number => mod8(n + 1);
-/** Return true if n is within the range lo through hi, computed (mod 8) */
-export const withinRange = (lo: number, n: number, hi: number): boolean => mod8(n - lo) <= mod8(hi - lo);
-
-//--------------------------------------------------------------
-// CRC
-
-/**
- * Calculates 16-bit cyclic redundancy code (CITT CRC 16).
- *
- * Applies the standard CITT CRC 16 polynomial to a
- * single byte. It should support being called first with an initial
- * value, then repeatedly until all data is processed.
- *
- * @param newByte     The new byte to be run through CRC.
- * @param prevResult  The previous CRC result.
- * @returns The new CRC result.
- */
-export const halCommonCrc16 = (newByte: number, prevResult: number): number => {
-    /*
-     *    16bit CRC notes:
-     *    "CRC-CCITT"
-     *     poly is g(X) = X^16 + X^12 + X^5 + 1  (0x1021)
-     *     used in the FPGA (green boards and 15.4)
-     *     initial remainder should be 0xFFFF
-     */
-    prevResult = ((prevResult >> 8) & 0xffff) | ((prevResult << 8) & 0xffff);
-    prevResult ^= newByte;
-    prevResult ^= (prevResult & 0xff) >> 4;
-    prevResult ^= (((prevResult << 8) & 0xffff) << 4) & 0xffff;
-
-    prevResult ^= (((prevResult & 0xff) << 5) & 0xff) | (((((prevResult & 0xff) >> 3) & 0xffff) << 8) & 0xffff);
-
-    return prevResult;
-};
-
-//--------------------------------------------------------------
-// Byte manipulation
-
-/** Returns the low bits of the 8-bit value 'n' as uint8_t. */
-export const lowBits = (n: number): number => n & 0xf;
-/** Returns the high bits of the 8-bit value 'n' as uint8_t. */
-export const highBits = (n: number): number => lowBits(n >> 4) & 0xf;
-/** Returns the low byte of the 16-bit value 'n' as uint8_t. */
-export const lowByte = (n: number): number => n & 0xff;
-/** Returns the high byte of the 16-bit value 'n' as uint8_t. */
-export const highByte = (n: number): number => lowByte(n >> 8) & 0xff;
-/** Returns the value built from the two uint8_t values high and low. */
-export const highLowToInt = (high: number, low: number): number => ((high & 0xffff) << 8) + (low & 0xffff & 0xff);
-/** Useful to reference a single bit of a byte. */
-export const bit = (x: number): number => 1 << x;
-/** Useful to reference a single bit of an uint32_t type. */
-export const bit32 = (x: number): number => 1 << x;
-/** Returns both the low and high bytes (in that order) of the same 16-bit value 'n' as uint8_t. */
-export const lowHighBytes = (n: number): [number, highByte: number] => [lowByte(n), highByte(n)];
-/** Returns both the low and high bits (in that order) of the same 8-bit value 'n' as uint8_t. */
-export const lowHighBits = (n: number): [number, highBits: number] => [lowBits(n), highBits(n)];
-
-/**
- * Get byte as an 8-bit string (`n` assumed of proper range).
- * @param n
- * @returns
- */
-export const byteToBits = (n: number): string => {
-    return (n >>> 0).toString(2).padStart(8, "0");
-};

package/src/adapter/events.ts

@@ -1,21 +0,0 @@
-import type {Header as ZclHeader} from "../zspec/zcl";
-
-export type DeviceJoinedPayload = {
-    networkAddress: number;
-    ieeeAddr: string;
-};
-
-export type DeviceLeavePayload = {networkAddress?: number; ieeeAddr: string} | {networkAddress: number; ieeeAddr?: string};
-
-export interface ZclPayload {
-    clusterID: number;
-    address: number | string;
-    header: ZclHeader | undefined;
-    // This buffer contains the whole Zcl.Frame (including the ZclHeader)
-    data: Buffer;
-    endpoint: number;
-    linkquality: number;
-    groupID: number;
-    wasBroadcast: boolean;
-    destinationEndpoint: number;
-}

package/src/adapter/ezsp/adapter/backup.ts

@@ -1,109 +0,0 @@
-/* v8 ignore start */
-
-import * as fs from "node:fs";
-
-import type * as Models from "../../../models";
-import {BackupUtils} from "../../../utils";
-import {logger} from "../../../utils/logger";
-import {uint32MaskToChannels} from "../../../zspec/utils";
-import type {Driver} from "../driver";
-import {
-    type EmberKeyData,
-    type EmberKeyStruct,
-    EmberKeyType,
-    type EmberNetworkParameters,
-    type EmberSecurityManagerNetworkKeyInfo,
-} from "../driver/types";
-
-const NS = "zh:ezsp:backup";
-
-export class EZSPAdapterBackup {
-    private driver: Driver;
-    private defaultPath: string;
-
-    public constructor(driver: Driver, path: string) {
-        this.driver = driver;
-        this.defaultPath = path;
-    }
-
-    public async createBackup(): Promise<Models.Backup> {
-        logger.debug("creating backup", NS);
-        const version: number = await this.driver.ezsp.version();
-        const linkResult = await this.driver.getKey(EmberKeyType.TRUST_CENTER_LINK_KEY);
-        const netParams = await this.driver.ezsp.execCommand("getNetworkParameters");
-        const networkParams: EmberNetworkParameters = netParams.parameters;
-        const netResult = await this.driver.getKey(EmberKeyType.CURRENT_NETWORK_KEY);
-        let tclKey: Buffer;
-        let netKey: Buffer;
-        let netKeySequenceNumber = 0;
-        let netKeyFrameCounter = 0;
-
-        if (version < 13) {
-            tclKey = Buffer.from((linkResult.keyStruct as EmberKeyStruct).key.contents);
-            netKey = Buffer.from((netResult.keyStruct as EmberKeyStruct).key.contents);
-            netKeySequenceNumber = (netResult.keyStruct as EmberKeyStruct).sequenceNumber;
-            netKeyFrameCounter = (netResult.keyStruct as EmberKeyStruct).outgoingFrameCounter;
-        } else {
-            tclKey = Buffer.from((linkResult.keyData as EmberKeyData).contents);
-            netKey = Buffer.from((netResult.keyData as EmberKeyData).contents);
-            // get rest of info from second cmd in EZSP 13+
-            const netKeyInfoResult = await this.driver.getNetworkKeyInfo();
-            const networkKeyInfo: EmberSecurityManagerNetworkKeyInfo = netKeyInfoResult.networkKeyInfo;
-            netKeySequenceNumber = networkKeyInfo.networkKeySequenceNumber;
-            netKeyFrameCounter = networkKeyInfo.networkKeyFrameCounter;
-        }
-
-        const ieee = (await this.driver.ezsp.execCommand("getEui64")).eui64;
-        /* return backup structure */
-        return {
-            ezsp: {
-                version: version,
-                hashed_tclk: tclKey,
-            },
-            networkOptions: {
-                panId: networkParams.panId,
-                extendedPanId: Buffer.from(networkParams.extendedPanId),
-                channelList: uint32MaskToChannels(networkParams.channels),
-                networkKey: netKey,
-                networkKeyDistribute: true,
-            },
-            logicalChannel: networkParams.radioChannel,
-            networkKeyInfo: {
-                sequenceNumber: netKeySequenceNumber,
-                frameCounter: netKeyFrameCounter,
-            },
-            securityLevel: 5,
-            networkUpdateId: networkParams.nwkUpdateId,
-            coordinatorIeeeAddress: ieee,
-            devices: [],
-        };
-    }
-
-    /**
-     * Loads currently stored backup and returns it in internal backup model.
-     */
-    public getStoredBackup(): Models.Backup | undefined {
-        try {
-            fs.accessSync(this.defaultPath);
-        } catch {
-            return undefined;
-        }
-        let data: Models.UnifiedBackupStorage;
-        try {
-            data = JSON.parse(fs.readFileSync(this.defaultPath).toString());
-        } catch (error) {
-            throw new Error(`Coordinator backup is corrupted (${(error as Error).stack})`);
-        }
-        if (data.metadata?.format === "zigpy/open-coordinator-backup" && data.metadata?.version) {
-            if (data.metadata?.version !== 1) {
-                throw new Error(`Unsupported open coordinator backup version (version=${data.metadata?.version})`);
-            }
-            if (!data.metadata.internal?.ezspVersion) {
-                throw new Error("This open coordinator backup format not for EZSP adapter");
-            }
-            return BackupUtils.fromUnifiedBackup(data);
-        }
-
-        throw new Error("Unknown backup format");
-    }
-}