@project-chip/matter.js 0.2.1 → 0.3.0

package/dist/cjs/math/ReedSolomon.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReedSolomon = void 0;
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const ByteArray_js_1 = require("../util/ByteArray.js");
+class GaloisField {
+    constructor(prime = 0x11d, generator = 2, c_exp = 8) {
+        this.prime = prime;
+        this.exp = new Array();
+        this.log = new Array();
+        this.size = Math.floor(Math.pow(2, c_exp) - 1);
+        let x = 1;
+        for (let i = 0; i < this.size; i++) {
+            this.exp[i] = x;
+            this.log[x] = i;
+            x = this.multiplyNoLut(x, generator);
+        }
+        for (let i = this.size; i < this.size * 2; i++) {
+            this.exp[i] = this.exp[i - this.size];
+        }
+    }
+    multiply(x, y) {
+        if (x === 0 || y === 0)
+            return 0;
+        return this.exp[(this.log[x] + this.log[y]) % this.size];
+    }
+    multiplyPolynom(p, q) {
+        const result = new Array();
+        const logP = new Array();
+        for (let i = 0; i < p.length; i++) {
+            logP[i] = this.log[p[i]];
+        }
+        for (let j = 0; j < q.length; j++) {
+            if (q[j] === 0)
+                continue;
+            const lq = this.log[q[j]];
+            for (let i = 0; i < p.length; i++) {
+                if (p[i] === 0)
+                    continue;
+                result[i + j] ^= this.exp[logP[i] + lq];
+            }
+        }
+        return result;
+    }
+    power(x, power) {
+        return this.exp[(this.log[x] * power) % this.size];
+    }
+    multiplyNoLut(x, y) {
+        let result = 0;
+        while (y > 0) {
+            if ((y & 1) !== 0)
+                result = result ^ x;
+            y = y >> 1;
+            x = x << 1;
+            if (x > this.size) {
+                x = x ^ this.prime;
+            }
+        }
+        return result;
+    }
+}
+class ReedSolomon {
+    constructor() {
+        this.galoisField = new GaloisField();
+    }
+    computeErrorCorrection(data, ecLength) {
+        const { length } = data;
+        if (length + ecLength > this.galoisField.size)
+            throw new Error("Message is too long");
+        const generator = this.generatePolynom(ecLength);
+        const { length: generatorLength } = generator;
+        const buffer = new ByteArray_js_1.ByteArray(length + generatorLength - 1);
+        buffer.set(data, 0);
+        for (let i = 0; i < length; i++) {
+            const coef = buffer[i];
+            if (coef === 0)
+                continue;
+            for (let j = 0; j < generatorLength; j++) {
+                buffer[i + j] ^= this.galoisField.multiply(generator[j], coef);
+            }
+        }
+        return buffer.slice(length);
+    }
+    generatePolynom(ecLength) {
+        let result = [1];
+        for (let i = 0; i < ecLength; i++) {
+            result = this.galoisField.multiplyPolynom(result, [1, this.galoisField.power(2, i)]);
+        }
+        return result;
+    }
+}
+exports.ReedSolomon = ReedSolomon;

package/dist/cjs/math/Verhoeff.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Verhoeff algorithm to compute a checksum.
+ *
+ * @see {@link https://en.wikipedia.org/wiki/Verhoeff_algorithm}
+ */
+export declare class Verhoeff {
+    private readonly multiply;
+    private readonly inverse;
+    private readonly permute;
+    computeChecksum(digits: string): number;
+}
+//# sourceMappingURL=Verhoeff.d.ts.map

package/dist/cjs/math/Verhoeff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Verhoeff.d.ts","sourceRoot":"","sources":["../../../src/math/Verhoeff.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;GAIG;AACH,qBAAa,QAAQ;IAEjB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAWvB;IACF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAC1D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAStB;IAEF,eAAe,CAAC,MAAM,EAAE,MAAM;CASjC"}

package/dist/cjs/math/Verhoeff.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Verhoeff = void 0;
+/**
+ * Verhoeff algorithm to compute a checksum.
+ *
+ * @see {@link https://en.wikipedia.org/wiki/Verhoeff_algorithm}
+ */
+class Verhoeff {
+    constructor() {
+        // This is rarely used so no need to keep those constants in memory
+        this.multiply = [
+            [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+            [1, 2, 3, 4, 0, 6, 7, 8, 9, 5],
+            [2, 3, 4, 0, 1, 7, 8, 9, 5, 6],
+            [3, 4, 0, 1, 2, 8, 9, 5, 6, 7],
+            [4, 0, 1, 2, 3, 9, 5, 6, 7, 8],
+            [5, 9, 8, 7, 6, 0, 4, 3, 2, 1],
+            [6, 5, 9, 8, 7, 1, 0, 4, 3, 2],
+            [7, 6, 5, 9, 8, 2, 1, 0, 4, 3],
+            [8, 7, 6, 5, 9, 3, 2, 1, 0, 4],
+            [9, 8, 7, 6, 5, 4, 3, 2, 1, 0],
+        ];
+        this.inverse = [0, 4, 3, 2, 1, 5, 6, 7, 8, 9];
+        this.permute = [
+            [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+            [1, 5, 7, 6, 2, 8, 3, 0, 9, 4],
+            [5, 8, 0, 3, 7, 9, 6, 1, 4, 2],
+            [8, 9, 1, 6, 0, 4, 3, 5, 2, 7],
+            [9, 4, 5, 3, 1, 2, 6, 8, 7, 0],
+            [4, 2, 8, 6, 5, 7, 3, 9, 0, 1],
+            [2, 7, 9, 3, 8, 0, 6, 4, 1, 5],
+            [7, 0, 4, 6, 9, 1, 3, 2, 5, 8],
+        ];
+    }
+    computeChecksum(digits) {
+        const { length } = digits;
+        let checksum = 0;
+        for (let i = 1; i <= length; i++) {
+            const digit = Number.parseInt(digits[length - i]);
+            checksum = this.multiply[checksum][this.permute[(i) % 8][digit]];
+        }
+        return this.inverse[checksum];
+    }
+}
+exports.Verhoeff = Verhoeff;

package/dist/cjs/math/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./ReedSolomon.js";
+export * from "./Verhoeff.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/math/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/math/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC"}

package/dist/cjs/math/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ReedSolomon.js"), exports);
+__exportStar(require("./Verhoeff.js"), exports);

package/dist/cjs/mdns/MdnsBroadcaster.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Broadcaster } from "../common/Broadcaster.js";
+import { MdnsServer } from "./MdnsServer.js";
+import { VendorId } from "../datatype/VendorId.js";
+import { Fabric } from "../fabric/Fabric.js";
+export declare class MdnsBroadcaster implements Broadcaster {
+    private readonly mdnsServer;
+    private readonly port;
+    static create(port: number, multicastInterface?: string): Promise<MdnsBroadcaster>;
+    private readonly network;
+    constructor(mdnsServer: MdnsServer, port: number);
+    setCommissionMode(mode: number, deviceName: string, deviceType: number, vendorId: VendorId, productId: number, discriminator: number): void;
+    setFabrics(fabrics: Fabric[]): void;
+    announce(): void;
+    close(): void;
+}
+//# sourceMappingURL=MdnsBroadcaster.d.ts.map

package/dist/cjs/mdns/MdnsBroadcaster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MdnsBroadcaster.d.ts","sourceRoot":"","sources":["../../../src/mdns/MdnsBroadcaster.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAInD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAI7C,qBAAa,eAAgB,YAAW,WAAW;IAQ3C,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,IAAI;WARZ,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,kBAAkB,CAAC,EAAE,MAAM;IAI7D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;gBAGpB,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM;IAGjC,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;IAwDpI,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE;IAqC5B,QAAQ;IAKR,KAAK;CAGR"}

package/dist/cjs/mdns/MdnsBroadcaster.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MdnsBroadcaster = void 0;
+const DnsCodec_js_1 = require("../codec/DnsCodec.js");
+const Crypto_js_1 = require("../crypto/Crypto.js");
+const MdnsConsts_js_1 = require("./MdnsConsts.js");
+const MdnsServer_js_1 = require("./MdnsServer.js");
+const Network_js_1 = require("../net/Network.js");
+const Ip_js_1 = require("../util/Ip.js");
+const Logger_js_1 = require("../log/Logger.js");
+const logger = Logger_js_1.Logger.get("MdnsBroadcaster");
+class MdnsBroadcaster {
+    static create(port, multicastInterface) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new MdnsBroadcaster(yield MdnsServer_js_1.MdnsServer.create(multicastInterface), port);
+        });
+    }
+    constructor(mdnsServer, port) {
+        this.mdnsServer = mdnsServer;
+        this.port = port;
+        this.network = Network_js_1.Network.get();
+    }
+    setCommissionMode(mode, deviceName, deviceType, vendorId, productId, discriminator) {
+        logger.debug(`announce commissioning mode ${mode} ${deviceName} ${deviceType} ${vendorId} ${productId} ${discriminator}`);
+        const shortDiscriminator = (discriminator >> 8) & 0x0F;
+        const instanceId = Crypto_js_1.Crypto.getRandomData(8).toHex().toUpperCase();
+        const vendorQname = `_V${vendorId.id}._sub.${MdnsConsts_js_1.MATTER_COMMISSION_SERVICE_QNAME}`;
+        const deviceTypeQname = `_T${deviceType}._sub.${MdnsConsts_js_1.MATTER_COMMISSION_SERVICE_QNAME}`;
+        const shortDiscriminatorQname = `_S${shortDiscriminator}._sub.${MdnsConsts_js_1.MATTER_COMMISSION_SERVICE_QNAME}`;
+        const longDiscriminatorQname = `_L${discriminator}._sub.${MdnsConsts_js_1.MATTER_COMMISSION_SERVICE_QNAME}`;
+        const commissionModeQname = `_CM._sub.${MdnsConsts_js_1.MATTER_COMMISSION_SERVICE_QNAME}`;
+        const deviceQname = `${instanceId}.${MdnsConsts_js_1.MATTER_COMMISSION_SERVICE_QNAME}`;
+        this.mdnsServer.setRecordsGenerator(netInterface => {
+            const ipMac = this.network.getIpMac(netInterface);
+            if (ipMac === undefined)
+                return [];
+            const { mac, ips } = ipMac;
+            const hostname = mac.replace(/:/g, "").toUpperCase() + "0000.local";
+            const records = [
+                (0, DnsCodec_js_1.PtrRecord)(MdnsConsts_js_1.SERVICE_DISCOVERY_QNAME, MdnsConsts_js_1.MATTER_COMMISSION_SERVICE_QNAME),
+                (0, DnsCodec_js_1.PtrRecord)(MdnsConsts_js_1.SERVICE_DISCOVERY_QNAME, vendorQname),
+                (0, DnsCodec_js_1.PtrRecord)(MdnsConsts_js_1.SERVICE_DISCOVERY_QNAME, deviceTypeQname),
+                (0, DnsCodec_js_1.PtrRecord)(MdnsConsts_js_1.SERVICE_DISCOVERY_QNAME, shortDiscriminatorQname),
+                (0, DnsCodec_js_1.PtrRecord)(MdnsConsts_js_1.SERVICE_DISCOVERY_QNAME, longDiscriminatorQname),
+                (0, DnsCodec_js_1.PtrRecord)(MdnsConsts_js_1.SERVICE_DISCOVERY_QNAME, commissionModeQname),
+                (0, DnsCodec_js_1.PtrRecord)(MdnsConsts_js_1.MATTER_COMMISSION_SERVICE_QNAME, deviceQname),
+                (0, DnsCodec_js_1.PtrRecord)(vendorQname, deviceQname),
+                (0, DnsCodec_js_1.PtrRecord)(deviceTypeQname, deviceQname),
+                (0, DnsCodec_js_1.PtrRecord)(shortDiscriminatorQname, deviceQname),
+                (0, DnsCodec_js_1.PtrRecord)(longDiscriminatorQname, deviceQname),
+                (0, DnsCodec_js_1.PtrRecord)(commissionModeQname, deviceQname),
+                // TODO: the Matter port should not be hardcoded here
+                (0, DnsCodec_js_1.SrvRecord)(deviceQname, { priority: 0, weight: 0, port: this.port, target: hostname }),
+                (0, DnsCodec_js_1.TxtRecord)(deviceQname, [
+                    `VP=${vendorId.id}+${productId}`,
+                    `DT=${deviceType}`,
+                    `DN=${deviceName}`,
+                    "SII=5000",
+                    "SAI=300",
+                    "T=0",
+                    `D=${discriminator}`,
+                    `CM=${mode}`,
+                    "PH=33",
+                    "PI=", /* Pairing Instruction */
+                ]),
+            ];
+            ips.forEach(ip => {
+                if ((0, Ip_js_1.isIPv4)(ip)) {
+                    records.push((0, DnsCodec_js_1.ARecord)(hostname, ip));
+                }
+                else {
+                    records.push((0, DnsCodec_js_1.AAAARecord)(hostname, ip));
+                }
+            });
+            return records;
+        });
+    }
+    setFabrics(fabrics) {
+        this.mdnsServer.setRecordsGenerator(netInterface => {
+            const records = [
+                (0, DnsCodec_js_1.PtrRecord)(MdnsConsts_js_1.SERVICE_DISCOVERY_QNAME, MdnsConsts_js_1.MATTER_SERVICE_QNAME),
+            ];
+            fabrics.forEach(fabric => {
+                const { operationalId, nodeId } = fabric;
+                const operationalIdString = operationalId.toHex().toUpperCase();
+                const fabricQname = (0, MdnsConsts_js_1.getFabricQname)(operationalIdString);
+                const deviceMatterQname = (0, MdnsConsts_js_1.getDeviceMatterQname)(operationalIdString, nodeId.toString());
+                logger.debug(`Set fabric ${operationalId.toHex()} ${nodeId.id}: ${deviceMatterQname} for announcement on ${netInterface}`);
+                const ipMac = this.network.getIpMac(netInterface);
+                if (ipMac === undefined)
+                    return [];
+                const { mac, ips } = ipMac;
+                const hostname = mac.replace(/:/g, "").toUpperCase() + "0000.local";
+                const fabricRecords = [
+                    (0, DnsCodec_js_1.PtrRecord)(MdnsConsts_js_1.SERVICE_DISCOVERY_QNAME, fabricQname),
+                    (0, DnsCodec_js_1.PtrRecord)(MdnsConsts_js_1.MATTER_SERVICE_QNAME, deviceMatterQname),
+                    (0, DnsCodec_js_1.PtrRecord)(fabricQname, deviceMatterQname),
+                    // TODO: the Matter port should not be hardcoded here
+                    (0, DnsCodec_js_1.SrvRecord)(deviceMatterQname, { priority: 0, weight: 0, port: this.port, target: hostname }),
+                    (0, DnsCodec_js_1.TxtRecord)(deviceMatterQname, ["SII=5000", "SAI=300", "T=1"]),
+                ];
+                ips.forEach(ip => {
+                    if ((0, Ip_js_1.isIPv4)(ip)) {
+                        fabricRecords.push((0, DnsCodec_js_1.ARecord)(hostname, ip));
+                    }
+                    else {
+                        fabricRecords.push((0, DnsCodec_js_1.AAAARecord)(hostname, ip));
+                    }
+                });
+                records.push(...fabricRecords);
+            });
+            return records;
+        });
+    }
+    announce() {
+        this.mdnsServer.announce()
+            .catch(error => logger.error(error));
+    }
+    close() {
+        this.mdnsServer.close();
+    }
+}
+exports.MdnsBroadcaster = MdnsBroadcaster;

package/dist/cjs/mdns/MdnsConsts.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const SERVICE_DISCOVERY_QNAME = "_services._dns-sd._udp.local";
+export declare const MATTER_COMMISSION_SERVICE_QNAME = "_matterc._udp.local";
+export declare const MATTER_SERVICE_QNAME = "_matter._tcp.local";
+export declare const getFabricQname: (operationalIdString: string) => string;
+export declare const getDeviceMatterQname: (operationalIdString: string, nodeIdString: string) => string;
+//# sourceMappingURL=MdnsConsts.d.ts.map

package/dist/cjs/mdns/MdnsConsts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MdnsConsts.d.ts","sourceRoot":"","sources":["../../../src/mdns/MdnsConsts.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,uBAAuB,iCAAiC,CAAC;AACtE,eAAO,MAAM,+BAA+B,wBAAwB,CAAC;AACrE,eAAO,MAAM,oBAAoB,uBAAuB,CAAC;AAEzD,eAAO,MAAM,cAAc,wBAAyB,MAAM,WAA4D,CAAC;AACvH,eAAO,MAAM,oBAAoB,wBAAyB,MAAM,gBAAgB,MAAM,WAAqE,CAAC"}

package/dist/cjs/mdns/MdnsConsts.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDeviceMatterQname = exports.getFabricQname = exports.MATTER_SERVICE_QNAME = exports.MATTER_COMMISSION_SERVICE_QNAME = exports.SERVICE_DISCOVERY_QNAME = void 0;
+exports.SERVICE_DISCOVERY_QNAME = "_services._dns-sd._udp.local";
+exports.MATTER_COMMISSION_SERVICE_QNAME = "_matterc._udp.local";
+exports.MATTER_SERVICE_QNAME = "_matter._tcp.local";
+const getFabricQname = (operationalIdString) => `_I${operationalIdString}._sub.${exports.MATTER_SERVICE_QNAME}`;
+exports.getFabricQname = getFabricQname;
+const getDeviceMatterQname = (operationalIdString, nodeIdString) => `${operationalIdString}-${nodeIdString}.${exports.MATTER_SERVICE_QNAME}`;
+exports.getDeviceMatterQname = getDeviceMatterQname;

package/dist/cjs/mdns/MdnsScanner.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { UdpMulticastServer } from "../net/UdpMulticastServer.js";
+import { MatterServer, Scanner } from "../common/Scanner.js";
+import { Fabric } from "../fabric/Fabric.js";
+import { NodeId } from "../datatype/NodeId.js";
+export declare class MdnsScanner implements Scanner {
+    private readonly multicastServer;
+    static create(netInterface?: string): Promise<MdnsScanner>;
+    private readonly matterDeviceRecords;
+    private readonly recordWaiters;
+    private readonly periodicTimer;
+    constructor(multicastServer: UdpMulticastServer);
+    findDevice({ operationalId }: Fabric, nodeId: NodeId, timeoutSeconds?: number): Promise<MatterServer | undefined>;
+    close(): void;
+    private handleDnsMessage;
+    private expire;
+}
+//# sourceMappingURL=MdnsScanner.d.ts.map

package/dist/cjs/mdns/MdnsScanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MdnsScanner.d.ts","sourceRoot":"","sources":["../../../src/mdns/MdnsScanner.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAMlE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAI/C,qBAAa,WAAY,YAAW,OAAO;IAenC,OAAO,CAAC,QAAQ,CAAC,eAAe;WAdvB,MAAM,CAAC,YAAY,CAAC,EAAE,MAAM;IASzC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAmD;IACvF,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAiE;IAC/F,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAQ;gBAGjB,eAAe,EAAE,kBAAkB;IAMlD,UAAU,CAAC,EAAE,aAAa,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,SAAI,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC;IAmBlH,KAAK;IAML,OAAO,CAAC,gBAAgB;IAqBxB,OAAO,CAAC,MAAM;CAOjB"}

package/dist/cjs/mdns/MdnsScanner.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MdnsScanner = void 0;
+const DnsCodec_js_1 = require("../codec/DnsCodec.js");
+const UdpMulticastServer_js_1 = require("../net/UdpMulticastServer.js");
+const MdnsServer_js_1 = require("./MdnsServer.js");
+const MdnsConsts_js_1 = require("./MdnsConsts.js");
+const Promises_js_1 = require("../util/Promises.js");
+const Time_js_1 = require("../time/Time.js");
+class MdnsScanner {
+    static create(netInterface) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new MdnsScanner(yield UdpMulticastServer_js_1.UdpMulticastServer.create({
+                netInterface: netInterface,
+                broadcastAddressIpv4: MdnsServer_js_1.MDNS_BROADCAST_IPV4,
+                broadcastAddressIpv6: MdnsServer_js_1.MDNS_BROADCAST_IPV6,
+                listeningPort: MdnsServer_js_1.MDNS_BROADCAST_PORT,
+            }));
+        });
+    }
+    constructor(multicastServer) {
+        this.multicastServer = multicastServer;
+        this.matterDeviceRecords = new Map();
+        this.recordWaiters = new Map();
+        multicastServer.onMessage((message, remoteIp) => this.handleDnsMessage(message, remoteIp));
+        this.periodicTimer = Time_js_1.Time.getPeriodicTimer(60 * 1000 /* 1 mn */, () => this.expire()).start();
+    }
+    findDevice({ operationalId }, nodeId, timeoutSeconds = 5) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const operationalIdString = operationalId.toHex().toUpperCase();
+            const deviceMatterQname = (0, MdnsConsts_js_1.getDeviceMatterQname)(operationalIdString, nodeId.toString());
+            const record = this.matterDeviceRecords.get(deviceMatterQname);
+            if (record !== undefined)
+                return { ip: record.ip, port: record.port };
+            const { promise, resolver } = yield (0, Promises_js_1.getPromiseResolver)();
+            const timer = Time_js_1.Time.getTimer(timeoutSeconds * 1000, () => {
+                this.recordWaiters.delete(deviceMatterQname);
+                resolver(undefined);
+            }).start();
+            this.recordWaiters.set(deviceMatterQname, resolver);
+            yield this.multicastServer.send(DnsCodec_js_1.DnsCodec.encode({ queries: [{ name: deviceMatterQname, recordClass: 1 /* RecordClass.IN */, recordType: 33 /* RecordType.SRV */ }] }));
+            const result = yield promise;
+            timer.stop();
+            return result;
+        });
+    }
+    close() {
+        this.multicastServer.close();
+        this.periodicTimer.stop();
+        [...this.recordWaiters.values()].forEach(waiter => waiter(undefined));
+    }
+    handleDnsMessage(messageBytes, _remoteIp) {
+        const message = DnsCodec_js_1.DnsCodec.decode(messageBytes);
+        if (message === undefined)
+            return; // The message cannot be parsed
+        if (message.messageType !== 33792 /* MessageType.Response */)
+            return;
+        const answers = [...message.answers, ...message.additionalRecords];
+        const srvRecord = answers.find(({ name, recordType }) => recordType === 33 /* RecordType.SRV */ && name.endsWith(MdnsConsts_js_1.MATTER_SERVICE_QNAME));
+        if (srvRecord === undefined)
+            return;
+        const { name: matterName, ttl, value: { target, port: matterPort } } = srvRecord;
+        const aRecord = answers.find(({ name, recordType }) => recordType === 1 /* RecordType.A */ && name === target);
+        if (aRecord === undefined)
+            return;
+        const matterIp = aRecord.value;
+        const record = { ip: matterIp, port: matterPort, expires: Date.now() + ttl * 1000 };
+        this.matterDeviceRecords.set(matterName, record);
+        const waiter = this.recordWaiters.get(matterName);
+        if (waiter === undefined)
+            return;
+        waiter({ ip: matterIp, port: matterPort });
+        this.recordWaiters.delete(matterName);
+    }
+    expire() {
+        const now = Date.now();
+        [...this.matterDeviceRecords.entries()].forEach(([key, { expires }]) => {
+            if (now < expires)
+                return;
+            this.matterDeviceRecords.delete(key);
+        });
+    }
+}
+exports.MdnsScanner = MdnsScanner;

package/dist/cjs/mdns/MdnsServer.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Record } from "../codec/DnsCodec.js";
+import { UdpMulticastServer } from "../net/UdpMulticastServer.js";
+export declare const MDNS_BROADCAST_IPV4 = "224.0.0.251";
+export declare const MDNS_BROADCAST_IPV6 = "ff02::fb";
+export declare const MDNS_BROADCAST_PORT = 5353;
+export declare class MdnsServer {
+    private readonly multicastServer;
+    private readonly netInterface;
+    static create(netInterface?: string): Promise<MdnsServer>;
+    private readonly network;
+    private recordsGenerator;
+    private readonly records;
+    constructor(multicastServer: UdpMulticastServer, netInterface: string | undefined);
+    private handleDnsMessage;
+    announce(): Promise<void>;
+    setRecordsGenerator(generator: (netInterface: string) => Record<any>[]): void;
+    close(): void;
+    private getMulticastInterfacesForAnnounce;
+    private queryRecords;
+}
+//# sourceMappingURL=MdnsServer.d.ts.map

package/dist/cjs/mdns/MdnsServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MdnsServer.d.ts","sourceRoot":"","sources":["../../../src/mdns/MdnsServer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAyB,MAAM,EAAc,MAAM,sBAAsB,CAAC;AAEjF,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAIlE,eAAO,MAAM,mBAAmB,gBAAgB,CAAC;AACjD,eAAO,MAAM,mBAAmB,aAAa,CAAC;AAC9C,eAAO,MAAM,mBAAmB,OAAO,CAAC;AAExC,qBAAa,UAAU;IAkBf,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,YAAY;WAlBpB,MAAM,CAAC,YAAY,CAAC,EAAE,MAAM;IAYzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IACzC,OAAO,CAAC,gBAAgB,CAAqD;IAC7E,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwH;gBAG3H,eAAe,EAAE,kBAAkB,EACnC,YAAY,EAAE,MAAM,GAAG,SAAS;IAKrD,OAAO,CAAC,gBAAgB;IAsBlB,QAAQ;IASd,mBAAmB,CAAC,SAAS,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,MAAM,CAAC,GAAG,CAAC,EAAE;IAKtE,KAAK;IAKL,OAAO,CAAC,iCAAiC;IAIzC,OAAO,CAAC,YAAY;CAOvB"}

package/dist/cjs/mdns/MdnsServer.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MdnsServer = exports.MDNS_BROADCAST_PORT = exports.MDNS_BROADCAST_IPV6 = exports.MDNS_BROADCAST_IPV4 = void 0;
+const DnsCodec_js_1 = require("../codec/DnsCodec.js");
+const Network_js_1 = require("../net/Network.js");
+const UdpMulticastServer_js_1 = require("../net/UdpMulticastServer.js");
+const Cache_js_1 = require("../util/Cache.js");
+exports.MDNS_BROADCAST_IPV4 = "224.0.0.251";
+exports.MDNS_BROADCAST_IPV6 = "ff02::fb";
+exports.MDNS_BROADCAST_PORT = 5353;
+class MdnsServer {
+    static create(netInterface) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new MdnsServer(yield UdpMulticastServer_js_1.UdpMulticastServer.create({
+                netInterface: netInterface,
+                broadcastAddressIpv4: exports.MDNS_BROADCAST_IPV4,
+                broadcastAddressIpv6: exports.MDNS_BROADCAST_IPV6,
+                listeningPort: exports.MDNS_BROADCAST_PORT
+            }), netInterface);
+        });
+    }
+    constructor(multicastServer, netInterface) {
+        this.multicastServer = multicastServer;
+        this.netInterface = netInterface;
+        this.network = Network_js_1.Network.get();
+        this.recordsGenerator = () => [];
+        this.records = new Cache_js_1.Cache((multicastInterface) => this.recordsGenerator(multicastInterface), 5 * 60 * 1000 /* 5mn */);
+        multicastServer.onMessage((message, remoteIp, netInterface) => this.handleDnsMessage(message, remoteIp, netInterface));
+    }
+    handleDnsMessage(messageBytes, _remoteIp, netInterface) {
+        // This message was on a subnet not supported by this device
+        if (netInterface === undefined)
+            return;
+        const records = this.records.get(netInterface);
+        // No need to process the DNS message if there are no records to serve
+        if (records.length === 0)
+            return;
+        const message = DnsCodec_js_1.DnsCodec.decode(messageBytes);
+        if (message === undefined)
+            return; // The message cannot be parsed
+        const { transactionId, messageType, queries } = message;
+        if (messageType !== 0 /* MessageType.Query */)
+            return;
+        const answers = queries.flatMap(query => this.queryRecords(query, records));
+        if (answers.length === 0)
+            return;
+        const additionalRecords = records.filter(record => !answers.includes(record));
+        this.multicastServer.send(DnsCodec_js_1.DnsCodec.encode({ transactionId, answers, additionalRecords }), netInterface).catch(() => {
+            // ignore because already catched in UdpMulticastServer
+        });
+    }
+    announce() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(this.getMulticastInterfacesForAnnounce().map(netInterface => {
+                const records = this.records.get(netInterface);
+                const answers = records.filter(({ recordType }) => recordType === 12 /* RecordType.PTR */);
+                const additionalRecords = records.filter(({ recordType }) => recordType !== 12 /* RecordType.PTR */);
+                return this.multicastServer.send(DnsCodec_js_1.DnsCodec.encode({ answers, additionalRecords }), netInterface);
+            }));
+        });
+    }
+    setRecordsGenerator(generator) {
+        this.records.clear();
+        this.recordsGenerator = generator;
+    }
+    close() {
+        this.records.close();
+        this.multicastServer.close();
+    }
+    getMulticastInterfacesForAnnounce() {
+        return this.netInterface === undefined ? this.network.getNetInterfaces() : [this.netInterface];
+    }
+    queryRecords({ name, recordType }, records) {
+        if (recordType === 255 /* RecordType.ANY */) {
+            return records.filter(record => record.name === name);
+        }
+        else {
+            return records.filter(record => record.name === name && record.recordType === recordType);
+        }
+    }
+}
+exports.MdnsServer = MdnsServer;