@netkitty/codec 1.0.0

package/dist/headers/OSPF.js

@@ -0,0 +1,365 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OSPF = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+const BufferToIP_1 = require("../helper/BufferToIP");
+const IPToBuffer_1 = require("../helper/IPToBuffer");
+const BufferToHex_1 = require("../helper/BufferToHex");
+/**
+ * OSPF — Open Shortest Path First (OSPFv2, RFC 2328), carried directly on IP as protocol 89. This codec
+ * decodes the 24-octet common header: an 8-bit Version (`version`, offset 0), an 8-bit Message Type
+ * (`type`, offset 1; 1 Hello, 2 Database Description, 3 LS Request, 4 LS Update, 5 LS Ack), a 16-bit
+ * Packet Length (`packetLength`, offset 2), the Source Router ID (`routerId`, IPv4, offset 4), the Area
+ * ID (`areaId`, IPv4, offset 8), a 16-bit Checksum (`checksum`, offset 12, honored verbatim and never
+ * recomputed so a captured packet round-trips), a 16-bit Auth Type (`auType`, offset 14) and the 8-octet
+ * Authentication field (`auth`, hex, offset 16).
+ *
+ * For a Hello (type 1) the body is decoded field-by-field: Network Mask (offset 24), 16-bit Hello Interval
+ * (offset 28), 8-bit Options (offset 30), 8-bit Router Priority (offset 31), 32-bit Router Dead Interval
+ * (offset 32), Designated and Backup Designated Routers (IPv4, offsets 36 and 40), then the Active
+ * Neighbors list (4-octet Router IDs from offset 44 onward). For all other types the payload is kept
+ * verbatim as `rawBody` hex from offset 24. Both are bounded by min(Packet Length, the bytes the IP layer
+ * below actually made available) and never below the 24-octet header, so a lying length field can't read
+ * past the real IP payload. match() fires on IPv4 protocol 89 or IPv6 Next Header 89 with a full common
+ * header present.
+ */
+class OSPF extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'ospf';
+        this.matchKeys = ['ipproto:89'];
+        this.name = 'Open Shortest Path First';
+        this.nickname = 'OSPF';
+        //A leaf header (OSPF LSA bodies are decoded inline / kept as rawBody).
+        this.demuxProducers = [];
+    }
+    /**
+     * Bytes of OSPF the IP layer below says are available.
+     * IPv4 carries a total-length field, so the OSPF payload is (total length - IP header length);
+     * IPv6 carries the payload length directly (plen). Mirrors the GRE #available() pattern so the
+     * body decode can be bounded by the real on-wire length rather than trusting the OSPF length
+     * field alone (which a malformed packet may overstate). Returns 0 when neither is present.
+     * @private
+     */
+    #available() {
+        const prev = this.prevCodecModule;
+        if (!prev)
+            return 0;
+        const ipv4TotalLength = prev.instance.length.getValue(0);
+        if (ipv4TotalLength)
+            return ipv4TotalLength - prev.length;
+        const ipv6PayloadLength = prev.instance.plen.getValue(0);
+        if (ipv6PayloadLength)
+            return ipv6PayloadLength;
+        return 0;
+    }
+    /**
+     * Header-relative end offset of the OSPF packet body: the OSPF length field, clamped down to the
+     * bytes the IP layer actually made available (#available). Never less than the 24-byte common
+     * header. Both the Hello neighbour list and the raw-body fallback are bounded by this.
+     * @private
+     */
+    #bodyEnd() {
+        let end = this.instance.packetLength.getValue(0);
+        const available = this.#available();
+        if (available && available < end)
+            end = available;
+        if (end < 24)
+            end = 24;
+        return end;
+    }
+    static #schemaCache;
+    //Class-cached SCHEMA (field closures are plain functions taking dynamic `this` via .call(this)).
+    get SCHEMA() {
+        return (OSPF.#schemaCache ??= OSPF.#buildSchema());
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'OSPF type=${type} rid=${routerId}',
+            properties: {
+                //==== Common header (24 bytes, RFC 2328 §A.3.1) ====
+                version: this.fieldUInt('version', 0, 1, 'Version'),
+                type: this.fieldUInt('type', 1, 1, 'Message Type'),
+                packetLength: this.fieldUInt('packetLength', 2, 2, 'Packet Length'),
+                routerId: {
+                    type: 'string',
+                    label: 'Source Router ID',
+                    minLength: 7,
+                    maxLength: 15,
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.IPv4,
+                    decode: function () {
+                        this.instance.routerId.setValue((0, BufferToIP_1.BufferToIPv4)(this.readBytes(4, 4)));
+                    },
+                    encode: function () {
+                        const routerId = this.instance.routerId.getValue('0.0.0.0', (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        this.instance.routerId.setValue(routerId);
+                        this.writeBytes(4, (0, IPToBuffer_1.IPv4ToBuffer)(routerId));
+                    }
+                },
+                areaId: {
+                    type: 'string',
+                    label: 'Area ID',
+                    minLength: 7,
+                    maxLength: 15,
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.IPv4,
+                    decode: function () {
+                        this.instance.areaId.setValue((0, BufferToIP_1.BufferToIPv4)(this.readBytes(8, 4)));
+                    },
+                    encode: function () {
+                        const areaId = this.instance.areaId.getValue('0.0.0.0', (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        this.instance.areaId.setValue(areaId);
+                        this.writeBytes(8, (0, IPToBuffer_1.IPv4ToBuffer)(areaId));
+                    }
+                },
+                //Honored verbatim: the OSPF checksum (ones-complement over the packet excluding the
+                //authentication field) is never recomputed, so a captured packet round-trips byte-for-byte.
+                checksum: this.fieldUInt('checksum', 12, 2, 'Checksum'),
+                auType: this.fieldUInt('auType', 14, 2, 'Auth Type'),
+                auth: {
+                    type: 'string',
+                    label: 'Authentication',
+                    minLength: 0,
+                    maxLength: 16,
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        this.instance.auth.setValue((0, BufferToHex_1.BufferToHex)(this.readBytes(16, 8)));
+                    },
+                    encode: function () {
+                        const auth = this.instance.auth.getValue('0000000000000000');
+                        this.instance.auth.setValue(auth);
+                        this.writeBytes(16, Buffer.from(auth, 'hex'));
+                    }
+                },
+                //==== Hello body (RFC 2328 §A.3.2), decoded only for type 1 ====
+                hello: {
+                    type: 'object',
+                    label: 'Hello Packet',
+                    properties: {
+                        networkMask: {
+                            type: 'string',
+                            label: 'Network Mask',
+                            minLength: 7,
+                            maxLength: 15,
+                            contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.IPv4,
+                            decode: function () {
+                                const type = this.instance.type.getValue(0);
+                                if (type !== 1)
+                                    return;
+                                this.instance.hello.networkMask.setValue((0, BufferToIP_1.BufferToIPv4)(this.readBytes(24, 4)));
+                            },
+                            encode: function () {
+                                const type = this.instance.type.getValue(0);
+                                if (type !== 1)
+                                    return;
+                                const networkMask = this.instance.hello.networkMask.getValue('0.0.0.0');
+                                this.instance.hello.networkMask.setValue(networkMask);
+                                this.writeBytes(24, (0, IPToBuffer_1.IPv4ToBuffer)(networkMask));
+                            }
+                        },
+                        helloInterval: {
+                            type: 'integer',
+                            label: 'Hello Interval',
+                            minimum: 0,
+                            maximum: 65535,
+                            decode: function () {
+                                const type = this.instance.type.getValue(0);
+                                if (type !== 1)
+                                    return;
+                                this.instance.hello.helloInterval.setValue(this.readBits(28, 2, 0, 16));
+                            },
+                            encode: function () {
+                                const type = this.instance.type.getValue(0);
+                                if (type !== 1)
+                                    return;
+                                const helloInterval = this.instance.hello.helloInterval.getValue(0);
+                                this.instance.hello.helloInterval.setValue(helloInterval);
+                                this.writeBits(28, 2, 0, 16, helloInterval);
+                            }
+                        },
+                        options: {
+                            type: 'integer',
+                            label: 'Options',
+                            minimum: 0,
+                            maximum: 255,
+                            decode: function () {
+                                const type = this.instance.type.getValue(0);
+                                if (type !== 1)
+                                    return;
+                                this.instance.hello.options.setValue(this.readBits(30, 1, 0, 8));
+                            },
+                            encode: function () {
+                                const type = this.instance.type.getValue(0);
+                                if (type !== 1)
+                                    return;
+                                const options = this.instance.hello.options.getValue(0);
+                                this.instance.hello.options.setValue(options);
+                                this.writeBits(30, 1, 0, 8, options);
+                            }
+                        },
+                        routerPriority: {
+                            type: 'integer',
+                            label: 'Router Priority',
+                            minimum: 0,
+                            maximum: 255,
+                            decode: function () {
+                                const type = this.instance.type.getValue(0);
+                                if (type !== 1)
+                                    return;
+                                this.instance.hello.routerPriority.setValue(this.readBits(31, 1, 0, 8));
+                            },
+                            encode: function () {
+                                const type = this.instance.type.getValue(0);
+                                if (type !== 1)
+                                    return;
+                                const routerPriority = this.instance.hello.routerPriority.getValue(0);
+                                this.instance.hello.routerPriority.setValue(routerPriority);
+                                this.writeBits(31, 1, 0, 8, routerPriority);
+                            }
+                        },
+                        routerDeadInterval: {
+                            type: 'integer',
+                            label: 'Router Dead Interval',
+                            minimum: 0,
+                            maximum: 4294967295,
+                            decode: function () {
+                                const type = this.instance.type.getValue(0);
+                                if (type !== 1)
+                                    return;
+                                this.instance.hello.routerDeadInterval.setValue(this.readBits(32, 4, 0, 32));
+                            },
+                            encode: function () {
+                                const type = this.instance.type.getValue(0);
+                                if (type !== 1)
+                                    return;
+                                const routerDeadInterval = this.instance.hello.routerDeadInterval.getValue(0);
+                                this.instance.hello.routerDeadInterval.setValue(routerDeadInterval);
+                                this.writeBits(32, 4, 0, 32, routerDeadInterval);
+                            }
+                        },
+                        designatedRouter: {
+                            type: 'string',
+                            label: 'Designated Router',
+                            minLength: 7,
+                            maxLength: 15,
+                            contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.IPv4,
+                            decode: function () {
+                                const type = this.instance.type.getValue(0);
+                                if (type !== 1)
+                                    return;
+                                this.instance.hello.designatedRouter.setValue((0, BufferToIP_1.BufferToIPv4)(this.readBytes(36, 4)));
+                            },
+                            encode: function () {
+                                const type = this.instance.type.getValue(0);
+                                if (type !== 1)
+                                    return;
+                                const designatedRouter = this.instance.hello.designatedRouter.getValue('0.0.0.0');
+                                this.instance.hello.designatedRouter.setValue(designatedRouter);
+                                this.writeBytes(36, (0, IPToBuffer_1.IPv4ToBuffer)(designatedRouter));
+                            }
+                        },
+                        backupDesignatedRouter: {
+                            type: 'string',
+                            label: 'Backup Designated Router',
+                            minLength: 7,
+                            maxLength: 15,
+                            contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.IPv4,
+                            decode: function () {
+                                const type = this.instance.type.getValue(0);
+                                if (type !== 1)
+                                    return;
+                                this.instance.hello.backupDesignatedRouter.setValue((0, BufferToIP_1.BufferToIPv4)(this.readBytes(40, 4)));
+                            },
+                            encode: function () {
+                                const type = this.instance.type.getValue(0);
+                                if (type !== 1)
+                                    return;
+                                const backupDesignatedRouter = this.instance.hello.backupDesignatedRouter.getValue('0.0.0.0');
+                                this.instance.hello.backupDesignatedRouter.setValue(backupDesignatedRouter);
+                                this.writeBytes(40, (0, IPToBuffer_1.IPv4ToBuffer)(backupDesignatedRouter));
+                            }
+                        },
+                        neighbors: {
+                            type: 'array',
+                            label: 'Active Neighbors',
+                            items: {
+                                type: 'string',
+                                minLength: 7,
+                                maxLength: 15,
+                                contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.IPv4
+                            },
+                            //Neighbour Router IDs run from the end of the fixed Hello fields (offset 44)
+                            //to the OSPF packet length, 4 bytes each. Bounded by #bodyEnd so a corrupt
+                            //length field can't read past the IP payload.
+                            decode: function () {
+                                const type = this.instance.type.getValue(0);
+                                if (type !== 1)
+                                    return;
+                                const end = this.#bodyEnd();
+                                const neighbors = [];
+                                let offset = 44;
+                                while (offset + 4 <= end) {
+                                    neighbors.push((0, BufferToIP_1.BufferToIPv4)(this.readBytes(offset, 4)));
+                                    offset += 4;
+                                }
+                                this.instance.hello.neighbors.setValue(neighbors);
+                            },
+                            encode: function () {
+                                const type = this.instance.type.getValue(0);
+                                if (type !== 1)
+                                    return;
+                                const neighbors = this.instance.hello.neighbors.getValue();
+                                if (!neighbors)
+                                    return;
+                                let offset = 44;
+                                neighbors.forEach((neighbor) => {
+                                    this.writeBytes(offset, (0, IPToBuffer_1.IPv4ToBuffer)(neighbor));
+                                    offset += 4;
+                                });
+                            }
+                        }
+                    }
+                },
+                //==== Raw body fallback for types 2-5 (DD / LS Request / LS Update / LS Ack) ====
+                //Kept verbatim (like SNMP pduRaw), byte-perfect. Bounded by #bodyEnd.
+                rawBody: {
+                    type: 'string',
+                    label: 'Body',
+                    minLength: 0,
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const type = this.instance.type.getValue(0);
+                        if (type === 1)
+                            return;
+                        const end = this.#bodyEnd();
+                        if (end <= 24)
+                            return;
+                        this.instance.rawBody.setValue((0, BufferToHex_1.BufferToHex)(this.readBytes(24, end - 24)));
+                    },
+                    encode: function () {
+                        const type = this.instance.type.getValue(0);
+                        if (type === 1)
+                            return;
+                        if (this.instance.rawBody.isUndefined())
+                            return;
+                        this.writeBytes(24, Buffer.from(this.instance.rawBody.getValue(''), 'hex'));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        if (!this.prevCodecModule)
+            return false;
+        //OSPF sits directly on IP (protocol 89). Accept the demux value from either the IPv4
+        //protocol field or the IPv6 next-header field, and require at least a full 24-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 !== 89 && nextHeader !== 89)
+            return false;
+        return this.#available() >= 24;
+    }
+}
+exports.OSPF = OSPF;

package/dist/headers/OmronFINS.d.ts

@@ -0,0 +1,31 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * OMRON FINS (Factory Interface Network Service), UDP port 9600. FINS is OMRON's industrial control
+ * protocol for PLC access. This codec handles the UDP-encapsulated form (the TCP form prefixes a 16-byte
+ * 'FINS' frame header + length and is not covered here).
+ *
+ * Every UDP FINS message opens with a fixed 10-byte FINS header — ICF (Information Control Field), a
+ * reserved octet, GCT (Gateway Count), the destination address triple DNA/DA1/DA2 (network / node /
+ * unit), the source address triple SNA/SA1/SA2, and SID (Service ID) — followed by a 2-byte command
+ * code (MRC/SRC, big-endian: 0x0101 Memory Area Read, 0x0102 Memory Area Write, 0x0501 Controller Status
+ * Read, …) and the command-specific parameter/data area.
+ *
+ * The parameter/data area layout is command-dependent (and for responses carries a 2-byte end code and
+ * variable data), cross-message state that this single-message codec does not sub-decode; it is kept
+ * verbatim as `body` hex (byte-perfect), bounded by the captured UDP payload. There is no length field
+ * in the FINS header — a single UDP datagram carries exactly one FINS message — so the body runs to the
+ * end of the payload and a well-formed message round-trips byte-for-byte. The command is stored as a
+ * plain integer (no enum) so any on-wire MRC/SRC value decodes and re-encodes without rejection.
+ */
+export declare class OmronFINS 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/OmronFINS.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmronFINS = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+/**
+ * OMRON FINS (Factory Interface Network Service), UDP port 9600. FINS is OMRON's industrial control
+ * protocol for PLC access. This codec handles the UDP-encapsulated form (the TCP form prefixes a 16-byte
+ * 'FINS' frame header + length and is not covered here).
+ *
+ * Every UDP FINS message opens with a fixed 10-byte FINS header — ICF (Information Control Field), a
+ * reserved octet, GCT (Gateway Count), the destination address triple DNA/DA1/DA2 (network / node /
+ * unit), the source address triple SNA/SA1/SA2, and SID (Service ID) — followed by a 2-byte command
+ * code (MRC/SRC, big-endian: 0x0101 Memory Area Read, 0x0102 Memory Area Write, 0x0501 Controller Status
+ * Read, …) and the command-specific parameter/data area.
+ *
+ * The parameter/data area layout is command-dependent (and for responses carries a 2-byte end code and
+ * variable data), cross-message state that this single-message codec does not sub-decode; it is kept
+ * verbatim as `body` hex (byte-perfect), bounded by the captured UDP payload. There is no length field
+ * in the FINS header — a single UDP datagram carries exactly one FINS message — so the body runs to the
+ * end of the payload and a well-formed message round-trips byte-for-byte. The command is stored as a
+ * plain integer (no enum) so any on-wire MRC/SRC value decodes and re-encodes without rejection.
+ */
+class OmronFINS extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'fins';
+        this.name = 'OMRON FINS';
+        this.nickname = 'FINS';
+        this.matchKeys = ['udpport:9600'];
+        //A leaf header — the parameter/data area requires per-command, cross-message parsing.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (OmronFINS.#schemaCache ??= OmronFINS.#buildSchema());
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'FINS cmd=${command} ${sna}.${sa1}.${sa2}->${dna}.${da1}.${da2}',
+            properties: {
+                //ICF — Information Control Field: bit0 response-required flag, bit6 command/response,
+                //bit7 gateway; kept as a whole octet so any legal value round-trips.
+                icf: this.fieldUInt('icf', 0, 1, 'Information Control Field'),
+                //Reserved octet — kept verbatim.
+                rsv: this.fieldUInt('rsv', 1, 1, 'Reserved'),
+                //Gateway Count — how many gateways the message may still traverse.
+                gct: this.fieldUInt('gct', 2, 1, 'Gateway Count'),
+                dna: this.fieldUInt('dna', 3, 1, 'Destination Network Address'),
+                da1: this.fieldUInt('da1', 4, 1, 'Destination Node Address'),
+                da2: this.fieldUInt('da2', 5, 1, 'Destination Unit Address'),
+                sna: this.fieldUInt('sna', 6, 1, 'Source Network Address'),
+                sa1: this.fieldUInt('sa1', 7, 1, 'Source Node Address'),
+                sa2: this.fieldUInt('sa2', 8, 1, 'Source Unit Address'),
+                sid: this.fieldUInt('sid', 9, 1, 'Service ID'),
+                //Command code MRC/SRC, big-endian (0x0101 Memory Area Read, 0x0102 Write, 0x0501
+                //Controller Status Read, …). Plain integer — any on-wire value decodes/re-encodes.
+                command: this.fieldUInt('command', 10, 2, 'Command Code'),
+                //Command-specific parameter/data area, kept verbatim. Bounded by the captured UDP
+                //payload (a single datagram = one FINS message), so the whole remainder is consumed.
+                body: {
+                    type: 'string',
+                    label: 'Body',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const remaining = this.packet.length - this.startPos;
+                        this.instance.body.setValue(remaining > 12 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(12, remaining - 12)) : '');
+                    },
+                    encode: function () {
+                        const body = this.instance.body.getValue('');
+                        if (body)
+                            this.writeBytes(12, (0, HexToBuffer_1.HexToBuffer)(body));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //UDP FINS rides on port 9600. The FINS header carries no strong content magic, so the
+        //well-known port is the signature: require the full 10-byte header + 2-byte command (12 bytes)
+        //to be present so a too-short datagram falls through to raw.
+        if (!this.prevCodecModule || this.prevCodecModule.id !== 'udp')
+            return false;
+        return this.packet.length - this.startPos >= 12;
+    }
+}
+exports.OmronFINS = OmronFINS;

package/dist/headers/OpenFlow.d.ts

@@ -0,0 +1,30 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * OpenFlow (Open Networking Foundation), the SDN switch/controller protocol. Runs over TLS or plain TCP,
+ * well-known port 6653 (modern; the pre-ONF IANA-assigned 6633 is still widely seen). Every OpenFlow
+ * message begins with a fixed 8-byte header (big-endian) — Version (0x01 OF 1.0, 0x04 OF 1.3, 0x05 OF 1.4,
+ * 0x06 OF 1.5), Type (0 Hello, 1 Error, 2 Echo Request, 3 Echo Reply, 5 Features Request, 6 Features
+ * Reply, …), Length (the total message octet count INCLUDING this 8-byte header) and a Transaction ID
+ * (xid, echoed on replies) — followed by the type-and-version-specific body.
+ *
+ * The body layout differs per Type and per Version (Error's code/data, Features Reply's datapath id and
+ * port descriptions, Flow-Mod's match/instructions, …) and much of it needs cross-message negotiation
+ * context, so this single-message codec keeps the body verbatim as `body` hex (byte-perfect) and does not
+ * sub-decode it. Version and Type are plain uints (no hard enum) so an unknown/experimental value still
+ * decodes and re-encodes. The Length is auto-computed from the body on encode when not supplied, else
+ * honored verbatim (a crafted message may lie); the message is bounded by Length so a second pipelined
+ * OpenFlow message or trailing bytes are left to the codec's recursion / RawData. A well-formed message
+ * round-trips byte-for-byte.
+ */
+export declare class OpenFlow 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/OpenFlow.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenFlow = 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");
+/**
+ * OpenFlow (Open Networking Foundation), the SDN switch/controller protocol. Runs over TLS or plain TCP,
+ * well-known port 6653 (modern; the pre-ONF IANA-assigned 6633 is still widely seen). Every OpenFlow
+ * message begins with a fixed 8-byte header (big-endian) — Version (0x01 OF 1.0, 0x04 OF 1.3, 0x05 OF 1.4,
+ * 0x06 OF 1.5), Type (0 Hello, 1 Error, 2 Echo Request, 3 Echo Reply, 5 Features Request, 6 Features
+ * Reply, …), Length (the total message octet count INCLUDING this 8-byte header) and a Transaction ID
+ * (xid, echoed on replies) — followed by the type-and-version-specific body.
+ *
+ * The body layout differs per Type and per Version (Error's code/data, Features Reply's datapath id and
+ * port descriptions, Flow-Mod's match/instructions, …) and much of it needs cross-message negotiation
+ * context, so this single-message codec keeps the body verbatim as `body` hex (byte-perfect) and does not
+ * sub-decode it. Version and Type are plain uints (no hard enum) so an unknown/experimental value still
+ * decodes and re-encodes. The Length is auto-computed from the body on encode when not supplied, else
+ * honored verbatim (a crafted message may lie); the message is bounded by Length so a second pipelined
+ * OpenFlow message or trailing bytes are left to the codec's recursion / RawData. A well-formed message
+ * round-trips byte-for-byte.
+ */
+class OpenFlow extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'openflow';
+        this.name = 'OpenFlow';
+        this.nickname = 'OpenFlow';
+        this.matchKeys = ['tcpport:6653', 'tcpport:6633'];
+        //A leaf header — the body is type-and-version-specific and negotiation-dependent.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (OpenFlow.#schemaCache ??= OpenFlow.#buildSchema());
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'OpenFlow v=${version} type=${type} len=${length}',
+            properties: {
+                //Protocol version (0x01 OF 1.0, 0x04 OF 1.3, 0x05 OF 1.4, 0x06 OF 1.5). Kept as a plain
+                //uint8 — an unknown/experimental version must still decode and round-trip, so no enum.
+                version: this.fieldUInt('version', 0, 1, 'Version'),
+                //Message type (0 Hello, 1 Error, 2 Echo Request, 3 Echo Reply, 5 Features Request,
+                //6 Features Reply, …). Plain uint8 — versions differ in the type table, so no hard enum.
+                type: this.fieldUInt('type', 1, 1, 'Type'),
+                length: {
+                    type: 'integer',
+                    label: 'Length',
+                    //Full uint16 range: Length is honored verbatim on encode, so any on-wire value
+                    //(including a crafted/short one) must re-encode without Ajv rejecting it.
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: function () {
+                        this.instance.length.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(2, 2)));
+                    },
+                    encode: function () {
+                        //Length counts the whole message = 8-byte header + body. Honored when supplied
+                        //(a crafted message may lie); else derived from the body.
+                        const provided = this.instance.length.getValue();
+                        let value = (provided !== undefined && provided !== null)
+                            ? provided
+                            : 8 + (0, HexToBuffer_1.HexToBuffer)(this.instance.body.getValue('')).length;
+                        if (value > 65535) {
+                            this.recordError(this.instance.length.getPath(), 'Maximum value is 65535');
+                            value = 65535;
+                        }
+                        this.instance.length.setValue(value);
+                        this.writeBytes(2, (0, NumberToBuffer_1.UInt16ToBuffer)(value));
+                    }
+                },
+                //Transaction ID (xid): the sender picks it and the peer echoes it on the matching reply.
+                xid: this.fieldUInt('xid', 4, 4, 'Transaction ID'),
+                //The type-and-version-specific body after the 8-byte header, 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.
+                body: {
+                    type: 'string',
+                    label: 'Body',
+                    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 = remaining;
+                        this.instance.body.setValue(end > 8 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(8, end - 8)) : '');
+                    },
+                    encode: function () {
+                        const body = this.instance.body.getValue('');
+                        if (body)
+                            this.writeBytes(8, (0, HexToBuffer_1.HexToBuffer)(body));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //OpenFlow rides on TCP port 6653 (modern) / 6633 (legacy). The 8-byte header carries no strong
+        //content magic (Version+Type are weak, one-byte hints), so the well-known port is the signature:
+        //require the full 8-byte header to be present. Selection stays port-bucketed (matchKeys), no
+        //heuristic fallback — a bare Version byte is far too weak to claim off-port traffic.
+        if (!this.prevCodecModule || this.prevCodecModule.id !== 'tcp')
+            return false;
+        return this.packet.length - this.startPos >= 8;
+    }
+}
+exports.OpenFlow = OpenFlow;