@netkitty/codec 1.0.0

package/dist/headers/IPv6HopByHopOptions.js

@@ -0,0 +1,495 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IPv6HopByHopOptions = 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 node_tlv_1 = __importDefault(require("node-tlv"));
+const HexToNumber_1 = require("../helper/HexToNumber");
+//Type=1 PadN
+//Type=4 Tunnel Encapsulation Limit
+//Type=5 Router Alert
+//Type=7 CALIPSO
+//Type=8 SMF_DPD
+//Type=11 MPL Option
+//Type=12 ILNP Nonce
+//Type=13 Line-Identification Option
+//Type=30 IPv6 DFF Header
+//Type=138 Endpoint Identification
+var Type;
+(function (Type) {
+    Type["Pad1"] = "Pad1";
+    Type["PadN"] = "PadN";
+    Type["Tunnel_Encapsulation_Limit"] = "Tunnel-Encapsulation-Limit";
+    Type["Router_Alert"] = "Router-Alert";
+    Type["CALIPSO"] = "CALIPSO";
+    Type["SMF_DPD"] = "SMF_DPD";
+    Type["MPL_Option"] = "MPL-Option";
+    Type["ILNP_Nonce"] = "ILNP-Nonce";
+    Type["Line_Identification_Option"] = "Line-Identification-Option";
+    Type["IPv6_DFF_Header"] = "IPv6-DFF-Header";
+    Type["Endpoint_Identification"] = "Endpoint-Identification";
+})(Type || (Type = {}));
+class IPv6HopByHopOptions extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        //Byte length of the encoded options area after 8-octet alignment padding.
+        //Set during items encode, consumed by the len recompute handler.
+        this.paddedOptionsLength = 0;
+        this.items = [];
+        this.SCHEMA = {
+            type: 'object',
+            properties: {
+                nxt: {
+                    type: 'integer',
+                    label: 'Next Header',
+                    minimum: 0,
+                    maximum: 255,
+                    decode: () => {
+                        this.instance.nxt.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(0, 1)));
+                    },
+                    encode: () => {
+                        const nxt = this.instance.nxt.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        this.instance.nxt.setValue(nxt);
+                        this.writeBytes(0, (0, NumberToBuffer_1.UInt8ToBuffer)(nxt));
+                    }
+                },
+                len: {
+                    type: 'integer',
+                    label: 'Length',
+                    minimum: 0,
+                    maximum: 255,
+                    decode: () => {
+                        this.instance.len.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(1, 1)));
+                    },
+                    encode: () => {
+                        const len = this.instance.len.getValue(0);
+                        this.instance.len.setValue(len);
+                        this.writeBytes(1, (0, NumberToBuffer_1.UInt8ToBuffer)(len));
+                        if (!len) {
+                            this.addPostSelfEncodeHandler(() => {
+                                //Total header = 2 (nxt+len) + options area, and must be an integral
+                                //multiple of 8 octets (RFC 8200 §4.3). items encode already padded the
+                                //options area to alignment, so (2 + paddedOptionsLength) is a multiple
+                                //of 8 and HdrExtLen = totalOctets/8 - 1.
+                                const totalOctets = 2 + this.paddedOptionsLength;
+                                const calcLength = Math.max(0, Math.ceil(totalOctets / 8) - 1);
+                                this.instance.len.setValue(calcLength);
+                                this.writeBytes(1, (0, NumberToBuffer_1.UInt8ToBuffer)(calcLength));
+                            });
+                        }
+                    }
+                },
+                items: {
+                    type: 'array',
+                    label: 'Option Items',
+                    items: {
+                        anyOf: [
+                            //Type=0 Pad1 (single octet, no length/value)
+                            {
+                                type: 'object',
+                                label: 'Pad1',
+                                properties: {
+                                    type: {
+                                        type: 'string',
+                                        label: 'Type',
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.UTF8,
+                                        enum: [Type.Pad1],
+                                        const: Type.Pad1,
+                                        hidden: true
+                                    }
+                                }
+                            },
+                            //Type=1 PadN
+                            {
+                                type: 'object',
+                                label: 'PadN',
+                                properties: {
+                                    type: {
+                                        type: 'string',
+                                        label: 'Type',
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.UTF8,
+                                        enum: [Type.PadN],
+                                        const: Type.PadN,
+                                        hidden: true
+                                    },
+                                    n: {
+                                        type: 'integer',
+                                        label: 'N'
+                                    }
+                                }
+                            },
+                            //Type=4 Tunnel Encapsulation Limit
+                            {
+                                type: 'object',
+                                label: 'Tunnel Encapsulation Limit',
+                                properties: {
+                                    type: {
+                                        type: 'string',
+                                        label: 'Type',
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.UTF8,
+                                        enum: [Type.Tunnel_Encapsulation_Limit],
+                                        const: Type.Tunnel_Encapsulation_Limit,
+                                        hidden: true
+                                    },
+                                    limit: {
+                                        type: 'integer',
+                                        label: 'Limit',
+                                        minimum: 1,
+                                        maximum: 255
+                                    }
+                                }
+                            },
+                            //Type=5 Router Alert
+                            {
+                                type: 'object',
+                                label: 'Router Alert',
+                                properties: {
+                                    type: {
+                                        type: 'string',
+                                        label: 'Type',
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.UTF8,
+                                        enum: [Type.Router_Alert],
+                                        const: Type.Router_Alert,
+                                        hidden: true
+                                    },
+                                    alert: {
+                                        type: 'string',
+                                        label: 'Router Alert',
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                                        minLength: 4,
+                                        maxLength: 4
+                                    }
+                                }
+                            },
+                            //Type=7 CALIPSO
+                            {
+                                type: 'object',
+                                label: 'CALIPSO',
+                                properties: {
+                                    type: {
+                                        type: 'string',
+                                        label: 'Type',
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.UTF8,
+                                        enum: [Type.CALIPSO],
+                                        const: Type.CALIPSO,
+                                        hidden: true
+                                    },
+                                    tag: {
+                                        type: 'string',
+                                        label: 'Tag',
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                                        minLength: 16,
+                                        maxLength: 16
+                                    }
+                                }
+                            },
+                            //Type=8 SMF_DPD
+                            {
+                                type: 'object',
+                                label: 'SMF_DPD',
+                                properties: {
+                                    type: {
+                                        type: 'string',
+                                        label: 'Type',
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.UTF8,
+                                        enum: [Type.SMF_DPD],
+                                        const: Type.SMF_DPD,
+                                        hidden: true
+                                    },
+                                    hash: {
+                                        type: 'string',
+                                        label: 'Hash',
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.UTF8
+                                    }
+                                }
+                            },
+                            //Type=11 MPL Option
+                            {
+                                type: 'object',
+                                label: 'MPL Option',
+                                properties: {
+                                    type: {
+                                        type: 'string',
+                                        label: 'Type',
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.UTF8,
+                                        enum: [Type.MPL_Option],
+                                        const: Type.MPL_Option,
+                                        hidden: true
+                                    },
+                                    value: {
+                                        type: 'string',
+                                        label: 'Value',
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX
+                                    }
+                                }
+                            },
+                            //Type=12 ILNP Nonce
+                            {
+                                type: 'object',
+                                label: 'ILNP Nonce',
+                                properties: {
+                                    type: {
+                                        type: 'string',
+                                        label: 'Type',
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.UTF8,
+                                        enum: [Type.ILNP_Nonce],
+                                        const: Type.ILNP_Nonce,
+                                        hidden: true
+                                    },
+                                    nonce: {
+                                        type: 'string',
+                                        label: 'Nonce',
+                                        minLength: 12,
+                                        maxLength: 12,
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX
+                                    }
+                                }
+                            },
+                            //Type=13 Line-Identification Option
+                            {
+                                type: 'object',
+                                label: 'Line-Identification Option',
+                                properties: {
+                                    type: {
+                                        type: 'string',
+                                        label: 'Type',
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.UTF8,
+                                        enum: [Type.Line_Identification_Option],
+                                        const: Type.Line_Identification_Option,
+                                        hidden: true
+                                    },
+                                    id: {
+                                        type: 'string',
+                                        label: 'Identity',
+                                        minLength: 8,
+                                        maxLength: 8,
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX
+                                    }
+                                }
+                            },
+                            //Type=30 IPv6 DFF Header
+                            {
+                                type: 'object',
+                                label: 'IPv6 DFF Header',
+                                properties: {
+                                    type: {
+                                        type: 'string',
+                                        label: 'Type',
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.UTF8,
+                                        enum: [Type.IPv6_DFF_Header],
+                                        const: Type.IPv6_DFF_Header,
+                                        hidden: true
+                                    },
+                                    message: {
+                                        type: 'string',
+                                        label: 'Message',
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX
+                                    }
+                                }
+                            },
+                            //Type=138 Endpoint Identification
+                            {
+                                type: 'object',
+                                label: 'Endpoint Identification',
+                                properties: {
+                                    type: {
+                                        type: 'string',
+                                        label: 'Type',
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.UTF8,
+                                        enum: [Type.Endpoint_Identification],
+                                        const: Type.Endpoint_Identification,
+                                        hidden: true
+                                    },
+                                    id: {
+                                        type: 'string',
+                                        label: 'Identity',
+                                        minLength: 32,
+                                        maxLength: 32,
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX
+                                    }
+                                }
+                            },
+                            //Custom
+                            {
+                                type: 'object',
+                                label: 'Custom',
+                                properties: {
+                                    type: {
+                                        type: 'integer',
+                                        label: 'Type'
+                                    },
+                                    data: {
+                                        type: 'string',
+                                        label: 'Data',
+                                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX
+                                    }
+                                }
+                            }
+                        ]
+                    },
+                    decode: () => {
+                        //Options area length = (HdrExtLen+1)*8 - 2 = len*8 + 6 octets, bounded to the
+                        //bytes actually present.
+                        const optionsLength = this.instance.len.getValue(0) * 8 + 6;
+                        const buffer = this.readBytes(2, optionsLength);
+                        this.items = [];
+                        //Walk the options manually (RFC 8200 §4.2): Pad1 (type 0) is a single octet with
+                        //no Length/Value; every other option is type(1)+length(1)+value(length). Bounds
+                        //are checked so a truncated area records what it can rather than throwing (and so
+                        //an interior Pad1 no longer desyncs a length-prefix TLV parser).
+                        let p = 0;
+                        while (p < buffer.length) {
+                            const type = buffer[p];
+                            if (type === 0x00) {
+                                this.items.push({ type: Type.Pad1 });
+                                p += 1;
+                                continue;
+                            }
+                            if (p + 2 > buffer.length)
+                                break;
+                            const optionLength = buffer[p + 1];
+                            if (p + 2 + optionLength > buffer.length)
+                                break;
+                            const valueHex = buffer.subarray(p + 2, p + 2 + optionLength).toString('hex');
+                            this.items.push(this.decodeHbhOption(type, optionLength, valueHex));
+                            p += 2 + optionLength;
+                        }
+                        this.instance.items.setValue(this.items);
+                    },
+                    encode: () => {
+                        this.items = this.instance.items.getValue([]);
+                        const parts = [];
+                        const tlvBytes = (tlv) => Buffer.from(tlv.getTLV(), 'hex');
+                        this.items.forEach((item) => {
+                            switch (item.type) {
+                                case Type.Pad1:
+                                    {
+                                        //Pad1 is a single zero octet with no Length/Value.
+                                        parts.push(Buffer.from([0x00]));
+                                    }
+                                    break;
+                                case Type.PadN:
+                                    {
+                                        const typedItem = { ...item };
+                                        parts.push(tlvBytes(new node_tlv_1.default(0x01, Buffer.alloc(typedItem.n, 0))));
+                                    }
+                                    break;
+                                case Type.Tunnel_Encapsulation_Limit:
+                                    {
+                                        const typedItem = { ...item };
+                                        parts.push(tlvBytes(new node_tlv_1.default(0x04, (0, NumberToBuffer_1.UInt8ToBuffer)(typedItem.limit))));
+                                    }
+                                    break;
+                                case Type.Router_Alert:
+                                    {
+                                        const typedItem = { ...item };
+                                        parts.push(tlvBytes(new node_tlv_1.default(0x05, (0, NumberToBuffer_1.UInt16ToBuffer)((0, HexToNumber_1.HexToUInt16)(typedItem.alert)))));
+                                    }
+                                    break;
+                                case Type.CALIPSO:
+                                    {
+                                        const typedItem = { ...item };
+                                        parts.push(tlvBytes(new node_tlv_1.default(0x07, (0, NumberToBuffer_1.UInt64ToBuffer)((0, HexToNumber_1.HexToUInt64)(typedItem.tag)))));
+                                    }
+                                    break;
+                                case Type.SMF_DPD:
+                                    {
+                                        const typedItem = { ...item };
+                                        parts.push(tlvBytes(new node_tlv_1.default(0x08, Buffer.from(typedItem.hash, 'hex'))));
+                                    }
+                                    break;
+                                case Type.MPL_Option:
+                                    {
+                                        const typedItem = { ...item };
+                                        parts.push(tlvBytes(new node_tlv_1.default(0x0B, Buffer.from(typedItem.value, 'hex'))));
+                                    }
+                                    break;
+                                case Type.ILNP_Nonce:
+                                    {
+                                        const typedItem = { ...item };
+                                        parts.push(tlvBytes(new node_tlv_1.default(0x0C, Buffer.from(typedItem.nonce.padStart(12, '0'), 'hex'))));
+                                    }
+                                    break;
+                                case Type.Line_Identification_Option:
+                                    {
+                                        const typedItem = { ...item };
+                                        parts.push(tlvBytes(new node_tlv_1.default(0x0D, (0, NumberToBuffer_1.UInt32ToBuffer)((0, HexToNumber_1.HexToUInt32)(typedItem.id)))));
+                                    }
+                                    break;
+                                case Type.IPv6_DFF_Header:
+                                    {
+                                        const typedItem = { ...item };
+                                        parts.push(tlvBytes(new node_tlv_1.default(0x1E, Buffer.from(typedItem.message, 'hex'))));
+                                    }
+                                    break;
+                                case Type.Endpoint_Identification:
+                                    {
+                                        const typedItem = { ...item };
+                                        parts.push(tlvBytes(new node_tlv_1.default(0x8A, Buffer.from(typedItem.id.padStart(32, '0'), 'hex'))));
+                                    }
+                                    break;
+                                default: {
+                                    if (typeof item.type !== 'number')
+                                        return;
+                                    const customItem = { ...item };
+                                    parts.push(tlvBytes(new node_tlv_1.default(customItem.type, Buffer.from(customItem.data, 'hex'))));
+                                }
+                            }
+                        });
+                        let itemsBuffer = Buffer.concat(parts);
+                        //Pad the options area so the whole header (2 header bytes + options) is an
+                        //integral multiple of 8 octets (RFC 8200 §4.3). Use a PadN option (type 0x01)
+                        //for >=2 bytes so it re-decodes as a PadN, and a single Pad1 (0x00) for 1 byte.
+                        const pad = (8 - (2 + itemsBuffer.length) % 8) % 8;
+                        if (pad === 1) {
+                            itemsBuffer = Buffer.concat([itemsBuffer, Buffer.from([0x00])]);
+                        }
+                        else if (pad >= 2) {
+                            const padN = new node_tlv_1.default(0x01, Buffer.alloc(pad - 2, 0));
+                            itemsBuffer = Buffer.concat([itemsBuffer, Buffer.from(padN.getTLV(), 'hex')]);
+                        }
+                        this.paddedOptionsLength = itemsBuffer.length;
+                        this.writeBytes(2, itemsBuffer);
+                    }
+                }
+            }
+        };
+        this.id = 'ipv6-hopopt';
+        this.matchKeys = ['ipproto:0'];
+        //Extension header: it both consumes ipproto:0 and produces the next-header key for the layer after it.
+        this.demuxProducers = [{ field: 'nxt', namespace: 'ipproto', kind: 'uint' }];
+        this.name = 'IPv6 Hop-by-Hop Option';
+        this.nickname = 'HopOpt';
+        this.isProtocol = false;
+    }
+    /**
+     * Map a decoded Hop-by-Hop option (type + length + hex value) to its structured item.
+     * Unknown types become a Custom item so they still round-trip.
+     */
+    decodeHbhOption(type, length, valueHex) {
+        switch (type) {
+            case 0x01: return { type: Type.PadN, n: length };
+            case 0x04: return { type: Type.Tunnel_Encapsulation_Limit, limit: (0, HexToNumber_1.HexToUInt8)(valueHex) };
+            case 0x05: return { type: Type.Router_Alert, alert: valueHex };
+            case 0x07: return { type: Type.CALIPSO, tag: valueHex };
+            case 0x08: return { type: Type.SMF_DPD, hash: valueHex };
+            case 0x0B: return { type: Type.MPL_Option, value: valueHex };
+            case 0x0C: return { type: Type.ILNP_Nonce, nonce: valueHex };
+            case 0x0D: return { type: Type.Line_Identification_Option, id: valueHex };
+            case 0x1E: return { type: Type.IPv6_DFF_Header, message: valueHex };
+            case 0x8A: return { type: Type.Endpoint_Identification, id: valueHex };
+            default: return { type: type, data: valueHex };
+        }
+    }
+    match() {
+        if (!this.prevCodecModule || this.prevCodecModule.id !== 'ipv6')
+            return false;
+        return this.prevCodecModule.instance.nxt.getValue() === 0x00;
+    }
+}
+exports.IPv6HopByHopOptions = IPv6HopByHopOptions;

package/dist/headers/IRC.d.ts

@@ -0,0 +1,34 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * IRC — the Internet Relay Chat protocol (RFC 1459 / RFC 2812), carried as US-ASCII text over TCP
+ * well-known port 6667 (or 6697 for the TLS-wrapped IRC-over-TLS bucket). The channel is line-based: each
+ * message is an optional `:prefix` (source), then a COMMAND (a verb word like PRIVMSG/JOIN/NICK, or a
+ * 3-digit numeric reply code such as 001/433), then space-separated params with an optional ` :trailing`
+ * argument, terminated by CRLF. A client sends `NICK alice\r\n`, `JOIN #chan\r\n`, `PRIVMSG #chan :hi\r\n`;
+ * a server prefixes its messages with the source (`:server 001 alice :Welcome\r\n`,
+ * `:nick!user@host PRIVMSG #chan :hi\r\n`).
+ *
+ * Like FTP, SMTP, POP3, Syslog, SIP and HTTP, the message is text whose full internal structure
+ * (arbitrary params, significant whitespace, an optional trailing argument, multiple lines per segment)
+ * is richer than a form needs. So the ENTIRE raw message is kept verbatim as the authoritative `message`
+ * field (hex) and re-emitted untouched; only the FIRST line is parsed on decode into display-only
+ * metadata (prefix/command/params/isNumeric). Encode never reconstructs the message from the parsed
+ * fields — it writes `message` back byte-for-byte — so any conformant (or even malformed) IRC line
+ * round-trips exactly.
+ *
+ * Note: a single TCP segment may carry more than one line (IRC peers pipeline freely) or only part of a
+ * line; reassembly across segments is out of scope. This single-segment codec keeps whatever bytes are
+ * present verbatim, which is byte-perfect for the single-packet case.
+ */
+export declare class IRC extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}