@matter/protocol 0.16.0-alpha.0-20250809-ee8375bcb → 0.16.0-alpha.0-20250812-285b75d83

package/src/mdns/MdnsServer.ts

@@ -6,100 +6,68 @@
 
 import {
     AsyncCache,
-    Diagnostic,
-    DnsCodec,
-    DnsMessage,
-    DnsMessagePartiallyPreEncoded,
     DnsMessageType,
     DnsRecord,
     DnsRecordType,
     isDeepEqual,
     Logger,
     MatterAggregateError,
-    MAX_MDNS_MESSAGE_SIZE,
-    Network,
+    NetworkInterfaceDetails,
+    ObserverGroup,
     Time,
-    UdpMulticastServer,
 } from "#general";
+import { MdnsSocket } from "./MdnsSocket.js";
 
 const logger = Logger.get("MdnsServer");
 
-export const MDNS_BROADCAST_IPV4 = "224.0.0.251";
-export const MDNS_BROADCAST_IPV6 = "ff02::fb";
-export const MDNS_BROADCAST_PORT = 5353;
-
-export enum AnnouncementType {
-    Commissionable,
-    Operative,
-}
-
 export class MdnsServer {
-    static async create(network: Network, options?: { enableIpv4?: boolean; netInterface?: string }) {
-        const { enableIpv4 = true, netInterface } = options ?? {};
-        return new MdnsServer(
-            network,
-            await UdpMulticastServer.create({
-                network,
-                netInterface,
-                broadcastAddressIpv4: enableIpv4 ? MDNS_BROADCAST_IPV4 : undefined,
-                broadcastAddressIpv6: MDNS_BROADCAST_IPV6,
-                listeningPort: MDNS_BROADCAST_PORT,
-            }),
-            netInterface,
-        );
-    }
-
-    #recordsGenerator = new Map<string, (netInterface: string) => Promise<DnsRecord<any>[]>>();
+    #observers = new ObserverGroup();
+    #recordsGenerator = new Map<string, MdnsServer.RecordGenerator>();
     readonly #records = new AsyncCache<Map<string, DnsRecord<any>[]>>(
         "MDNS discovery",
         async (multicastInterface: string) => {
-            const portTypeMap = new Map<string, DnsRecord<any>[]>();
-            for (const [announceTypePort, generator] of this.#recordsGenerator) {
-                portTypeMap.set(announceTypePort, await generator(multicastInterface));
+            const serviceRecords = new Map<string, DnsRecord<any>[]>();
+            const addrs = await this.network.getIpMac(multicastInterface);
+            if (addrs === undefined) {
+                return serviceRecords;
             }
-            return portTypeMap;
+
+            for (const [service, generator] of this.#recordsGenerator) {
+                serviceRecords.set(service, generator(multicastInterface, addrs));
+            }
+
+            return serviceRecords;
         },
         15 * 60 * 1000 /* 15mn - also matches maximum commissioning window time. */,
     );
     readonly #recordLastSentAsMulticastAnswer = new Map<string, number>();
-    readonly #recordLastSentAsUnicastAnswer = new Map<string, number>();
 
-    readonly #network: Network;
-    readonly #multicastServer: UdpMulticastServer;
-    readonly #netInterface: string | undefined;
+    readonly #socket: MdnsSocket;
 
-    constructor(network: Network, multicastServer: UdpMulticastServer, netInterface: string | undefined) {
-        multicastServer.onMessage(
-            (message, remoteIp, netInterface) => void this.#handleDnsMessage(message, remoteIp, netInterface),
-        );
-        this.#network = network;
-        this.#multicastServer = multicastServer;
-        this.#netInterface = netInterface;
+    constructor(socket: MdnsSocket) {
+        this.#socket = socket;
+        this.#observers.on(this.#socket.receipt, this.#handleMessage.bind(this));
     }
 
-    buildDnsRecordKey(record: DnsRecord<any>, netInterface?: string, unicastTarget?: string) {
-        return `${record.name}-${record.recordClass}-${record.recordType}-${netInterface}-${unicastTarget}`;
+    get network() {
+        return this.#socket.network;
     }
 
-    buildTypePortKey(type: AnnouncementType, port: number) {
-        return `${port}-${type}`;
+    get supportsIpv4() {
+        return this.#socket.supportsIpv4;
     }
 
-    isKeyForPort(key: string, port: number) {
-        return key.startsWith(`${port}-`);
+    buildDnsRecordKey(record: DnsRecord<any>, netInterface?: string, unicastTarget?: string) {
+        return `${record.name}-${record.recordClass}-${record.recordType}-${netInterface}-${unicastTarget}`;
     }
 
-    async #handleDnsMessage(messageBytes: Uint8Array, remoteIp: string, netInterface: string) {
-        // This message was on a subnet not supported by this device
-        if (netInterface === undefined) return;
-        const records = await this.#records.get(netInterface);
+    async #handleMessage(message: MdnsSocket.Message) {
+        const records = await this.#records.get(message.sourceIntf);
 
-        // No need to process the DNS message if there are no records to serve
+        // Ignore if we have no records for interface
         if (records.size === 0) return;
 
-        const message = DnsCodec.decode(messageBytes);
-        if (message === undefined) return; // The message cannot be parsed
-        const { transactionId, messageType, queries, answers: knownAnswers } = message;
+        const { sourceIntf, sourceIp, 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
         for (const portRecords of records.values()) {
@@ -132,54 +100,41 @@ export class MdnsServer {
             let uniCastResponse = queries.filter(query => !query.uniCastResponse).length === 0;
             const answersTimeSinceLastSent = answers.map(answer => ({
                 timeSinceLastMultiCast:
-                    now -
-                    (this.#recordLastSentAsMulticastAnswer.get(this.buildDnsRecordKey(answer, netInterface)) ?? 0),
-                timeSinceLastUniCast:
-                    now -
-                    (this.#recordLastSentAsUnicastAnswer.get(this.buildDnsRecordKey(answer, netInterface, remoteIp)) ??
-                        0),
-                ttl: answer.ttl,
+                    now - (this.#recordLastSentAsMulticastAnswer.get(this.buildDnsRecordKey(answer, sourceIntf)) ?? 0),
+                ttl: answer.ttl * 1000,
             }));
             if (
                 uniCastResponse &&
-                answersTimeSinceLastSent.some(
-                    ({ timeSinceLastMultiCast, ttl }) => timeSinceLastMultiCast > (ttl / 4) * 1000,
-                )
+                answersTimeSinceLastSent.some(({ timeSinceLastMultiCast, ttl }) => timeSinceLastMultiCast > ttl / 4)
             ) {
                 // If the query is for unicast response, still send as multicast if they were last sent as multicast longer then 1/4 of their ttl
                 uniCastResponse = false;
             }
             if (!uniCastResponse) {
-                answers = answers.filter((_, index) => answersTimeSinceLastSent[index].timeSinceLastMultiCast > 1000);
-                if (answers.length === 0) continue; // Nothing to send
-
-                answers.forEach(answer =>
-                    this.#recordLastSentAsMulticastAnswer.set(this.buildDnsRecordKey(answer, netInterface), now),
+                answers = answers.filter(
+                    (_, index) => answersTimeSinceLastSent[index].timeSinceLastMultiCast >= 900, // The last time sent as multicast was more than 900 ms ago
                 );
-            } else {
-                answers = answers.filter((_, index) => answersTimeSinceLastSent[index].timeSinceLastUniCast > 1000);
                 if (answers.length === 0) continue; // Nothing to send
 
                 answers.forEach(answer =>
-                    this.#recordLastSentAsUnicastAnswer.set(
-                        this.buildDnsRecordKey(answer, netInterface, remoteIp),
-                        now,
-                    ),
+                    this.#recordLastSentAsMulticastAnswer.set(this.buildDnsRecordKey(answer, sourceIntf), now),
                 );
             }
 
-            this.#sendRecords(
-                {
-                    messageType: DnsMessageType.Response,
-                    transactionId,
-                    answers,
-                    additionalRecords,
-                },
-                netInterface,
-                uniCastResponse ? remoteIp : undefined,
-            ).catch(error => {
-                logger.warn(`Failed to send mDNS response to ${remoteIp}`, error);
-            });
+            this.#socket
+                .send(
+                    {
+                        messageType: DnsMessageType.Response,
+                        transactionId,
+                        answers,
+                        additionalRecords,
+                    },
+                    sourceIntf,
+                    uniCastResponse ? sourceIp : undefined,
+                )
+                .catch(error => {
+                    logger.warn(`Failed to send mDNS response to ${sourceIp}`, error);
+                });
             await Time.sleep("MDNS delay", 20 + Math.floor(Math.random() * 100)); // as per DNS-SD spec wait 20-120ms before sending more packets
         }
     }
@@ -188,7 +143,7 @@ export class MdnsServer {
         const answers = records.filter(({ recordType }) => recordType === DnsRecordType.PTR);
         const additionalRecords = records.filter(({ recordType }) => recordType !== DnsRecordType.PTR);
 
-        await this.#sendRecords(
+        await this.#socket.send(
             {
                 messageType: DnsMessageType.Response,
                 answers,
@@ -198,150 +153,67 @@ export class MdnsServer {
         );
     }
 
-    async #sendRecords(dnsMessageData: Partial<DnsMessage>, netInterface: string, unicastTarget?: string) {
-        const { answers = [], additionalRecords = [] } = dnsMessageData;
-        const answersToSend = [...answers];
-        const additionalRecordsToSend = [...additionalRecords];
-
-        const dnsMessageDataToSend = {
-            ...dnsMessageData,
-            answers: [],
-            additionalRecords: [],
-        } as DnsMessagePartiallyPreEncoded;
-
-        const emptyDnsMessage = DnsCodec.encode(dnsMessageDataToSend);
-        let dnsMessageSize = emptyDnsMessage.length;
-
-        while (true) {
-            if (answersToSend.length > 0) {
-                const nextAnswer = answersToSend.shift();
-                if (nextAnswer === undefined) {
-                    break;
-                }
-
-                const nextAnswerEncoded = DnsCodec.encodeRecord(nextAnswer);
-                dnsMessageSize += nextAnswerEncoded.length; // Add additional record as long as size is ok
-
-                if (dnsMessageSize > MAX_MDNS_MESSAGE_SIZE) {
-                    // New answer do not fit anymore, send out the message
-                    await this.#multicastServer.send(
-                        DnsCodec.encode(dnsMessageDataToSend),
-                        netInterface,
-                        unicastTarget,
-                    );
-
-                    // Reset the message, length counter and included answers to count for next message
-                    dnsMessageDataToSend.answers.length = 0;
-                    dnsMessageSize = emptyDnsMessage.length + nextAnswerEncoded.length;
-                }
-                dnsMessageDataToSend.answers.push(nextAnswerEncoded);
-            } else {
-                break;
-            }
-        }
-
-        for (const additionalRecord of additionalRecordsToSend) {
-            const additionalRecordEncoded = DnsCodec.encodeRecord(additionalRecord);
-            dnsMessageSize += additionalRecordEncoded.length; // Add additional record as long as size is ok
-            if (dnsMessageSize > MAX_MDNS_MESSAGE_SIZE) {
-                break;
-            }
-            dnsMessageDataToSend.additionalRecords.push(additionalRecordEncoded);
-        }
-
-        await this.#multicastServer.send(DnsCodec.encode(dnsMessageDataToSend), netInterface, unicastTarget);
-    }
-
-    async announce(announcedNetPort?: number) {
+    async broadcast(...services: string[]) {
         await MatterAggregateError.allSettled(
             (await this.#getMulticastInterfacesForAnnounce()).map(async ({ name: netInterface }) => {
                 const records = await this.#records.get(netInterface);
-                for (const [portType, portTypeRecords] of records) {
-                    if (announcedNetPort !== undefined && !this.isKeyForPort(portType, announcedNetPort)) continue;
+                for (const [service, serviceRecords] of records) {
+                    if (services.length && !services.includes(service)) continue;
 
                     // TODO: try to combine the messages to avoid sending multiple messages but keep under 1500 bytes per message
-                    await this.#announceRecordsForInterface(netInterface, portTypeRecords);
+                    await this.#announceRecordsForInterface(netInterface, serviceRecords);
                     await Time.sleep("MDNS delay", 20 + Math.floor(Math.random() * 100)); // as per DNS-SD spec wait 20-120ms before sending more packets
                 }
             }),
-            "Error happened when announcing MDNS messages",
+            "Error announcing MDNS messages",
         ).catch(error => logger.error(error));
     }
 
-    async expireAnnouncements(options?: { announcedNetPort?: number; type?: AnnouncementType; forInstance?: string }) {
-        const { announcedNetPort, type, forInstance: instanceToExpire } = options ?? {};
+    async expireAnnouncements(...services: string[]) {
         await MatterAggregateError.allSettled(
             this.#records.keys().map(async netInterface => {
                 const records = await this.#records.get(netInterface);
-                for (const [portType, portTypeRecords] of records) {
-                    if (announcedNetPort !== undefined && !this.isKeyForPort(portType, announcedNetPort)) continue;
-                    if (
-                        announcedNetPort !== undefined &&
-                        type !== undefined &&
-                        portType !== this.buildTypePortKey(type, announcedNetPort)
-                    )
-                        continue;
-                    const recordsToProcess =
-                        instanceToExpire !== undefined
-                            ? portTypeRecords.filter(
-                                  ({ forInstance }) => forInstance !== undefined && instanceToExpire === forInstance,
-                              )
-                            : portTypeRecords;
+                for (const [service, serviceRecords] of records) {
+                    if (services.length && !services.includes(service)) continue;
                     const instanceSet = new Set<string>();
-                    recordsToProcess.forEach(record => {
+                    serviceRecords.forEach(record => {
                         record.ttl = 0;
                         if (record.recordType === DnsRecordType.TXT) {
                             instanceSet.add(record.name);
                         }
                     });
-                    const instanceName =
-                        instanceSet.size > 1
-                            ? "multiple"
-                            : instanceSet.size === 1
-                              ? Array.from(instanceSet.values())[0]
-                              : "";
-                    logger.debug(
-                        `Expiring records`,
-                        Diagnostic.dict({
-                            instanceName,
-                            port: announcedNetPort,
-                            netInterface,
-                        }),
-                    );
 
                     // TODO: try to combine the messages to avoid sending multiple messages but keep under 1500 bytes per message
-                    await this.#announceRecordsForInterface(netInterface, portTypeRecords);
-                    this.#recordsGenerator.delete(portType);
+                    await this.#announceRecordsForInterface(netInterface, serviceRecords);
+                    this.#recordsGenerator.delete(service);
                     await Time.sleep("MDNS delay", 20 + Math.floor(Math.random() * 100)); // as per DNS-SD spec wait 20-120ms before sending more packets
                 }
             }),
             "Error happened when expiring MDNS announcements",
         ).catch(error => logger.error(error));
+        await this.#resetServices();
+    }
+
+    async setRecordsGenerator(service: string, generator: MdnsServer.RecordGenerator) {
         await this.#records.clear();
         this.#recordLastSentAsMulticastAnswer.clear();
-        this.#recordLastSentAsUnicastAnswer.clear();
+        this.#recordsGenerator.set(service, generator);
     }
 
-    async setRecordsGenerator(
-        hostPort: number,
-        type: AnnouncementType,
-        generator: (netInterface: string) => Promise<DnsRecord<any>[]>,
-    ) {
+    async #resetServices() {
         await this.#records.clear();
         this.#recordLastSentAsMulticastAnswer.clear();
-        this.#recordLastSentAsUnicastAnswer.clear();
-        this.#recordsGenerator.set(this.buildTypePortKey(type, hostPort), generator);
     }
 
     async close() {
+        this.#observers.close();
         await this.#records.close();
         this.#recordLastSentAsMulticastAnswer.clear();
-        this.#recordLastSentAsUnicastAnswer.clear();
-        await this.#multicastServer.close();
     }
 
     #getMulticastInterfacesForAnnounce() {
-        return this.#netInterface === undefined ? this.#network.getNetInterfaces() : [{ name: this.#netInterface }];
+        const { netInterface } = this.#socket;
+        return netInterface === undefined ? this.network.getNetInterfaces() : [{ name: netInterface }];
     }
 
     #queryRecords({ name, recordType }: { name: string; recordType: DnsRecordType }, records: DnsRecord<any>[]) {
@@ -352,3 +224,9 @@ export class MdnsServer {
         }
     }
 }
+
+export namespace MdnsServer {
+    export interface RecordGenerator {
+        (intf: string, addrs: NetworkInterfaceDetails): DnsRecord[];
+    }
+}

package/src/mdns/MdnsService.ts

@@ -6,7 +6,6 @@
 
 import {
     Construction,
-    Crypto,
     Diagnostic,
     Environment,
     Environmental,
@@ -16,14 +15,16 @@ import {
     Network,
     VariableService,
 } from "#general";
-import { MdnsBroadcaster } from "../mdns/MdnsBroadcaster.js";
-import { MdnsScanner } from "../mdns/MdnsScanner.js";
+import { MdnsServer } from "../mdns/MdnsServer.js";
+import { MdnsClient } from "./MdnsClient.js";
+import { MdnsSocket } from "./MdnsSocket.js";
 
 const logger = Logger.get("MDNS");
 
 export class MdnsService {
-    #broadcaster?: MdnsBroadcaster;
-    #scanner?: MdnsScanner;
+    #socket?: MdnsSocket;
+    #server?: MdnsServer;
+    #client?: MdnsClient;
     #env: Environment;
     readonly #construction: Construction<MdnsService>;
     readonly #enableIpv4: boolean;
@@ -35,6 +36,7 @@ export class MdnsService {
 
     constructor(environment: Environment, options?: MdnsService.Options) {
         this.#env = environment;
+        const network = environment.get(Network);
         const rootEnvironment = environment.root;
         rootEnvironment.set(MdnsService, this);
         rootEnvironment.runtime.add(this);
@@ -44,18 +46,13 @@ export class MdnsService {
         this.limitedToNetInterface = vars.get("mdns.networkInterface", options?.networkInterface);
 
         this.#construction = Construction(this, async () => {
-            const crypto = environment.get(Crypto);
-            const network = environment.get(Network);
-
-            this.#broadcaster = await MdnsBroadcaster.create(crypto, network, {
-                enableIpv4: this.enableIpv4,
-                multicastInterface: this.limitedToNetInterface,
-            });
-
-            this.#scanner = await MdnsScanner.create(network, {
+            this.#socket = await MdnsSocket.create(network, {
                 enableIpv4: this.enableIpv4,
                 netInterface: this.limitedToNetInterface,
             });
+
+            this.#server = new MdnsServer(this.#socket);
+            this.#client = new MdnsClient(this.#socket);
         });
     }
 
@@ -63,16 +60,12 @@ export class MdnsService {
         return new this(environment);
     }
 
-    createInstanceBroadcaster(port: number) {
-        return this.broadcaster.createInstanceBroadcaster(port);
-    }
-
-    get broadcaster() {
-        return this.#construction.assert("MDNS service", this.#broadcaster);
+    get server() {
+        return this.#construction.assert("MDNS service", this.#server);
     }
 
-    get scanner() {
-        return this.#construction.assert("MDNS service", this.#scanner);
+    get client() {
+        return this.#construction.assert("MDNS service", this.#client);
     }
 
     get [Diagnostic.value]() {
@@ -87,12 +80,12 @@ export class MdnsService {
         this.#env.delete(MdnsService, this);
 
         await this.#construction.close(async () => {
-            const broadcasterDisposal = MaybePromise.then(this.#broadcaster?.close(), undefined, e =>
-                logger.error("Error disposing of MDNS broadcaster", e),
+            const broadcasterDisposal = MaybePromise.then(this.#server?.close(), undefined, e =>
+                logger.error("Error disposing of MDNS server", e),
             );
 
-            const scannerDisposal = MaybePromise.then(this.#scanner?.close(), undefined, e =>
-                logger.error("Error disposing of MDNS scanner", e),
+            const scannerDisposal = MaybePromise.then(this.#client?.close(), undefined, e =>
+                logger.error("Error disposing of MDNS client", e),
             );
 
             await MatterAggregateError.allSettled(
@@ -100,7 +93,11 @@ export class MdnsService {
                 "Error disposing MDNS services",
             ).catch(error => logger.error(error));
 
-            this.#broadcaster = this.#scanner = undefined;
+            if (this.#socket) {
+                await this.#socket?.close();
+            }
+
+            this.#server = this.#client = undefined;
         });
     }
 }

package/src/mdns/MdnsSocket.ts

@@ -0,0 +1,179 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+    BasicObservable,
+    Diagnostic,
+    DnsCodec,
+    DnsMessage,
+    DnsMessagePartiallyPreEncoded,
+    DnsMessageType,
+    Logger,
+    MatterAggregateError,
+    MAX_MDNS_MESSAGE_SIZE,
+    MaybePromise,
+    Network,
+    UdpMulticastServer,
+} from "#general";
+import { MDNS_BROADCAST_IPV4, MDNS_BROADCAST_IPV6, MDNS_BROADCAST_PORT } from "./MdnsConsts.js";
+
+const logger = Logger.get("MdnsListener");
+
+/**
+ * Manages the UDP socket for {@link MdnsServer} and {@link MdnsClient}.
+ */
+export class MdnsSocket {
+    #socket: UdpMulticastServer;
+    #handlers?: Set<PromiseLike<void>>;
+    #isClosed = false;
+    #receipt = new BasicObservable<[message: MdnsSocket.Message]>(
+        error => logger.error("Unhandled error in MDNS listener", error),
+        true,
+    );
+
+    static async create(network: Network, options?: { enableIpv4?: boolean; netInterface?: string }) {
+        const { enableIpv4 = true, netInterface } = options ?? {};
+        const socket = new MdnsSocket(
+            await UdpMulticastServer.create({
+                network,
+                netInterface,
+                broadcastAddressIpv4: enableIpv4 ? MDNS_BROADCAST_IPV4 : undefined,
+                broadcastAddressIpv6: MDNS_BROADCAST_IPV6,
+                listeningPort: MDNS_BROADCAST_PORT,
+            }),
+        );
+        return socket;
+    }
+
+    constructor(socket: UdpMulticastServer) {
+        this.#socket = socket;
+        socket.onMessage(this.#handleMessage.bind(this));
+    }
+
+    get network() {
+        return this.#socket.network;
+    }
+
+    get supportsIpv4() {
+        return this.#socket.supportsIpv4;
+    }
+
+    get netInterface() {
+        return this.#socket.netInterface;
+    }
+
+    get receipt() {
+        return this.#receipt;
+    }
+
+    async send(message: Partial<DnsMessage> & { messageType: DnsMessageType }, intf?: string, unicastDest?: string) {
+        const chunk: DnsMessagePartiallyPreEncoded = {
+            transactionId: 0,
+            queries: [],
+            authorities: [],
+
+            ...message,
+
+            answers: [],
+            additionalRecords: [],
+        };
+
+        // Note - for size calculations we assume queries are relatively small.  We only split answers across messages
+        let encodedChunkWithoutAnswers = DnsCodec.encode(chunk);
+        let chunkSize = encodedChunkWithoutAnswers.length;
+
+        // Add answers, splitting message as necessary
+        for (const answer of message.answers ?? []) {
+            const answerEncoded = DnsCodec.encodeRecord(answer);
+
+            if (chunkSize + answerEncoded.length > MAX_MDNS_MESSAGE_SIZE) {
+                if (chunk.answers.length === 0) {
+                    // The first answer is already too big, log at least a warning
+                    logger.warn(
+                        `MDNS message with ${Diagnostic.json(
+                            chunk.queries,
+                        )} is too big to fit into a single MDNS message. Send anyway, but please report!`,
+                    );
+                }
+
+                // New answer does not fit anymore, send out the message
+                await this.#send(chunk, intf, unicastDest);
+
+                // Reset the message, length counter and included answers to count for next message
+                if (chunk.queries.length) {
+                    chunk.queries.length = 0;
+                    encodedChunkWithoutAnswers = DnsCodec.encode(chunk);
+                }
+                chunk.answers.length = 0;
+                chunkSize = encodedChunkWithoutAnswers.length + answerEncoded.length;
+            } else {
+                chunkSize += answerEncoded.length;
+            }
+
+            chunk.answers.push(answerEncoded);
+        }
+
+        // Add "additional records"...  We include these but only if they fit
+        const additionalRecords = message.additionalRecords ?? [];
+        for (const additionalRecord of additionalRecords) {
+            const additionalRecordEncoded = DnsCodec.encodeRecord(additionalRecord);
+            chunkSize += additionalRecordEncoded.length;
+            if (chunkSize > MAX_MDNS_MESSAGE_SIZE) {
+                break;
+            }
+            chunk.additionalRecords.push(additionalRecordEncoded);
+        }
+
+        await this.#send(chunk, intf, unicastDest);
+    }
+
+    async #send(message: DnsMessagePartiallyPreEncoded, intf?: string, unicastDest?: string) {
+        await this.#socket.send(DnsCodec.encode(message), intf, unicastDest);
+    }
+
+    async close() {
+        this.#isClosed = true;
+        await this.#socket.close();
+        if (this.#handlers) {
+            await MatterAggregateError.allSettled(this.#handlers);
+        }
+    }
+
+    #handleMessage(bytes: Uint8Array, sourceIp: string, sourceIntf: string) {
+        // Ignore if closed
+        if (this.#isClosed) {
+            return;
+        }
+
+        // Parse
+        const parsed = DnsCodec.decode(bytes);
+
+        // Skip unparseable
+        if (parsed === undefined) {
+            return;
+        }
+
+        let promise = this.#receipt.emit({
+            ...parsed,
+            sourceIp,
+            sourceIntf,
+        }) as MaybePromise;
+
+        if (MaybePromise.is(promise)) {
+            if (this.#handlers === undefined) {
+                this.#handlers = new Set();
+            }
+            promise = Promise.resolve(promise).finally(() => this.#handlers?.delete(promise as PromiseLike<void>));
+        }
+    }
+}
+
+export namespace MdnsSocket {
+    export interface Message extends DnsMessage {
+        sourceIp: string;
+        sourceIntf: string;
+    }
+}