@netkitty/codec 1.0.0

package/dist/headers/GTPU.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GTPU = 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");
+/**
+ * GTP-U — GPRS Tunnelling Protocol, User plane (3GPP TS 29.281), UDP port 2152. The mandatory 8-byte
+ * header is a Flags byte (Version[3] / Protocol-Type / reserved / E / S / PN), a Message Type
+ * (0xFF = G-PDU carries a user IP packet), a 2-byte Length (everything after the 8-byte header), and a
+ * 4-byte TEID (Tunnel Endpoint Identifier). If any of E/S/PN is set, a 4-byte optional field
+ * (Sequence Number + N-PDU Number + Next-Extension-Header-Type) follows, then a chain of extension
+ * headers. For a G-PDU the payload after the header is a raw inner IP packet.
+ *
+ * The optional field + extension-header chain is kept verbatim (optionalHeader hex) so any GTP-U
+ * variant round-trips byte-for-byte; the inner IP packet is left to the codec's recursion (IPv4/IPv6
+ * accept a GTP-U tunnel parent, matching by IP version), decoding a fresh ip/… stack after the tunnel.
+ */
+class GTPU extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'gtp';
+        this.name = 'GPRS Tunnelling Protocol, User plane';
+        this.nickname = 'GTP-U';
+        this.matchKeys = ['udpport:2152'];
+        //No child demux key; the inner IP packet is matched by IPv4/IPv6's tunnel-aware match() (which
+        //accepts a 'gtp' parent and matches by the IP version nibble), so recursion decodes the inner stack.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (GTPU.#schemaCache ??= GTPU.#buildSchema());
+    }
+    static #flagBit(name, bitOffset, label) {
+        return {
+            type: 'boolean',
+            label: label,
+            decode: function () {
+                this.instance.flags[name].setValue(!!this.readBits(0, 1, bitOffset, 1));
+            },
+            encode: function () {
+                const value = !!this.instance.flags[name].getValue();
+                this.instance.flags[name].setValue(value);
+                this.writeBits(0, 1, bitOffset, 1, value ? 1 : 0);
+            }
+        };
+    }
+    /** The payload length available for this GTP-U message, clamped by the UDP datagram. */
+    #available() {
+        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: 'GTP-U teid=${teid} type=${msgType}',
+            properties: {
+                //Flags byte (bit 0 = MSB): Version[0..2], PT[3], reserved[4], E[5], S[6], PN[7].
+                flags: {
+                    type: 'object',
+                    label: 'Flags',
+                    properties: {
+                        version: {
+                            type: 'integer',
+                            label: 'Version',
+                            minimum: 0,
+                            maximum: 7,
+                            decode: function () { this.instance.flags.version.setValue(this.readBits(0, 1, 0, 3)); },
+                            encode: function () { this.writeBits(0, 1, 0, 3, this.instance.flags.version.getValue(0)); }
+                        },
+                        pt: this.#flagBit('pt', 3, 'Protocol Type'),
+                        e: this.#flagBit('e', 5, 'Extension Header Present'),
+                        s: this.#flagBit('s', 6, 'Sequence Number Present'),
+                        pn: this.#flagBit('pn', 7, 'N-PDU Number Present')
+                    }
+                },
+                msgType: this.fieldUInt('msgType', 1, 1, 'Message Type'),
+                length: {
+                    type: 'integer',
+                    label: 'Length',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: function () {
+                        this.instance.length.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(2, 2)));
+                    },
+                    encode: function () {
+                        const length = this.instance.length.getValue();
+                        if (length !== undefined && length !== null) {
+                            this.instance.length.setValue(length);
+                            this.writeBytes(2, (0, NumberToBuffer_1.UInt16ToBuffer)(length));
+                        }
+                        else {
+                            this.writeBytes(2, (0, NumberToBuffer_1.UInt16ToBuffer)(0));
+                            //GTP-U Length = every byte after the mandatory 8-byte header (optional field +
+                            //extension headers + inner payload). Compute it after the whole packet encodes.
+                            this.addPostPacketEncodeHandler(() => {
+                                let started = false;
+                                let total = 0;
+                                this.codecModules.forEach((codecModule) => {
+                                    if (codecModule === this)
+                                        started = true;
+                                    if (started)
+                                        total += codecModule.length;
+                                });
+                                const value = total - 8 < 0 ? 0 : total - 8;
+                                this.instance.length.setValue(value);
+                                this.writeBytes(2, (0, NumberToBuffer_1.UInt16ToBuffer)(value));
+                            }, 1);
+                        }
+                    }
+                },
+                teid: this.fieldHex('teid', 4, 4, 'TEID'),
+                //Optional field (Sequence Number + N-PDU Number + Next Extension Header Type) and any
+                //extension-header chain, kept verbatim. Empty when E/S/PN are all clear.
+                optionalHeader: {
+                    type: 'string',
+                    label: 'Optional Header',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    hidden: true,
+                    decode: function () {
+                        const e = !!this.instance.flags.e.getValue();
+                        const s = !!this.instance.flags.s.getValue();
+                        const pn = !!this.instance.flags.pn.getValue();
+                        if (!e && !s && !pn) {
+                            this.instance.optionalHeader.setValue('');
+                            return;
+                        }
+                        const available = this.#available();
+                        //4 optional bytes: Sequence Number(2) + N-PDU Number(1) + Next-Ext-Header-Type(1).
+                        let optionalLength = 4;
+                        if (e) {
+                            //Walk the extension-header chain: each is length(1, in 4-octet units) + body +
+                            //a trailing Next-Extension-Header-Type; a 0 type ends the chain.
+                            let nextType = (0, BufferToNumber_1.BufferToUInt8)(this.readBytes(11, 1, true));
+                            let offset = 12;
+                            let guard = 0;
+                            while (nextType !== 0 && offset < available && guard++ < 256) {
+                                const units = (0, BufferToNumber_1.BufferToUInt8)(this.readBytes(offset, 1, true));
+                                if (units === 0)
+                                    break;
+                                const extBytes = units * 4;
+                                if (offset + extBytes > available)
+                                    break;
+                                nextType = (0, BufferToNumber_1.BufferToUInt8)(this.readBytes(offset + extBytes - 1, 1, true));
+                                offset += extBytes;
+                            }
+                            optionalLength = offset - 8;
+                        }
+                        if (8 + optionalLength > available)
+                            optionalLength = available - 8;
+                        this.instance.optionalHeader.setValue(optionalLength > 0 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(8, optionalLength)) : '');
+                    },
+                    encode: function () {
+                        const optionalHeader = this.instance.optionalHeader.getValue('');
+                        if (optionalHeader)
+                            this.writeBytes(8, (0, HexToBuffer_1.HexToBuffer)(optionalHeader));
+                    }
+                },
+                //Non-G-PDU messages (message type != 0xFF: Echo, Error Indication, End Marker, …) carry
+                //GTP Information Elements, NOT an inner IP packet. Consume them here so the codec's
+                //recursion has nothing left to (mis)interpret as inner IP by the version nibble. For a
+                //G-PDU (0xFF) this is empty and the header stops after the optional field, leaving the
+                //inner IP packet to be decoded recursively.
+                payload: {
+                    type: 'string',
+                    label: 'Payload',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    hidden: true,
+                    decode: function () {
+                        const msgType = this.instance.msgType.getValue(0);
+                        if (msgType === 0xff) {
+                            this.instance.payload.setValue('');
+                            return;
+                        }
+                        const available = this.#available();
+                        const consumed = 8 + (0, HexToBuffer_1.HexToBuffer)(this.instance.optionalHeader.getValue('')).length;
+                        this.instance.payload.setValue(consumed < available ? (0, BufferToHex_1.BufferToHex)(this.readBytes(consumed, available - consumed)) : '');
+                    },
+                    encode: function () {
+                        const payload = this.instance.payload.getValue('');
+                        if (payload) {
+                            const consumed = 8 + (0, HexToBuffer_1.HexToBuffer)(this.instance.optionalHeader.getValue('')).length;
+                            this.writeBytes(consumed, (0, HexToBuffer_1.HexToBuffer)(payload));
+                        }
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //Require the 8-byte mandatory header within the UDP payload (see RADIUS: bound by payload).
+        return !!this.prevCodecModule && this.prevCodecModule.id === 'udp' && this.#available() >= 8;
+    }
+}
+exports.GTPU = GTPU;

package/dist/headers/GTPv2C.d.ts

@@ -0,0 +1,30 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * GTPv2-C — GPRS Tunnelling Protocol version 2, Control plane (3GPP TS 29.274), UDP port 2123. The
+ * mandatory part is the first 4 octets: a Flags byte (Version[3] = 2, P = Piggybacking, T = TEID flag,
+ * then 3 spare bits), a Message Type (1 Echo Request, 2 Echo Response, 32 Create Session Request,
+ * 33 Create Session Response, …), and a 2-byte Message Length (the octet count of everything after
+ * these first 4 octets). When the T flag is set a 4-byte TEID follows; then a 3-byte Sequence Number
+ * and a 1-byte Spare are always present. The rest of the message is a flat list of Information Elements,
+ * each a 1-byte Type, a 2-byte Length (the value byte count), a byte carrying a 4-bit spare + 4-bit
+ * Instance, and Length value octets.
+ *
+ * IEs are carried generically (type + instance + verbatim hex value) so every IE — including grouped and
+ * vendor-specific ones whose value is opaque — round-trips byte-for-byte; per-IE semantic decoding is a
+ * later enrichment. The Message Length is honoured verbatim when supplied (a crafted message may lie),
+ * else derived from the actual TEID/Sequence/Spare/IE bytes. The IE walk is bounded by both the Message
+ * Length and the UDP datagram, so retained Ethernet padding / trailing bytes are not absorbed. A
+ * well-formed message round-trips byte-for-byte. GTPv2-C is a leaf — nothing rides on top of it.
+ */
+export declare class GTPv2C 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/GTPv2C.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GTPv2C = 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");
+/**
+ * GTPv2-C — GPRS Tunnelling Protocol version 2, Control plane (3GPP TS 29.274), UDP port 2123. The
+ * mandatory part is the first 4 octets: a Flags byte (Version[3] = 2, P = Piggybacking, T = TEID flag,
+ * then 3 spare bits), a Message Type (1 Echo Request, 2 Echo Response, 32 Create Session Request,
+ * 33 Create Session Response, …), and a 2-byte Message Length (the octet count of everything after
+ * these first 4 octets). When the T flag is set a 4-byte TEID follows; then a 3-byte Sequence Number
+ * and a 1-byte Spare are always present. The rest of the message is a flat list of Information Elements,
+ * each a 1-byte Type, a 2-byte Length (the value byte count), a byte carrying a 4-bit spare + 4-bit
+ * Instance, and Length value octets.
+ *
+ * IEs are carried generically (type + instance + verbatim hex value) so every IE — including grouped and
+ * vendor-specific ones whose value is opaque — round-trips byte-for-byte; per-IE semantic decoding is a
+ * later enrichment. The Message Length is honoured verbatim when supplied (a crafted message may lie),
+ * else derived from the actual TEID/Sequence/Spare/IE bytes. The IE walk is bounded by both the Message
+ * Length and the UDP datagram, so retained Ethernet padding / trailing bytes are not absorbed. A
+ * well-formed message round-trips byte-for-byte. GTPv2-C is a leaf — nothing rides on top of it.
+ */
+class GTPv2C extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'gtpv2';
+        this.name = 'GPRS Tunnelling Protocol version 2, Control plane';
+        this.nickname = 'GTPv2-C';
+        this.matchKeys = ['udpport:2123'];
+        //A leaf header — the IE values are kept as verbatim hex, so nothing demuxes above GTPv2-C.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (GTPv2C.#schemaCache ??= GTPv2C.#buildSchema());
+    }
+    /** A single flag bit of the first byte (byte 0), MSB-first: bitOffset 3 = P, 4 = T. */
+    static #flagBit(name, bitOffset, label) {
+        return {
+            type: 'boolean',
+            label: label,
+            decode: function () {
+                this.instance.flags[name].setValue(!!this.readBits(0, 1, bitOffset, 1));
+            },
+            encode: function () {
+                const value = !!this.instance.flags[name].getValue();
+                this.instance.flags[name].setValue(value);
+                this.writeBits(0, 1, bitOffset, 1, value ? 1 : 0);
+            }
+        };
+    }
+    /** True when the T (TEID) flag is set — a 4-byte TEID then sits between the length field and the sequence number. */
+    #teidPresent() {
+        return !!this.instance.flags.teidFlag.getValue();
+    }
+    /** Header-relative offset of the 3-byte Sequence Number: after the 4 mandatory octets, +4 for the TEID when present. */
+    #sequenceOffset() {
+        return this.#teidPresent() ? 8 : 4;
+    }
+    /** The payload length available to this message, clamped by the UDP datagram (so padding/FCS is not absorbed). */
+    #available() {
+        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;
+    }
+    /** Header-relative end offset of the IE list: 4 (mandatory) + Message Length, clamped down to the UDP payload. */
+    #messageEnd() {
+        let end = 4 + this.instance.messageLength.getValue(0);
+        const available = this.#available();
+        if (available && available < end)
+            end = available;
+        return end;
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'GTPv2-C type=${messageType} seq=${sequenceNumber}',
+            properties: {
+                //Byte 0 (MSB-first): Version[0..2] (= 2), P[3] Piggybacking, T[4] TEID flag, spare[5..7].
+                flags: {
+                    type: 'object',
+                    label: 'Flags',
+                    properties: {
+                        version: {
+                            type: 'integer',
+                            label: 'Version',
+                            minimum: 0,
+                            maximum: 7,
+                            decode: function () { this.instance.flags.version.setValue(this.readBits(0, 1, 0, 3)); },
+                            encode: function () { this.writeBits(0, 1, 0, 3, this.instance.flags.version.getValue(2)); }
+                        },
+                        piggybacking: this.#flagBit('piggybacking', 3, 'Piggybacking'),
+                        teidFlag: this.#flagBit('teidFlag', 4, 'TEID Flag'),
+                        //3 spare bits kept verbatim so a non-canonical first byte still round-trips.
+                        spare: {
+                            type: 'integer',
+                            label: 'Spare',
+                            minimum: 0,
+                            maximum: 7,
+                            hidden: true,
+                            decode: function () { this.instance.flags.spare.setValue(this.readBits(0, 1, 5, 3)); },
+                            encode: function () { this.writeBits(0, 1, 5, 3, this.instance.flags.spare.getValue(0)); }
+                        }
+                    }
+                },
+                messageType: this.fieldUInt('messageType', 1, 1, 'Message Type'),
+                messageLength: {
+                    type: 'integer',
+                    label: 'Message Length',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: function () {
+                        this.instance.messageLength.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(2, 2)));
+                    },
+                    encode: function () {
+                        //Message Length counts every octet after the first 4: the TEID (if T), the 3-byte
+                        //Sequence Number, the 1-byte Spare, and all IEs. Honoured when supplied (a crafted
+                        //message may lie); else derived from the actual fields.
+                        const provided = this.instance.messageLength.getValue();
+                        let value;
+                        if (provided !== undefined && provided !== null) {
+                            value = provided;
+                        }
+                        else {
+                            let iesBytes = 0;
+                            const ies = this.instance.ies.getValue([]);
+                            if (ies)
+                                for (const ie of ies)
+                                    iesBytes += 4 + (0, HexToBuffer_1.HexToBuffer)(ie.value ? ie.value : '').length;
+                            value = (this.#teidPresent() ? 4 : 0) + 3 + 1 + iesBytes;
+                        }
+                        if (value > 65535) {
+                            this.recordError(this.instance.messageLength.getPath(), 'Maximum value is 65535');
+                            value = 65535;
+                        }
+                        this.instance.messageLength.setValue(value);
+                        this.writeBytes(2, (0, NumberToBuffer_1.UInt16ToBuffer)(value));
+                    }
+                },
+                //4-byte TEID, present only when the T flag is set. Kept verbatim as hex.
+                teid: {
+                    type: 'string',
+                    label: 'TEID',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        if (!this.#teidPresent())
+                            return;
+                        this.instance.teid.setValue((0, BufferToHex_1.BufferToHex)(this.readBytes(4, 4)));
+                    },
+                    encode: function () {
+                        if (!this.#teidPresent())
+                            return;
+                        this.writeBytes(4, (0, HexToBuffer_1.HexToBuffer)(this.instance.teid.getValue('00000000')));
+                    }
+                },
+                //3-byte Sequence Number, at offset 4 (no TEID) or 8 (TEID present).
+                sequenceNumber: {
+                    type: 'integer',
+                    label: 'Sequence Number',
+                    minimum: 0,
+                    maximum: 16777215,
+                    decode: function () {
+                        this.instance.sequenceNumber.setValue(this.readBits(this.#sequenceOffset(), 3, 0, 24));
+                    },
+                    encode: function () {
+                        const node = this.instance.sequenceNumber;
+                        let value = node.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        if (value > 16777215) {
+                            this.recordError(node.getPath(), 'Maximum value is 16777215');
+                            value = 16777215;
+                        }
+                        if (value < 0) {
+                            this.recordError(node.getPath(), 'Minimum value is 0');
+                            value = 0;
+                        }
+                        node.setValue(value);
+                        this.writeBits(this.#sequenceOffset(), 3, 0, 24, value);
+                    }
+                },
+                //1-byte Spare after the Sequence Number, kept verbatim.
+                spare: {
+                    type: 'string',
+                    label: 'Spare',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    hidden: true,
+                    decode: function () {
+                        this.instance.spare.setValue((0, BufferToHex_1.BufferToHex)(this.readBytes(this.#sequenceOffset() + 3, 1)));
+                    },
+                    encode: function () {
+                        this.writeBytes(this.#sequenceOffset() + 3, (0, HexToBuffer_1.HexToBuffer)(this.instance.spare.getValue('00')));
+                    }
+                },
+                //Information Elements: a flat list from the end of the mandatory part to the Message Length
+                //end (clamped to the UDP payload). Each IE = Type(1) + Length(2) + (spare[4]+Instance[4])(1)
+                //+ Length value octets. The Length is derived from the value byte count on encode.
+                ies: {
+                    type: 'array',
+                    label: 'Information Elements',
+                    items: {
+                        type: 'object',
+                        label: 'IE',
+                        properties: {
+                            type: { type: 'integer', label: 'Type', minimum: 0, maximum: 255 },
+                            spare: { type: 'integer', label: 'Spare', minimum: 0, maximum: 15, hidden: true },
+                            instance: { type: 'integer', label: 'Instance', minimum: 0, maximum: 15 },
+                            value: { type: 'string', label: 'Value', contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX }
+                        }
+                    },
+                    decode: function () {
+                        const end = this.#messageEnd();
+                        const ies = [];
+                        let offset = this.#sequenceOffset() + 4;
+                        //Each IE needs a 4-byte header; stop when it or its value would overrun the bound.
+                        while (offset + 4 <= end) {
+                            const type = (0, BufferToNumber_1.BufferToUInt8)(this.readBytes(offset, 1));
+                            const length = (0, BufferToNumber_1.BufferToUInt16)(this.readBytes(offset + 1, 2));
+                            const instByte = (0, BufferToNumber_1.BufferToUInt8)(this.readBytes(offset + 3, 1));
+                            const valueStart = offset + 4;
+                            if (valueStart + length > end)
+                                break;
+                            const value = length > 0 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(valueStart, length)) : '';
+                            ies.push({ type: type, spare: instByte >> 4, instance: instByte & 0x0f, value: value });
+                            offset = valueStart + length;
+                        }
+                        this.instance.ies.setValue(ies);
+                    },
+                    encode: function () {
+                        const ies = this.instance.ies.getValue([]);
+                        if (!ies)
+                            return;
+                        let offset = this.#sequenceOffset() + 4;
+                        for (let i = 0; i < ies.length; i++) {
+                            const ie = ies[i];
+                            let value = (0, HexToBuffer_1.HexToBuffer)(ie.value ? ie.value : '');
+                            //The IE Length is a 16-bit field; a longer value cannot be represented, so clamp
+                            //it and record the error rather than silently wrapping (which corrupts the chain).
+                            if (value.length > 65535) {
+                                this.recordError(`ies[${i}].value`, 'Maximum IE value length is 65535 bytes');
+                                value = value.subarray(0, 65535);
+                            }
+                            this.writeBytes(offset, (0, NumberToBuffer_1.UInt8ToBuffer)(ie.type ? ie.type : 0));
+                            this.writeBytes(offset + 1, (0, NumberToBuffer_1.UInt16ToBuffer)(value.length));
+                            const spare = ie.spare ? ie.spare : 0;
+                            const instance = ie.instance ? ie.instance : 0;
+                            this.writeBytes(offset + 3, (0, NumberToBuffer_1.UInt8ToBuffer)(((spare & 0x0f) << 4) | (instance & 0x0f)));
+                            offset += 4;
+                            if (value.length) {
+                                this.writeBytes(offset, value);
+                                offset += value.length;
+                            }
+                        }
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //GTPv2-C rides on UDP port 2123 (either endpoint — a request's destination or a response's
+        //source). Require the mandatory 8-byte header (flags + type + length + seq + spare, no TEID) to
+        //be present in the UDP payload, and Version == 2 in the first byte so GTPv1-C (version 1) on the
+        //same port falls through.
+        if (!this.prevCodecModule || this.prevCodecModule.id !== 'udp')
+            return false;
+        const dstport = this.prevCodecModule.instance.dstport.getValue(0);
+        const srcport = this.prevCodecModule.instance.srcport.getValue(0);
+        if (dstport !== 2123 && srcport !== 2123)
+            return false;
+        if (this.#available() < 8)
+            return false;
+        return this.readBits(0, 1, 0, 3) === 2;
+    }
+}
+exports.GTPv2C = GTPv2C;

package/dist/headers/GitProtocol.d.ts

@@ -0,0 +1,34 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * Git Smart Transport over the native `git://` protocol (git-daemon, TCP port 9418). The wire format is
+ * a stream of pkt-lines: each pkt-line is a 4-character ASCII hexadecimal length prefix (the length
+ * COUNTS those 4 characters) followed by that many minus four bytes of payload; the special value
+ * "0000" is a flush-pkt (an empty delimiter, no payload). A git-daemon session opens with a single
+ * request pkt-line such as `0032git-upload-pack /project.git\0host=example.com\0` — a length prefix,
+ * the service command and repository path, then NUL-delimited extra parameters (host, and for v2 an
+ * extra NUL plus capabilities).
+ *
+ * Like SIP/HTTP, the message body is a text-ish framed stream whose full internal structure (an
+ * arbitrary number of pkt-lines, service negotiation, ref advertisements, packfile data) is far richer
+ * than a form needs, and byte layout is significant. So the ENTIRE payload of the current segment is
+ * kept verbatim as the authoritative `message` field (hex) and re-emitted untouched; only the FIRST
+ * pkt-line is parsed on decode into display-only metadata (its declared length and command line).
+ * Encode never reconstructs the stream from the parsed fields — it writes `message` back byte-for-byte
+ * — so any conformant (or even malformed) git segment round-trips exactly.
+ *
+ * Note: a git session spans many TCP segments (request, ref advertisement, want/have negotiation, the
+ * packfile); reassembly across segments is out of scope. This single-segment codec keeps whatever bytes
+ * are present in the current segment verbatim, which is byte-perfect for the single-packet case.
+ */
+export declare class GitProtocol extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}