@netkitty/codec 1.0.0

package/dist/headers/RIPng.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RIPng = 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");
+/**
+ * RIPng — RIP for IPv6 (RFC 2080), carried over UDP port 521 (the RIPng process address ff02::9). A
+ * RIPng message is a 4-byte fixed header — Command (1 Request, 2 Response), Version (= 1) and a 2-byte
+ * reserved field (kept verbatim) — followed by zero or more 20-byte Route Table Entries (RTEs). Each
+ * RTE is an IPv6 Prefix (16 bytes), a Route Tag (2 bytes), a Prefix Length (1 byte) and a Metric
+ * (1 byte). An RTE with Metric 255 and Prefix Length 0 is a Next Hop RTE (RFC 2080 §2.1.1) carrying the
+ * next-hop address for the RTEs that follow it; it is carried structurally like any other RTE.
+ *
+ * The message has no length field of its own — the RTE array runs to the end of the UDP payload
+ * (udp.length - 8), which bounds the walk so retained Ethernet padding / trailing bytes are not
+ * absorbed. The IPv6 Prefix is kept verbatim as a lower-case hex string so any prefix (including a
+ * zero prefix, or a next-hop address) round-trips byte-for-byte. RIPng is a leaf — nothing rides on it.
+ */
+class RIPng extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'ripng';
+        this.name = 'RIP for IPv6';
+        this.nickname = 'RIPng';
+        this.matchKeys = ['udpport:521'];
+        //A leaf header — nothing is carried on top of a RIPng message.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (RIPng.#schemaCache ??= RIPng.#buildSchema());
+    }
+    /** The payload length bounded by the UDP datagram (so retained padding/FCS is not absorbed). */
+    #payloadLength() {
+        let available = this.packet.length - this.startPos;
+        if (this.prevCodecModule && this.prevCodecModule.id === 'udp') {
+            const udpLength = this.prevCodecModule.instance.length.getValue(0);
+            if (udpLength >= 8 && udpLength - 8 < available)
+                available = udpLength - 8;
+        }
+        return available < 0 ? 0 : available;
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'RIPng cmd=${command} ${rtes.length} RTEs',
+            properties: {
+                //Fixed 4-byte header: Command (1 Request / 2 Response), Version (= 1), 2-byte reserved.
+                command: this.fieldUInt('command', 0, 1, 'Command'),
+                version: this.fieldUInt('version', 1, 1, 'Version'),
+                //Reserved (2 bytes, must be zero per RFC 2080 but kept verbatim so a non-zero value in a
+                //crafted/non-conformant message still round-trips byte-for-byte).
+                reserved: this.fieldUInt('reserved', 2, 2, 'Reserved'),
+                //Route Table Entries — 20 bytes each, running from offset 4 to the end of the UDP payload.
+                rtes: {
+                    type: 'array',
+                    label: 'Route Table Entries',
+                    items: {
+                        type: 'object',
+                        label: 'RTE',
+                        properties: {
+                            prefix: { type: 'string', label: 'IPv6 Prefix', contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX },
+                            routeTag: { type: 'integer', label: 'Route Tag', minimum: 0, maximum: 65535 },
+                            prefixLength: { type: 'integer', label: 'Prefix Length', minimum: 0, maximum: 255 },
+                            metric: { type: 'integer', label: 'Metric', minimum: 0, maximum: 255 }
+                        }
+                    },
+                    decode: function () {
+                        //No length field: the RTE array runs to the end of the UDP payload, 20 bytes each.
+                        //A trailing fragment shorter than 20 bytes (truncation/padding) is not consumed.
+                        const end = this.#payloadLength();
+                        const rtes = [];
+                        let offset = 4;
+                        while (offset + 20 <= end) {
+                            rtes.push({
+                                prefix: (0, BufferToHex_1.BufferToHex)(this.readBytes(offset, 16)),
+                                routeTag: (0, BufferToNumber_1.BufferToUInt16)(this.readBytes(offset + 16, 2)),
+                                prefixLength: (0, BufferToNumber_1.BufferToUInt8)(this.readBytes(offset + 18, 1)),
+                                metric: (0, BufferToNumber_1.BufferToUInt8)(this.readBytes(offset + 19, 1))
+                            });
+                            offset += 20;
+                        }
+                        this.instance.rtes.setValue(rtes);
+                    },
+                    encode: function () {
+                        const rtes = this.instance.rtes.getValue([]);
+                        if (!rtes)
+                            return;
+                        let offset = 4;
+                        for (let i = 0; i < rtes.length; i++) {
+                            const rte = rtes[i];
+                            //The Prefix is a fixed 16 bytes: pad/truncate a crafted value to exactly 16
+                            //(32 hex chars) so a malformed input can never shift the following RTEs.
+                            const prefix = (rte.prefix ? rte.prefix : '').padStart(32, '0').slice(-32);
+                            this.writeBytes(offset, (0, HexToBuffer_1.HexToBuffer)(prefix));
+                            this.writeBytes(offset + 16, (0, NumberToBuffer_1.UInt16ToBuffer)(this.#clamp(`rtes[${i}].routeTag`, rte.routeTag, 65535)));
+                            this.writeBytes(offset + 18, (0, NumberToBuffer_1.UInt8ToBuffer)(this.#clamp(`rtes[${i}].prefixLength`, rte.prefixLength, 255)));
+                            this.writeBytes(offset + 19, (0, NumberToBuffer_1.UInt8ToBuffer)(this.#clamp(`rtes[${i}].metric`, rte.metric, 255)));
+                            offset += 20;
+                        }
+                    }
+                }
+            }
+        };
+    }
+    /** Clamp a crafted RTE field to [0, max], recording an error rather than throwing or wrapping. */
+    #clamp(path, value, max) {
+        let v = (value === undefined || value === null) ? 0 : value;
+        if (v > max) {
+            this.recordError(path, `Maximum value is ${max}`);
+            v = max;
+        }
+        if (v < 0) {
+            this.recordError(path, 'Minimum value is 0');
+            v = 0;
+        }
+        return v;
+    }
+    match() {
+        //RIPng rides on UDP port 521. Require the full 4-byte fixed header within the UDP payload and a
+        //conformant Command (1 Request / 2 Response) + Version (1) signature, so non-RIPng traffic on
+        //port 521 falls through to raw rather than claiming a layer.
+        if (!this.prevCodecModule || this.prevCodecModule.id !== 'udp')
+            return false;
+        if (this.#payloadLength() < 4)
+            return false;
+        const command = (0, BufferToNumber_1.BufferToUInt8)(this.readBytes(0, 1, true));
+        const version = (0, BufferToNumber_1.BufferToUInt8)(this.readBytes(1, 1, true));
+        if (command !== 1 && command !== 2)
+            return false;
+        if (version !== 1)
+            return false;
+        return true;
+    }
+}
+exports.RIPng = RIPng;

package/dist/headers/RMCP.d.ts

@@ -0,0 +1,26 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * RMCP — Remote Management Control Protocol (ASF 2.0 / DSP0136, IPMI 2.0), UDP port 623. The 4-byte
+ * header is Version (0x06 = RMCP 1.0), a Reserved byte, a Sequence Number (0xFF = no ACK requested),
+ * and a Class-of-Message byte whose top bit is the ACK flag, bit 6 is reserved, and the low 6 bits are
+ * the message class (6 = ASF, 7 = IPMI, 8 = OEM).
+ *
+ * The payload after the header depends on the class. For an ASF message (class 6) the payload is an
+ * ASF frame — IANA Enterprise Number (4542 for ASF), Message Type, Message Tag, a reserved byte, a
+ * Data Length, and the data — which this codec decodes structurally (the trailing data is kept as raw
+ * hex so any length rounds-trips). For IPMI (7, a session-wrapped message) and OEM (8) classes the
+ * payload is kept verbatim (rawBody) — those are stateful session protocols for a higher layer. A
+ * well-formed message round-trips byte-for-byte.
+ */
+export declare class RMCP 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/RMCP.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RMCP = 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");
+/**
+ * RMCP — Remote Management Control Protocol (ASF 2.0 / DSP0136, IPMI 2.0), UDP port 623. The 4-byte
+ * header is Version (0x06 = RMCP 1.0), a Reserved byte, a Sequence Number (0xFF = no ACK requested),
+ * and a Class-of-Message byte whose top bit is the ACK flag, bit 6 is reserved, and the low 6 bits are
+ * the message class (6 = ASF, 7 = IPMI, 8 = OEM).
+ *
+ * The payload after the header depends on the class. For an ASF message (class 6) the payload is an
+ * ASF frame — IANA Enterprise Number (4542 for ASF), Message Type, Message Tag, a reserved byte, a
+ * Data Length, and the data — which this codec decodes structurally (the trailing data is kept as raw
+ * hex so any length rounds-trips). For IPMI (7, a session-wrapped message) and OEM (8) classes the
+ * payload is kept verbatim (rawBody) — those are stateful session protocols for a higher layer. A
+ * well-formed message round-trips byte-for-byte.
+ */
+class RMCP extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'rmcp';
+        this.name = 'Remote Management Control Protocol';
+        this.nickname = 'RMCP';
+        this.matchKeys = ['udpport:623'];
+        //A leaf header — the IPMI session/OEM payloads are stateful and belong to a higher layer.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (RMCP.#schemaCache ??= RMCP.#buildSchema());
+    }
+    /** The payload length bounded by the UDP datagram (so a retained FCS/padding is not absorbed). */
+    #payloadLength() {
+        let available = this.packet.length - this.startPos;
+        if (this.prevCodecModule && this.prevCodecModule.id === 'udp') {
+            const udpLength = this.prevCodecModule.instance.length.getValue(0);
+            if (udpLength >= 8 && udpLength - 8 < available)
+                available = udpLength - 8;
+        }
+        return available < 0 ? 0 : available;
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'RMCP class=${messageClass.class} seq=${sequence}',
+            properties: {
+                version: this.fieldUInt('version', 0, 1, 'Version'),
+                reserved: this.fieldHex('reserved', 1, 1, 'Reserved'),
+                sequence: this.fieldUInt('sequence', 2, 1, 'Sequence Number'),
+                //Class-of-Message byte (ASF DSP0136 / IPMI, MSB first): bit 7 = ACK flag, bits 6:5 =
+                //reserved (2 bits, kept for byte-perfect), bits 4:0 = message class (6 = ASF, 7 = IPMI,
+                //8 = OEM). readBits' bitOffset 0 = MSB, so ACK is bitOffset 0, reserved 1..2, class 3..7.
+                messageClass: {
+                    type: 'object',
+                    label: 'Class of Message',
+                    properties: {
+                        ack: {
+                            type: 'boolean',
+                            label: 'ACK',
+                            decode: function () { this.instance.messageClass.ack.setValue(!!this.readBits(3, 1, 0, 1)); },
+                            encode: function () {
+                                const ack = !!this.instance.messageClass.ack.getValue();
+                                this.instance.messageClass.ack.setValue(ack);
+                                this.writeBits(3, 1, 0, 1, ack ? 1 : 0);
+                            }
+                        },
+                        reserved: {
+                            type: 'integer',
+                            label: 'Reserved',
+                            minimum: 0,
+                            maximum: 3,
+                            hidden: true,
+                            decode: function () { this.instance.messageClass.reserved.setValue(this.readBits(3, 1, 1, 2)); },
+                            encode: function () { this.writeBits(3, 1, 1, 2, this.instance.messageClass.reserved.getValue(0)); }
+                        },
+                        class: {
+                            type: 'integer',
+                            label: 'Message Class',
+                            minimum: 0,
+                            maximum: 31,
+                            decode: function () { this.instance.messageClass.class.setValue(this.readBits(3, 1, 3, 5)); },
+                            encode: function () { this.writeBits(3, 1, 3, 5, this.instance.messageClass.class.getValue(0)); }
+                        }
+                    }
+                },
+                //Class-driven payload: an ASF message (class 6) is decoded structurally; every other class
+                //(IPMI session, OEM) is kept verbatim. Runs after messageClass so the class is known.
+                asf: {
+                    type: 'object',
+                    label: 'ASF Message',
+                    properties: {
+                        enterprise: { type: 'integer', label: 'IANA Enterprise Number', minimum: 0, maximum: 4294967295 },
+                        type: { type: 'integer', label: 'Message Type', minimum: 0, maximum: 255 },
+                        tag: { type: 'integer', label: 'Message Tag', minimum: 0, maximum: 255 },
+                        reserved: { type: 'string', label: 'Reserved', contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX },
+                        dataLength: { type: 'integer', label: 'Data Length', minimum: 0, maximum: 255 },
+                        data: { type: 'string', label: 'Data', contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX }
+                    },
+                    decode: function () {
+                        const available = this.#payloadLength();
+                        const classValue = this.instance.messageClass.class.getValue(0);
+                        //ASF class with a full 8-byte ASF header present (enterprise+type+tag+reserved+len).
+                        if (classValue === 6 && available >= 12) {
+                            this.instance.asf.enterprise.setValue((0, BufferToNumber_1.BufferToUInt32)(this.readBytes(4, 4)));
+                            this.instance.asf.type.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(8, 1)));
+                            this.instance.asf.tag.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(9, 1)));
+                            this.instance.asf.reserved.setValue((0, BufferToHex_1.BufferToHex)(this.readBytes(10, 1)));
+                            this.instance.asf.dataLength.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(11, 1)));
+                            this.instance.asf.data.setValue(available > 12 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(12, available - 12)) : '');
+                            this.instance.rawBody.setValue('');
+                            return;
+                        }
+                        //IPMI / OEM / a too-short ASF frame: keep the payload verbatim.
+                        this.instance.rawBody.setValue(available > 4 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(4, available - 4)) : '');
+                    },
+                    encode: function () {
+                        //A verbatim body (IPMI/OEM, or a short-ASF fallback) is re-emitted as-is and wins.
+                        const rawBody = this.instance.rawBody.getValue('');
+                        if (rawBody) {
+                            this.writeBytes(4, (0, HexToBuffer_1.HexToBuffer)(rawBody));
+                            return;
+                        }
+                        //Only emit an ASF header when one was actually decoded/provided (the mandatory
+                        //Enterprise Number is present). A bare 4-byte class-6 payload (e.g. an ASF-class
+                        //RMCP ACK: 06 00 seq 86) has no ASF message and must NOT gain phantom bytes.
+                        const classValue = this.instance.messageClass.class.getValue(0);
+                        const enterprise = this.instance.asf.enterprise.getValue();
+                        if (classValue !== 6 || enterprise === undefined || enterprise === null)
+                            return;
+                        this.writeBytes(4, (0, NumberToBuffer_1.UInt32ToBuffer)(enterprise));
+                        this.writeBytes(8, (0, NumberToBuffer_1.UInt8ToBuffer)(this.instance.asf.type.getValue(0)));
+                        this.writeBytes(9, (0, NumberToBuffer_1.UInt8ToBuffer)(this.instance.asf.tag.getValue(0)));
+                        this.writeBytes(10, (0, HexToBuffer_1.HexToBuffer)(this.instance.asf.reserved.getValue('00')));
+                        this.writeBytes(11, (0, NumberToBuffer_1.UInt8ToBuffer)(this.instance.asf.dataLength.getValue(0)));
+                        const data = this.instance.asf.data.getValue('');
+                        if (data)
+                            this.writeBytes(12, (0, HexToBuffer_1.HexToBuffer)(data));
+                    }
+                },
+                rawBody: { type: 'string', label: 'Body', contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX, hidden: true }
+            }
+        };
+    }
+    match() {
+        //Require the 4-byte RMCP header within the UDP payload (a shorter datagram on port 623 is not
+        //an RMCP message and must fall through to raw rather than claim an un-decodable layer).
+        return !!this.prevCodecModule && this.prevCodecModule.id === 'udp' && this.#payloadLength() >= 4;
+    }
+}
+exports.RMCP = RMCP;

package/dist/headers/RSVP.d.ts

@@ -0,0 +1,31 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * RSVP — Resource ReSerVation Protocol (RFC 2205), carried directly over IP as protocol 46. Every RSVP
+ * message opens with an 8-byte common header: a byte splitting Version (high 4 bits, 1 for RFC 2205) and
+ * Flags (low 4 bits), a Message Type (1 Path, 2 Resv, 3 PathErr, 4 ResvErr, 5 PathTear, 6 ResvTear, 7
+ * ResvConf), a 2-byte RSVP Checksum, a 1-byte Send_TTL, a 1-byte Reserved, and a 2-byte RSVP Length (the
+ * whole message octet count including this common header). The header is followed by a sequence of
+ * objects, each a 2-byte Length (the object octet count including its own 4-byte header) + 1-byte
+ * Class-Num + 1-byte C-Type + contents.
+ *
+ * The object contents are class/C-Type specific and several (SESSION, SENDER_TSPEC, FLOWSPEC, …) need
+ * cross-object and policy context, so this codec keeps each object's contents verbatim as `data` hex
+ * (byte-perfect) and does not sub-decode them. The RSVP Length is honored verbatim when supplied on
+ * encode (a crafted message may lie) and derived from the objects otherwise; each object's Length is
+ * likewise honored-else-derived. The Checksum is honored verbatim, never recomputed. Object walking is
+ * doubly bounded — by the RSVP Length field and by the bytes the IP layer actually made available — so a
+ * lying length can't read past the datagram, and trailing / pipelined bytes are left to the codec's
+ * recursion / RawData. A well-formed message round-trips byte-for-byte.
+ */
+export declare class RSVP 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/RSVP.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RSVP = 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");
+/**
+ * RSVP — Resource ReSerVation Protocol (RFC 2205), carried directly over IP as protocol 46. Every RSVP
+ * message opens with an 8-byte common header: a byte splitting Version (high 4 bits, 1 for RFC 2205) and
+ * Flags (low 4 bits), a Message Type (1 Path, 2 Resv, 3 PathErr, 4 ResvErr, 5 PathTear, 6 ResvTear, 7
+ * ResvConf), a 2-byte RSVP Checksum, a 1-byte Send_TTL, a 1-byte Reserved, and a 2-byte RSVP Length (the
+ * whole message octet count including this common header). The header is followed by a sequence of
+ * objects, each a 2-byte Length (the object octet count including its own 4-byte header) + 1-byte
+ * Class-Num + 1-byte C-Type + contents.
+ *
+ * The object contents are class/C-Type specific and several (SESSION, SENDER_TSPEC, FLOWSPEC, …) need
+ * cross-object and policy context, so this codec keeps each object's contents verbatim as `data` hex
+ * (byte-perfect) and does not sub-decode them. The RSVP Length is honored verbatim when supplied on
+ * encode (a crafted message may lie) and derived from the objects otherwise; each object's Length is
+ * likewise honored-else-derived. The Checksum is honored verbatim, never recomputed. Object walking is
+ * doubly bounded — by the RSVP Length field and by the bytes the IP layer actually made available — so a
+ * lying length can't read past the datagram, and trailing / pipelined bytes are left to the codec's
+ * recursion / RawData. A well-formed message round-trips byte-for-byte.
+ */
+class RSVP extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'rsvp';
+        this.name = 'Resource ReSerVation Protocol';
+        this.nickname = 'RSVP';
+        this.matchKeys = ['ipproto:46'];
+        //A leaf header — object contents require per-class, policy-dependent parsing.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (RSVP.#schemaCache ??= RSVP.#buildSchema());
+    }
+    /**
+     * Bytes of RSVP the IP layer below says are available. IPv4 carries a total-length field, so the
+     * RSVP payload is (total length - IP header length); IPv6 carries the payload length directly (plen).
+     * Mirrors the OSPF/GRE #available() pattern so object walking is bounded by the real on-wire length
+     * rather than trusting the RSVP Length field alone (which a malformed packet may overstate). Falls
+     * back to the captured bytes after this header when neither IP length is present.
+     * @private
+     */
+    #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 RSVP message: the RSVP Length field, clamped down to the bytes
+     * the IP layer actually made available (#available), and never below the 8-byte common header. Object
+     * walking is bounded by this so a corrupt Length can't read past the IP payload, and any bytes beyond
+     * it (padding / a pipelined message) fall through to the codec's recursion / RawData.
+     * @private
+     */
+    #messageEnd() {
+        let end = this.instance.length.getValue(0);
+        const available = this.#available();
+        if (available && available < end)
+            end = available;
+        if (!end || end < 8)
+            end = 8;
+        if (available && end > available)
+            end = available;
+        return end;
+    }
+    /** Effective on-wire byte length of one object: its Length field when supplied, else 4 + its data. */
+    static #objectLength(object) {
+        const provided = Number(object && object.length);
+        if (Number.isFinite(provided) && provided > 0)
+            return provided;
+        const data = object && object.data ? String(object.data) : '';
+        return 4 + (0, HexToBuffer_1.HexToBuffer)(data).length;
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'RSVP msgType=${msgType} len=${length}',
+            properties: {
+                //==== Common header (8 bytes, RFC 2205 §3.1.1) ====
+                //Byte 0 high nibble: Version (1 for RFC 2205). Read/written as its own bit field so the
+                //Flags nibble below is preserved (writeBits is read-modify-write).
+                version: {
+                    type: 'integer',
+                    label: 'Version',
+                    minimum: 0,
+                    maximum: 15,
+                    decode: function () {
+                        this.instance.version.setValue(this.readBits(0, 1, 0, 4));
+                    },
+                    encode: function () {
+                        const value = this.instance.version.getValue(1);
+                        this.instance.version.setValue(value);
+                        this.writeBits(0, 1, 0, 4, value);
+                    }
+                },
+                //Byte 0 low nibble: Flags. Reserved bits are kept verbatim so a non-canonical frame still
+                //round-trips byte-for-byte.
+                flags: {
+                    type: 'integer',
+                    label: 'Flags',
+                    minimum: 0,
+                    maximum: 15,
+                    decode: function () {
+                        this.instance.flags.setValue(this.readBits(0, 1, 4, 4));
+                    },
+                    encode: function () {
+                        const value = this.instance.flags.getValue(0);
+                        this.instance.flags.setValue(value);
+                        this.writeBits(0, 1, 4, 4, value);
+                    }
+                },
+                msgType: this.fieldUInt('msgType', 1, 1, 'Message Type'),
+                //Honored verbatim: the RSVP checksum (ones-complement over the message) is never
+                //recomputed, so a captured message round-trips byte-for-byte. A zero value means no
+                //checksum was transmitted (RFC 2205 §3.1.1).
+                checksum: this.fieldUInt('checksum', 2, 2, 'Checksum'),
+                sendTTL: this.fieldUInt('sendTTL', 4, 1, 'Send TTL'),
+                //Reserved byte — kept verbatim and re-emitted for byte-perfect.
+                reserved: this.fieldUInt('reserved', 5, 1, 'Reserved'),
+                length: {
+                    type: 'integer',
+                    label: 'Length',
+                    minimum: 8,
+                    maximum: 65535,
+                    decode: function () {
+                        this.instance.length.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(6, 2)));
+                    },
+                    encode: function () {
+                        //RSVP Length counts the whole message = 8-byte common header + all objects. Honored
+                        //when supplied (a crafted message may lie); else derived from the objects.
+                        const provided = this.instance.length.getValue();
+                        let value;
+                        if (provided !== undefined && provided !== null) {
+                            value = provided;
+                        }
+                        else {
+                            const objects = this.instance.objects.getValue();
+                            let total = 8;
+                            if (Array.isArray(objects)) {
+                                for (const object of objects)
+                                    total += RSVP.#objectLength(object);
+                            }
+                            value = total;
+                        }
+                        if (value > 65535) {
+                            this.recordError(this.instance.length.getPath(), 'Maximum value is 65535');
+                            value = 65535;
+                        }
+                        if (value < 8)
+                            value = 8;
+                        this.instance.length.setValue(value);
+                        this.writeBytes(6, (0, NumberToBuffer_1.UInt16ToBuffer)(value));
+                    }
+                },
+                //==== Objects (RFC 2205 §3.1.2) ====
+                //Each object: Length(2) + Class-Num(1) + C-Type(1) + contents. Contents kept verbatim as
+                //`data` hex (byte-perfect); class/C-Type specific parsing is deliberately not attempted.
+                //Walking is bounded by #messageEnd (RSVP Length ∧ IP payload), so a lying object Length
+                //can't run past the datagram and trailing bytes are left to the codec.
+                objects: {
+                    type: 'array',
+                    label: 'Objects',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            length: { type: 'integer', label: 'Length', minimum: 0, maximum: 65535 },
+                            classNum: { type: 'integer', label: 'Class-Num', minimum: 0, maximum: 255 },
+                            cType: { type: 'integer', label: 'C-Type', minimum: 0, maximum: 255 },
+                            data: { type: 'string', label: 'Data', contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX }
+                        }
+                    },
+                    decode: function () {
+                        const end = this.#messageEnd();
+                        const objects = [];
+                        let offset = 8;
+                        //Each object needs at least its own 4-byte header within the message.
+                        while (offset + 4 <= end) {
+                            const objectLength = (0, BufferToNumber_1.BufferToUInt16)(this.readBytes(offset, 2, true));
+                            const classNum = this.readBytes(offset + 2, 1, true)[0];
+                            const cType = this.readBytes(offset + 3, 1, true)[0];
+                            //A Length below the 4-byte header is malformed and would stall the walk —
+                            //record it and stop (decode never throws).
+                            if (objectLength < 4) {
+                                this.recordError(this.instance.objects.getPath(), `Invalid object length ${objectLength}`);
+                                break;
+                            }
+                            //Contents run to the object's Length but never past the message end.
+                            let dataEnd = offset + objectLength;
+                            if (dataEnd > end)
+                                dataEnd = end;
+                            const dataStart = offset + 4;
+                            const data = dataEnd > dataStart ? (0, BufferToHex_1.BufferToHex)(this.readBytes(dataStart, dataEnd - dataStart)) : '';
+                            objects.push({ length: objectLength, classNum: classNum, cType: cType, data: data });
+                            offset += objectLength;
+                        }
+                        //The object header bytes are peeked dryRun (so a malformed-length break leaves
+                        //them to trailing RawData), and an empty object (Length 4, no contents) does no
+                        //non-dry data read of its own. Mark the whole consumed object region with one
+                        //non-dry read so headerLength covers every byte the walk captured — otherwise an
+                        //empty trailing object is re-decoded as trailing RawData and duplicated on encode.
+                        const consumedEnd = offset < end ? offset : end;
+                        if (consumedEnd > 8)
+                            this.readBytes(8, consumedEnd - 8);
+                        this.instance.objects.setValue(objects);
+                    },
+                    encode: function () {
+                        const objects = this.instance.objects.getValue();
+                        if (!Array.isArray(objects))
+                            return;
+                        let offset = 8;
+                        for (const object of objects) {
+                            const dataBuffer = (0, HexToBuffer_1.HexToBuffer)(object && object.data ? String(object.data) : '');
+                            //Object Length honored when supplied (may lie), else derived from contents.
+                            const providedLength = Number(object && object.length);
+                            const lengthValue = (Number.isFinite(providedLength) && providedLength > 0)
+                                ? providedLength
+                                : 4 + dataBuffer.length;
+                            const classNum = Number(object && object.classNum) || 0;
+                            const cType = Number(object && object.cType) || 0;
+                            this.writeBytes(offset, (0, NumberToBuffer_1.UInt16ToBuffer)(lengthValue > 65535 ? 65535 : lengthValue));
+                            this.writeBytes(offset + 2, Buffer.from([classNum & 0xff, cType & 0xff]));
+                            if (dataBuffer.length)
+                                this.writeBytes(offset + 4, dataBuffer);
+                            //Physical layout always advances by the actual bytes written (4 + contents),
+                            //independent of a lying Length field — mirrors BGP's honor-else-derive body.
+                            offset += 4 + dataBuffer.length;
+                        }
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        if (!this.prevCodecModule)
+            return false;
+        //RSVP sits directly on IP (protocol 46). Accept the demux value from either the IPv4 protocol
+        //field or the IPv6 next-header field, and require at least the full 8-byte common header of IP
+        //payload to be present.
+        const protocol = this.prevCodecModule.instance.protocol.getValue(0);
+        const nextHeader = this.prevCodecModule.instance.nxt.getValue(0);
+        if (protocol !== 46 && nextHeader !== 46)
+            return false;
+        return this.#available() >= 8;
+    }
+}
+exports.RSVP = RSVP;

package/dist/headers/RTCP.d.ts

@@ -0,0 +1,34 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * RTCP — RTP Control Protocol (RFC 3550 §6), the companion control channel to RTP. Rides UDP on
+ * dynamically negotiated ports (classically the RTP media port + 1, or multiplexed onto the media port
+ * with rtcp-mux, RFC 5761), so there is no fixed well-known port; a small set of common defaults is
+ * declared as matchKeys and selection stays strictly port-bucketed (see match()).
+ *
+ * Every RTCP packet begins with a 4-byte common header — Version (2 bits, always 2), Padding (1 bit),
+ * a 5-bit count whose meaning is packet-type-specific (Reception Report Count for SR/RR, Source Count
+ * for SDES/BYE), an 8-bit Packet Type (200 SR, 201 RR, 202 SDES, 203 BYE, 204 APP, 205 RTPFB, 206
+ * PSFB, 207 XR) and a 16-bit Length in 32-bit words minus one (RFC 3550 §6.4.1) — and, for the
+ * report-bearing types, an SSRC of the sender. RTCP packets are transmitted as COMPOUND packets:
+ * several stacked back-to-back in a single UDP datagram (RFC 3550 §6.1).
+ *
+ * This minimal codec structures the FIRST packet's common header (version/padding/count/packetType/
+ * length) plus its SSRC, then keeps that first packet's remaining body verbatim as `body` hex (bounded
+ * by the Length field — packet-type-specific decoding of SR sender info / report blocks / SDES chunks
+ * is a later enrichment), and keeps any further compound packets verbatim as `rest` hex (bounded by
+ * the UDP payload). The Length is honored when supplied (a crafted packet may lie) else derived from
+ * the body; every field is width-clamped so a decoded value always re-encodes. A well-formed datagram
+ * round-trips byte-for-byte.
+ */
+export declare class RTCP extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}