@matterbridge/dgram 3.10.12-dev-20260925-36fa6cb → 3.10.12-dev-20260928-9345dd7

package/dist/mdns.d.ts

@@ -1,6 +1,8 @@
 import type dgram 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;
@@ -158,11 +172,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 +194,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

@@ -2,6 +2,8 @@ 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';
+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 +109,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 +133,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,7 +141,7 @@ 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 class Mdns extends Multicast {
@@ -196,14 +211,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 +308,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 +382,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 +500,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 +540,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/dgram",
-  "version": "3.10.12-dev-20260925-36fa6cb",
+  "version": "3.10.12-dev-20260928-9345dd7",
   "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-20260925-36fa6cb",
+    "@matterbridge/utils": "3.10.12-dev-20260928-9345dd7",
     "node-ansi-logger": "3.3.1"
   }
 }