@netkitty/codec 1.0.0

package/dist/headers/IEC104_S_Frame.d.ts

@@ -0,0 +1,26 @@
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { BaseHeader } from '../abstracts/BaseHeader';
+/**
+ * IEC 60870-5-104 S-format APCI — the "Supervisory" frame of IEC 104, which rides on TCP port 2404. Every
+ * IEC 104 APDU begins with a 6-octet APCI: an 8-bit Start byte (`startByte`, offset 0, always 0x68 / 104),
+ * an 8-bit APDU Length (`apduLength`, offset 1, the octet count that follows), and a 4-octet Control Field
+ * (`controlField`, offset 2, kept verbatim as hex — the authoritative bytes). This codec covers the
+ * S-format APDU, which carries no ASDU and exists only to acknowledge received I-frames: it additionally
+ * exposes, read-only, the 15-bit Receive Sequence Number N(R) (`rxSequence`, decoded from control octets
+ * 3-4 as a little-endian value right-shifted by 1) and an `apciType` label derived from the control-format
+ * bits (set to "S-Format").
+ *
+ * `rxSequence` and `apciType` are display projections over the same bytes; `controlField` stays the encode
+ * authority, so a captured frame round-trips byte-for-byte. In the heuristic chain (`heuristicFallback`),
+ * match() requires a TCP peer on port 2404, a Start byte of 104, and the control format bits to select
+ * S-format.
+ */
+export declare class IEC104_S_Frame extends BaseHeader {
+    SCHEMA: ProtocolJSONSchema;
+    id: string;
+    readonly matchKeys: string[];
+    readonly heuristicFallback: boolean;
+    name: string;
+    nickname: string;
+    match(): boolean;
+}

package/dist/headers/IEC104_S_Frame.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IEC104_S_Frame = void 0;
+const BufferToNumber_1 = require("../helper/BufferToNumber");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const NumberToBuffer_1 = require("../helper/NumberToBuffer");
+/**
+ * IEC 60870-5-104 S-format APCI — the "Supervisory" frame of IEC 104, which rides on TCP port 2404. Every
+ * IEC 104 APDU begins with a 6-octet APCI: an 8-bit Start byte (`startByte`, offset 0, always 0x68 / 104),
+ * an 8-bit APDU Length (`apduLength`, offset 1, the octet count that follows), and a 4-octet Control Field
+ * (`controlField`, offset 2, kept verbatim as hex — the authoritative bytes). This codec covers the
+ * S-format APDU, which carries no ASDU and exists only to acknowledge received I-frames: it additionally
+ * exposes, read-only, the 15-bit Receive Sequence Number N(R) (`rxSequence`, decoded from control octets
+ * 3-4 as a little-endian value right-shifted by 1) and an `apciType` label derived from the control-format
+ * bits (set to "S-Format").
+ *
+ * `rxSequence` and `apciType` are display projections over the same bytes; `controlField` stays the encode
+ * authority, so a captured frame round-trips byte-for-byte. In the heuristic chain (`heuristicFallback`),
+ * match() requires a TCP peer on port 2404, a Start byte of 104, and the control format bits to select
+ * S-format.
+ */
+class IEC104_S_Frame extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.SCHEMA = {
+            type: 'object',
+            properties: {
+                startByte: {
+                    type: 'integer',
+                    label: 'Start Byte',
+                    minimum: 0,
+                    maximum: 255,
+                    decode: () => {
+                        this.instance.startByte.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(0, 1)));
+                    },
+                    encode: () => {
+                        this.writeBytes(0, (0, NumberToBuffer_1.UInt8ToBuffer)(this.instance.startByte.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'))));
+                    }
+                },
+                apduLength: {
+                    type: 'integer',
+                    label: 'APDU Length',
+                    minimum: 0,
+                    maximum: 255,
+                    decode: () => {
+                        this.instance.apduLength.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(1, 1)));
+                    },
+                    encode: () => {
+                        this.writeBytes(1, (0, NumberToBuffer_1.UInt8ToBuffer)(this.instance.apduLength.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'))));
+                    }
+                },
+                controlField: {
+                    type: 'string',
+                    label: 'Control Field',
+                    decode: () => {
+                        this.instance.controlField.setValue((0, BufferToHex_1.BufferToHex)(this.readBytes(2, 4)));
+                    },
+                    encode: () => {
+                        this.writeBytes(2, (0, HexToBuffer_1.HexToBuffer)(this.instance.controlField.getValue('0', (nodePath) => this.recordError(nodePath, 'Not Found'))));
+                    }
+                },
+                //Receive sequence number N(R): a 15-bit value in control octets 3-4, stored
+                //little-endian and left-shifted by 1. Exposed read-only for analysis (S-frames exist
+                //precisely to acknowledge this sequence number); controlField holds the authoritative bytes.
+                rxSequence: {
+                    type: 'integer',
+                    label: 'Rx Sequence Number N(R)',
+                    decode: () => {
+                        this.instance.rxSequence.setValue(this.readBytes(4, 2).readUInt16LE() >> 1);
+                    }
+                },
+                apciType: {
+                    type: 'string',
+                    label: 'APCI Type',
+                    minimum: 0,
+                    maximum: 3,
+                    decode: () => {
+                        const controlType = this.readBits(2, 1, 7, 1);
+                        switch (controlType) {
+                            case 1:
+                                {
+                                    this.instance.apciType.setValue('S-Format');
+                                }
+                                break;
+                            default: {
+                                this.recordError(this.instance.apciType.getPath(), 'Illegal acpiType!');
+                                this.instance.apciType.setValue(controlType);
+                            }
+                        }
+                    },
+                    encode: () => {
+                        const controlType = this.instance.apciType.getValue('0', (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        switch (controlType) {
+                            case 'S-Format':
+                                {
+                                    this.writeBits(2, 1, 7, 1, 1);
+                                }
+                                break;
+                            default: {
+                                this.writeBits(2, 1, 7, 1, this.instance.apciType.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found')));
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        this.id = 'IEC104_S_Frame';
+        this.matchKeys = ['tcpport:2404'];
+        this.heuristicFallback = true;
+        this.name = 'IEC 60870-5-104';
+        this.nickname = 'iec60870_104';
+    }
+    match() {
+        if (!this.prevCodecModules)
+            return false;
+        //IEC 104 always rides on TCP port 2404 (see IEC104_I_Frame.match for rationale).
+        if (!this.prevCodecModules.some((module) => module.id === 'tcp' && (module.instance.srcport.getValue() === 2404 || module.instance.dstport.getValue() === 2404)))
+            return false;
+        if ((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(0, 1)) != 104)
+            return false;
+        const type = this.readBits(2, 1, 6, 2);
+        switch (type) {
+            case 1: {
+                return true;
+            }
+            default: {
+                return false;
+            }
+        }
+    }
+    ;
+}
+exports.IEC104_S_Frame = IEC104_S_Frame;

package/dist/headers/IEC104_U_Frame.d.ts

@@ -0,0 +1,27 @@
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { BaseHeader } from '../abstracts/BaseHeader';
+/**
+ * IEC 60870-5-104 U-format APCI — the "Unnumbered" control frame of IEC 104, which rides on TCP port 2404.
+ * Like every IEC 104 APDU it begins with a 6-octet APCI: an 8-bit Start byte (`startByte`, offset 0,
+ * always 0x68 / 104), an 8-bit APDU Length (`apduLength`, offset 1), and a 4-octet Control Field
+ * (`controlField`, offset 2, kept verbatim as hex — the encode authority). U-format frames carry no ASDU
+ * and no sequence numbers; they signal link control. This codec decodes an `apciType` label by matching
+ * the whole 4-octet control field to one of the six defined U functions — Test Frame Activation
+ * (43000000) / Confirmation (83000000), Stop Data Transfer Activation (13000000) / Confirmation
+ * (23000000), and Start Data Transfer Activation (07000000) / Confirmation (0b000000) — and records an
+ * error while keeping the raw hex for any other value.
+ *
+ * On encode a recognized `apciType` label writes back its fixed 4-octet control word, else the verbatim
+ * hex is re-emitted, so a captured frame round-trips byte-for-byte. In the heuristic chain
+ * (`heuristicFallback`), match() requires a TCP peer on port 2404, a Start byte of 104, and the control
+ * format bits to select U-format.
+ */
+export declare class IEC104_U_Frame extends BaseHeader {
+    SCHEMA: ProtocolJSONSchema;
+    id: string;
+    readonly matchKeys: string[];
+    readonly heuristicFallback: boolean;
+    name: string;
+    nickname: string;
+    match(): boolean;
+}

package/dist/headers/IEC104_U_Frame.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IEC104_U_Frame = void 0;
+const BufferToNumber_1 = require("../helper/BufferToNumber");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const NumberToBuffer_1 = require("../helper/NumberToBuffer");
+/**
+ * IEC 60870-5-104 U-format APCI — the "Unnumbered" control frame of IEC 104, which rides on TCP port 2404.
+ * Like every IEC 104 APDU it begins with a 6-octet APCI: an 8-bit Start byte (`startByte`, offset 0,
+ * always 0x68 / 104), an 8-bit APDU Length (`apduLength`, offset 1), and a 4-octet Control Field
+ * (`controlField`, offset 2, kept verbatim as hex — the encode authority). U-format frames carry no ASDU
+ * and no sequence numbers; they signal link control. This codec decodes an `apciType` label by matching
+ * the whole 4-octet control field to one of the six defined U functions — Test Frame Activation
+ * (43000000) / Confirmation (83000000), Stop Data Transfer Activation (13000000) / Confirmation
+ * (23000000), and Start Data Transfer Activation (07000000) / Confirmation (0b000000) — and records an
+ * error while keeping the raw hex for any other value.
+ *
+ * On encode a recognized `apciType` label writes back its fixed 4-octet control word, else the verbatim
+ * hex is re-emitted, so a captured frame round-trips byte-for-byte. In the heuristic chain
+ * (`heuristicFallback`), match() requires a TCP peer on port 2404, a Start byte of 104, and the control
+ * format bits to select U-format.
+ */
+class IEC104_U_Frame extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.SCHEMA = {
+            type: 'object',
+            properties: {
+                startByte: {
+                    type: 'integer',
+                    label: 'Start Byte',
+                    minimum: 0,
+                    maximum: 255,
+                    decode: () => {
+                        this.instance.startByte.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(0, 1)));
+                    },
+                    encode: () => {
+                        this.writeBytes(0, (0, NumberToBuffer_1.UInt8ToBuffer)(this.instance.startByte.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'))));
+                    }
+                },
+                apduLength: {
+                    type: 'integer',
+                    label: 'APDU Length',
+                    minimum: 0,
+                    maximum: 255,
+                    decode: () => {
+                        this.instance.apduLength.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(1, 1)));
+                    },
+                    encode: () => {
+                        this.writeBytes(1, (0, NumberToBuffer_1.UInt8ToBuffer)(this.instance.apduLength.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'))));
+                    }
+                },
+                controlField: {
+                    type: 'string',
+                    label: 'Control Field',
+                    decode: () => {
+                        this.instance.controlField.setValue((0, BufferToHex_1.BufferToHex)(this.readBytes(2, 4)));
+                    },
+                    encode: () => {
+                        this.writeBytes(2, (0, HexToBuffer_1.HexToBuffer)(this.instance.controlField.getValue('0', (nodePath) => this.recordError(nodePath, 'Not Found'))));
+                    }
+                },
+                apciType: {
+                    type: 'string',
+                    label: 'APCI Type',
+                    minimum: 0,
+                    maximum: 3,
+                    decode: () => {
+                        const uframeType = (0, BufferToHex_1.BufferToHex)(this.readBytes(2, 4));
+                        switch (uframeType) {
+                            case '43000000':
+                                {
+                                    this.instance.apciType.setValue('U-Format Type:Test Frame Activation');
+                                }
+                                break;
+                            case '83000000':
+                                {
+                                    this.instance.apciType.setValue('U-Format Type:Test Frame Confirmation');
+                                }
+                                break;
+                            case '13000000':
+                                {
+                                    this.instance.apciType.setValue('U-Format Type:Stop Data Transfer Activation');
+                                }
+                                break;
+                            case '23000000':
+                                {
+                                    this.instance.apciType.setValue('U-Format Type:Stop Data Transfer Confirmation');
+                                }
+                                break;
+                            case '07000000':
+                                {
+                                    this.instance.apciType.setValue('U-Format Type:Start Data Transfer Activation');
+                                }
+                                break;
+                            case '0b000000':
+                                {
+                                    this.instance.apciType.setValue('U-Format Type:Start Data Transfer Confirmation');
+                                }
+                                break;
+                            default: {
+                                this.recordError(this.instance.apciType.getPath(), 'Illegal acpiType!');
+                                this.instance.apciType.setValue(uframeType);
+                            }
+                        }
+                    },
+                    encode: () => {
+                        const controlType = this.instance.apciType.getValue('0', (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        switch (controlType) {
+                            case 'U-Format Type:Test Frame Activation':
+                                {
+                                    this.writeBytes(2, (0, NumberToBuffer_1.UInt32ToBuffer)(1124073472));
+                                }
+                                break;
+                            case 'U-Format Type:Test Frame Confirmation':
+                                {
+                                    this.writeBytes(2, (0, NumberToBuffer_1.UInt32ToBuffer)(2197815296));
+                                }
+                                break;
+                            case 'U-Format Type:Stop Data Transfer Activation':
+                                {
+                                    this.writeBytes(2, (0, NumberToBuffer_1.UInt32ToBuffer)(318767104));
+                                }
+                                break;
+                            case 'U-Format Type:Stop Data Transfer Confirmation':
+                                {
+                                    this.writeBytes(2, (0, NumberToBuffer_1.UInt32ToBuffer)(587202560));
+                                }
+                                break;
+                            case 'U-Format Type:Start Data Transfer Activation':
+                                {
+                                    this.writeBytes(2, (0, NumberToBuffer_1.UInt32ToBuffer)(117440512));
+                                }
+                                break;
+                            case 'U-Format Type:Start Data Transfer Confirmation':
+                                {
+                                    this.writeBytes(2, (0, NumberToBuffer_1.UInt32ToBuffer)(184549376));
+                                }
+                                break;
+                            default: {
+                                this.writeBytes(2, (0, HexToBuffer_1.HexToBuffer)(this.instance.apciType.getValue('0', (nodePath) => this.recordError(nodePath, 'Not Found'))));
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        this.id = 'IEC104_U_Frame';
+        this.matchKeys = ['tcpport:2404'];
+        this.heuristicFallback = true;
+        this.name = 'IEC 60870-5-104';
+        this.nickname = 'iec60870_104';
+    }
+    match() {
+        if (!this.prevCodecModules)
+            return false;
+        //IEC 104 always rides on TCP port 2404 (see IEC104_I_Frame.match for rationale).
+        if (!this.prevCodecModules.some((module) => module.id === 'tcp' && (module.instance.srcport.getValue() === 2404 || module.instance.dstport.getValue() === 2404)))
+            return false;
+        if ((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(0, 1)) != 104)
+            return false;
+        const type = this.readBits(2, 1, 6, 2);
+        switch (type) {
+            case 3: {
+                return true;
+            }
+            default: {
+                return false;
+            }
+        }
+    }
+    ;
+}
+exports.IEC104_U_Frame = IEC104_U_Frame;

package/dist/headers/IEC61850SampledValues.d.ts

@@ -0,0 +1,20 @@
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { BaseHeader } from '../abstracts/BaseHeader';
+import TLV from 'node-tlv';
+export declare class IEC61850SampledValues extends BaseHeader {
+    protected TLVInstance: TLV;
+    protected TLVChild: TLV[];
+    /**
+     * True when decode preserved an unparsed raw svPdu region and the caller has not
+     * supplied any structured PDU content. In that state encode re-emits the raw bytes
+     * verbatim (faithful passthrough of a malformed capture); the moment a structured
+     * field is set, this turns false and encode rebuilds the PDU from fields instead.
+     */
+    protected svPduRawFallbackActive(): boolean;
+    SCHEMA: ProtocolJSONSchema;
+    readonly id: string;
+    readonly matchKeys: string[];
+    readonly name: string;
+    readonly nickname: string;
+    match(): boolean;
+}