@matterbridge/dgram 3.10.12-dev-20260927-5bb5023 → 3.10.12-dev-20260929-3d70112

package/dist/coap.d.ts

@@ -1,4 +1,5 @@
 import type dgram from 'node:dgram';
+import type { SocketType } from 'node:dgram';
 import { Multicast } from './multicast.js';
 export interface CoapMessage {
     version: number;
@@ -21,7 +22,7 @@ export declare const COIOT_OPTION_SERIAL = 3420;
 export declare const COIOT_REQUEST_STATUS_ID = 56831;
 export declare const COIOT_REQUEST_DESCRIPTION_ID = 56832;
 export declare class Coap extends Multicast {
-    constructor(name: string, multicastAddress: string, multicastPort: number, socketType: 'udp4' | 'udp6', reuseAddr?: boolean | undefined, interfaceName?: string, interfaceAddress?: string);
+    constructor(name: string, multicastAddress: string, multicastPort: number, socketType: SocketType, reuseAddr?: boolean | undefined, interfaceName?: string, interfaceAddress?: string);
     onCoapMessage(message: CoapMessage, rinfo: dgram.RemoteInfo): void;
     onMessage(msg: Buffer, rinfo: dgram.RemoteInfo): void;
     decodeCoapMessage(msg: Buffer): CoapMessage;

package/dist/dgram.d.ts

@@ -1,4 +1,4 @@
-import dgram from 'node:dgram';
+import dgram, { type SocketType } from 'node:dgram';
 import EventEmitter from 'node:events';
 import type { AddressInfo } from 'node:net';
 import { AnsiLogger } from 'node-ansi-logger';
@@ -19,12 +19,12 @@ export declare class Dgram extends EventEmitter<DgramEvents> {
     log: AnsiLogger;
     socket: dgram.Socket;
     bound: boolean;
-    socketType: 'udp4' | 'udp6';
+    socketType: SocketType;
     interfaceName?: string;
     interfaceAddress?: string;
     interfaceNetmask?: string;
     excludedInterfaceNamePattern: RegExp;
-    constructor(name: string, socketType: 'udp4' | 'udp6', reuseAddr?: boolean | undefined, interfaceName?: string, interfaceAddress?: string);
+    constructor(name: string, socketType: SocketType, reuseAddr?: boolean | undefined, interfaceName?: string, interfaceAddress?: string);
     send(msg: Buffer, serverAddress: string, serverPort: number): void;
     onError(error: Error): void;
     onClose(): void;

package/dist/dgram.js

@@ -40,7 +40,7 @@ export class Dgram extends EventEmitter {
             this.onClose();
         });
         this.socket.on('connect', () => {
-            this.log.info('Socket connected');
+            this.log.debug('Socket connected');
             this.emit('connect');
             this.onConnect();
         });
@@ -75,23 +75,23 @@ export class Dgram extends EventEmitter {
         this.log.error(`Socket error: ${getErrorMessage(error)}`);
     }
     onClose() {
-        this.log.info(`Socket closed`);
+        this.log.debug(`Socket closed`);
     }
     onConnect() {
-        this.log.info(`Socket connected`);
+        this.log.debug(`Socket connected`);
     }
     onSent(msg, serverAddress, serverPort) {
-        this.log.info(`Socket sent a message to ${BLUE}${serverAddress}${db}:${BLUE}${serverPort}${db}`);
+        this.log.debug(`Socket sent a message to ${BLUE}${serverAddress}${db}:${BLUE}${serverPort}${db}`);
     }
     onMessage(msg, rinfo) {
-        this.log.info(`Socket received a message from ${BLUE}${rinfo.family}${nf} ${BLUE}${rinfo.address}${nf}:${BLUE}${rinfo.port}${nf}`);
+        this.log.debug(`Socket received a message from ${BLUE}${rinfo.family}${nf} ${BLUE}${rinfo.address}${nf}:${BLUE}${rinfo.port}${nf}`);
     }
     onListening(address) {
-        this.log.info(`Socket listening on ${BLUE}${address.family}${nf} ${BLUE}${address.address}${nf}:${BLUE}${address.port}${nf}`);
+        this.log.debug(`Socket listening on ${BLUE}${address.family}${nf} ${BLUE}${address.address}${nf}:${BLUE}${address.port}${nf}`);
         this.onReady(address);
     }
     onReady(address) {
-        this.log.info(`Socket ready on ${BLUE}${address.family}${nf} ${BLUE}${address.address}${nf}:${BLUE}${address.port}${nf}`);
+        this.log.debug(`Socket ready on ${BLUE}${address.family}${nf} ${BLUE}${address.address}${nf}:${BLUE}${address.port}${nf}`);
         this.emit('ready', address);
     }
     getIpv4InterfaceAddress(networkInterface) {

package/dist/mdns.d.ts

@@ -1,6 +1,8 @@
-import type dgram from 'node:dgram';
+import dgram, { type SocketType } from 'node:dgram';
 import { type AnsiLogger } from 'node-ansi-logger';
 import { Multicast } from './multicast.js';
+export declare const MDNS_MAX_MESSAGE_LENGTH: number;
+export declare const MDNS_MAX_RESOURCE_RECORD_LENGTH: number;
 export declare enum DnsRecordType {
     A = 1,
     NS = 2,
@@ -103,6 +105,18 @@ export declare enum DnsClassFlag {
     FLUSH = 32768,
     QU = 32768
 }
+export declare enum DnsHeaderFlag {
+    QR = 32768,
+    OPCODE = 30720,
+    AA = 1024,
+    TC = 512,
+    RD = 256,
+    RA = 128,
+    Z = 64,
+    AD = 32,
+    CD = 16,
+    RCODE = 15
+}
 export interface MdnsMessage {
     id: number;
     qr: number;
@@ -124,8 +138,8 @@ export interface MdnsMessage {
 }
 interface DnsQuestion {
     name: string;
-    type: number;
-    class: number;
+    type: DnsRecordType;
+    class: DnsClass;
 }
 interface MdnsRecord {
     name: string;
@@ -137,6 +151,7 @@ interface MdnsRecord {
 export declare function isMdns(message: Buffer): boolean;
 export declare function isMdnsQuery(message: Buffer): boolean;
 export declare function isMdnsResponse(message: Buffer): boolean;
+export declare function isFirstOnPort(socketType: SocketType, port?: number): Promise<boolean>;
 export declare class Mdns extends Multicast {
     deviceQueries: Map<string, {
         rinfo: dgram.RemoteInfo;
@@ -149,7 +164,7 @@ export declare class Mdns extends Multicast {
     }>;
     filters: string[];
     ipFilters: string[];
-    constructor(name: string, multicastAddress: string, multicastPort: number, socketType: 'udp4' | 'udp6', reuseAddr?: boolean | undefined, interfaceName?: string, interfaceAddress?: string, outgoingInterfaceAddress?: string);
+    constructor(name: string, multicastAddress: string, multicastPort: number, socketType: SocketType, reuseAddr?: boolean | undefined, interfaceName?: string, interfaceAddress?: string, outgoingInterfaceAddress?: string);
     onQuery(rinfo: dgram.RemoteInfo, _query: MdnsMessage): void;
     onResponse(rinfo: dgram.RemoteInfo, _response: MdnsMessage): void;
     onMessage(msg: Buffer, rinfo: dgram.RemoteInfo): void;
@@ -158,11 +173,19 @@ export declare class Mdns extends Multicast {
         name: string;
         newOffset: number;
     };
-    encodeDnsName(name: string): Buffer;
+    encodeDnsName(name: string, compression?: Map<string, number>, offset?: number): Buffer;
     encodeTxtRdata(txt: string[]): Buffer;
     encodeSrvRdata(priority: number, weight: number, port: number, target: string): Buffer;
     encodeA(ipv4: string): Buffer;
     encodeAAAA(ipv6WithOptionalScope: string): Buffer;
+    encodeResourceRecord({ name, rtype, rclass, flush, ttl, rdata }: {
+        name: string;
+        rtype: number;
+        rclass: number;
+        flush?: boolean;
+        ttl: number;
+        rdata: Buffer;
+    }, compression?: Map<string, number>, offset?: number): Buffer;
     decodeResourceRecord(msg: Buffer, offset: number): {
         record: MdnsRecord;
         newOffset: number;
@@ -172,11 +195,47 @@ export declare class Mdns extends Multicast {
         type: number;
         class: number;
         unicastResponse?: boolean;
+    }[], answers?: {
+        name: string;
+        rtype: number;
+        rclass: number;
+        flush?: boolean;
+        ttl: number;
+        rdata: Buffer;
+    }[], authorities?: {
+        name: string;
+        rtype: number;
+        rclass: number;
+        flush?: boolean;
+        ttl: number;
+        rdata: Buffer;
+    }[], additionals?: {
+        name: string;
+        rtype: number;
+        rclass: number;
+        flush?: boolean;
+        ttl: number;
+        rdata: Buffer;
     }[]): Buffer<ArrayBuffer>;
     sendResponse(answers: {
         name: string;
         rtype: number;
         rclass: number;
+        flush?: boolean;
+        ttl: number;
+        rdata: Buffer;
+    }[], authorities?: {
+        name: string;
+        rtype: number;
+        rclass: number;
+        flush?: boolean;
+        ttl: number;
+        rdata: Buffer;
+    }[], additionals?: {
+        name: string;
+        rtype: number;
+        rclass: number;
+        flush?: boolean;
         ttl: number;
         rdata: Buffer;
     }[]): Buffer<ArrayBuffer>;

package/dist/mdns.js

@@ -1,7 +1,10 @@
+import dgram from 'node:dgram';
 import { hasParameter } from '@matterbridge/utils/cli';
 import { getErrorMessage } from '@matterbridge/utils/error';
 import { BLUE, CYAN, db, GREEN, idn, MAGENTA, nf, rs } from 'node-ansi-logger';
-import { Multicast } from './multicast.js';
+import { MDNS_MULTICAST_PORT, Multicast } from './multicast.js';
+export const MDNS_MAX_MESSAGE_LENGTH = 1500 - 40 - 8;
+export const MDNS_MAX_RESOURCE_RECORD_LENGTH = MDNS_MAX_MESSAGE_LENGTH - 12;
 export var DnsRecordType;
 (function (DnsRecordType) {
     DnsRecordType[DnsRecordType["A"] = 1] = "A";
@@ -107,6 +110,19 @@ export var DnsClassFlag;
     DnsClassFlag[DnsClassFlag["FLUSH"] = 32768] = "FLUSH";
     DnsClassFlag[DnsClassFlag["QU"] = 32768] = "QU";
 })(DnsClassFlag || (DnsClassFlag = {}));
+export var DnsHeaderFlag;
+(function (DnsHeaderFlag) {
+    DnsHeaderFlag[DnsHeaderFlag["QR"] = 32768] = "QR";
+    DnsHeaderFlag[DnsHeaderFlag["OPCODE"] = 30720] = "OPCODE";
+    DnsHeaderFlag[DnsHeaderFlag["AA"] = 1024] = "AA";
+    DnsHeaderFlag[DnsHeaderFlag["TC"] = 512] = "TC";
+    DnsHeaderFlag[DnsHeaderFlag["RD"] = 256] = "RD";
+    DnsHeaderFlag[DnsHeaderFlag["RA"] = 128] = "RA";
+    DnsHeaderFlag[DnsHeaderFlag["Z"] = 64] = "Z";
+    DnsHeaderFlag[DnsHeaderFlag["AD"] = 32] = "AD";
+    DnsHeaderFlag[DnsHeaderFlag["CD"] = 16] = "CD";
+    DnsHeaderFlag[DnsHeaderFlag["RCODE"] = 15] = "RCODE";
+})(DnsHeaderFlag || (DnsHeaderFlag = {}));
 export function isMdns(message) {
     if (!message || message.length < 12)
         return false;
@@ -118,7 +134,7 @@ export function isMdnsQuery(message) {
         return false;
     const id = message.readUInt16BE(0);
     const flags = message.readUInt16BE(2);
-    const qr = (flags & 0x8000) >> 15;
+    const qr = (flags & DnsHeaderFlag.QR) >> 15;
     return id == 0 && qr === 0;
 }
 export function isMdnsResponse(message) {
@@ -126,9 +142,22 @@ export function isMdnsResponse(message) {
         return false;
     const id = message.readUInt16BE(0);
     const flags = message.readUInt16BE(2);
-    const qr = (flags & 0x8000) >> 15;
+    const qr = (flags & DnsHeaderFlag.QR) >> 15;
     return id == 0 && qr === 1;
 }
+export async function isFirstOnPort(socketType, port = MDNS_MULTICAST_PORT) {
+    return new Promise((resolve) => {
+        const probe = dgram.createSocket({ type: socketType, reuseAddr: false });
+        probe.once('error', () => {
+            probe.close();
+            resolve(false);
+        });
+        probe.bind(port, socketType === 'udp4' ? '0.0.0.0' : '::', () => {
+            probe.close();
+            resolve(true);
+        });
+    });
+}
 export class Mdns extends Multicast {
     deviceQueries = new Map();
     deviceResponses = new Map();
@@ -196,14 +225,14 @@ export class Mdns extends Multicast {
         }
         const id = msg.readUInt16BE(0);
         const flags = msg.readUInt16BE(2);
-        const qr = (flags & 0x8000) >> 15;
-        const opcode = (flags & 0x7800) >> 11;
-        const aa = Boolean(flags & 0x0400);
-        const tc = Boolean(flags & 0x0200);
-        const rd = Boolean(flags & 0x0100);
-        const ra = Boolean(flags & 0x0080);
-        const z = (flags & 0x0070) >> 4;
-        const rcode = flags & 0x000f;
+        const qr = (flags & DnsHeaderFlag.QR) >> 15;
+        const opcode = (flags & DnsHeaderFlag.OPCODE) >> 11;
+        const aa = Boolean(flags & DnsHeaderFlag.AA);
+        const tc = Boolean(flags & DnsHeaderFlag.TC);
+        const rd = Boolean(flags & DnsHeaderFlag.RD);
+        const ra = Boolean(flags & DnsHeaderFlag.RA);
+        const z = (flags & (DnsHeaderFlag.Z | DnsHeaderFlag.AD | DnsHeaderFlag.CD)) >> 4;
+        const rcode = flags & DnsHeaderFlag.RCODE;
         const qdCount = msg.readUInt16BE(4);
         const anCount = msg.readUInt16BE(6);
         const nsCount = msg.readUInt16BE(8);
@@ -293,13 +322,25 @@ export class Mdns extends Multicast {
         }
         return { name: labels.join('.'), newOffset: jumped ? originalOffset : offset };
     }
-    encodeDnsName(name) {
+    encodeDnsName(name, compression, offset = 0) {
         const labels = name.split('.');
-        const buffers = labels.map((label) => {
+        const buffers = [];
+        let length = 0;
+        for (const [index, label] of labels.entries()) {
+            if (compression && label !== '') {
+                const suffix = labels.slice(index).join('.');
+                const pointer = compression.get(suffix);
+                if (pointer !== undefined)
+                    return Buffer.concat([...buffers, Buffer.from([0xc0 | (pointer >> 8), pointer & 0xff])]);
+                if (offset + length < 0x4000)
+                    compression.set(suffix, offset + length);
+            }
+            const labelBuf = Buffer.from(label, 'utf8');
             const lenBuf = Buffer.alloc(1);
-            lenBuf.writeUInt8(label.length, 0);
-            return Buffer.concat([lenBuf, Buffer.from(label)]);
-        });
+            lenBuf.writeUInt8(labelBuf.length, 0);
+            buffers.push(lenBuf, labelBuf);
+            length += 1 + labelBuf.length;
+        }
         return Buffer.concat([...buffers, Buffer.from([0])]);
     }
     encodeTxtRdata(txt) {
@@ -355,6 +396,28 @@ export class Mdns extends Multicast {
             return [(word >> 8) & 0xff, word & 0xff];
         }));
     }
+    encodeResourceRecord({ name, rtype, rclass, flush = false, ttl, rdata }, compression, offset = 0) {
+        const rname = this.encodeDnsName(name, compression, offset);
+        const nameStart = rtype === DnsRecordType.PTR ? 0 : rtype === DnsRecordType.SRV ? 6 : -1;
+        if (compression && nameStart >= 0) {
+            let rdataName;
+            try {
+                rdataName = this.decodeDnsName(rdata, nameStart).name;
+            }
+            catch {
+                rdataName = undefined;
+            }
+            if (rdataName !== undefined && this.encodeDnsName(rdataName).equals(rdata.subarray(nameStart))) {
+                rdata = Buffer.concat([rdata.subarray(0, nameStart), this.encodeDnsName(rdataName, compression, offset + rname.length + 10 + nameStart)]);
+            }
+        }
+        const recordFixed = Buffer.alloc(10);
+        recordFixed.writeUInt16BE(rtype, 0);
+        recordFixed.writeUInt16BE(flush ? rclass | DnsClassFlag.FLUSH : rclass, 2);
+        recordFixed.writeUInt32BE(ttl, 4);
+        recordFixed.writeUInt16BE(rdata.length, 8);
+        return Buffer.concat([rname, recordFixed, rdata]);
+    }
     decodeResourceRecord(msg, offset) {
         const nameResult = this.decodeDnsName(msg, offset);
         const name = nameResult.name;
@@ -451,22 +514,30 @@ export class Mdns extends Multicast {
             newOffset: offset,
         };
     }
-    sendQuery(questions) {
+    sendQuery(questions, answers = [], authorities = [], additionals = []) {
         const header = Buffer.alloc(12);
         header.writeUInt16BE(0, 0);
         header.writeUInt16BE(0, 2);
         header.writeUInt16BE(questions.length, 4);
-        header.writeUInt16BE(0, 6);
-        header.writeUInt16BE(0, 8);
-        header.writeUInt16BE(0, 10);
+        header.writeUInt16BE(answers.length, 6);
+        header.writeUInt16BE(authorities.length, 8);
+        header.writeUInt16BE(additionals.length, 10);
+        const compression = new Map();
+        let offset = 12;
         const questionBuffers = questions.map(({ name, type: qtype, class: qclass, unicastResponse = false }) => {
-            const qname = this.encodeDnsName(name);
+            const qname = this.encodeDnsName(name, compression, offset);
             const qfields = Buffer.alloc(4);
             qfields.writeUInt16BE(qtype, 0);
             qfields.writeUInt16BE(unicastResponse ? qclass | DnsClassFlag.QU : qclass, 2);
+            offset += qname.length + 4;
             return Buffer.concat([qname, qfields]);
         });
-        const query = Buffer.concat([header, ...questionBuffers]);
+        const recordBuffers = [...answers, ...authorities, ...additionals].map((record) => {
+            const recordBuffer = this.encodeResourceRecord(record, compression, offset);
+            offset += recordBuffer.length;
+            return recordBuffer;
+        });
+        const query = Buffer.concat([header, ...questionBuffers, ...recordBuffers]);
         if (hasParameter('v') || hasParameter('verbose')) {
             const decoded = this.decodeMdnsMessage(query);
             this.logMdnsMessage(decoded, undefined, `Sending query mDNS message (${query.length} bytes)`);
@@ -483,27 +554,25 @@ export class Mdns extends Multicast {
         });
         return query;
     }
-    sendResponse(answers) {
+    sendResponse(answers, authorities = [], additionals = []) {
         if (!Array.isArray(answers) || answers.length === 0) {
             throw new Error('sendResponse requires a non-empty answers array');
         }
         const header = Buffer.alloc(12);
         header.writeUInt16BE(0, 0);
-        header.writeUInt16BE(0x8400, 2);
+        header.writeUInt16BE(DnsHeaderFlag.QR | DnsHeaderFlag.AA, 2);
         header.writeUInt16BE(0, 4);
         header.writeUInt16BE(answers.length, 6);
-        header.writeUInt16BE(0, 8);
-        header.writeUInt16BE(0, 10);
-        const answerBuffers = answers.map(({ name, rtype, rclass, ttl, rdata }) => {
-            const aname = this.encodeDnsName(name);
-            const answerFixed = Buffer.alloc(10);
-            answerFixed.writeUInt16BE(rtype, 0);
-            answerFixed.writeUInt16BE(rclass, 2);
-            answerFixed.writeUInt32BE(ttl, 4);
-            answerFixed.writeUInt16BE(rdata.length, 8);
-            return Buffer.concat([aname, answerFixed, rdata]);
+        header.writeUInt16BE(authorities.length, 8);
+        header.writeUInt16BE(additionals.length, 10);
+        const compression = new Map();
+        let offset = 12;
+        const recordBuffers = [...answers, ...authorities, ...additionals].map((record) => {
+            const recordBuffer = this.encodeResourceRecord(record, compression, offset);
+            offset += recordBuffer.length;
+            return recordBuffer;
         });
-        const response = Buffer.concat([header, ...answerBuffers]);
+        const response = Buffer.concat([header, ...recordBuffers]);
         if (hasParameter('v') || hasParameter('verbose')) {
             const decoded = this.decodeMdnsMessage(response);
             this.logMdnsMessage(decoded, undefined, `Sending response mDNS message (${response.length} bytes)`);

package/dist/multicast.d.ts

@@ -1,3 +1,4 @@
+import type { SocketType } from 'node:dgram';
 import type { AddressInfo } from 'node:net';
 import { Dgram } from './dgram.js';
 export declare const MDNS_MULTICAST_IPV4_ADDRESS = "224.0.0.251";
@@ -11,7 +12,7 @@ export declare class Multicast extends Dgram {
     multicastPort: number;
     outgoingInterfaceAddress: string | undefined;
     joinedInterfaces: string[];
-    constructor(name: string, multicastAddress: string, multicastPort: number, socketType: 'udp4' | 'udp6', reuseAddr?: boolean | undefined, interfaceName?: string, interfaceAddress?: string, outgoingInterfaceAddress?: string);
+    constructor(name: string, multicastAddress: string, multicastPort: number, socketType: SocketType, reuseAddr?: boolean | undefined, interfaceName?: string, interfaceAddress?: string, outgoingInterfaceAddress?: string);
     start(): void;
     onListening(address: AddressInfo): void;
     stop(): void;

package/dist/unicast.d.ts

@@ -1,9 +1,9 @@
-import type { RemoteInfo } from 'node:dgram';
+import type { RemoteInfo, SocketType } from 'node:dgram';
 import type { AddressInfo } from 'node:net';
 import { Dgram } from './dgram.js';
 export declare class Unicast extends Dgram {
     port: number | undefined;
-    constructor(name: string, socketType: 'udp4' | 'udp6', reuseAddr?: boolean | undefined, interfaceName?: string, interfaceAddress?: string, port?: number);
+    constructor(name: string, socketType: SocketType, reuseAddr?: boolean | undefined, interfaceName?: string, interfaceAddress?: string, port?: number);
     start(): void;
     onListening(address: AddressInfo): void;
     onMessage(msg: Buffer, rinfo: RemoteInfo): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/dgram",
-  "version": "3.10.12-dev-20260927-5bb5023",
+  "version": "3.10.12-dev-20260929-3d70112",
   "description": "Matterbridge dgram library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -67,7 +67,7 @@
     "skipTsconfig": true
   },
   "dependencies": {
-    "@matterbridge/utils": "3.10.12-dev-20260927-5bb5023",
+    "@matterbridge/utils": "3.10.12-dev-20260929-3d70112",
     "node-ansi-logger": "3.3.1"
   }
 }