@netkitty/codec 1.0.0

package/dist/headers/UDP.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UDP = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToNumber_1 = require("../helper/BufferToNumber");
+const NumberToBuffer_1 = require("../helper/NumberToBuffer");
+const IPToBuffer_1 = require("../helper/IPToBuffer");
+class UDP extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'udp';
+        this.matchKeys = ['ipproto:17'];
+        //Produces a port demux key from BOTH ports (a protocol's well-known port may be src or dst).
+        this.demuxProducers = [
+            { field: 'dstport', namespace: 'udpport', kind: 'uint' },
+            { field: 'srcport', namespace: 'udpport', kind: 'uint' }
+        ];
+        this.name = 'User Datagram Protocol';
+        this.nickname = 'UDP';
+    }
+    /**
+     * Calculate UDP Checksum
+     * @protected
+     * @param udpHeaderBuffer
+     */
+    calculateUDPChecksum(udpHeaderBuffer) {
+        const udpHeaderLength = udpHeaderBuffer.length;
+        const ipVersion = this.prevCodecModule.instance.version.getValue();
+        let pseudoHeaderBuffer = Buffer.from([]);
+        const sourceIp = this.prevCodecModule.instance.sip.getValue();
+        const destinationIp = this.prevCodecModule.instance.dip.getValue();
+        if (ipVersion === 4) {
+            //4 Bytes
+            const sourceIPv4Buffer = Buffer.from(sourceIp.split('.').map((value) => parseInt(value)));
+            const destinationIPv4Buffer = Buffer.from(destinationIp.split('.').map((value) => parseInt(value)));
+            //IPv4 Pseudo header
+            pseudoHeaderBuffer = Buffer.concat([
+                sourceIPv4Buffer,
+                destinationIPv4Buffer,
+                (0, NumberToBuffer_1.UInt8ToBuffer)(0), //Reserved field
+                (0, NumberToBuffer_1.UInt8ToBuffer)(17), //Protocol type (UDP = 17)
+                Buffer.from([(udpHeaderLength >> 8) & 0xFF]),
+                Buffer.from([udpHeaderLength & 0xFF])
+            ]);
+        }
+        else if (ipVersion === 6) {
+            //16 Bytes
+            const sourceIPv6Buffer = (0, IPToBuffer_1.IPv6ToBuffer)(sourceIp);
+            const destinationIPv6Buffer = (0, IPToBuffer_1.IPv6ToBuffer)(destinationIp);
+            //IPv6 Pseudo header
+            pseudoHeaderBuffer = Buffer.concat([
+                sourceIPv6Buffer,
+                destinationIPv6Buffer,
+                (0, NumberToBuffer_1.UInt8ToBuffer)(0), //Reserved field
+                (0, NumberToBuffer_1.UInt8ToBuffer)(0), //Reserved field
+                (0, NumberToBuffer_1.UInt8ToBuffer)(0), //Reserved field
+                (0, NumberToBuffer_1.UInt8ToBuffer)(17), //Protocol type (UDP = 17)
+                Buffer.from([(udpHeaderLength >> 8) & 0xFF]),
+                Buffer.from([udpHeaderLength & 0xFF])
+            ]);
+        }
+        else {
+            return 0;
+        }
+        let dataBuffer = Buffer.concat([pseudoHeaderBuffer, udpHeaderBuffer]);
+        if (dataBuffer.length % 2)
+            dataBuffer = Buffer.concat([dataBuffer, Buffer.from('00', 'hex')]);
+        const data = Uint8Array.from(dataBuffer);
+        let sum = 0;
+        for (let i = 0; i < data.length; i += 2)
+            sum += (data[i] << 8) + (data[i + 1] || 0);
+        while (sum > 0xFFFF)
+            sum = (sum & 0xFFFF) + (sum >>> 16);
+        const _cs = (~sum) & 0xFFFF;
+        return _cs === 0 ? 0xFFFF : _cs;
+    }
+    static #schemaCache;
+    //Class-cached SCHEMA (④): field closures are functions taking dynamic `this` via .call(this).
+    //fieldUInt is a static factory, so `this.fieldUInt` below resolves against the class.
+    get SCHEMA() {
+        return (UDP.#schemaCache ??= UDP.#buildSchema());
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            properties: {
+                //Migrated to the declarative field building block: one call replaces the hand-mirrored
+                //decode/encode twin, byte-for-byte identical (proven by the unchanged golden + round-trip).
+                srcport: this.fieldUInt('srcport', 0, 2, 'Source Port'),
+                dstport: this.fieldUInt('dstport', 2, 2, 'Destination Port'),
+                length: {
+                    type: 'integer',
+                    label: 'Length',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: function () {
+                        this.instance.length.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(4, 2)));
+                    },
+                    encode: function () {
+                        const length = this.instance.length.getValue(0);
+                        if (length) {
+                            this.instance.length.setValue(length);
+                            this.writeBytes(4, (0, NumberToBuffer_1.UInt16ToBuffer)(length));
+                        }
+                        else {
+                            this.instance.length.setValue(length);
+                            this.writeBytes(4, (0, NumberToBuffer_1.UInt16ToBuffer)(length));
+                            this.addPostPacketEncodeHandler(() => {
+                                let startCount = false;
+                                let udpLength = 0;
+                                this.codecModules.forEach((codecModule) => {
+                                    if (codecModule === this)
+                                        startCount = true;
+                                    if (startCount)
+                                        udpLength += codecModule.length;
+                                });
+                                this.instance.length.setValue(udpLength);
+                                this.writeBytes(4, (0, NumberToBuffer_1.UInt16ToBuffer)(udpLength));
+                            }, 1);
+                        }
+                    }
+                },
+                checksum: {
+                    type: 'integer',
+                    label: 'Checksum',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: function () {
+                        this.instance.checksum.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(6, 2)));
+                    },
+                    encode: function () {
+                        const checksum = this.instance.checksum.getValue(0);
+                        if (checksum) {
+                            this.instance.checksum.setValue(checksum);
+                            this.writeBytes(6, (0, NumberToBuffer_1.UInt16ToBuffer)(checksum));
+                        }
+                        else {
+                            this.writeBytes(6, (0, NumberToBuffer_1.UInt16ToBuffer)(checksum));
+                            this.instance.checksum.setValue(checksum);
+                            this.addPostPacketEncodeHandler(() => {
+                                let startCount = false;
+                                let udpHeaderWithDataLength = 0;
+                                this.codecModules.forEach((codecModule) => {
+                                    if (codecModule === this)
+                                        startCount = true;
+                                    if (startCount)
+                                        udpHeaderWithDataLength += codecModule.length;
+                                });
+                                const calcChecksum = this.calculateUDPChecksum(this.packet.subarray(this.startPos, this.startPos + udpHeaderWithDataLength));
+                                this.instance.checksum.setValue(calcChecksum);
+                                this.writeBytes(6, (0, NumberToBuffer_1.UInt16ToBuffer)(calcChecksum));
+                            }, 2);
+                        }
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        if (!this.prevCodecModule)
+            return false;
+        //UDP sits above IPv4 (protocol field) or IPv6 (next-header field) — accept its demux value from
+        //either, so match() stays consistent with the shared 'ipproto:17' dispatch key.
+        if (this.prevCodecModule.instance.protocol.getValue() === 0x11)
+            return true;
+        if (this.prevCodecModule.instance.nxt.getValue() === 0x11)
+            return true;
+        return false;
+    }
+}
+exports.UDP = UDP;

package/dist/headers/VLAN_802dot1Q.d.ts

@@ -0,0 +1,24 @@
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * VLAN 802.1Q — the IEEE 802.1Q VLAN tag, selected when the carrying layer's EtherType is the TPID 0x8100.
+ * This codec decodes the 4-octet tag that follows the TPID: the 2-octet Tag Control Information split into
+ * a 3-bit Priority / PCP (`priority`, top bits of offset 0), a 1-bit Drop Eligible Indicator (`dei`,
+ * boolean) and a 12-bit VLAN ID (`id`, the low 12 bits), followed by the 16-bit EtherType of the
+ * encapsulated frame (`etherType`, offset 2, a lowercase 4-hex string).
+ *
+ * The trailing `etherType` is published as an `ethertype` demux key so the tagged inner protocol
+ * (IPv4/IPv6/ARP, another VLAN for QinQ, GOOSE, SV…) is selected exactly as it would be off bare Ethernet.
+ * match() fires whenever the parent's EtherType is 0x8100, regardless of which layer carries it, so it
+ * handles both single- and stacked-tag frames.
+ */
+export declare class VLAN_802dot1Q extends BaseHeader {
+    SCHEMA: ProtocolJSONSchema;
+    readonly id: string;
+    readonly matchKeys: string[];
+    readonly demuxProducers: DemuxProducer[];
+    readonly name: string;
+    readonly nickname: string;
+    match(): boolean;
+}

package/dist/headers/VLAN_802dot1Q.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VLAN_802dot1Q = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const NumberToHex_1 = require("../helper/NumberToHex");
+const BufferToHex_1 = require("../helper/BufferToHex");
+/**
+ * VLAN 802.1Q — the IEEE 802.1Q VLAN tag, selected when the carrying layer's EtherType is the TPID 0x8100.
+ * This codec decodes the 4-octet tag that follows the TPID: the 2-octet Tag Control Information split into
+ * a 3-bit Priority / PCP (`priority`, top bits of offset 0), a 1-bit Drop Eligible Indicator (`dei`,
+ * boolean) and a 12-bit VLAN ID (`id`, the low 12 bits), followed by the 16-bit EtherType of the
+ * encapsulated frame (`etherType`, offset 2, a lowercase 4-hex string).
+ *
+ * The trailing `etherType` is published as an `ethertype` demux key so the tagged inner protocol
+ * (IPv4/IPv6/ARP, another VLAN for QinQ, GOOSE, SV…) is selected exactly as it would be off bare Ethernet.
+ * match() fires whenever the parent's EtherType is 0x8100, regardless of which layer carries it, so it
+ * handles both single- and stacked-tag frames.
+ */
+class VLAN_802dot1Q extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.SCHEMA = {
+            type: 'object',
+            properties: {
+                priority: {
+                    type: 'integer',
+                    minimum: 0,
+                    maximum: 7,
+                    default: 0,
+                    label: 'Priority',
+                    decode: () => {
+                        this.instance.priority.setValue(this.readBits(0, 2, 0, 3));
+                    },
+                    encode: () => {
+                        const priorityValue = this.instance.priority.getValue(0);
+                        this.instance.priority.setValue(priorityValue);
+                        this.writeBits(0, 2, 0, 3, priorityValue);
+                    }
+                },
+                dei: {
+                    type: 'boolean',
+                    label: 'DEI',
+                    decode: () => {
+                        this.instance.dei.setValue(!!this.readBits(0, 2, 3, 1));
+                    },
+                    encode: () => {
+                        const dei = !!this.instance.dei.getValue();
+                        this.instance.dei.setValue(dei);
+                        this.writeBits(0, 2, 3, 1, dei ? 1 : 0);
+                    }
+                },
+                id: {
+                    type: 'integer',
+                    minimum: 0,
+                    maximum: 4095,
+                    label: 'ID',
+                    decode: () => {
+                        this.instance.id.setValue(this.readBits(0, 2, 4, 12));
+                    },
+                    encode: () => {
+                        const vlanId = this.instance.id.getValue(0);
+                        this.instance.id.setValue(vlanId);
+                        this.writeBits(0, 2, 4, 12, vlanId);
+                    }
+                },
+                etherType: {
+                    type: 'string',
+                    minLength: 4,
+                    maxLength: 4,
+                    label: 'EtherType',
+                    decode: () => {
+                        this.instance.etherType.setValue((0, BufferToHex_1.BufferToHex)(this.readBytes(2, 2)));
+                    },
+                    encode: () => {
+                        const etherType = this.instance.etherType.getValue((0, NumberToHex_1.UInt16ToHex)(0x0000), (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        const typeBuffer = Buffer.from(etherType, 'hex');
+                        if (typeBuffer.length < 2)
+                            typeBuffer.fill(0, 0, 1);
+                        this.writeBytes(2, typeBuffer.subarray(0, 2));
+                    }
+                }
+            }
+        };
+        this.id = 'vlan';
+        this.matchKeys = ['ethertype:8100'];
+        this.demuxProducers = [{ field: 'etherType', namespace: 'ethertype', kind: 'string' }];
+        this.name = '802.1Q Virtual LAN';
+        this.nickname = 'VLAN';
+    }
+    match() {
+        if (!this.prevCodecModule)
+            return false;
+        return this.prevCodecModule.instance.etherType.getValue() === (0, NumberToHex_1.UInt16ToHex)(0x8100);
+    }
+}
+exports.VLAN_802dot1Q = VLAN_802dot1Q;

package/dist/headers/VRRP.d.ts

@@ -0,0 +1,26 @@
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * VRRP — Virtual Router Redundancy Protocol (v2 RFC 3768, v3 RFC 5798), carried directly over IP as
+ * protocol 112. A fixed 8-byte header — Version (high nibble of byte 0) + Type (low nibble), Virtual
+ * Router ID, Priority, Count of addresses, then two version-specific bytes, then a Checksum — followed
+ * by the advertised virtual IP addresses (4-byte IPv4 each). In v2 bytes 4/5 are Auth Type / whole-second
+ * Advertisement Interval and (with Auth Type 1) 8 trailing bytes of authentication data follow the
+ * address list; in v3 bytes 4/5 are a reserved nibble + 12-bit Max Advertisement Interval (centiseconds).
+ *
+ * The version is the high nibble of byte 0 and selects how bytes 4-5 and the trailer are interpreted;
+ * version-specific fields no-op when the decoded version does not match, so on encode each octet is
+ * written by exactly one field — a well-formed advertisement round-trips byte-for-byte. The checksum is
+ * honored verbatim (not recomputed — it differs by version and, in v3, covers an IP pseudo-header).
+ */
+export declare class VRRP extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly matchKeys: string[];
+    readonly name: string;
+    readonly nickname: string;
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}

package/dist/headers/VRRP.js

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VRRP = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToNumber_1 = require("../helper/BufferToNumber");
+const NumberToBuffer_1 = require("../helper/NumberToBuffer");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+const BufferToIP_1 = require("../helper/BufferToIP");
+const IPToBuffer_1 = require("../helper/IPToBuffer");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+/**
+ * VRRP — Virtual Router Redundancy Protocol (v2 RFC 3768, v3 RFC 5798), carried directly over IP as
+ * protocol 112. A fixed 8-byte header — Version (high nibble of byte 0) + Type (low nibble), Virtual
+ * Router ID, Priority, Count of addresses, then two version-specific bytes, then a Checksum — followed
+ * by the advertised virtual IP addresses (4-byte IPv4 each). In v2 bytes 4/5 are Auth Type / whole-second
+ * Advertisement Interval and (with Auth Type 1) 8 trailing bytes of authentication data follow the
+ * address list; in v3 bytes 4/5 are a reserved nibble + 12-bit Max Advertisement Interval (centiseconds).
+ *
+ * The version is the high nibble of byte 0 and selects how bytes 4-5 and the trailer are interpreted;
+ * version-specific fields no-op when the decoded version does not match, so on encode each octet is
+ * written by exactly one field — a well-formed advertisement round-trips byte-for-byte. The checksum is
+ * honored verbatim (not recomputed — it differs by version and, in v3, covers an IP pseudo-header).
+ */
+class VRRP extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'vrrp';
+        this.matchKeys = ['ipproto:112'];
+        this.name = 'Virtual Router Redundancy Protocol';
+        this.nickname = 'VRRP';
+        //A leaf header — nothing rides on top of a VRRP advertisement.
+        this.demuxProducers = [];
+    }
+    /**
+     * Bytes available to this header within the enclosing IP layer's payload. Mirrors the IP-carried
+     * pattern: for IPv4 the payload is (Total Length - IP header length); for IPv6 it is the Payload
+     * Length field. Falls back to the raw remaining buffer when there is no IP layer beneath (e.g. a
+     * malformed stack or a standalone decode), so match() and the address loop stay bounded.
+     * @private
+     */
+    #available() {
+        if (!this.prevCodecModule)
+            return this.packet.length - this.startPos;
+        const version = this.prevCodecModule.instance.version.getValue(0);
+        if (version === 4) {
+            const ipTotalLength = this.prevCodecModule.instance.length.getValue(0);
+            const available = ipTotalLength - this.prevCodecModule.length;
+            return available > 0 ? available : this.packet.length - this.startPos;
+        }
+        if (version === 6) {
+            const payloadLength = this.prevCodecModule.instance.plen.getValue(0);
+            return payloadLength > 0 ? payloadLength : this.packet.length - this.startPos;
+        }
+        return this.packet.length - this.startPos;
+    }
+    static #schemaCache;
+    //Class-cached SCHEMA: field closures are plain functions taking dynamic `this` via .call(this), so
+    //the structure is shareable and never rebuilt per packet. VRRP carries both v2 (RFC 3768) and v3
+    //(RFC 5798) advertisements; the version is the high nibble of byte 0 and selects how bytes 4-5 and
+    //the optional trailer are interpreted. Version-specific fields no-op when the decoded version does
+    //not match, so each octet is written by exactly one field on encode (byte-perfect round-trip).
+    get SCHEMA() {
+        return (VRRP.#schemaCache ??= VRRP.#buildSchema());
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'VRRP v${version} vrid=${vrid} prio=${priority}',
+            properties: {
+                version: {
+                    type: 'integer',
+                    label: 'Version',
+                    minimum: 0,
+                    maximum: 15,
+                    decode: function () {
+                        this.instance.version.setValue(this.readBits(0, 1, 0, 4));
+                        const version = this.instance.version.getValue(0);
+                        if (version !== 2 && version !== 3)
+                            this.recordError(this.instance.version.getPath(), 'VRRP version should be 2 or 3');
+                    },
+                    encode: function () {
+                        let version = this.instance.version.getValue(2, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        version = version > 15 ? 15 : version;
+                        version = version < 0 ? 0 : version;
+                        this.instance.version.setValue(version);
+                        this.writeBits(0, 1, 0, 4, version);
+                    }
+                },
+                type: {
+                    type: 'integer',
+                    label: 'Type',
+                    minimum: 0,
+                    maximum: 15,
+                    decode: function () {
+                        this.instance.type.setValue(this.readBits(0, 1, 4, 4));
+                    },
+                    encode: function () {
+                        const type = this.instance.type.getValue(1, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        this.instance.type.setValue(type);
+                        this.writeBits(0, 1, 4, 4, type);
+                    }
+                },
+                vrid: this.fieldUInt('vrid', 1, 1, 'Virtual Router ID'),
+                priority: this.fieldUInt('priority', 2, 1, 'Priority'),
+                count: this.fieldUInt('count', 3, 1, 'Count IP Addrs'),
+                authType: {
+                    type: 'integer',
+                    label: 'Auth Type',
+                    minimum: 0,
+                    maximum: 255,
+                    //v2 only: byte 4 is the Authentication Type (RFC 3768 §5.3.6). In v3 byte 4 holds the
+                    //reserved nibble + top of Max Adver Int, handled by rsvd/maxAdverInt below.
+                    decode: function () {
+                        const version = this.instance.version.getValue(0);
+                        if (version !== 2)
+                            return;
+                        this.instance.authType.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(4, 1)));
+                    },
+                    encode: function () {
+                        const version = this.instance.version.getValue(2);
+                        if (version !== 2)
+                            return;
+                        const authType = this.instance.authType.getValue(0);
+                        this.instance.authType.setValue(authType);
+                        this.writeBytes(4, Buffer.from([authType & 0xFF]));
+                    }
+                },
+                adverInt: {
+                    type: 'integer',
+                    label: 'Adver Int (seconds)',
+                    minimum: 0,
+                    maximum: 255,
+                    //v2 only: byte 5, advertisement interval in whole seconds (RFC 3768 §5.3.7).
+                    decode: function () {
+                        const version = this.instance.version.getValue(0);
+                        if (version !== 2)
+                            return;
+                        this.instance.adverInt.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(5, 1)));
+                    },
+                    encode: function () {
+                        const version = this.instance.version.getValue(2);
+                        if (version !== 2)
+                            return;
+                        const adverInt = this.instance.adverInt.getValue(1);
+                        this.instance.adverInt.setValue(adverInt);
+                        this.writeBytes(5, Buffer.from([adverInt & 0xFF]));
+                    }
+                },
+                rsvd: {
+                    type: 'integer',
+                    label: 'Reserved',
+                    minimum: 0,
+                    maximum: 15,
+                    //v3 only: high 4 bits of byte 4 are reserved (RFC 5798 §5.2.4). Preserved verbatim.
+                    decode: function () {
+                        const version = this.instance.version.getValue(0);
+                        if (version !== 3)
+                            return;
+                        this.instance.rsvd.setValue(this.readBits(4, 1, 0, 4));
+                    },
+                    encode: function () {
+                        const version = this.instance.version.getValue(2);
+                        if (version !== 3)
+                            return;
+                        const rsvd = this.instance.rsvd.getValue(0);
+                        this.instance.rsvd.setValue(rsvd);
+                        this.writeBits(4, 1, 0, 4, rsvd);
+                    }
+                },
+                maxAdverInt: {
+                    type: 'integer',
+                    label: 'Max Adver Int (centiseconds)',
+                    minimum: 0,
+                    maximum: 4095,
+                    //v3 only: low 4 bits of byte 4 + all of byte 5 = 12-bit Max Advertisement Interval in
+                    //centiseconds (RFC 5798 §5.2.5).
+                    decode: function () {
+                        const version = this.instance.version.getValue(0);
+                        if (version !== 3)
+                            return;
+                        this.instance.maxAdverInt.setValue(this.readBits(4, 2, 4, 12));
+                    },
+                    encode: function () {
+                        const version = this.instance.version.getValue(2);
+                        if (version !== 3)
+                            return;
+                        const maxAdverInt = this.instance.maxAdverInt.getValue(0);
+                        this.instance.maxAdverInt.setValue(maxAdverInt);
+                        this.writeBits(4, 2, 4, 12, maxAdverInt);
+                    }
+                },
+                reserved45: {
+                    type: 'string',
+                    label: 'Reserved',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    hidden: true,
+                    //Bytes 4-5 for any version other than 2 or 3 (a malformed or future advertisement):
+                    //no v2/v3 field owns them, so capture them verbatim here to keep the round-trip
+                    //lossless (decode never fails, and each octet is still written by exactly one field).
+                    decode: function () {
+                        const version = this.instance.version.getValue(0);
+                        if (version === 2 || version === 3)
+                            return;
+                        this.instance.reserved45.setValue((0, BufferToHex_1.BufferToHex)(this.readBytes(4, 2)));
+                    },
+                    encode: function () {
+                        const version = this.instance.version.getValue(2);
+                        if (version === 2 || version === 3)
+                            return;
+                        if (this.instance.reserved45.isUndefined())
+                            return;
+                        this.writeBytes(4, (0, HexToBuffer_1.HexToBuffer)(this.instance.reserved45.getValue('0000')));
+                    }
+                },
+                checksum: {
+                    type: 'integer',
+                    label: 'Checksum',
+                    minimum: 0,
+                    maximum: 65535,
+                    //Honoured verbatim (faithful executor): decode reads it, encode writes the same value
+                    //back untouched. VRRP checksums differ by version (v2 over the message only, v3 over
+                    //an IP pseudo-header too), so recomputation is left to the caller.
+                    decode: function () {
+                        this.instance.checksum.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(6, 2)));
+                    },
+                    encode: function () {
+                        let checksum = this.instance.checksum.getValue(0);
+                        checksum = checksum > 65535 ? 65535 : checksum;
+                        checksum = checksum < 0 ? 0 : checksum;
+                        this.instance.checksum.setValue(checksum);
+                        this.writeBytes(6, (0, NumberToBuffer_1.UInt16ToBuffer)(checksum));
+                    }
+                },
+                addresses: {
+                    type: 'array',
+                    label: 'IP Addresses',
+                    items: {
+                        type: 'string',
+                        label: 'IP Address',
+                        minLength: 7,
+                        maxLength: 15,
+                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.IPv4
+                    },
+                    //Count IPvX addresses follow the fixed 8-byte header. For IPv4-carried VRRP each
+                    //address is 4 bytes; IPv6-carried v3 (16-byte addresses) is not modelled here.
+                    decode: function () {
+                        const count = this.instance.count.getValue(0);
+                        const addresses = [];
+                        const available = this.#available();
+                        for (let i = 0; i < count; i++) {
+                            if (8 + i * 4 + 4 > available)
+                                break;
+                            addresses.push((0, BufferToIP_1.BufferToIPv4)(this.readBytes(8 + i * 4, 4)));
+                        }
+                        this.instance.addresses.setValue(addresses);
+                    },
+                    encode: function () {
+                        const addresses = this.instance.addresses.getValue();
+                        if (!addresses)
+                            return;
+                        addresses.forEach((address, i) => {
+                            this.writeBytes(8 + i * 4, (0, IPToBuffer_1.IPv4ToBuffer)(address));
+                        });
+                    }
+                },
+                authData: {
+                    type: 'string',
+                    label: 'Authentication Data',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    //v2 with Auth Type 1 (Simple Text Password, RFC 2338/3768): 8 trailing bytes of
+                    //authentication data after the address list. Kept as hex, re-emitted verbatim.
+                    decode: function () {
+                        const version = this.instance.version.getValue(0);
+                        const authType = this.instance.authType.getValue(0);
+                        if (version !== 2 || authType !== 1)
+                            return;
+                        const count = this.instance.count.getValue(0);
+                        //Bounded by the IP payload (mirrors the address loop) so a truncated auth packet
+                        //does not pull trailing L2 padding into the authentication field.
+                        if (8 + count * 4 + 8 > this.#available())
+                            return;
+                        this.instance.authData.setValue((0, BufferToHex_1.BufferToHex)(this.readBytes(8 + count * 4, 8)));
+                    },
+                    encode: function () {
+                        const version = this.instance.version.getValue(2);
+                        const authType = this.instance.authType.getValue(0);
+                        if (version !== 2 || authType !== 1)
+                            return;
+                        if (this.instance.authData.isUndefined())
+                            return;
+                        const count = this.instance.count.getValue(0);
+                        this.writeBytes(8 + count * 4, (0, HexToBuffer_1.HexToBuffer)(this.instance.authData.getValue('')));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        if (!this.prevCodecModule)
+            return false;
+        const protocol = this.prevCodecModule.instance.protocol.getValue(0);
+        const nxt = this.prevCodecModule.instance.nxt.getValue(0);
+        if (protocol !== 112 && nxt !== 112)
+            return false;
+        return this.#available() >= 8;
+    }
+}
+exports.VRRP = VRRP;

package/dist/headers/VXLAN.d.ts

@@ -0,0 +1,24 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * VXLAN — Virtual eXtensible LAN (RFC 7348), a Layer-2-over-UDP overlay on UDP port 4789. An 8-byte
+ * header — Flags(1, the 'I' bit marks the VNI valid), 3 reserved bytes, the 24-bit VNI (VXLAN Network
+ * Identifier), and 1 reserved byte — is followed by a COMPLETE inner Ethernet frame.
+ *
+ * This codec decodes only its own 8-byte header (headerLength = 8); the inner Ethernet frame is left to
+ * the codec's normal recursion, which decodes it as a fresh eth/ip/… stack. That works because
+ * EthernetII.match() already accepts a tunnel (vxlan/gre/geneve/…) as its parent — the demux
+ * generalization anticipates tunnels — so an inner Ethernet frame after VXLAN is dispatched to
+ * EthernetII automatically. The whole nested packet round-trips byte-for-byte layer by layer.
+ */
+export declare class VXLAN extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}