@matter/protocol 0.15.4 → 0.15.6

package/src/interaction/InteractionMessenger.ts

@@ -13,14 +13,20 @@ import {
     NoResponseTimeoutError,
     UnexpectedDataError,
 } from "#general";
+import { DecodedAttributeReportValue } from "#interaction/AttributeDataDecoder.js";
+import { DecodedDataReport } from "#interaction/DecodedDataReport.js";
 import { Specification } from "#model";
 import { ChannelNotConnectedError } from "#protocol/MessageChannel.js";
 import {
+    AttributeId,
+    ClusterId,
+    EndpointNumber,
     ReceivedStatusResponseError,
     Status,
     StatusCode,
     StatusResponseError,
     TlvAny,
+    TlvAttributeReport,
     TlvDataReport,
     TlvDataReportForSend,
     TlvDataVersionFilter,
@@ -796,8 +802,105 @@ export class IncomingInteractionClientMessenger extends InteractionMessenger {
         return message;
     }
 
-    async readAggregateDataReport(expectedSubscriptionIds?: number[]): Promise<DataReport> {
-        let result: DataReport | undefined;
+    /**
+     * Reads data report stream and aggregates them into a single report.
+     * Additionally, a callback can be provided that is called for each cluster chunk received.
+     */
+    async readAggregateDataReport(
+        chunkListener?: (chunk: DecodedAttributeReportValue<any>[]) => Promise<void>,
+        expectedSubscriptionIds?: number[],
+    ): Promise<DecodedDataReport> {
+        let result: DecodedDataReport | undefined = undefined;
+        let currentEndpointId: EndpointNumber | undefined = undefined;
+        let currentClusterId: ClusterId | undefined = undefined;
+        const currentClusterChunk = new Array<DecodedAttributeReportValue<any>>();
+        let pendingAttributeReports: TypeFromSchema<typeof TlvAttributeReport>[] | undefined = undefined;
+
+        const handleAttributeReportEntries = (
+            attributeReports: TypeFromSchema<typeof TlvAttributeReport>[] | undefined,
+            previousPendingAttributeReports: TypeFromSchema<typeof TlvAttributeReport>[] | undefined,
+        ) => {
+            if (previousPendingAttributeReports?.length) {
+                attributeReports = attributeReports ?? [];
+                attributeReports.unshift(...previousPendingAttributeReports);
+            }
+
+            let lastAttributeDataIndex = -1;
+            if (attributeReports?.length) {
+                let lastEndpointId: EndpointNumber | undefined = undefined;
+                let lastClusterId: ClusterId | undefined = undefined;
+                let lastAttributeId: AttributeId | undefined = undefined;
+                for (let i = attributeReports.length - 1; i >= 0; i--) {
+                    const attributeReport = attributeReports[i];
+                    if (attributeReport.attributeData === undefined) {
+                        break; // No data report, so nothing more to search for
+                    }
+                    const {
+                        path: { endpointId, clusterId, attributeId },
+                    } = attributeReport.attributeData;
+                    if (lastEndpointId === undefined && lastClusterId === undefined && lastAttributeId === undefined) {
+                        // Remember path of the last attribute data entry and check if previous entries match
+                        lastEndpointId = endpointId;
+                        lastClusterId = clusterId;
+                        lastAttributeId = attributeId;
+                    }
+                    if (
+                        endpointId === lastEndpointId &&
+                        clusterId === lastClusterId &&
+                        attributeId === lastAttributeId
+                    ) {
+                        lastAttributeDataIndex = i;
+                        continue;
+                    }
+                    break; // We found an attribute that does not match the last one, so we are done
+                }
+
+                if (lastAttributeDataIndex > 0) {
+                    return attributeReports.splice(lastAttributeDataIndex);
+                }
+            }
+        };
+
+        const processDecodedReport = async (
+            decodedReport: DecodedDataReport,
+            result: DecodedDataReport | undefined,
+        ) => {
+            if (!result) {
+                result = decodedReport;
+            } else {
+                if (!result.attributeReports) {
+                    result.attributeReports = decodedReport.attributeReports;
+                } else {
+                    result.attributeReports.push(...decodedReport.attributeReports);
+                }
+                if (Array.isArray(decodedReport.eventReports)) {
+                    if (!result.eventReports) {
+                        result.eventReports = decodedReport.eventReports;
+                    } else {
+                        result.eventReports.push(...decodedReport.eventReports);
+                    }
+                }
+            }
+
+            if (chunkListener !== undefined && decodedReport.attributeReports) {
+                for (const data of decodedReport.attributeReports) {
+                    const {
+                        path: { endpointId, clusterId },
+                    } = data;
+                    if (currentEndpointId !== endpointId || currentClusterId !== clusterId) {
+                        // We switched the cluster, so we need to send the current chunk first
+                        if (currentClusterChunk.length > 0) {
+                            await chunkListener(currentClusterChunk);
+                            currentClusterChunk.length = 0;
+                        }
+                        currentEndpointId = endpointId;
+                        currentClusterId = clusterId;
+                    }
+                    currentClusterChunk.push(data);
+                }
+            }
+            return result;
+        };
 
         for await (const report of this.readDataReports()) {
             if (expectedSubscriptionIds !== undefined) {
@@ -820,24 +923,25 @@ export class IncomingInteractionClientMessenger extends InteractionMessenger {
                 throw new UnexpectedDataError(`Invalid subscription ID ${report.subscriptionId} received`);
             }
 
-            if (!result) {
-                result = report;
-            } else {
-                if (Array.isArray(report.attributeReports)) {
-                    if (!result.attributeReports) {
-                        result.attributeReports = report.attributeReports;
-                    } else {
-                        result.attributeReports.push(...report.attributeReports);
-                    }
-                }
-                if (Array.isArray(report.eventReports)) {
-                    if (!result.eventReports) {
-                        result.eventReports = report.eventReports;
-                    } else {
-                        result.eventReports.push(...report.eventReports);
-                    }
-                }
-            }
+            report.attributeReports = report.attributeReports ?? [];
+            pendingAttributeReports = handleAttributeReportEntries(report.attributeReports, pendingAttributeReports);
+
+            result = await processDecodedReport(DecodedDataReport(report), result);
+        }
+
+        if (pendingAttributeReports?.length && result !== undefined) {
+            result = await processDecodedReport(
+                DecodedDataReport({
+                    interactionModelRevision: result.interactionModelRevision,
+                    attributeReports: pendingAttributeReports,
+                }),
+                result,
+            );
+        }
+
+        if (chunkListener !== undefined && currentClusterChunk.length > 0) {
+            await chunkListener(currentClusterChunk);
+            currentClusterChunk.length = 0;
         }
 
         if (result === undefined) {
@@ -1007,8 +1111,8 @@ export class InteractionClientMessenger extends IncomingInteractionClientMesseng
         await this.send(MessageType.SubscribeRequest, request);
     }
 
-    async readAggregateSubscribeResponse() {
-        const report = await this.readAggregateDataReport();
+    async readAggregateSubscribeResponse(chunkListener?: (chunk: DecodedAttributeReportValue<any>[]) => Promise<void>) {
+        const report = await this.readAggregateDataReport(chunkListener);
         const { subscriptionId } = report;
 
         if (subscriptionId === undefined) {
@@ -1077,15 +1181,23 @@ export class InteractionClientMessenger extends IncomingInteractionClientMesseng
         request: RequestT,
         expectedProcessingTimeMs?: number,
     ): Promise<void> {
-        await this.send(requestMessageType, requestSchema.encode(request), {
-            expectAckOnly: true,
-            expectedProcessingTimeMs,
-            logContext: {
-                invokeFlags: Diagnostic.asFlags({
-                    suppressResponse: true,
-                }),
-            },
-        });
+        try {
+            await this.send(requestMessageType, requestSchema.encode(request), {
+                expectAckOnly: true,
+                expectedProcessingTimeMs,
+                logContext: {
+                    invokeFlags: Diagnostic.asFlags({
+                        suppressResponse: true,
+                    }),
+                },
+            });
+        } catch (e) {
+            // If we got anything other than a standalone ack, we throw when receiving a status response, otherwise we ignore it
+            // Mainly needed because of a Matter-SDK bug where a command response is sent even when suppressResponse is true
+            UnexpectedMessageError.accept(e);
+            const { receivedMessage } = e;
+            this.throwIfErrorStatusMessage(receivedMessage);
+        }
     }
 
     private async request<RequestT, ResponseT>(

package/src/interaction/SubscriptionClient.ts

@@ -5,10 +5,11 @@
  */
 
 import { Environment, Environmental, Logger, MaybePromise, Time, Timer } from "#general";
+import { DecodedDataReport } from "#interaction/DecodedDataReport.js";
 import { MessageExchange } from "#protocol/MessageExchange.js";
 import { ProtocolHandler } from "#protocol/ProtocolHandler.js";
 import { INTERACTION_PROTOCOL_ID } from "#types";
-import { DataReport, IncomingInteractionClientMessenger } from "./InteractionMessenger.js";
+import { IncomingInteractionClientMessenger } from "./InteractionMessenger.js";
 
 const logger = Logger.get("SubscriptionClient");
 
@@ -16,7 +17,7 @@ export interface RegisteredSubscription {
     id: number;
     maximumPeerResponseTimeMs: number;
     maxIntervalS: number;
-    onData: (dataReport: DataReport) => MaybePromise<void>;
+    onData: (dataReport: DecodedDataReport) => MaybePromise<void>;
     onTimeout?: () => void;
 }
 
@@ -28,7 +29,7 @@ export interface RegisteredSubscription {
 export class SubscriptionClient implements ProtocolHandler {
     readonly id = INTERACTION_PROTOCOL_ID;
     readonly requiresSecureSession = true;
-    readonly #listeners = new Map<number, (dataReport: DataReport) => MaybePromise<void>>();
+    readonly #listeners = new Map<number, (dataReport: DecodedDataReport) => MaybePromise<void>>();
     readonly #timeouts = new Map<number, Timer>();
 
     constructor() {}
@@ -80,10 +81,10 @@ export class SubscriptionClient implements ProtocolHandler {
     async onNewExchange(exchange: MessageExchange) {
         const messenger = new IncomingInteractionClientMessenger(exchange);
 
-        let dataReport: DataReport;
+        let dataReport: DecodedDataReport;
         try {
             // TODO Adjust this to getting packages as callback when received to handle error cases and checks outside
-            dataReport = await messenger.readAggregateDataReport([...this.#listeners.keys()]);
+            dataReport = await messenger.readAggregateDataReport(undefined, [...this.#listeners.keys()]);
         } finally {
             messenger.close().catch(error => logger.info("Error closing client messenger", error));
         }

package/src/mdns/MdnsScanner.ts

@@ -1042,8 +1042,7 @@ export class MdnsScanner implements Scanner {
         if (this.#closing) return;
         const message = DnsCodec.decode(messageBytes);
         if (message === undefined) return; // The message cannot be parsed
-        if (message.messageType !== DnsMessageType.Response && message.messageType !== DnsMessageType.TruncatedResponse)
-            return;
+        if (!DnsMessageType.isResponse(message.messageType)) return;
 
         const answers = this.#structureAnswers([...message.answers, ...message.additionalRecords]);
 

package/src/mdns/MdnsServer.ts

@@ -100,8 +100,8 @@ export class MdnsServer {
         const message = DnsCodec.decode(messageBytes);
         if (message === undefined) return; // The message cannot be parsed
         const { transactionId, messageType, queries, answers: knownAnswers } = message;
-        if (messageType !== DnsMessageType.Query && messageType !== DnsMessageType.TruncatedQuery) return;
-        if (queries.length === 0) return; // No queries to answer, can happen in a TruncatedQuery, let's ignore for now
+        if (!DnsMessageType.isQuery(messageType)) return;
+        if (queries.length === 0) return; // TODO correctly handle TruncatedQueries by waiting and combining multiple queries
         for (const portRecords of records.values()) {
             let answers = queries.flatMap(query => this.#queryRecords(query, portRecords));
             if (answers.length === 0) continue;

package/src/peer/PeerAddressStore.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { ReadScope } from "#action/client/ReadScope.js";
 import { Construction, MaybePromise } from "#general";
 import { DecodedAttributeReportValue } from "#interaction/AttributeDataDecoder.js";
 import { AttributeId, ClusterId, EndpointNumber, EventNumber } from "#types";
@@ -27,7 +28,7 @@ export abstract class PeerDataStore {
     abstract maxEventNumber: EventNumber;
     abstract updateLastEventNumber(eventNumber: EventNumber): MaybePromise<void>;
 
-    abstract persistAttributes(attributes: DecodedAttributeReportValue<any>[]): MaybePromise<void>;
+    abstract persistAttributes(attributes: DecodedAttributeReportValue<any>[], scope: ReadScope): MaybePromise<void>;
 
     // TODO: Find a maybe better way to achieve this without functions
     abstract retrieveAttribute(
@@ -41,4 +42,5 @@ export abstract class PeerDataStore {
         filterEndpointId?: EndpointNumber,
         filterClusterId?: ClusterId,
     ): { endpointId: EndpointNumber; clusterId: ClusterId; dataVersion: number }[];
+    abstract cleanupAttributeData(endpointId: EndpointNumber, clusterIds?: ClusterId[]): MaybePromise<void>;
 }

package/src/protocol/ExchangeManager.ts

@@ -327,9 +327,10 @@ export class ExchangeManager {
             return;
         }
         const { session } = exchange;
+        this.#exchanges.delete(exchangeIndex);
         if (NodeSession.is(session) && session.closingAfterExchangeFinished) {
             logger.debug(
-                `Exchange index ${exchangeIndex} Session ${session.name} is already marked for closure. Close session now.`,
+                `Exchange index ${exchangeIndex} on Session ${session.name} is already marked for closure. Close session now.`,
             );
             try {
                 await this.#closeSession(session);
@@ -337,7 +338,6 @@ export class ExchangeManager {
                 logger.error(`Error closing session ${session.name}. Ignoring.`, error);
             }
         }
-        this.#exchanges.delete(exchangeIndex);
     }
 
     async #closeSession(session: NodeSession) {

package/src/protocol/MessageExchange.ts

@@ -200,6 +200,7 @@ export class MessageExchange {
 
         logger.debug(
             "New exchange",
+            isInitiator ? "»" : "«",
             Diagnostic.dict({
                 channel: channel.name,
                 protocol: this.#protocolId,

package/src/session/SessionManager.ts

@@ -21,6 +21,7 @@ import {
     ObserverGroup,
     StorageContext,
     StorageManager,
+    toHex,
 } from "#general";
 import { Subscription } from "#interaction/Subscription.js";
 import { Specification } from "#model";
@@ -76,6 +77,7 @@ type ResumptionStorageRecord = {
     sharedSecret: Uint8Array;
     resumptionId: Uint8Array;
     fabricId: FabricId;
+    fabricIndex: FabricIndex;
     peerNodeId: NodeId;
     sessionParameters: {
         idleIntervalMs: number;
@@ -545,21 +547,21 @@ export class SessionManager {
                 ([
                     address,
                     { sharedSecret, resumptionId, peerNodeId, fabric, sessionParameters, caseAuthenticatedTags },
-                ]) =>
-                    ({
-                        nodeId: address.nodeId,
-                        sharedSecret,
-                        resumptionId,
-                        fabricId: fabric.fabricId,
-                        peerNodeId: peerNodeId,
-                        sessionParameters: {
-                            ...sessionParameters,
-                            supportedTransports: sessionParameters.supportedTransports
-                                ? SupportedTransportsSchema.encode(sessionParameters.supportedTransports)
-                                : undefined,
-                        },
-                        caseAuthenticatedTags,
-                    }) as ResumptionStorageRecord,
+                ]): ResumptionStorageRecord => ({
+                    nodeId: address.nodeId,
+                    sharedSecret,
+                    resumptionId,
+                    fabricId: fabric.fabricId,
+                    fabricIndex: fabric.fabricIndex,
+                    peerNodeId: peerNodeId,
+                    sessionParameters: {
+                        ...sessionParameters,
+                        supportedTransports: sessionParameters.supportedTransports
+                            ? SupportedTransportsSchema.encode(sessionParameters.supportedTransports)
+                            : undefined,
+                    },
+                    caseAuthenticatedTags,
+                }),
             ),
         );
     }
@@ -578,6 +580,7 @@ export class SessionManager {
                 sharedSecret,
                 resumptionId,
                 fabricId,
+                fabricIndex,
                 peerNodeId,
                 sessionParameters: {
                     idleIntervalMs,
@@ -592,19 +595,27 @@ export class SessionManager {
                 } = {},
                 caseAuthenticatedTags,
             }) => {
-                const fabric = this.#context.fabrics.find(fabric => fabric.fabricId === fabricId);
-                logger.info(
-                    "restoring resumption record for node",
-                    nodeId,
-                    "and peer node",
-                    peerNodeId,
-                    "for fabric index",
-                    fabric?.fabricIndex,
+                const fabric = this.#context.fabrics.find(
+                    fabric =>
+                        fabric.fabricId === fabricId &&
+                        // Backward compatibility logic: fabricIndex was added later (0.15.5), so it might be undefined in older records
+                        (fabricIndex === undefined || fabric.fabricIndex === fabricIndex),
                 );
                 if (!fabric) {
-                    logger.error("fabric not found for resumption record", fabricId);
+                    logger.warn(
+                        `Ignoring resumption record for fabric 0x${toHex(fabricId)} and index ${fabricIndex} because we cannot find a matching fabric`,
+                    );
                     return;
                 }
+                logger.info(
+                    "restoring resumption record for node",
+                    fabric.addressOf(nodeId).toString(),
+                    "and peer node",
+                    fabric.addressOf(peerNodeId).toString(),
+                    "for fabric id",
+                    `0x${toHex(fabric.fabricId)}`,
+                    `(0x${toHex(fabric.rootVendorId)}, "${fabric?.label}")`,
+                );
                 this.#resumptionRecords.set(fabric.addressOf(nodeId), {
                     sharedSecret,
                     resumptionId,

package/src/session/pase/PaseServer.ts

@@ -68,7 +68,8 @@ export class PaseServer implements ProtocolHandler {
             // successfully established a session, the Commissionee SHALL NOT accept any more requests for new PASE
             // sessions until session establishment fails or the successfully established PASE session is terminated on
             // the commissioning channel.
-            if (this.sessions.getPaseSession()) {
+            const paseSession = this.sessions.getPaseSession();
+            if (paseSession !== undefined && !paseSession.isClosing) {
                 logger.info("Pase server: Pairing already in progress (PASE session exists), ignoring new exchange.");
             } else if (this.#pairingTimer?.isRunning) {
                 logger.info(