matterbridge 3.4.7-dev-20260104-6b10cee → 3.4.7-dev-20260112-a00b2bf

package/packages/dgram/dist/mdns.js

@@ -0,0 +1,702 @@
+import { BLUE, CYAN, db, GREEN, idn, MAGENTA, nf, rs } from 'node-ansi-logger';
+import { hasParameter } from '@matterbridge/utils';
+import { Multicast } from './multicast.js';
+export var DnsRecordType;
+(function (DnsRecordType) {
+    DnsRecordType[DnsRecordType["A"] = 1] = "A";
+    DnsRecordType[DnsRecordType["NS"] = 2] = "NS";
+    DnsRecordType[DnsRecordType["MD"] = 3] = "MD";
+    DnsRecordType[DnsRecordType["MF"] = 4] = "MF";
+    DnsRecordType[DnsRecordType["CNAME"] = 5] = "CNAME";
+    DnsRecordType[DnsRecordType["SOA"] = 6] = "SOA";
+    DnsRecordType[DnsRecordType["MB"] = 7] = "MB";
+    DnsRecordType[DnsRecordType["MG"] = 8] = "MG";
+    DnsRecordType[DnsRecordType["MR"] = 9] = "MR";
+    DnsRecordType[DnsRecordType["NULL"] = 10] = "NULL";
+    DnsRecordType[DnsRecordType["WKS"] = 11] = "WKS";
+    DnsRecordType[DnsRecordType["PTR"] = 12] = "PTR";
+    DnsRecordType[DnsRecordType["HINFO"] = 13] = "HINFO";
+    DnsRecordType[DnsRecordType["MINFO"] = 14] = "MINFO";
+    DnsRecordType[DnsRecordType["MX"] = 15] = "MX";
+    DnsRecordType[DnsRecordType["TXT"] = 16] = "TXT";
+    DnsRecordType[DnsRecordType["RP"] = 17] = "RP";
+    DnsRecordType[DnsRecordType["AFSDB"] = 18] = "AFSDB";
+    DnsRecordType[DnsRecordType["X25"] = 19] = "X25";
+    DnsRecordType[DnsRecordType["ISDN"] = 20] = "ISDN";
+    DnsRecordType[DnsRecordType["RT"] = 21] = "RT";
+    DnsRecordType[DnsRecordType["NSAP"] = 22] = "NSAP";
+    DnsRecordType[DnsRecordType["NSAP_PTR"] = 23] = "NSAP_PTR";
+    DnsRecordType[DnsRecordType["SIG"] = 24] = "SIG";
+    DnsRecordType[DnsRecordType["KEY"] = 25] = "KEY";
+    DnsRecordType[DnsRecordType["PX"] = 26] = "PX";
+    DnsRecordType[DnsRecordType["GPOS"] = 27] = "GPOS";
+    DnsRecordType[DnsRecordType["AAAA"] = 28] = "AAAA";
+    DnsRecordType[DnsRecordType["LOC"] = 29] = "LOC";
+    DnsRecordType[DnsRecordType["NXT"] = 30] = "NXT";
+    DnsRecordType[DnsRecordType["EID"] = 31] = "EID";
+    DnsRecordType[DnsRecordType["NIMLOC"] = 32] = "NIMLOC";
+    DnsRecordType[DnsRecordType["SRV"] = 33] = "SRV";
+    DnsRecordType[DnsRecordType["ATMA"] = 34] = "ATMA";
+    DnsRecordType[DnsRecordType["NAPTR"] = 35] = "NAPTR";
+    DnsRecordType[DnsRecordType["KX"] = 36] = "KX";
+    DnsRecordType[DnsRecordType["CERT"] = 37] = "CERT";
+    DnsRecordType[DnsRecordType["A6"] = 38] = "A6";
+    DnsRecordType[DnsRecordType["DNAME"] = 39] = "DNAME";
+    DnsRecordType[DnsRecordType["SINK"] = 40] = "SINK";
+    DnsRecordType[DnsRecordType["OPT"] = 41] = "OPT";
+    DnsRecordType[DnsRecordType["APL"] = 42] = "APL";
+    DnsRecordType[DnsRecordType["DS"] = 43] = "DS";
+    DnsRecordType[DnsRecordType["SSHFP"] = 44] = "SSHFP";
+    DnsRecordType[DnsRecordType["IPSECKEY"] = 45] = "IPSECKEY";
+    DnsRecordType[DnsRecordType["RRSIG"] = 46] = "RRSIG";
+    DnsRecordType[DnsRecordType["NSEC"] = 47] = "NSEC";
+    DnsRecordType[DnsRecordType["DNSKEY"] = 48] = "DNSKEY";
+    DnsRecordType[DnsRecordType["DHCID"] = 49] = "DHCID";
+    DnsRecordType[DnsRecordType["NSEC3"] = 50] = "NSEC3";
+    DnsRecordType[DnsRecordType["NSEC3PARAM"] = 51] = "NSEC3PARAM";
+    DnsRecordType[DnsRecordType["TLSA"] = 52] = "TLSA";
+    DnsRecordType[DnsRecordType["SMIMEA"] = 53] = "SMIMEA";
+    DnsRecordType[DnsRecordType["HIP"] = 55] = "HIP";
+    DnsRecordType[DnsRecordType["NINFO"] = 56] = "NINFO";
+    DnsRecordType[DnsRecordType["RKEY"] = 57] = "RKEY";
+    DnsRecordType[DnsRecordType["TALINK"] = 58] = "TALINK";
+    DnsRecordType[DnsRecordType["CDS"] = 59] = "CDS";
+    DnsRecordType[DnsRecordType["CDNSKEY"] = 60] = "CDNSKEY";
+    DnsRecordType[DnsRecordType["OPENPGPKEY"] = 61] = "OPENPGPKEY";
+    DnsRecordType[DnsRecordType["CSYNC"] = 62] = "CSYNC";
+    DnsRecordType[DnsRecordType["ZONEMD"] = 63] = "ZONEMD";
+    DnsRecordType[DnsRecordType["SVCB"] = 64] = "SVCB";
+    DnsRecordType[DnsRecordType["HTTPS"] = 65] = "HTTPS";
+    DnsRecordType[DnsRecordType["SPF"] = 99] = "SPF";
+    DnsRecordType[DnsRecordType["UINFO"] = 100] = "UINFO";
+    DnsRecordType[DnsRecordType["UID"] = 101] = "UID";
+    DnsRecordType[DnsRecordType["GID"] = 102] = "GID";
+    DnsRecordType[DnsRecordType["UNSPEC"] = 103] = "UNSPEC";
+    DnsRecordType[DnsRecordType["NID"] = 104] = "NID";
+    DnsRecordType[DnsRecordType["L32"] = 105] = "L32";
+    DnsRecordType[DnsRecordType["L64"] = 106] = "L64";
+    DnsRecordType[DnsRecordType["LP"] = 107] = "LP";
+    DnsRecordType[DnsRecordType["EUI48"] = 108] = "EUI48";
+    DnsRecordType[DnsRecordType["EUI64"] = 109] = "EUI64";
+    DnsRecordType[DnsRecordType["TKEY"] = 249] = "TKEY";
+    DnsRecordType[DnsRecordType["TSIG"] = 250] = "TSIG";
+    DnsRecordType[DnsRecordType["IXFR"] = 251] = "IXFR";
+    DnsRecordType[DnsRecordType["AXFR"] = 252] = "AXFR";
+    DnsRecordType[DnsRecordType["MAILB"] = 253] = "MAILB";
+    DnsRecordType[DnsRecordType["MAILA"] = 254] = "MAILA";
+    DnsRecordType[DnsRecordType["ANY"] = 255] = "ANY";
+    DnsRecordType[DnsRecordType["URI"] = 256] = "URI";
+    DnsRecordType[DnsRecordType["CAA"] = 257] = "CAA";
+    DnsRecordType[DnsRecordType["AVC"] = 258] = "AVC";
+    DnsRecordType[DnsRecordType["DOA"] = 259] = "DOA";
+    DnsRecordType[DnsRecordType["AMTRELAY"] = 260] = "AMTRELAY";
+    DnsRecordType[DnsRecordType["ZONEVERSION"] = 261] = "ZONEVERSION";
+    DnsRecordType[DnsRecordType["TA"] = 32768] = "TA";
+    DnsRecordType[DnsRecordType["DLV"] = 32769] = "DLV";
+})(DnsRecordType || (DnsRecordType = {}));
+export var DnsClass;
+(function (DnsClass) {
+    DnsClass[DnsClass["IN"] = 1] = "IN";
+    DnsClass[DnsClass["CH"] = 3] = "CH";
+    DnsClass[DnsClass["HS"] = 4] = "HS";
+    DnsClass[DnsClass["ANY"] = 255] = "ANY";
+})(DnsClass || (DnsClass = {}));
+export var DnsClassFlag;
+(function (DnsClassFlag) {
+    DnsClassFlag[DnsClassFlag["FLUSH"] = 32768] = "FLUSH";
+    DnsClassFlag[DnsClassFlag["QU"] = 32768] = "QU";
+})(DnsClassFlag || (DnsClassFlag = {}));
+export function isMdns(message) {
+    if (!message || message.length < 12)
+        return false;
+    const id = message.readUInt16BE(0);
+    return id === 0;
+}
+export function isMdnsQuery(message) {
+    if (message.length < 12)
+        return false;
+    const id = message.readUInt16BE(0);
+    const flags = message.readUInt16BE(2);
+    const qr = (flags & 0x8000) >> 15;
+    return id == 0 && qr === 0;
+}
+export function isMdnsResponse(message) {
+    if (message.length < 12)
+        return false;
+    const id = message.readUInt16BE(0);
+    const flags = message.readUInt16BE(2);
+    const qr = (flags & 0x8000) >> 15;
+    return id == 0 && qr === 1;
+}
+export class Mdns extends Multicast {
+    deviceQueries = new Map();
+    deviceResponses = new Map();
+    filters = [];
+    constructor(name, multicastAddress, multicastPort, socketType, reuseAddr = true, interfaceName, interfaceAddress, outgoingInterfaceAddress) {
+        super(name, multicastAddress, multicastPort, socketType, reuseAddr, interfaceName, interfaceAddress, outgoingInterfaceAddress);
+    }
+    onQuery(rinfo, _query) {
+        this.log.debug(`mDNS query received from ${BLUE}${rinfo.family}${db} ${BLUE}${rinfo.address}${db}:${BLUE}${rinfo.port}${db}`);
+    }
+    onResponse(rinfo, _response) {
+        this.log.debug(`mDNS response received from ${BLUE}${rinfo.family}${db} ${BLUE}${rinfo.address}${db}:${BLUE}${rinfo.port}${db}`);
+    }
+    onMessage(msg, rinfo) {
+        if (this.filters.length === 0)
+            this.log.info(`Dgram mDNS server received a mDNS message from ${BLUE}${rinfo.family}${nf} ${BLUE}${rinfo.address}${nf}:${BLUE}${rinfo.port}${nf}`);
+        try {
+            const result = this.decodeMdnsMessage(msg);
+            if (result.qr === 0) {
+                this.deviceQueries.set(rinfo.address, { rinfo, query: result });
+                this.onQuery(rinfo, result);
+            }
+            else {
+                const ptr = result.answers?.find((record) => record.name === '_shelly._tcp.local' && record.type === 12) ||
+                    result.answers?.find((record) => record.name === '_http._tcp.local' && record.type === 12) ||
+                    result.answers?.find((record) => record.type === 12) ||
+                    result.answers?.find((record) => record.type === 16) ||
+                    result.answers
+                    ? result.answers[0]
+                    : undefined;
+                this.deviceResponses.set(rinfo.address, { rinfo, response: result, dataPTR: ptr?.type === 12 ? ptr?.data : ptr?.name });
+                this.onResponse(rinfo, result);
+            }
+            if (this.filters.length > 0) {
+                this.log.debug(`mDNS message filtered out by filters: ${this.filters.join(', ')}`);
+                for (const filter of this.filters) {
+                    const foundInQuestions = result.questions?.some((q) => q.name.includes(filter));
+                    const foundInAnswers = result.answers?.some((a) => a.name.includes(filter) || a.data.includes(filter));
+                    const foundInAdditionals = result.additionals?.some((a) => a.name.includes(filter) || a.data.includes(filter));
+                    if (foundInQuestions || foundInAnswers || foundInAdditionals) {
+                        this.log.info(`Dgram mDNS server received a mDNS message from ${BLUE}${rinfo.family}${nf} ${BLUE}${rinfo.address}${nf}:${BLUE}${rinfo.port}${nf}`);
+                        this.logMdnsMessage(result);
+                        return;
+                    }
+                }
+                this.log.debug(`mDNS message does not match any filter, ignoring.`);
+                return;
+            }
+            this.logMdnsMessage(result);
+        }
+        catch (error) {
+            this.log.error(`Error decoding mDNS message: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    decodeMdnsMessage(msg) {
+        if (msg.length < 12) {
+            throw new Error('mDNS message too short');
+        }
+        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 qdCount = msg.readUInt16BE(4);
+        const anCount = msg.readUInt16BE(6);
+        const nsCount = msg.readUInt16BE(8);
+        const arCount = msg.readUInt16BE(10);
+        const mdnsMessage = {
+            id,
+            qr,
+            opcode,
+            aa,
+            tc,
+            rd,
+            ra,
+            z,
+            rcode,
+            qdCount,
+            anCount,
+            nsCount,
+            arCount,
+            questions: [],
+            answers: [],
+            authorities: [],
+            additionals: [],
+        };
+        let offset = 12;
+        for (let i = 0; i < qdCount; i++) {
+            const qnameResult = this.decodeDnsName(msg, offset);
+            const qname = qnameResult.name;
+            offset = qnameResult.newOffset;
+            const qtype = msg.readUInt16BE(offset);
+            offset += 2;
+            const qclass = msg.readUInt16BE(offset);
+            offset += 2;
+            mdnsMessage.questions?.push({ name: qname, type: qtype, class: qclass });
+        }
+        for (let i = 0; i < anCount; i++) {
+            const rrResult = this.decodeResourceRecord(msg, offset);
+            mdnsMessage.answers?.push(rrResult.record);
+            offset = rrResult.newOffset;
+        }
+        for (let i = 0; i < nsCount; i++) {
+            const rrResult = this.decodeResourceRecord(msg, offset);
+            mdnsMessage.authorities?.push(rrResult.record);
+            offset = rrResult.newOffset;
+        }
+        for (let i = 0; i < arCount; i++) {
+            const rrResult = this.decodeResourceRecord(msg, offset);
+            mdnsMessage.additionals?.push(rrResult.record);
+            offset = rrResult.newOffset;
+        }
+        return mdnsMessage;
+    }
+    decodeDnsName(msg, offset) {
+        const labels = [];
+        let jumped = false;
+        let originalOffset = offset;
+        let iterations = 0;
+        while (true) {
+            if (iterations++ > 1000) {
+                throw new Error('Too many iterations while decoding DNS name. Possible malformed message.');
+            }
+            if (offset >= msg.length) {
+                throw new Error('Offset exceeds buffer length while decoding DNS name.');
+            }
+            const len = msg.readUInt8(offset);
+            if (len === 0) {
+                offset++;
+                break;
+            }
+            if ((len & 0xc0) === 0xc0) {
+                if (offset + 1 >= msg.length) {
+                    throw new Error('Incomplete pointer encountered while decoding DNS name.');
+                }
+                const pointer = ((len & 0x3f) << 8) | msg.readUInt8(offset + 1);
+                if (!jumped) {
+                    originalOffset = offset + 2;
+                }
+                offset = pointer;
+                jumped = true;
+                continue;
+            }
+            offset++;
+            if (offset + len > msg.length) {
+                throw new Error('Label length exceeds buffer bounds while decoding DNS name.');
+            }
+            labels.push(msg.toString('utf8', offset, offset + len));
+            offset += len;
+        }
+        return { name: labels.join('.'), newOffset: jumped ? originalOffset : offset };
+    }
+    encodeDnsName(name) {
+        const labels = name.split('.');
+        const buffers = labels.map((label) => {
+            const lenBuf = Buffer.alloc(1);
+            lenBuf.writeUInt8(label.length, 0);
+            return Buffer.concat([lenBuf, Buffer.from(label)]);
+        });
+        return Buffer.concat([...buffers, Buffer.from([0])]);
+    }
+    encodeTxtRdata(txt) {
+        const parts = txt.map((entry) => {
+            const value = Buffer.from(entry, 'utf8');
+            if (value.length > 255)
+                throw new Error(`TXT entry too long: ${entry}`);
+            return Buffer.concat([Buffer.from([value.length]), value]);
+        });
+        return Buffer.concat(parts);
+    }
+    encodeSrvRdata(priority, weight, port, target) {
+        const fixed = Buffer.alloc(6);
+        fixed.writeUInt16BE(priority, 0);
+        fixed.writeUInt16BE(weight, 2);
+        fixed.writeUInt16BE(port, 4);
+        return Buffer.concat([fixed, this.encodeDnsName(target)]);
+    }
+    encodeA(ipv4) {
+        const parts = ipv4.split('.').map((p) => Number(p));
+        if (parts.length !== 4 || parts.some((n) => !Number.isInteger(n) || n < 0 || n > 255)) {
+            throw new Error(`Invalid IPv4 address: ${ipv4}`);
+        }
+        return Buffer.from(parts);
+    }
+    encodeAAAA(ipv6WithOptionalScope) {
+        const ipv6 = ipv6WithOptionalScope.split('%')[0];
+        const [left, right] = ipv6.split('::');
+        const leftParts = left ? left.split(':').filter(Boolean) : [];
+        const rightParts = right ? right.split(':').filter(Boolean) : [];
+        if (ipv6.includes('::')) {
+            const missing = 8 - (leftParts.length + rightParts.length);
+            if (missing < 0)
+                throw new Error(`Invalid IPv6 address: ${ipv6WithOptionalScope}`);
+            const groups = [...leftParts, ...Array(missing).fill('0'), ...rightParts];
+            return Buffer.from(groups.flatMap((g) => {
+                const word = parseInt(g, 16);
+                if (!Number.isFinite(word) || word < 0 || word > 0xffff) {
+                    throw new Error(`Invalid IPv6 group: ${g}`);
+                }
+                return [(word >> 8) & 0xff, word & 0xff];
+            }));
+        }
+        const groups = ipv6.split(':');
+        if (groups.length !== 8)
+            throw new Error(`Invalid IPv6 address: ${ipv6WithOptionalScope}`);
+        return Buffer.from(groups.flatMap((g) => {
+            if (!g)
+                throw new Error(`Invalid IPv6 group: ${g}`);
+            const word = parseInt(g, 16);
+            if (!Number.isFinite(word) || word < 0 || word > 0xffff)
+                throw new Error(`Invalid IPv6 group: ${g}`);
+            return [(word >> 8) & 0xff, word & 0xff];
+        }));
+    }
+    decodeResourceRecord(msg, offset) {
+        const nameResult = this.decodeDnsName(msg, offset);
+        const name = nameResult.name;
+        offset = nameResult.newOffset;
+        const type = msg.readUInt16BE(offset);
+        offset += 2;
+        const rrclass = msg.readUInt16BE(offset);
+        offset += 2;
+        const ttl = msg.readUInt32BE(offset);
+        offset += 4;
+        const rdlength = msg.readUInt16BE(offset);
+        offset += 2;
+        let data = '';
+        if (type === 12) {
+            const ptrResult = this.decodeDnsName(msg, offset);
+            data = ptrResult.name;
+            offset += rdlength;
+        }
+        else if (type === 16) {
+            const txtStrings = [];
+            const end = offset + rdlength;
+            while (offset < end) {
+                const txtLen = msg[offset];
+                offset++;
+                const txt = msg.slice(offset, offset + txtLen).toString('utf8');
+                txtStrings.push(txt);
+                offset += txtLen;
+            }
+            data = txtStrings.join(', ');
+        }
+        else if (type === 33) {
+            const priority = msg.readUInt16BE(offset);
+            const weight = msg.readUInt16BE(offset + 2);
+            const port = msg.readUInt16BE(offset + 4);
+            offset += 6;
+            const srvTargetResult = this.decodeDnsName(msg, offset);
+            data = JSON.stringify({
+                priority,
+                weight,
+                port,
+                target: srvTargetResult.name,
+            });
+            offset = srvTargetResult.newOffset;
+        }
+        else if (type === 1) {
+            const ipBytes = msg.slice(offset, offset + 4);
+            data = Array.from(ipBytes).join('.');
+            offset += 4;
+        }
+        else if (type === 28) {
+            const ipBytes = msg.slice(offset, offset + 16);
+            const ipv6Parts = [];
+            for (let i = 0; i < 16; i += 2) {
+                ipv6Parts.push(ipBytes.readUInt16BE(i).toString(16));
+            }
+            data = ipv6Parts.join(':');
+            offset += 16;
+        }
+        else if (type === 47) {
+            const { name: nextDomain, newOffset } = this.decodeDnsName(msg, offset);
+            const nextDomainLength = newOffset - offset;
+            offset = newOffset;
+            const bitmapLength = rdlength - nextDomainLength;
+            const bitmapData = msg.slice(offset, offset + bitmapLength);
+            const types = [];
+            let bitmapOffset = 0;
+            while (bitmapOffset < bitmapData.length) {
+                const windowBlock = bitmapData[bitmapOffset];
+                const windowLength = bitmapData[bitmapOffset + 1];
+                bitmapOffset += 2;
+                for (let i = 0; i < windowLength; i++) {
+                    const octet = bitmapData[bitmapOffset + i];
+                    for (let bit = 0; bit < 8; bit++) {
+                        if (octet & (0x80 >> bit)) {
+                            const typeCode = windowBlock * 256 + i * 8 + bit;
+                            types.push(this.dnsTypeToString(typeCode));
+                        }
+                    }
+                }
+                bitmapOffset += windowLength;
+            }
+            data = JSON.stringify({
+                nextDomain,
+                types,
+            });
+            offset += bitmapLength;
+        }
+        else {
+            data = msg.slice(offset, offset + rdlength).toString('hex');
+            offset += rdlength;
+        }
+        return {
+            record: { name, type, class: rrclass, ttl, data },
+            newOffset: offset,
+        };
+    }
+    sendQuery(questions) {
+        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);
+        const questionBuffers = questions.map(({ name, type: qtype, class: qclass, unicastResponse = false }) => {
+            const qname = this.encodeDnsName(name);
+            const qfields = Buffer.alloc(4);
+            qfields.writeUInt16BE(qtype, 0);
+            qfields.writeUInt16BE(unicastResponse ? qclass | 32768 : qclass, 2);
+            return Buffer.concat([qname, qfields]);
+        });
+        const query = Buffer.concat([header, ...questionBuffers]);
+        if (hasParameter('v') || hasParameter('verbose')) {
+            const decoded = this.decodeMdnsMessage(query);
+            this.logMdnsMessage(decoded, undefined, 'Sending query mDNS message');
+        }
+        this.socket.send(query, 0, query.length, this.multicastPort, this.multicastAddress, (error) => {
+            if (error) {
+                this.log.error(`Dgram mDNS server failed to send query message: ${error instanceof Error ? error.message : error}`);
+                this.emit('error', error);
+            }
+            else {
+                this.log.debug(`Dgram mDNS server sent query message`);
+                this.emit('sent', query, this.multicastAddress, this.multicastPort);
+            }
+        });
+        return query;
+    }
+    sendResponse(answers) {
+        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(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]);
+        });
+        const response = Buffer.concat([header, ...answerBuffers]);
+        if (hasParameter('v') || hasParameter('verbose')) {
+            const decoded = this.decodeMdnsMessage(response);
+            this.logMdnsMessage(decoded, undefined, 'Sending response mDNS message');
+        }
+        this.socket.send(response, 0, response.length, this.multicastPort, this.multicastAddress, (error) => {
+            if (error) {
+                this.log.error(`Dgram mDNS server failed to send response message: ${error instanceof Error ? error.message : error}`);
+                this.emit('error', error);
+            }
+            else {
+                this.log.debug(`Dgram mDNS server sent response message`);
+                this.emit('sent', response, this.multicastAddress, this.multicastPort);
+            }
+        });
+        return response;
+    }
+    dnsTypeToString(type) {
+        const typeMap = {
+            [1]: 'A',
+            [2]: 'NS',
+            [3]: 'MD',
+            [4]: 'MF',
+            [5]: 'CNAME',
+            [6]: 'SOA',
+            [7]: 'MB',
+            [8]: 'MG',
+            [9]: 'MR',
+            [10]: 'NULL',
+            [11]: 'WKS',
+            [12]: 'PTR',
+            [13]: 'HINFO',
+            [14]: 'MINFO',
+            [15]: 'MX',
+            [16]: 'TXT',
+            [17]: 'RP',
+            [18]: 'AFSDB',
+            [19]: 'X25',
+            [20]: 'ISDN',
+            [21]: 'RT',
+            [22]: 'NSAP',
+            [23]: 'NSAP_PTR',
+            [24]: 'SIG',
+            [25]: 'KEY',
+            [26]: 'PX',
+            [27]: 'GPOS',
+            [28]: 'AAAA',
+            [29]: 'LOC',
+            [30]: 'NXT',
+            [31]: 'EID',
+            [32]: 'NIMLOC',
+            [33]: 'SRV',
+            [34]: 'ATMA',
+            [35]: 'NAPTR',
+            [36]: 'KX',
+            [37]: 'CERT',
+            [38]: 'A6',
+            [39]: 'DNAME',
+            [40]: 'SINK',
+            [41]: 'OPT',
+            [42]: 'APL',
+            [43]: 'DS',
+            [44]: 'SSHFP',
+            [45]: 'IPSECKEY',
+            [46]: 'RRSIG',
+            [47]: 'NSEC',
+            [48]: 'DNSKEY',
+            [49]: 'DHCID',
+            [50]: 'NSEC3',
+            [51]: 'NSEC3PARAM',
+            [52]: 'TLSA',
+            [53]: 'SMIMEA',
+            [55]: 'HIP',
+            [56]: 'NINFO',
+            [57]: 'RKEY',
+            [58]: 'TALINK',
+            [59]: 'CDS',
+            [60]: 'CDNSKEY',
+            [61]: 'OPENPGPKEY',
+            [62]: 'CSYNC',
+            [63]: 'ZONEMD',
+            [64]: 'SVCB',
+            [65]: 'HTTPS',
+            [99]: 'SPF',
+            [100]: 'UINFO',
+            [101]: 'UID',
+            [102]: 'GID',
+            [103]: 'UNSPEC',
+            [104]: 'NID',
+            [105]: 'L32',
+            [106]: 'L64',
+            [107]: 'LP',
+            [108]: 'EUI48',
+            [109]: 'EUI64',
+            [249]: 'TKEY',
+            [250]: 'TSIG',
+            [251]: 'IXFR',
+            [252]: 'AXFR',
+            [253]: 'MAILB',
+            [254]: 'MAILA',
+            [255]: 'ANY',
+            [256]: 'URI',
+            [257]: 'CAA',
+            [258]: 'AVC',
+            [259]: 'DOA',
+            [260]: 'AMTRELAY',
+            [261]: 'ZONEVERSION',
+            [32768]: 'TA',
+            [32769]: 'DLV',
+        };
+        return typeMap[type] ?? `TYPE${type}`;
+    }
+    dnsResponseClassToString(cls) {
+        const isFlush = !!(cls & 32768);
+        const baseClass = cls & 0x7fff;
+        let classStr;
+        switch (baseClass) {
+            case 1:
+                classStr = 'IN';
+                break;
+            case 3:
+                classStr = 'CH';
+                break;
+            case 4:
+                classStr = 'HS';
+                break;
+            case 255:
+                classStr = 'ANY';
+                break;
+            default:
+                classStr = `CLASS${baseClass}`;
+        }
+        return isFlush ? `${classStr}|FLUSH` : classStr;
+    }
+    dnsQuestionClassToString(cls) {
+        const isQU = !!(cls & 32768);
+        const baseClass = cls & 0x7fff;
+        let classStr;
+        switch (baseClass) {
+            case 1:
+                classStr = 'IN';
+                break;
+            case 3:
+                classStr = 'CH';
+                break;
+            case 4:
+                classStr = 'HS';
+                break;
+            case 255:
+                classStr = 'ANY';
+                break;
+            default:
+                classStr = `CLASS${baseClass}`;
+        }
+        return isQU ? `${classStr}|QU` : classStr;
+    }
+    logMdnsMessage(msg, log = this.log, text = 'Decoded mDNS message') {
+        log.info(`${text}: ID ${MAGENTA}${msg.id}${nf}, QR ${GREEN}${msg.qr === 0 ? 'Query' : 'Response'}${nf}, OPCODE ${MAGENTA}${msg.opcode}${nf}, AA ${MAGENTA}${msg.aa}${nf}, TC ${MAGENTA}${msg.tc}${nf}, RD ${MAGENTA}${msg.rd}${nf}, RA ${MAGENTA}${msg.ra}${nf}, Z ${MAGENTA}${msg.z}${nf}, RCODE ${MAGENTA}${msg.rcode}${nf}, QDCount ${MAGENTA}${msg.qdCount}${nf}, ANCount ${MAGENTA}${msg.anCount}${nf}, NSCount ${MAGENTA}${msg.nsCount}${nf}, ARCount ${MAGENTA}${msg.arCount}${nf}`);
+        msg.questions?.forEach((question) => {
+            log.info(`Question: ${CYAN}${question.name}${nf} type ${idn}${this.dnsTypeToString(question.type)}${rs}${nf} class ${CYAN}${this.dnsQuestionClassToString(question.class)}${nf}`);
+        });
+        msg.answers?.forEach((answer) => {
+            log.info(`Answer: ${CYAN}${answer.name}${nf} type ${idn}${this.dnsTypeToString(answer.type)}${rs}${nf} class ${CYAN}${this.dnsResponseClassToString(answer.class)}${nf} ttl ${CYAN}${answer.ttl}${nf} data ${CYAN}${answer.data}${nf}`);
+        });
+        msg.authorities?.forEach((authority) => {
+            log.info(`Authority: ${CYAN}${authority.name}${nf} type ${idn}${this.dnsTypeToString(authority.type)}${rs}${nf} class ${CYAN}${this.dnsResponseClassToString(authority.class)}${nf} ttl ${CYAN}${authority.ttl}${nf} data ${CYAN}${authority.data}${nf}`);
+        });
+        msg.additionals?.forEach((additional) => {
+            log.info(`Additional: ${CYAN}${additional.name}${nf} type ${idn}${this.dnsTypeToString(additional.type)}${rs}${nf} class ${CYAN}${this.dnsResponseClassToString(additional.class)}${nf} ttl ${CYAN}${additional.ttl}${nf} data ${CYAN}${additional.data}${nf}`);
+        });
+        log.info(`---\n`);
+    }
+    logDevices() {
+        this.log.info(`Discovered query devices: ${MAGENTA}${this.deviceQueries.size}${nf}`);
+        const deviceQueryArray = Array.from(this.deviceQueries.entries());
+        deviceQueryArray.sort(([addressA], [addressB]) => {
+            const partsA = addressA.split('.').map(Number);
+            const partsB = addressB.split('.').map(Number);
+            for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+                const diff = (partsA[i] || 0) - (partsB[i] || 0);
+                if (diff !== 0)
+                    return diff;
+            }
+            return 0;
+        });
+        deviceQueryArray.forEach(([rinfo, response]) => {
+            this.log.info(`- ${MAGENTA}${rinfo}${nf} family ${BLUE}${response.rinfo.family}${nf} address ${BLUE}${response.rinfo.address}${nf} port ${BLUE}${response.rinfo.port}${nf}`);
+        });
+        this.log.info(`Discovered response devices: ${MAGENTA}${this.deviceResponses.size}${nf}`);
+        const deviceResponseArray = Array.from(this.deviceResponses.entries());
+        deviceResponseArray.sort(([addressA], [addressB]) => {
+            const partsA = addressA.split(/[:.]/).map((part) => parseInt(part, 16));
+            const partsB = addressB.split(/[:.]/).map((part) => parseInt(part, 16));
+            for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+                const diff = (partsA[i] || 0) - (partsB[i] || 0);
+                if (diff !== 0)
+                    return diff;
+            }
+            return 0;
+        });
+        deviceResponseArray.forEach(([rinfo, response]) => {
+            this.log.info(`- ${MAGENTA}${rinfo}${nf} family ${BLUE}${response.rinfo.family}${nf} address ${BLUE}${response.rinfo.address}${nf} port ${BLUE}${response.rinfo.port}${nf} PTR ${GREEN}${response.dataPTR}${nf}`);
+        });
+    }
+}