@netkitty/codec 1.0.0

package/dist/headers/IPv6.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IPv6 = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const NumberToHex_1 = require("../helper/NumberToHex");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+const BufferToNumber_1 = require("../helper/BufferToNumber");
+const NumberToBuffer_1 = require("../helper/NumberToBuffer");
+const BufferToIP_1 = require("../helper/BufferToIP");
+const IPToBuffer_1 = require("../helper/IPToBuffer");
+/**
+ * IPv6 — Internet Protocol version 6 (RFC 8200), carried on Ethernet with EtherType 0x86dd. This codec
+ * decodes the 40-octet fixed header: a 4-bit Version (`version`, offset 0), an 8-bit Traffic Class split
+ * into a 6-bit DSCP (`tclass.dscp`) and 2-bit ECN (`tclass.ecn`), a 20-bit Flow Label (`flow`), a 16-bit
+ * Payload Length (`plen`, offset 4), an 8-bit Next Header (`nxt`, offset 6), an 8-bit Hop Limit (`hllm`,
+ * offset 7), and the 16-octet Source (`sip`, offset 8) and Destination (`dip`, offset 24) addresses. It
+ * stops at the fixed header: `nxt` is published as an `ipproto` demux key, so extension headers and the
+ * upper-layer protocol (TCP/UDP/ICMPv6/OSPF…) are decoded by the next module.
+ *
+ * Payload Length is honor-else-derive: a supplied value is written as-is, but when it is 0 on encode a
+ * post-packet-encode handler sums the byte length of this header and everything after it, subtracts the
+ * 40-octet header, and writes the result (falling back to 0 when it exceeds 65535, as a Hop-by-Hop Jumbo
+ * Payload would). match() accepts the normal `ethertype:86dd` path, and — being in the heuristic chain —
+ * also an IPv6 payload inside a bare-IP GTP-U tunnel (parent id `gtp` with a version nibble of 6) or a
+ * GENEVE/GRE tunnel whose Protocol Type is 0x86dd.
+ */
+class IPv6 extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.SCHEMA = {
+            type: 'object',
+            properties: {
+                version: {
+                    type: 'integer',
+                    label: 'Version',
+                    minimum: 0,
+                    maximum: 15,
+                    decode: () => {
+                        this.instance.version.setValue(this.readBits(0, 1, 0, 4));
+                    },
+                    encode: () => {
+                        const version = this.instance.version.getValue(6, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        this.instance.version.setValue(version);
+                        this.writeBits(0, 1, 0, 4, version);
+                    }
+                },
+                tclass: {
+                    type: 'object',
+                    label: 'Traffic Class',
+                    properties: {
+                        dscp: {
+                            type: 'integer',
+                            minimum: 0,
+                            maximum: 63,
+                            label: 'Differentiated Services Codepoint',
+                            decode: () => {
+                                this.instance.tclass.dscp.setValue(this.readBits(0, 4, 4, 6));
+                            },
+                            encode: () => {
+                                const dscp = this.instance.tclass.dscp.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                                this.instance.tclass.dscp.setValue(dscp);
+                                this.writeBits(0, 4, 4, 6, dscp);
+                            }
+                        },
+                        ecn: {
+                            type: 'integer',
+                            label: 'Explicit Congestion Notification',
+                            minimum: 0,
+                            maximum: 3,
+                            decode: () => {
+                                this.instance.tclass.ecn.setValue(this.readBits(0, 4, 10, 2));
+                            },
+                            encode: () => {
+                                const ecn = this.instance.tclass.ecn.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                                this.instance.tclass.ecn.setValue(ecn);
+                                this.writeBits(0, 4, 10, 2, ecn);
+                            }
+                        }
+                    }
+                },
+                flow: {
+                    type: 'integer',
+                    label: 'Flow Label',
+                    minimum: 0,
+                    maximum: 1048575,
+                    decode: () => {
+                        this.instance.flow.setValue(this.readBits(1, 3, 4, 20));
+                    },
+                    encode: () => {
+                        const flow = this.instance.flow.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        this.instance.flow.setValue(flow);
+                        this.writeBits(1, 3, 4, 20, flow);
+                    }
+                },
+                plen: {
+                    type: 'integer',
+                    label: 'Payload Length',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: () => {
+                        this.instance.plen.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(4, 2)));
+                    },
+                    encode: () => {
+                        const plen = this.instance.plen.getValue(0);
+                        this.instance.plen.setValue(plen);
+                        this.writeBytes(4, (0, NumberToBuffer_1.UInt16ToBuffer)(plen));
+                        if (!plen) {
+                            this.addPostPacketEncodeHandler(() => {
+                                let startCount = false;
+                                let totalLength = 0;
+                                this.codecModules.forEach((codecModule) => {
+                                    if (codecModule === this)
+                                        startCount = true;
+                                    if (startCount)
+                                        totalLength += codecModule.length;
+                                });
+                                let payloadLength = totalLength - 40;
+                                //The length is set to zero when a Hop-by-Hop extension header carries a Jumbo Payload option
+                                if (payloadLength > 65535)
+                                    payloadLength = 0;
+                                this.instance.plen.setValue(payloadLength);
+                                this.writeBytes(4, (0, NumberToBuffer_1.UInt16ToBuffer)(payloadLength));
+                            });
+                        }
+                    }
+                },
+                nxt: {
+                    type: 'integer',
+                    label: 'Next Header',
+                    minimum: 0,
+                    maximum: 255,
+                    decode: () => {
+                        this.instance.nxt.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(6, 1)));
+                    },
+                    encode: () => {
+                        const nxt = this.instance.nxt.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        this.instance.nxt.setValue(nxt);
+                        this.writeBytes(6, (0, NumberToBuffer_1.UInt8ToBuffer)(nxt));
+                    }
+                },
+                hllm: {
+                    type: 'integer',
+                    label: 'Hop Limit',
+                    minimum: 0,
+                    maximum: 255,
+                    decode: () => {
+                        this.instance.hllm.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(7, 1)));
+                    },
+                    encode: () => {
+                        const hllm = this.instance.hllm.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        this.instance.hllm.setValue(hllm);
+                        this.writeBytes(7, (0, NumberToBuffer_1.UInt8ToBuffer)(hllm));
+                    }
+                },
+                sip: {
+                    type: 'string',
+                    label: 'Source Address',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.IPv6,
+                    decode: () => {
+                        this.instance.sip.setValue((0, BufferToIP_1.BufferToIPv6)(this.readBytes(8, 16)));
+                    },
+                    encode: () => {
+                        const sip = this.instance.sip.getValue('0000:0000:0000:0000:0000:0000:0000:0000', (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        this.instance.sip.setValue(sip);
+                        this.writeBytes(8, (0, IPToBuffer_1.IPv6ToBuffer)(sip));
+                    }
+                },
+                dip: {
+                    type: 'string',
+                    label: 'Destination Address',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.IPv6,
+                    decode: () => {
+                        this.instance.dip.setValue((0, BufferToIP_1.BufferToIPv6)(this.readBytes(24, 16)));
+                    },
+                    encode: () => {
+                        const dip = this.instance.dip.getValue('0000:0000:0000:0000:0000:0000:0000:0000', (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        this.instance.dip.setValue(dip);
+                        this.writeBytes(24, (0, IPToBuffer_1.IPv6ToBuffer)(dip));
+                    }
+                }
+            }
+        };
+        this.id = 'ipv6';
+        this.matchKeys = ['ethertype:86dd'];
+        //Also in the heuristic chain so IPv6 can be recognized as the inner payload of a bare-IP tunnel
+        //(GTP-U G-PDU). The etherType path below still handles the ethertype:86dd bucket unchanged.
+        this.heuristicFallback = true;
+        this.demuxProducers = [{ field: 'nxt', namespace: 'ipproto', kind: 'uint' }];
+        this.name = 'Internet Protocol Version 6';
+        this.nickname = 'IPv6';
+    }
+    match() {
+        if (!this.prevCodecModule)
+            return false;
+        //Normal path (unchanged): a parent that demuxed to IPv6 via its etherType field.
+        if (this.prevCodecModule.instance.etherType.getValue() === (0, NumberToHex_1.UInt16ToHex)(0x86dd))
+            return true;
+        //Bare-IP tunnel path (GTP-U): no inner-protocol field, so match by the IPv6 version nibble. The
+        //tunnel-parent id gate MUST come first — a 4-bit nibble alone is too weak a signature.
+        if (['gtp'].includes(this.prevCodecModule.id) && (this.readBytes(0, 1, true)[0] >> 4) === 6)
+            return true;
+        //Typed-tunnel path: GENEVE/GRE carry a Protocol Type (an EtherType), so trust that self-describing
+        //field rather than the weak version nibble — the ethertype demux already routed us here.
+        if ((this.prevCodecModule.id === 'geneve' || this.prevCodecModule.id === 'gre') && this.prevCodecModule.instance.protocolType.getValue() === (0, NumberToHex_1.UInt16ToHex)(0x86dd))
+            return true;
+        return false;
+    }
+}
+exports.IPv6 = IPv6;

package/dist/headers/IPv6HopByHopOptions.d.ts

@@ -0,0 +1,81 @@
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { DemuxProducer } from '../types/DemuxProducer';
+declare enum Type {
+    Pad1 = "Pad1",
+    PadN = "PadN",
+    Tunnel_Encapsulation_Limit = "Tunnel-Encapsulation-Limit",
+    Router_Alert = "Router-Alert",
+    CALIPSO = "CALIPSO",
+    SMF_DPD = "SMF_DPD",
+    MPL_Option = "MPL-Option",
+    ILNP_Nonce = "ILNP-Nonce",
+    Line_Identification_Option = "Line-Identification-Option",
+    IPv6_DFF_Header = "IPv6-DFF-Header",
+    Endpoint_Identification = "Endpoint-Identification"
+}
+type Pad1 = {
+    type: Type.Pad1;
+};
+type PadN = {
+    type: Type.PadN;
+    n: number;
+};
+type Tunnel_Encapsulation_Limit = {
+    type: Type.Tunnel_Encapsulation_Limit;
+    limit: number;
+};
+type Router_Alert = {
+    type: Type.Router_Alert;
+    alert: string;
+};
+type CALIPSO = {
+    type: Type.CALIPSO;
+    tag: string;
+};
+type SMF_DPD = {
+    type: Type.SMF_DPD;
+    hash: string;
+};
+type MPL_Option = {
+    type: Type.MPL_Option;
+    value: string;
+};
+type ILNP_Nonce = {
+    type: Type.ILNP_Nonce;
+    nonce: string;
+};
+type Line_Identification_Option = {
+    type: Type.Line_Identification_Option;
+    id: string;
+};
+type IPv6_DFF_Header = {
+    type: Type.IPv6_DFF_Header;
+    message: string;
+};
+type Endpoint_Identification = {
+    type: Type.Endpoint_Identification;
+    id: string;
+};
+type Custom = {
+    type: number;
+    data: string;
+};
+export declare class IPv6HopByHopOptions extends BaseHeader {
+    protected paddedOptionsLength: number;
+    /**
+     * 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.
+     */
+    protected decodeHbhOption(type: number, length: number, valueHex: string): IPv6HopByHopOptions['items'][number];
+    protected items: (Pad1 | PadN | Tunnel_Encapsulation_Limit | Router_Alert | CALIPSO | SMF_DPD | MPL_Option | ILNP_Nonce | Line_Identification_Option | IPv6_DFF_Header | Endpoint_Identification | Custom)[];
+    SCHEMA: ProtocolJSONSchema;
+    id: string;
+    readonly matchKeys: string[];
+    readonly demuxProducers: DemuxProducer[];
+    name: string;
+    nickname: string;
+    readonly isProtocol: boolean;
+    match(): boolean;
+}
+export {};