@netkitty/codec 1.0.0

package/dist/headers/DCCP.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DCCP = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+const NumberToBuffer_1 = require("../helper/NumberToBuffer");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+/**
+ * DCCP — Datagram Congestion Control Protocol (RFC 4340), carried directly over IP as protocol 33. The
+ * generic header begins with Source Port (2), Destination Port (2), Data Offset (1, in 32-bit words —
+ * the length of the whole DCCP header including options), a byte split into CCVal (high 4 bits) and
+ * CsCov (low 4 bits), a 2-byte Checksum, and a byte split into Res (3 bits), Type (4 bits — 0 Request,
+ * 1 Response, 2 Data, 3 Ack, 4 DataAck, 5 CloseReq, 6 Close, 7 Reset) and X (1 bit, Extended Sequence
+ * Numbers). After that byte come the (X-dependent-width) Reserved + Sequence Number and any type-specific
+ * fields / options — everything up to Data Offset*4.
+ *
+ * To sidestep the X sequence-width branch and stay byte-perfect, this codec structures only the fixed
+ * 9-byte prefix (ports / data offset / ccval+cscov / checksum / res+type+x) and keeps the remainder of
+ * the header — Reserved, the Sequence/Ack numbers, per-type fields and options — verbatim as
+ * `headerOptions` hex (bytes 9 .. DataOffset*4). Application data after the header is kept as `payload`
+ * hex, bounded by the enclosing IP datagram so an inflated Data Offset can't read past the IP payload.
+ * The Checksum is honored verbatim, never recomputed; Data Offset is honored when supplied, else derived
+ * from the actual bytes. A well-formed datagram round-trips byte-for-byte.
+ */
+class DCCP extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'dccp';
+        this.name = 'Datagram Congestion Control Protocol';
+        this.nickname = 'DCCP';
+        this.matchKeys = ['ipproto:33'];
+        //A leaf header — application data is kept verbatim as `payload` hex.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (DCCP.#schemaCache ??= DCCP.#buildSchema());
+    }
+    /**
+     * Bytes of DCCP the IP layer below says are available. IPv4 carries a total-length field, so the
+     * DCCP payload is (total length - IP header length); IPv6 carries the payload length directly
+     * (plen). Mirrors the GRE/OSPF #available() pattern so header-option and payload reads are bounded
+     * by the real on-wire length rather than trusting Data Offset alone. Returns the captured remainder
+     * when neither IP length is present.
+     */
+    #available() {
+        let available = this.packet.length - this.startPos;
+        const prev = this.prevCodecModule;
+        if (prev && prev.id === 'ipv4') {
+            const ipPayload = prev.instance.length.getValue(0) - prev.length;
+            if (ipPayload >= 0 && ipPayload < available)
+                available = ipPayload;
+        }
+        else if (prev && prev.id === 'ipv6') {
+            const ipPayload = prev.instance.plen.getValue(0);
+            if (ipPayload >= 0 && ipPayload < available)
+                available = ipPayload;
+        }
+        return available < 0 ? 0 : available;
+    }
+    /**
+     * Header-relative end offset of the DCCP header = Data Offset*4, clamped down to the bytes the IP
+     * layer actually made available. Both `headerOptions` (which starts at the fixed 9-byte prefix) and
+     * the `payload` split are bounded by this.
+     */
+    #headerEnd() {
+        let end = this.instance.dataOffset.getValue(0) * 4;
+        const available = this.#available();
+        if (end > available)
+            end = available;
+        if (end < 0)
+            end = 0;
+        return end;
+    }
+    /** A big-endian bit-slice within a single octet at `offset`, read/written in place. */
+    static #bitField(name, offset, bitOffset, bitLength, label) {
+        const maximum = (2 ** bitLength) - 1;
+        return {
+            type: 'integer',
+            label: label,
+            minimum: 0,
+            maximum: maximum,
+            decode: function () {
+                this.instance[name].setValue(this.readBits(offset, 1, bitOffset, bitLength));
+            },
+            encode: function () {
+                const node = this.instance[name];
+                let value = node.getValue(0);
+                if (value > maximum)
+                    value = maximum;
+                if (value < 0)
+                    value = 0;
+                node.setValue(value);
+                this.writeBits(offset, 1, bitOffset, bitLength, value);
+            }
+        };
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'DCCP ${srcPort}→${dstPort} type=${type}',
+            properties: {
+                srcPort: this.fieldUInt('srcPort', 0, 2, 'Source Port'),
+                dstPort: this.fieldUInt('dstPort', 2, 2, 'Destination Port'),
+                //Data Offset (32-bit words) = the length of the whole DCCP header incl. options. Honored
+                //when supplied (a crafted datagram may lie); else derived from the fixed 9-byte prefix
+                //plus the verbatim headerOptions bytes, rounded up to a word.
+                dataOffset: {
+                    type: 'integer',
+                    label: 'Data Offset',
+                    minimum: 0,
+                    maximum: 255,
+                    decode: function () {
+                        this.instance.dataOffset.setValue(this.readBytes(4, 1)[0]);
+                    },
+                    encode: function () {
+                        const provided = this.instance.dataOffset.getValue();
+                        let value;
+                        if (provided !== undefined && provided !== null) {
+                            value = provided;
+                        }
+                        else {
+                            const optBytes = (0, HexToBuffer_1.HexToBuffer)(this.instance.headerOptions.getValue('')).length;
+                            value = Math.ceil((9 + optBytes) / 4);
+                        }
+                        if (value > 255) {
+                            this.recordError(this.instance.dataOffset.getPath(), 'Maximum value is 255');
+                            value = 255;
+                        }
+                        if (value < 0)
+                            value = 0;
+                        this.instance.dataOffset.setValue(value);
+                        this.writeBytes(4, (0, NumberToBuffer_1.UInt8ToBuffer)(value));
+                    }
+                },
+                //Byte 5: CCVal (high 4 bits) + CsCov (low 4 bits).
+                ccval: this.#bitField('ccval', 5, 0, 4, 'CCVal'),
+                cscov: this.#bitField('cscov', 5, 4, 4, 'Checksum Coverage'),
+                //Honored verbatim: the DCCP checksum (ones-complement over pseudo-header + coverage) is
+                //never recomputed, so a captured datagram round-trips byte-for-byte.
+                checksum: this.fieldUInt('checksum', 6, 2, 'Checksum'),
+                //Byte 8: Res (3 bits) + Type (4 bits) + X (1 bit, Extended Sequence Numbers).
+                res: this.#bitField('res', 8, 0, 3, 'Reserved'),
+                type: this.#bitField('type', 8, 3, 4, 'Type'),
+                x: this.#bitField('x', 8, 7, 1, 'Extended Sequence Numbers'),
+                //Everything after the fixed 9-byte prefix up to Data Offset*4 — Reserved, the
+                //(X-dependent) Sequence/Ack numbers, per-type fields and options — kept verbatim so the
+                //X sequence-width branch never has to be modelled. Bounded by #headerEnd.
+                headerOptions: {
+                    type: 'string',
+                    label: 'Header Options',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const end = this.#headerEnd();
+                        this.instance.headerOptions.setValue(end > 9 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(9, end - 9)) : '');
+                    },
+                    encode: function () {
+                        const headerOptions = this.instance.headerOptions.getValue('');
+                        if (headerOptions)
+                            this.writeBytes(9, (0, HexToBuffer_1.HexToBuffer)(headerOptions));
+                    }
+                },
+                //Application data after the DCCP header, kept verbatim. Runs from Data Offset*4 to the end
+                //of the IP payload (a leaf — DCCP consumes the whole IP datagram, nothing recurses after).
+                payload: {
+                    type: 'string',
+                    label: 'Payload',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const available = this.#available();
+                        let start = this.instance.dataOffset.getValue(0) * 4;
+                        if (start < 9)
+                            start = 9;
+                        if (start > available)
+                            start = available;
+                        this.instance.payload.setValue(available > start ? (0, BufferToHex_1.BufferToHex)(this.readBytes(start, available - start)) : '');
+                    },
+                    encode: function () {
+                        const payload = this.instance.payload.getValue('');
+                        if (!payload)
+                            return;
+                        let start = this.instance.dataOffset.getValue(0) * 4;
+                        if (start < 9)
+                            start = 9;
+                        this.writeBytes(start, (0, HexToBuffer_1.HexToBuffer)(payload));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //DCCP sits directly on IPv4 (protocol field) or IPv6 (next-header field) with protocol 33, and
+        //needs at least the smallest generic header (12 bytes, X=0) of IP payload present.
+        if (!this.prevCodecModule)
+            return false;
+        const protocol = this.prevCodecModule.instance.protocol.getValue(0);
+        const nextHeader = this.prevCodecModule.instance.nxt.getValue(0);
+        if (protocol !== 33 && nextHeader !== 33)
+            return false;
+        return this.#available() >= 12;
+    }
+}
+exports.DCCP = DCCP;

package/dist/headers/DHCP.d.ts

@@ -0,0 +1,26 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * DHCP — Dynamic Host Configuration Protocol (RFC 2131), built on the BOOTP message format (RFC 951).
+ * A 236-byte fixed header (op/htype/hlen/hops, xid, secs, flags, the four IP addresses, 16-byte client
+ * hardware address, 64-byte server name and 128-byte boot file name), then the 4-byte magic cookie
+ * 0x63825363 (RFC 2131 §3), then variable options in code-length-value form (§9) terminated by End
+ * (255). Rides UDP, ports 67 (server) and 68 (client).
+ *
+ * Options are carried generically (code + verbatim hex value) so every option — standard or unknown —
+ * round-trips byte-for-byte; per-option semantic decoding is a later enrichment. sname/file/chaddr are
+ * kept as raw hex (they contain fixed-width zero padding an editor must preserve). Any bytes after the
+ * End option (the BOOTP minimum-size padding) fall to the following raw layer.
+ */
+export declare class DHCP extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    readonly heuristicFallback: boolean;
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}

package/dist/headers/DHCP.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DHCP = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const BufferToNumber_1 = require("../helper/BufferToNumber");
+const NumberToBuffer_1 = require("../helper/NumberToBuffer");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+/**
+ * DHCP — Dynamic Host Configuration Protocol (RFC 2131), built on the BOOTP message format (RFC 951).
+ * A 236-byte fixed header (op/htype/hlen/hops, xid, secs, flags, the four IP addresses, 16-byte client
+ * hardware address, 64-byte server name and 128-byte boot file name), then the 4-byte magic cookie
+ * 0x63825363 (RFC 2131 §3), then variable options in code-length-value form (§9) terminated by End
+ * (255). Rides UDP, ports 67 (server) and 68 (client).
+ *
+ * Options are carried generically (code + verbatim hex value) so every option — standard or unknown —
+ * round-trips byte-for-byte; per-option semantic decoding is a later enrichment. sname/file/chaddr are
+ * kept as raw hex (they contain fixed-width zero padding an editor must preserve). Any bytes after the
+ * End option (the BOOTP minimum-size padding) fall to the following raw layer.
+ */
+class DHCP extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'dhcp';
+        this.name = 'Dynamic Host Configuration Protocol';
+        this.nickname = 'DHCP';
+        //Server port 67 and client port 68 (both UDP). heuristicFallback because the 0x63825363 magic
+        //cookie at offset 236 is a reliable 32-bit content signature.
+        this.matchKeys = ['udpport:67', 'udpport:68'];
+        this.heuristicFallback = true;
+        //A leaf header — nothing demuxes above DHCP.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (DHCP.#schemaCache ??= DHCP.#buildSchema());
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            properties: {
+                op: this.fieldUInt('op', 0, 1, 'Message Type'),
+                htype: this.fieldUInt('htype', 1, 1, 'Hardware Type'),
+                hlen: this.fieldUInt('hlen', 2, 1, 'Hardware Address Length'),
+                hops: this.fieldUInt('hops', 3, 1, 'Hops'),
+                xid: this.fieldUInt('xid', 4, 4, 'Transaction ID'),
+                secs: this.fieldUInt('secs', 8, 2, 'Seconds Elapsed'),
+                flags: this.fieldUInt('flags', 10, 2, 'Flags'),
+                ciaddr: this.fieldIPv4('ciaddr', 12, 'Client IP Address'),
+                yiaddr: this.fieldIPv4('yiaddr', 16, 'Your IP Address'),
+                siaddr: this.fieldIPv4('siaddr', 20, 'Next Server IP Address'),
+                giaddr: this.fieldIPv4('giaddr', 24, 'Relay Agent IP Address'),
+                chaddr: this.fieldHex('chaddr', 28, 16, 'Client Hardware Address'),
+                sname: this.fieldHex('sname', 44, 64, 'Server Host Name'),
+                file: this.fieldHex('file', 108, 128, 'Boot File Name'),
+                magicCookie: this.fieldHex('magicCookie', 236, 4, 'Magic Cookie'),
+                options: {
+                    type: 'array',
+                    label: 'Options',
+                    items: {
+                        type: 'object',
+                        label: 'Option',
+                        properties: {
+                            code: {
+                                type: 'integer',
+                                label: 'Code',
+                                minimum: 0,
+                                maximum: 255
+                            },
+                            value: {
+                                type: 'string',
+                                label: 'Value',
+                                contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX
+                            }
+                        }
+                    },
+                    decode: function () {
+                        //Options begin right after the 4-byte magic cookie (fixed 236 + 4 = 240).
+                        const available = this.packet.length - this.startPos;
+                        const options = [];
+                        let offset = 240;
+                        //Code(1) [Len(1) Value(Len)]. Pad(0) and End(255) are bare single bytes; End
+                        //terminates the option block (trailing BOOTP padding falls to the raw layer).
+                        //readBytes clamps at the buffer end and offset always advances, so a truncated
+                        //or option-list-with-no-End packet cannot read out of bounds or loop forever.
+                        while (offset < available) {
+                            const code = (0, BufferToNumber_1.BufferToUInt8)(this.readBytes(offset, 1));
+                            offset += 1;
+                            if (code === 0) {
+                                options.push({ code: 0 });
+                                continue;
+                            }
+                            if (code === 255) {
+                                options.push({ code: 255 });
+                                break;
+                            }
+                            //Need a length byte; if the buffer ends here, stop.
+                            if (offset >= available) {
+                                options.push({ code: code });
+                                break;
+                            }
+                            const length = (0, BufferToNumber_1.BufferToUInt8)(this.readBytes(offset, 1));
+                            offset += 1;
+                            let value = Buffer.alloc(0);
+                            if (length) {
+                                value = this.readBytes(offset, length);
+                                offset += length;
+                            }
+                            options.push({ code: code, value: (0, BufferToHex_1.BufferToHex)(value) });
+                        }
+                        this.instance.options.setValue(options);
+                    },
+                    encode: function () {
+                        const options = this.instance.options.getValue();
+                        if (!options)
+                            return;
+                        let offset = 240;
+                        options.forEach((option) => {
+                            const code = option.code ? option.code : 0;
+                            this.writeBytes(offset, (0, NumberToBuffer_1.UInt8ToBuffer)(code));
+                            offset += 1;
+                            //Pad (0) and End (255): a single byte, no length/value.
+                            if (code === 0 || code === 255)
+                                return;
+                            const value = Buffer.from(option.value ? option.value : '', 'hex');
+                            this.writeBytes(offset, (0, NumberToBuffer_1.UInt8ToBuffer)(value.length));
+                            offset += 1;
+                            if (value.length) {
+                                this.writeBytes(offset, value);
+                                offset += value.length;
+                            }
+                        });
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        if (!this.prevCodecModule)
+            return false;
+        //Magic cookie 0x63825363 at offset 236 (RFC 2131 §3) — the fixed BOOTP header is always 236
+        //bytes, so a valid DHCP message is at least 240 bytes.
+        if (this.packet.length - this.startPos < 240)
+            return false;
+        return (0, BufferToHex_1.BufferToHex)(this.readBytes(236, 4)) === '63825363';
+    }
+}
+exports.DHCP = DHCP;

package/dist/headers/DHCPFailover.d.ts

@@ -0,0 +1,30 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * DHCP Failover protocol (ISC DHCPv4 failover, draft-ietf-dhc-failover), TCP port 647. A failover
+ * connection carries a stream of messages between the primary and secondary DHCP servers. Every message
+ * begins with a fixed header — a 2-byte Message Length (the total octet count of the whole message,
+ * including this length field), a 1-byte Message Type (1 POOLREQ, 2 POOLRESP, 3 BNDUPD, 4 BNDACK,
+ * 5 CONNECT, 6 CONNECTACK, 7 UPDREQ, 8 UPDDONE, 9 UPDREQALL, 10 STATE, 11 CONTACT, 12 DISCONNECT) —
+ * followed by the rest of the message: a payload-offset byte, a time and transaction id, then a series
+ * of option TLVs (2-byte option code, 2-byte option length, value).
+ *
+ * The payload after the Message Type is a chain of option TLVs whose meaning is message-type- and
+ * cross-connection-dependent (server states, MCLT, binding status, message digests, TLS negotiation), so
+ * this single-message codec keeps everything after the type verbatim as `payload` hex (byte-perfect) and
+ * does not sub-decode the options. The Message Length is auto-computed from the payload on encode when
+ * not supplied, else honored verbatim (a crafted message may carry any Length); the message is bounded by
+ * Length so a second pipelined message or trailing bytes are left to the codec's recursion / RawData. A
+ * well-formed message round-trips byte-for-byte.
+ */
+export declare class DHCPFailover extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}

package/dist/headers/DHCPFailover.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DHCPFailover = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+const BufferToNumber_1 = require("../helper/BufferToNumber");
+const NumberToBuffer_1 = require("../helper/NumberToBuffer");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+/**
+ * DHCP Failover protocol (ISC DHCPv4 failover, draft-ietf-dhc-failover), TCP port 647. A failover
+ * connection carries a stream of messages between the primary and secondary DHCP servers. Every message
+ * begins with a fixed header — a 2-byte Message Length (the total octet count of the whole message,
+ * including this length field), a 1-byte Message Type (1 POOLREQ, 2 POOLRESP, 3 BNDUPD, 4 BNDACK,
+ * 5 CONNECT, 6 CONNECTACK, 7 UPDREQ, 8 UPDDONE, 9 UPDREQALL, 10 STATE, 11 CONTACT, 12 DISCONNECT) —
+ * followed by the rest of the message: a payload-offset byte, a time and transaction id, then a series
+ * of option TLVs (2-byte option code, 2-byte option length, value).
+ *
+ * The payload after the Message Type is a chain of option TLVs whose meaning is message-type- and
+ * cross-connection-dependent (server states, MCLT, binding status, message digests, TLS negotiation), so
+ * this single-message codec keeps everything after the type verbatim as `payload` hex (byte-perfect) and
+ * does not sub-decode the options. The Message Length is auto-computed from the payload on encode when
+ * not supplied, else honored verbatim (a crafted message may carry any Length); the message is bounded by
+ * Length so a second pipelined message or trailing bytes are left to the codec's recursion / RawData. A
+ * well-formed message round-trips byte-for-byte.
+ */
+class DHCPFailover extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'dhcpfo';
+        this.name = 'DHCP Failover';
+        this.nickname = 'DHCPFO';
+        this.matchKeys = ['tcpport:647'];
+        //A leaf header — the option TLVs are message-type- and connection-dependent; kept as payload hex.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (DHCPFailover.#schemaCache ??= DHCPFailover.#buildSchema());
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'DHCPFO type=${type} len=${length}',
+            properties: {
+                length: {
+                    type: 'integer',
+                    label: 'Message Length',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: function () {
+                        this.instance.length.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(0, 2)));
+                    },
+                    encode: function () {
+                        //Message Length counts the whole message = 2-byte length + 1-byte type + payload.
+                        //Honored when supplied (a crafted message may lie); else derived from the payload.
+                        const provided = this.instance.length.getValue();
+                        let value = (provided !== undefined && provided !== null)
+                            ? provided
+                            : 3 + (0, HexToBuffer_1.HexToBuffer)(this.instance.payload.getValue('')).length;
+                        if (value > 65535) {
+                            this.recordError(this.instance.length.getPath(), 'Maximum value is 65535');
+                            value = 65535;
+                        }
+                        this.instance.length.setValue(value);
+                        this.writeBytes(0, (0, NumberToBuffer_1.UInt16ToBuffer)(value));
+                    }
+                },
+                type: this.fieldUInt('type', 2, 1, 'Message Type'),
+                //Everything after the Message Type (payload-offset, time, xid, and the option TLVs), kept
+                //verbatim. Bounded by the Message Length (the message ends at offset Length) and the
+                //captured bytes, so trailing / pipelined data is left to the codec's recursion / RawData.
+                payload: {
+                    type: 'string',
+                    label: 'Payload',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const remaining = this.packet.length - this.startPos;
+                        const length = this.instance.length.getValue(0);
+                        let end = length;
+                        if (end > remaining || end < 3)
+                            end = remaining;
+                        this.instance.payload.setValue(end > 3 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(3, end - 3)) : '');
+                    },
+                    encode: function () {
+                        const payload = this.instance.payload.getValue('');
+                        if (payload)
+                            this.writeBytes(3, (0, HexToBuffer_1.HexToBuffer)(payload));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //DHCP Failover rides on TCP port 647. The message header carries no strong content magic, so the
+        //well-known port is the signature. Require at least the fixed message header (2-byte length +
+        //1-byte type + payload-offset + 4-byte time = 8 bytes) so tiny stray port-647 payloads fall
+        //through to raw; decode itself never throws on a shorter/malformed message.
+        if (!this.prevCodecModule || this.prevCodecModule.id !== 'tcp')
+            return false;
+        return this.packet.length - this.startPos >= 8;
+    }
+}
+exports.DHCPFailover = DHCPFailover;

package/dist/headers/DHCPv6.d.ts

@@ -0,0 +1,25 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * DHCPv6 — Dynamic Host Configuration Protocol for IPv6 (RFC 8415). A client/server message is a
+ * 1-byte message-type, a 3-byte transaction-id, then options in a regular code-length-value form:
+ * option-code(2) + option-len(2) + option-data(option-len), no padding. Rides UDP, client port 546 and
+ * server port 547 (over IPv6, multicast ff02::1:2).
+ *
+ * Options are carried generically (code + verbatim hex data) so every option — including ones whose
+ * data is itself nested options (IA_NA/IA_PD) — round-trips byte-for-byte; per-option / nested decoding
+ * is a later enrichment. Relay-agent messages (RELAY-FORW 12 / RELAY-REPL 13) have a DIFFERENT body
+ * (hop-count + 2 IPv6 addresses + options), so their body is kept verbatim (rawBody) rather than
+ * misparsed as a transaction-id, preserving a byte-perfect round-trip.
+ */
+export declare class DHCPv6 extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}