@netkitty/codec 1.0.0

package/dist/headers/NBDS.js

@@ -0,0 +1,176 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NBDS = 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");
+/**
+ * NBDS — NetBIOS Datagram Service (RFC 1002 §4.4), the NetBIOS-over-TCP/IP datagram service on UDP 138.
+ * Every NBDS packet opens with a fixed 10-byte common prefix — a 1-byte Message Type, a 1-byte Flags
+ * octet (MORE/FIRST fragment bits + 2-bit Source End-Node Type + reserved bits), a 2-byte Datagram ID,
+ * the 4-byte Source IP and the 2-byte Source Port of the originating node.
+ *
+ * What follows the prefix depends on the Message Type. The DIRECT_UNIQUE (0x10), DIRECT_GROUP (0x11)
+ * and BROADCAST (0x12) datagrams add a 2-byte Datagram Length and a 2-byte Packet Offset (fragmentation
+ * offset), then the second-level-encoded Source and Destination NetBIOS names followed by the user data
+ * (an SMB mailslot payload, e.g. a browser announcement). DATAGRAM ERROR (0x13) carries a 1-byte error
+ * code; the QUERY messages (0x14/0x15/0x16) carry only a destination name. So only the Direct/Broadcast
+ * types have the Datagram-Length / Packet-Offset words — they are structured for those types and left out
+ * of the byte stream otherwise (mirroring COTP's DT-only fields).
+ *
+ * The names + user data (for Direct/Broadcast) or the type-specific remainder (for the other types) are
+ * kept verbatim as `body` hex, bounded by the UDP payload length so trailing bytes are not absorbed:
+ * decoding the second-level NetBIOS names and handing the user data to SMB is a later enrichment. Message
+ * Type is stored as the raw octet (fieldUInt — no enum, so a crafted/unknown type still round-trips) and
+ * the Datagram Length is honored on encode when supplied, else derived from the body. A well-formed
+ * datagram of any type round-trips byte-for-byte.
+ */
+class NBDS extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'nbds';
+        this.name = 'NetBIOS Datagram Service';
+        this.nickname = 'NBDS';
+        this.matchKeys = ['udpport:138'];
+        //A leaf header — the NetBIOS names and the SMB mailslot user data are kept verbatim and decoded later.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (_a.#schemaCache ??= _a.#buildSchema());
+    }
+    /** The DIRECT_UNIQUE / DIRECT_GROUP / BROADCAST types (0x10-0x12) carry the length + offset words and names. */
+    static #isDirect(msgType) {
+        return msgType >= 0x10 && msgType <= 0x12;
+    }
+    /** End of this datagram within the captured bytes: bounded by the parent UDP payload (udp.length − 8). */
+    #payloadEnd() {
+        let end = this.packet.length - this.startPos;
+        const prev = this.prevCodecModule;
+        if (prev && prev.id === 'udp') {
+            const udpLength = prev.instance.length.getValue(0);
+            if (udpLength >= 8 && udpLength - 8 < end)
+                end = udpLength - 8;
+        }
+        return end < 0 ? 0 : end;
+    }
+    /** The offset where the type-specific body begins: after the length/offset words for Direct types, else right after the 10-byte prefix. */
+    #bodyStart() {
+        return _a.#isDirect(this.instance.msgType.getValue(0)) ? 14 : 10;
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'NBDS type=${msgType} id=${dgmId}',
+            properties: {
+                //The Message Type octet, kept raw (0x10 DIRECT_UNIQUE, 0x11 DIRECT_GROUP, 0x12 BROADCAST,
+                //0x13 DATAGRAM ERROR, 0x14 QUERY REQUEST, 0x15/0x16 QUERY RESPONSE, …). No enum: an unknown
+                //or crafted type must still decode and re-encode.
+                msgType: this.fieldUInt('msgType', 0, 1, 'Message Type'),
+                //The Flags octet, kept whole so the MORE/FIRST fragment bits, the 2-bit Source End-Node
+                //Type and the reserved bits all round-trip untouched.
+                flags: this.fieldUInt('flags', 1, 1, 'Flags'),
+                dgmId: this.fieldUInt('dgmId', 2, 2, 'Datagram ID'),
+                sourceIP: this.fieldIPv4('sourceIP', 4, 'Source IP'),
+                sourcePort: this.fieldUInt('sourcePort', 8, 2, 'Source Port'),
+                //Direct/Broadcast only: the 2-byte Datagram Length — the count of bytes that follow the
+                //Packet Offset (the NetBIOS names + user data). Honored on encode when supplied, else
+                //derived from the body. Meaningless for other types (not present on the wire — left 0).
+                dgmLength: {
+                    type: 'integer',
+                    label: 'Datagram Length',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: function () {
+                        if (!_a.#isDirect(this.instance.msgType.getValue(0)))
+                            return;
+                        this.instance.dgmLength.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(10, 2)));
+                    },
+                    encode: function () {
+                        if (!_a.#isDirect(this.instance.msgType.getValue(0)))
+                            return;
+                        const provided = this.instance.dgmLength.getValue();
+                        let value = (provided !== undefined && provided !== null)
+                            ? provided
+                            : (0, HexToBuffer_1.HexToBuffer)(this.instance.body.getValue('')).length;
+                        if (value > 65535) {
+                            this.recordError(this.instance.dgmLength.getPath(), 'Maximum value is 65535');
+                            value = 65535;
+                        }
+                        this.instance.dgmLength.setValue(value);
+                        this.writeBytes(10, (0, NumberToBuffer_1.UInt16ToBuffer)(value));
+                    }
+                },
+                //Direct/Broadcast only: the 2-byte Packet Offset (fragmentation offset within the datagram).
+                packetOffset: {
+                    type: 'integer',
+                    label: 'Packet Offset',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: function () {
+                        if (!_a.#isDirect(this.instance.msgType.getValue(0)))
+                            return;
+                        this.instance.packetOffset.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(12, 2)));
+                    },
+                    encode: function () {
+                        if (!_a.#isDirect(this.instance.msgType.getValue(0)))
+                            return;
+                        let value = this.instance.packetOffset.getValue(0);
+                        if (value > 65535) {
+                            this.recordError(this.instance.packetOffset.getPath(), 'Maximum value is 65535');
+                            value = 65535;
+                        }
+                        if (value < 0) {
+                            this.recordError(this.instance.packetOffset.getPath(), 'Minimum value is 0');
+                            value = 0;
+                        }
+                        this.instance.packetOffset.setValue(value);
+                        this.writeBytes(12, (0, NumberToBuffer_1.UInt16ToBuffer)(value));
+                    }
+                },
+                //The type-specific remainder kept verbatim: for Direct/Broadcast it is the second-level
+                //encoded Source + Destination NetBIOS names followed by the user data (SMB mailslot); for
+                //the error/query types it is their small type-specific tail. Bounded by the UDP payload
+                //length so any trailing bytes are left to the codec's recursion / RawData.
+                body: {
+                    type: 'string',
+                    label: 'Body',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const start = this.#bodyStart();
+                        const end = this.#payloadEnd();
+                        this.instance.body.setValue(end > start ? (0, BufferToHex_1.BufferToHex)(this.readBytes(start, end - start)) : '');
+                    },
+                    encode: function () {
+                        const body = this.instance.body.getValue('');
+                        if (body)
+                            this.writeBytes(this.#bodyStart(), (0, HexToBuffer_1.HexToBuffer)(body));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //NBDS rides UDP port 138 (selected via the udpport:138 bucket). Port-bucket only, NO
+        //heuristicFallback — the header has no strong content signature, so non-NBDS traffic on 138 must
+        //fall through to raw. Require at least the 10-byte common prefix within the UDP payload.
+        if (!this.prevCodecModule || this.prevCodecModule.id !== 'udp')
+            return false;
+        const available = this.#payloadEnd();
+        if (available < 10)
+            return false;
+        //Direct/Broadcast types (0x10-0x12) carry a 2-byte Datagram Length + 2-byte Packet Offset that are
+        //always re-emitted on encode, so require the full 14-byte fixed header. A shorter direct datagram
+        //could not round-trip those words (encode would sprout bytes the wire never had), so leave it to
+        //RawData rather than claim it. Non-direct types only need the 10-byte common prefix.
+        if (_a.#isDirect(this.readBytes(0, 1, true)[0]) && available < 14)
+            return false;
+        return true;
+    }
+}
+exports.NBDS = NBDS;
+_a = NBDS;

package/dist/headers/NBNS.d.ts

@@ -0,0 +1,34 @@
+import { DNS } from './DNS';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+/** A decoded DNS name {value, raw} — mirrors DNS's internal type (value = readable, raw = wire bytes). */
+type DnsName = {
+    value: string;
+    raw: string;
+};
+/**
+ * NBNS — NetBIOS Name Service (RFC 1002), the NetBIOS-over-TCP/IP name service on UDP 137. The message
+ * uses the DNS wire format (RFC 1035): the same 12-byte header, questions, and resource records with
+ * label compression — so it reuses the DNS decode/encode wholesale.
+ *
+ * The one NBNS-specific twist is the name: a NetBIOS name is a 16-byte value (15-byte name + 1-byte
+ * suffix) carried in a single DNS label of length 32 via "first-level encoding" (RFC 1001 §4.1) — each
+ * of the 16 bytes is split into two nibbles, each offset by 'A' (0x41) into a printable byte. This
+ * subclass overrides readName/writeName to present the readable "NAME<suffix>" form while re-emitting
+ * the exact wire bytes (`raw`) for a byte-perfect round-trip; crafting from `value` re-encodes the
+ * first-level form. Everything else (header bits, counts, RR structure, compression) is inherited DNS.
+ */
+export declare class NBNS extends DNS {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    protected readName(offset: number): {
+        name: DnsName;
+        next: number;
+    };
+    protected writeName(offset: number, name: DnsName | undefined): number;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    match(): boolean;
+}
+export {};

package/dist/headers/NBNS.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NBNS = void 0;
+const DNS_1 = require("./DNS");
+/**
+ * NBNS — NetBIOS Name Service (RFC 1002), the NetBIOS-over-TCP/IP name service on UDP 137. The message
+ * uses the DNS wire format (RFC 1035): the same 12-byte header, questions, and resource records with
+ * label compression — so it reuses the DNS decode/encode wholesale.
+ *
+ * The one NBNS-specific twist is the name: a NetBIOS name is a 16-byte value (15-byte name + 1-byte
+ * suffix) carried in a single DNS label of length 32 via "first-level encoding" (RFC 1001 §4.1) — each
+ * of the 16 bytes is split into two nibbles, each offset by 'A' (0x41) into a printable byte. This
+ * subclass overrides readName/writeName to present the readable "NAME<suffix>" form while re-emitting
+ * the exact wire bytes (`raw`) for a byte-perfect round-trip; crafting from `value` re-encodes the
+ * first-level form. Everything else (header bits, counts, RR structure, compression) is inherited DNS.
+ */
+class NBNS extends DNS_1.DNS {
+    constructor() {
+        super(...arguments);
+        this.id = 'nbns';
+        this.name = 'NetBIOS Name Service';
+        this.nickname = 'NBNS';
+        this.matchKeys = ['udpport:137'];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (NBNS.#schemaCache ??= { ...super.SCHEMA, summary: 'NBNS ${id} queries=${qdcount} answers=${ancount}' });
+    }
+    /** Decode a 32-char first-level-encoded label into "NAME<XX>" (suffix in hex). Non-32-char labels pass through. */
+    static #decodeNetBIOSName(label) {
+        if (label.length !== 32)
+            return label;
+        const bytes = [];
+        for (let i = 0; i < 32; i += 2) {
+            const high = (label.charCodeAt(i) - 0x41) & 0x0f;
+            const low = (label.charCodeAt(i + 1) - 0x41) & 0x0f;
+            bytes.push((high << 4) | low);
+        }
+        const buffer = Buffer.from(bytes);
+        const name = buffer.subarray(0, 15).toString('latin1').replace(/ +$/, '');
+        return `${name}<${buffer[15].toString(16).padStart(2, '0')}>`;
+    }
+    /** Encode "NAME<XX>" back to a 32-char first-level-encoded label. Non-matching values pass through. */
+    static #encodeNetBIOSName(value) {
+        const match = value.match(/^(.*)<([0-9a-fA-F]{2})>$/);
+        if (!match)
+            return value;
+        const buffer = Buffer.alloc(16, 0x20);
+        Buffer.from(match[1], 'latin1').copy(buffer, 0, 0, 15);
+        buffer[15] = parseInt(match[2], 16);
+        let out = '';
+        for (const octet of buffer) {
+            out += String.fromCharCode(0x41 + ((octet >> 4) & 0x0f));
+            out += String.fromCharCode(0x41 + (octet & 0x0f));
+        }
+        return out;
+    }
+    readName(offset) {
+        const result = super.readName(offset);
+        const parts = result.name.value.split('.');
+        parts[0] = NBNS.#decodeNetBIOSName(parts[0]);
+        return { name: { value: parts.join('.'), raw: result.name.raw }, next: result.next };
+    }
+    writeName(offset, name) {
+        //Byte-perfect for a decoded name: re-emit the exact wire bytes.
+        if (name && name.raw)
+            return super.writeName(offset, name);
+        //Crafted from value: first-level-encode the NetBIOS name label, then let DNS build the labels.
+        const value = name && name.value ? name.value : '';
+        const parts = value.split('.');
+        parts[0] = NBNS.#encodeNetBIOSName(parts[0]);
+        return super.writeName(offset, { value: parts.join('.'), raw: '' });
+    }
+    match() {
+        return !!this.prevCodecModule && this.prevCodecModule.id === 'udp';
+    }
+}
+exports.NBNS = NBNS;

package/dist/headers/NBSS.d.ts

@@ -0,0 +1,36 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * NBSS — NetBIOS Session Service (RFC 1002), TCP port 139. Every session-service PDU begins with a fixed
+ * 4-byte header:
+ *
+ *      0               1               2               3
+ *     +-------------- -+---------------+-------------------------------+
+ *     |     TYPE      |    FLAGS    |E|            LENGTH              |
+ *     +---------------+---------------+-------------------------------+
+ *
+ * TYPE (1 byte) names the PDU (0x00 Session Message, 0x81 Session Request, 0x82/0x83 Positive/Negative
+ * Session Response, 0x84 Retarget, 0x85 Keep Alive). FLAGS (1 byte) is seven reserved bits plus an
+ * Extension bit E in its least-significant position — E is bit 16 (the high-order bit) of a 17-bit LENGTH
+ * whose low 16 bits are the following 2-byte field. So the trailer byte count is
+ * ((FLAGS & 0x01) << 16) | LENGTH16, and the payload (an SMB message for a Session Message, the encoded
+ * Called/Calling NetBIOS names for a Session Request, empty for Keep Alive / responses) follows the header.
+ *
+ * Byte-perfect strategy: structure type + flags (both verbatim, so the reserved bits and the E bit
+ * round-trip exactly) + the 16-bit length, and keep the payload verbatim as `payload` hex bounded by the
+ * 17-bit length. The length is honored when supplied (a crafted PDU may lie) else derived from the actual
+ * payload byte count; the payload is bounded by the length so a second pipelined PDU or Ethernet padding is
+ * left to the codec's recursion / RawData. Sub-decoding the SMB payload / the NetBIOS names is a later
+ * enrichment. A well-formed PDU round-trips byte-for-byte.
+ */
+export declare class NBSS 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/NBSS.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NBSS = 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");
+/**
+ * The valid NetBIOS Session Service packet types (RFC 1002 §4.3.1): 0x00 Session Message,
+ * 0x81 Session Request, 0x82 Positive Session Response, 0x83 Negative Session Response,
+ * 0x84 Retarget Response, 0x85 Session Keep Alive. Used as the match() signature on port 139.
+ */
+const NBSS_TYPES = new Set([0x00, 0x81, 0x82, 0x83, 0x84, 0x85]);
+/**
+ * NBSS — NetBIOS Session Service (RFC 1002), TCP port 139. Every session-service PDU begins with a fixed
+ * 4-byte header:
+ *
+ *      0               1               2               3
+ *     +-------------- -+---------------+-------------------------------+
+ *     |     TYPE      |    FLAGS    |E|            LENGTH              |
+ *     +---------------+---------------+-------------------------------+
+ *
+ * TYPE (1 byte) names the PDU (0x00 Session Message, 0x81 Session Request, 0x82/0x83 Positive/Negative
+ * Session Response, 0x84 Retarget, 0x85 Keep Alive). FLAGS (1 byte) is seven reserved bits plus an
+ * Extension bit E in its least-significant position — E is bit 16 (the high-order bit) of a 17-bit LENGTH
+ * whose low 16 bits are the following 2-byte field. So the trailer byte count is
+ * ((FLAGS & 0x01) << 16) | LENGTH16, and the payload (an SMB message for a Session Message, the encoded
+ * Called/Calling NetBIOS names for a Session Request, empty for Keep Alive / responses) follows the header.
+ *
+ * Byte-perfect strategy: structure type + flags (both verbatim, so the reserved bits and the E bit
+ * round-trip exactly) + the 16-bit length, and keep the payload verbatim as `payload` hex bounded by the
+ * 17-bit length. The length is honored when supplied (a crafted PDU may lie) else derived from the actual
+ * payload byte count; the payload is bounded by the length so a second pipelined PDU or Ethernet padding is
+ * left to the codec's recursion / RawData. Sub-decoding the SMB payload / the NetBIOS names is a later
+ * enrichment. A well-formed PDU round-trips byte-for-byte.
+ */
+class NBSS extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'nbss';
+        this.name = 'NetBIOS Session Service';
+        this.nickname = 'NBSS';
+        this.matchKeys = ['tcpport:139'];
+        //A leaf header — the SMB payload / the encoded NetBIOS names are kept verbatim for now.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (NBSS.#schemaCache ??= NBSS.#buildSchema());
+    }
+    /**
+     * The 17-bit trailer byte count = the Extension bit E (FLAGS bit 0) as bit 16, plus the 16-bit LENGTH.
+     * Read dry-run so it can be used to bound the payload without disturbing the decoded header length.
+     */
+    #declaredLength() {
+        const flags = this.readBytes(1, 1, true)[0];
+        const low16 = (0, BufferToNumber_1.BufferToUInt16)(this.readBytes(2, 2, true));
+        return ((flags & 0x01) * 0x10000) + low16;
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'NBSS type=${type} len=${length}',
+            properties: {
+                //0x00 Session Message, 0x81 Session Request, 0x82/0x83 Positive/Negative Response,
+                //0x84 Retarget, 0x85 Keep Alive. Kept verbatim.
+                type: this.fieldUInt('type', 0, 1, 'Type'),
+                //Seven reserved bits + the Extension bit E in the LSB (bit 16 of the 17-bit length). Kept
+                //verbatim so the reserved bits and E round-trip; the payload boundary reads E from here.
+                flags: this.fieldUInt('flags', 1, 1, 'Flags'),
+                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 () {
+                        //The low 16 bits of the trailer byte count. Honored when supplied (a crafted PDU may
+                        //lie); else derived from the actual payload length (its low 16 bits — the E bit lives
+                        //in the verbatim FLAGS byte and is not synthesized here).
+                        const provided = this.instance.length.getValue();
+                        let value = (provided !== undefined && provided !== null)
+                            ? provided
+                            : (0, HexToBuffer_1.HexToBuffer)(this.instance.payload.getValue('')).length % 0x10000;
+                        if (value > 65535) {
+                            this.recordError(this.instance.length.getPath(), 'Maximum value is 65535');
+                            value = 65535;
+                        }
+                        if (value < 0) {
+                            this.recordError(this.instance.length.getPath(), 'Minimum value is 0');
+                            value = 0;
+                        }
+                        this.instance.length.setValue(value);
+                        this.writeBytes(2, (0, NumberToBuffer_1.UInt16ToBuffer)(value));
+                    }
+                },
+                //The PDU payload after the 4-byte header, kept verbatim. Bounded by the 17-bit declared
+                //length and the captured bytes, so trailing / pipelined PDUs and Ethernet padding are left
+                //to the codec's recursion / RawData (never read to the buffer end).
+                payload: {
+                    type: 'string',
+                    label: 'Payload',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const remaining = this.packet.length - this.startPos - 4;
+                        let length = this.#declaredLength();
+                        if (length > remaining)
+                            length = remaining;
+                        this.instance.payload.setValue(length > 0 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(4, length)) : '');
+                    },
+                    encode: function () {
+                        const payload = this.instance.payload.getValue('');
+                        if (payload)
+                            this.writeBytes(4, (0, HexToBuffer_1.HexToBuffer)(payload));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //NBSS rides on TCP port 139 (selected via the tcpport:139 bucket). This stays a port-bucket
+        //protocol: matchKeys only, NO heuristicFallback — a single valid type byte is too weak a signature
+        //to claim NBSS off port 139, and non-NBSS traffic on 139 must fall through to raw. Require the full
+        //4-byte header within the captured bytes and a recognized packet type.
+        if (!this.prevCodecModule || this.prevCodecModule.id !== 'tcp')
+            return false;
+        if (this.packet.length - this.startPos < 4)
+            return false;
+        const type = this.readBytes(0, 1, true)[0];
+        return NBSS_TYPES.has(type);
+    }
+}
+exports.NBSS = NBSS;

package/dist/headers/NFS.d.ts

@@ -0,0 +1,36 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * Network File System (NFS, RFC 1813 v3 / RFC 7530 v4), TCP + UDP port 2049. NFS is carried inside an
+ * ONC RPC (RFC 5531) message, so on the wire an NFS packet is a plain RPC message: a 4-byte XID followed
+ * by a 4-byte Message Type (0 CALL, 1 REPLY). A CALL body continues with the RPC version (== 2), the
+ * program number (NFS = 100003), the program version, the procedure, then the credential + verifier auth
+ * structures and the NFS procedure arguments. NFS parses this RPC envelope itself at its 2049 port bucket
+ * (it does not depend on the SunRPC header, which is scoped to the portmapper's port 111).
+ *
+ * Transport framing differs by L4 (RFC 5531 §11): over UDP the RPC message is the whole datagram; over
+ * TCP a 4-byte Record Marking prefix precedes it — the high bit is the last-fragment flag and the low 31
+ * bits are the fragment length. This header detects the transport via prevCodecModule.id and structures
+ * accordingly: TCP → recordMark (lastFragment + fragmentLength) then the message at offset 4; UDP → the
+ * message directly at offset 0.
+ *
+ * Byte-perfect strategy (minimal slice): structure the XID and Message Type, and for a CALL the four
+ * fixed program-identity words (rpcVersion / program / programVersion / procedure); the remainder — the
+ * credential, verifier and NFS procedure arguments for a CALL, or the whole REPLY body — is kept verbatim
+ * as `body` hex, bounded by the transport payload (UDP length − 8, or the TCP Record Marking fragment
+ * length). The TCP fragmentLength is honored when supplied (a crafted frame may lie) else derived as the
+ * encoded message length; a well-formed message round-trips byte-for-byte. Trailing / pipelined bytes are
+ * left to the codec's recursion / RawData. Sub-decoding the per-procedure NFS argument/reply structures
+ * (GETATTR fh, LOOKUP dir+name, READ/WRITE, …) is a later enrichment.
+ */
+export declare class NFS extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}