@matter/protocol 0.12.0-alpha.0-20241229-9d9c99934 → 0.12.0-alpha.0-20241231-14ac774ba

package/src/protocol/MessageExchange.ts

@@ -42,6 +42,8 @@ export class UnexpectedMessageError extends MatterError {
     }
 }
 
+export type ExchangeLogContext = Record<string, unknown>;
+
 export type ExchangeSendOptions = {
     /**
      * The response to this send should be an ack only and no StatusResponse or such. If a StatusResponse is returned
@@ -66,6 +68,14 @@ export type ExchangeSendOptions = {
 
     /** Use the provided acknowledge MessageId instead checking the latest to send one */
     includeAcknowledgeMessageId?: number;
+
+    /**
+     * Disables the MRP logic which means that no retransmissions are done and receiving an ack is not awaited.
+     */
+    disableMrpLogic?: boolean;
+
+    /** Additional context information for logging to be included at the beginning of the Message log. */
+    logContext?: ExchangeLogContext;
 };
 
 /**
@@ -214,14 +224,16 @@ export class MessageExchange {
             Diagnostic.dict({
                 channel: channel.name,
                 protocol: this.#protocolId,
-                id: this.#exchangeId,
-                session: session.name,
-                peerSessionId: this.#peerSessionId,
-                "active threshold ms": this.#activeThresholdMs,
-                "active interval ms": this.#activeIntervalMs,
-                "idle interval ms": this.#idleIntervalMs,
-                maxTransmissions: this.#maxTransmissions,
-                useMrp: this.#useMRP,
+                exId: this.#exchangeId,
+                sess: session.name,
+                peerSess: this.#peerSessionId,
+                SAT: this.#activeThresholdMs,
+                SAI: this.#activeIntervalMs,
+                SII: this.#idleIntervalMs,
+                maxTrans: this.#maxTransmissions,
+                exchangeFlags: Diagnostic.asFlags({
+                    MRP: this.#useMRP,
+                }),
             }),
         );
     }
@@ -266,8 +278,8 @@ export class MessageExchange {
         await this.send(SecureMessageType.StandaloneAck, new Uint8Array(0), { includeAcknowledgeMessageId: messageId });
     }
 
-    async onMessageReceived(message: Message, isDuplicate = false) {
-        logger.debug("Message «", MessageCodec.messageDiagnostics(message, isDuplicate));
+    async onMessageReceived(message: Message, duplicate = false) {
+        logger.debug("Message «", MessageCodec.messageDiagnostics(message, { duplicate }));
 
         // Adjust the incoming message when ack was required but this exchange do not use it to skip all relevant logic
         if (message.payloadHeader.requiresAck && !this.#useMRP) {
@@ -289,7 +301,7 @@ export class MessageExchange {
 
         this.session.notifyActivity(true);
 
-        if (isDuplicate) {
+        if (duplicate) {
             // Received a message retransmission but the reply is not ready yet, ignoring
             if (requiresAck) {
                 await this.sendStandaloneAckForMessage(message);
@@ -354,9 +366,11 @@ export class MessageExchange {
 
         const {
             expectAckOnly = false,
+            disableMrpLogic,
             expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME_MS,
             requiresAck,
             includeAcknowledgeMessageId,
+            logContext,
         } = options ?? {};
         if (!this.#useMRP && includeAcknowledgeMessageId !== undefined) {
             throw new InternalError("Cannot include an acknowledge message ID when MRP is not used");
@@ -409,10 +423,10 @@ export class MessageExchange {
         };
 
         let ackPromise: Promise<Message> | undefined;
-        if (this.#useMRP && message.payloadHeader.requiresAck) {
+        if (this.#useMRP && message.payloadHeader.requiresAck && !disableMrpLogic) {
             this.#sentMessageToAck = message;
             this.#retransmissionTimer = Time.getTimer(
-                "Message retransmission",
+                `Message retransmission ${message.packetHeader.messageId}`,
                 this.#getResubmissionBackOffTime(0),
                 () => this.#retransmitMessage(message, expectedProcessingTimeMs),
             );
@@ -422,7 +436,7 @@ export class MessageExchange {
             this.#sentMessageAckFailure = rejecter;
         }
 
-        await this.channel.send(message);
+        await this.channel.send(message, logContext);
 
         if (ackPromise !== undefined) {
             this.#retransmissionCounter = 0;
@@ -441,30 +455,37 @@ export class MessageExchange {
         }
     }
 
-    nextMessage(expectedProcessingTimeMs?: number) {
+    nextMessage(options?: { expectedProcessingTimeMs?: number; timeoutMs?: number }) {
         let timeout: number;
-        switch (this.channel.type) {
-            case "tcp":
-                // TCP uses 30s timeout according to chip sdk implementation, so do the same
-                timeout = 30_000;
-                break;
-            case "udp":
-                // UDP normally uses MRP, if not we have Group communication which normally have no responses
-                if (!this.#useMRP) {
-                    throw new MatterFlowError("No response expected for this message exchange because UDP and no MRP.");
-                }
-                timeout = this.calculateMaximumPeerResponseTime(expectedProcessingTimeMs);
-                break;
-            case "ble":
-                // chip sdk uses BTP_ACK_TIMEOUT_MS which is wrong in my eyes, so we use static 30s as like TCP here
-                timeout = 30_000;
-                break;
-            default:
-                throw new MatterFlowError(
-                    `Can not calculate expected timeout for unknown channel type: ${this.channel.type}`,
-                );
+        if (options?.timeoutMs !== undefined) {
+            timeout = options.timeoutMs;
+        } else {
+            switch (this.channel.type) {
+                case "tcp":
+                    // TCP uses 30s timeout according to chip sdk implementation, so do the same
+                    timeout = 30_000;
+                    break;
+                case "udp":
+                    // UDP normally uses MRP, if not we have Group communication which normally have no responses
+                    if (!this.#useMRP) {
+                        throw new MatterFlowError(
+                            "No response expected for this message exchange because UDP and no MRP.",
+                        );
+                    }
+                    const { expectedProcessingTimeMs } = options ?? {};
+                    timeout = this.calculateMaximumPeerResponseTime(expectedProcessingTimeMs);
+                    break;
+                case "ble":
+                    // chip sdk uses BTP_ACK_TIMEOUT_MS which is wrong in my eyes, so we use static 30s as like TCP here
+                    timeout = 30_000;
+                    break;
+                default:
+                    throw new MatterFlowError(
+                        `Can not calculate expected timeout for unknown channel type: ${this.channel.type}`,
+                    );
+            }
+            timeout += PEER_RESPONSE_TIME_BUFFER_MS;
         }
-        timeout += PEER_RESPONSE_TIME_BUFFER_MS;
         return this.#messagesQueue.read(timeout);
     }
 
@@ -517,10 +538,10 @@ export class MessageExchange {
                 if (finalWaitTime > 0) {
                     this.#retransmissionCounter--; // We will not resubmit the message again
                     logger.debug(
-                        `Wait additional ${finalWaitTime}ms for processing time and peer resubmissions after all our resubmissions`,
+                        `Message ${message.packetHeader.messageId}: Wait additional ${finalWaitTime}ms for processing time and peer resubmissions after all our resubmissions`,
                     );
                     this.#retransmissionTimer = Time.getTimer(
-                        "Message wait time after resubmissions",
+                        `Message wait time after resubmissions ${message.packetHeader.messageId}`,
                         finalWaitTime,
                         () => this.#retransmitMessage(message),
                     ).start();

package/src/securechannel/SecureChannelMessenger.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { MatterError, UnexpectedDataError } from "#general";
+import { Diagnostic, MatterError, UnexpectedDataError } from "#general";
 import {
     GeneralStatusCode,
     ProtocolStatusCode,
@@ -43,17 +43,35 @@ export class SecureChannelMessenger {
         this.#defaultExpectedProcessingTimeMs = defaultExpectedProcessingTimeMs;
     }
 
+    async nextMessage(
+        expectedMessageType: number,
+        expectedProcessingTimeMs = this.#defaultExpectedProcessingTimeMs,
+        expectedMessageInfo?: string,
+    ) {
+        return this.#nextMessage(expectedMessageType, expectedProcessingTimeMs, expectedMessageInfo);
+    }
+
+    async anyNextMessage(
+        expectedMessageInfo: string,
+        expectedProcessingTimeMs = this.#defaultExpectedProcessingTimeMs,
+    ) {
+        return this.#nextMessage(undefined, expectedProcessingTimeMs, expectedMessageInfo);
+    }
+
     /**
      * Waits for the next message and returns it.
      * When no expectedProcessingTimeMs is provided, the default value of EXPECTED_CRYPTO_PROCESSING_TIME_MS is used.
      */
-    async nextMessage(
-        expectedMessageInfo: string,
+    async #nextMessage(
         expectedMessageType?: number,
         expectedProcessingTimeMs = this.#defaultExpectedProcessingTimeMs,
+        expectedMessageInfo?: string,
     ) {
-        const message = await this.exchange.nextMessage(expectedProcessingTimeMs);
+        const message = await this.exchange.nextMessage({ expectedProcessingTimeMs });
         const messageType = message.payloadHeader.messageType;
+        if (expectedMessageType !== undefined && expectedMessageInfo === undefined) {
+            expectedMessageInfo = SecureMessageType[expectedMessageType];
+        }
         this.throwIfErrorStatusReport(message, expectedMessageInfo);
         if (expectedMessageType !== undefined && messageType !== expectedMessageType)
             throw new UnexpectedDataError(
@@ -69,12 +87,9 @@ export class SecureChannelMessenger {
     async nextMessageDecoded<T>(
         expectedMessageType: number,
         schema: TlvSchema<T>,
-        expectedMessageInfo: string,
         expectedProcessingTimeMs = this.#defaultExpectedProcessingTimeMs,
     ) {
-        return schema.decode(
-            (await this.nextMessage(expectedMessageInfo, expectedMessageType, expectedProcessingTimeMs)).payload,
-        );
+        return schema.decode((await this.nextMessage(expectedMessageType, expectedProcessingTimeMs)).payload);
     }
 
     /**
@@ -86,7 +101,7 @@ export class SecureChannelMessenger {
         expectedProcessingTimeMs = this.#defaultExpectedProcessingTimeMs,
     ) {
         // If the status is not Success, this would throw an Error.
-        await this.nextMessage(expectedMessageInfo, SecureMessageType.StatusReport, expectedProcessingTimeMs);
+        await this.nextMessage(SecureMessageType.StatusReport, expectedProcessingTimeMs, expectedMessageInfo);
     }
 
     /**
@@ -136,7 +151,13 @@ export class SecureChannelMessenger {
                 protocolId: SECURE_CHANNEL_PROTOCOL_ID,
                 protocolStatus,
             }),
-            { requiresAck },
+            {
+                requiresAck,
+                logContext: {
+                    generalStatus: GeneralStatusCode[generalStatus] ?? Diagnostic.hex(generalStatus),
+                    protocolStatus: ProtocolStatusCode[protocolStatus] ?? Diagnostic.hex(protocolStatus),
+                },
+            },
         );
     }
 

package/src/session/SecureSession.ts

@@ -156,16 +156,23 @@ export class SecureSession extends Session {
         logger.debug(
             `Created secure ${this.isPase ? "PASE" : "CASE"} session for fabric index ${fabric?.fabricIndex}`,
             this.name,
-            Diagnostic.dict({
-                idleIntervalMs: this.idleIntervalMs,
-                activeIntervalMs: this.activeIntervalMs,
-                activeThresholdMs: this.activeThresholdMs,
-                dataModelRevision: this.dataModelRevision,
-                interactionModelRevision: this.interactionModelRevision,
-                specificationVersion: this.specificationVersion,
-                maxPathsPerInvoke: this.maxPathsPerInvoke,
-                caseAuthenticatedTags: this.#caseAuthenticatedTags,
-            }),
+            this.parameterDiagnostics(),
+        );
+    }
+
+    parameterDiagnostics() {
+        return Diagnostic.dict(
+            {
+                SII: this.idleIntervalMs,
+                SAI: this.activeIntervalMs,
+                SAT: this.activeThresholdMs,
+                DMRev: this.dataModelRevision,
+                IMRev: this.interactionModelRevision,
+                spec: Diagnostic.hex(this.specificationVersion),
+                maxPaths: this.maxPathsPerInvoke,
+                CATs: this.#caseAuthenticatedTags,
+            },
+            true,
         );
     }
 

package/src/session/SessionManager.ts

@@ -14,6 +14,7 @@ import {
     Environmental,
     Lifecycle,
     Logger,
+    MatterAggregateError,
     MatterFlowError,
     Mutex,
     Observable,
@@ -533,13 +534,16 @@ export class SessionManager {
 
         this.#observers.close();
         await this.#storeResumptionRecords();
-        for (const session of this.#sessions) {
+        const closePromises = this.#sessions.map(async session => {
             await session?.end(false);
             this.#sessions.delete(session);
-        }
+        });
         for (const session of this.#insecureSessions.values()) {
-            await session?.end();
+            closePromises.push(session?.end());
         }
+        await MatterAggregateError.allSettled(closePromises, "Error closing sessions").catch(error =>
+            logger.error(error),
+        );
     }
 
     async clear() {
@@ -558,7 +562,9 @@ export class SessionManager {
         });
     }
 
+    /** Clears all subscriptions for a given node and returns how many were cleared. */
     async clearSubscriptionsForNode(fabricIndex: FabricIndex, nodeId: NodeId, flushSubscriptions?: boolean) {
+        let clearedCount = 0;
         for (const session of this.#sessions) {
             if (session.fabric?.fabricIndex !== fabricIndex) {
                 continue;
@@ -567,7 +573,9 @@ export class SessionManager {
                 continue;
             }
             await session.clearSubscriptions(flushSubscriptions);
+            clearedCount++;
         }
+        return clearedCount;
     }
 }
 

package/src/session/case/CaseClient.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Bytes, Crypto, Diagnostic, Logger, PublicKey, UnexpectedDataError } from "#general";
+import { Bytes, Crypto, Logger, PublicKey, UnexpectedDataError } from "#general";
 import { SessionManager } from "#session/SessionManager.js";
 import { NodeId } from "#types";
 import { TlvIntermediateCertificate, TlvOperationalCertificate } from "../../certificate/CertificateManager.js";
@@ -106,8 +106,8 @@ export class CaseClient {
             });
             await messenger.sendSuccess();
             logger.info(
-                `Case client: session resumed with ${messenger.getChannelName()} and parameters`,
-                Diagnostic.dict(secureSession.parameters),
+                `Case client: Session resumed with ${messenger.getChannelName()} and parameters`,
+                secureSession.parameterDiagnostics(),
             );
 
             resumptionRecord.resumptionId = resumptionId; /* update resumptionId */
@@ -196,7 +196,7 @@ export class CaseClient {
             const encryptedData = TlvEncryptedDataSigma3.encode({ nodeOpCert, intermediateCACert, signature });
             const encrypted = Crypto.encrypt(sigma3Key, encryptedData, TBE_DATA3_NONCE);
             const sigma3Bytes = await messenger.sendSigma3({ encrypted });
-            await messenger.waitForSuccess("Success after CASE Sigma3");
+            await messenger.waitForSuccess("Sigma3-Success");
 
             // All good! Create secure session
             const secureSessionSalt = Bytes.concat(
@@ -216,7 +216,7 @@ export class CaseClient {
             });
             logger.info(
                 `Case client: Paired successfully with ${messenger.getChannelName()} and parameters`,
-                Diagnostic.dict(secureSession.parameters),
+                secureSession.parameterDiagnostics(),
             );
             resumptionRecord = {
                 fabric,

package/src/session/case/CaseMessenger.ts

@@ -11,7 +11,7 @@ import { TlvCaseSigma1, TlvCaseSigma2, TlvCaseSigma2Resume, TlvCaseSigma3 } from
 
 export class CaseServerMessenger extends SecureChannelMessenger {
     async readSigma1() {
-        const { payload } = await this.nextMessage("CASE Sigma1", SecureMessageType.Sigma1);
+        const { payload } = await this.nextMessage(SecureMessageType.Sigma1);
         return { sigma1Bytes: payload, sigma1: TlvCaseSigma1.decode(payload) };
     }
 
@@ -24,7 +24,7 @@ export class CaseServerMessenger extends SecureChannelMessenger {
     }
 
     async readSigma3() {
-        const { payload } = await this.nextMessage("CASE Sigma3", SecureMessageType.Sigma3);
+        const { payload } = await this.nextMessage(SecureMessageType.Sigma3);
         return { sigma3Bytes: payload, sigma3: TlvCaseSigma3.decode(payload) };
     }
 }
@@ -38,7 +38,7 @@ export class CaseClientMessenger extends SecureChannelMessenger {
         const {
             payload,
             payloadHeader: { messageType },
-        } = await this.nextMessage("CASE Sigma2 or Sigma2Resume");
+        } = await this.anyNextMessage("Sigma2(Resume)");
         switch (messageType) {
             case SecureMessageType.Sigma2:
                 return { sigma2Bytes: payload, sigma2: TlvCaseSigma2.decode(payload) };

package/src/session/case/CaseServer.ts

@@ -130,7 +130,7 @@ export class CaseServer implements ProtocolHandler {
             }
 
             logger.info(
-                `session ${secureSession.id} resumed with ${messenger.getChannelName()} for Fabric ${NodeId.toHexString(
+                `Session ${secureSession.id} resumed with ${messenger.getChannelName()} for Fabric ${NodeId.toHexString(
                     fabric.nodeId,
                 )}(index ${fabric.fabricIndex}) and PeerNode ${NodeId.toHexString(peerNodeId)}`,
                 "with CATs",
@@ -139,7 +139,7 @@ export class CaseServer implements ProtocolHandler {
             resumptionRecord.resumptionId = resumptionId; /* Update the ID */
 
             // Wait for success on the peer side
-            await messenger.waitForSuccess("Success after CASE Sigma2Resume");
+            await messenger.waitForSuccess("Sigma2Resume-Success");
 
             await messenger.close();
             await this.#sessions.saveResumptionRecord(resumptionRecord);

package/src/session/pase/PaseClient.ts

@@ -80,7 +80,7 @@ export class PaseClient {
         await messenger.sendPasePake3({ verifier: hAY });
 
         // All good! Creating the secure session
-        await messenger.waitForSuccess("Success after PASE Pake3");
+        await messenger.waitForSuccess("PasePake3-Success");
         const secureSession = await this.#sessions.createSecureSession({
             sessionId: initiatorSessionId,
             fabric: undefined,

package/src/session/pase/PaseMessenger.ts

@@ -30,7 +30,6 @@ type PasePake3 = TypeFromSchema<typeof TlvPasePake3>;
 export class PaseServerMessenger extends SecureChannelMessenger {
     async readPbkdfParamRequest() {
         const { payload } = await this.nextMessage(
-            "PASE PbkdfParamRequest",
             SecureMessageType.PbkdfParamRequest,
             DEFAULT_NORMAL_PROCESSING_TIME_MS,
         );
@@ -44,7 +43,7 @@ export class PaseServerMessenger extends SecureChannelMessenger {
     }
 
     readPasePake1() {
-        return this.nextMessageDecoded(SecureMessageType.PasePake1, TlvPasePake1, "PASE Pake1");
+        return this.nextMessageDecoded(SecureMessageType.PasePake1, TlvPasePake1);
     }
 
     sendPasePake2(pasePake2: PasePake2) {
@@ -52,7 +51,7 @@ export class PaseServerMessenger extends SecureChannelMessenger {
     }
 
     readPasePake3() {
-        return this.nextMessageDecoded(SecureMessageType.PasePake3, TlvPasePake3, "PASE Pake3");
+        return this.nextMessageDecoded(SecureMessageType.PasePake3, TlvPasePake3);
     }
 }
 
@@ -65,7 +64,6 @@ export class PaseClientMessenger extends SecureChannelMessenger {
 
     async readPbkdfParamResponse() {
         const { payload } = await this.nextMessage(
-            "PASE PbkdfParamResponse",
             SecureMessageType.PbkdfParamResponse,
             DEFAULT_NORMAL_PROCESSING_TIME_MS,
         );
@@ -77,7 +75,7 @@ export class PaseClientMessenger extends SecureChannelMessenger {
     }
 
     readPasePake2() {
-        return this.nextMessageDecoded(SecureMessageType.PasePake2, TlvPasePake2, "PASE Pake2");
+        return this.nextMessageDecoded(SecureMessageType.PasePake2, TlvPasePake2);
     }
 
     sendPasePake3(pasePake3: PasePake3) {