@bitpoolos/edge-bacnet 1.6.9 → 1.6.10

package/resources/node-bacstack-ts/dist/lib/services/write-property-multiple.js

@@ -0,0 +1,105 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeObject = exports.decode = exports.encode = void 0;
+const baAsn1 = require("../asn1");
+const baEnum = require("../enum");
+const encode = (buffer, objectId, values) => {
+    baAsn1.encodeContextObjectId(buffer, 0, objectId.type, objectId.instance);
+    baAsn1.encodeOpeningTag(buffer, 1);
+    values.forEach((pValue) => {
+        baAsn1.encodeContextEnumerated(buffer, 0, pValue.property.id);
+        if (pValue.property.index !== baEnum.ASN1_ARRAY_ALL) {
+            baAsn1.encodeContextUnsigned(buffer, 1, pValue.property.index);
+        }
+        baAsn1.encodeOpeningTag(buffer, 2);
+        pValue.value.forEach((value) => baAsn1.bacappEncodeApplicationData(buffer, value));
+        baAsn1.encodeClosingTag(buffer, 2);
+        if (pValue.priority !== baEnum.ASN1_NO_PRIORITY) {
+            baAsn1.encodeContextUnsigned(buffer, 3, pValue.priority);
+        }
+    });
+    baAsn1.encodeClosingTag(buffer, 1);
+};
+exports.encode = encode;
+const decode = (buffer, offset, apduLen) => {
+    let len = 0;
+    let result;
+    let decodedValue;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    if ((result.tagNumber !== 0) || (apduLen <= len))
+        return;
+    apduLen -= len;
+    if (apduLen < 4)
+        return;
+    decodedValue = baAsn1.decodeObjectId(buffer, offset + len);
+    len += decodedValue.len;
+    const objectId = {
+        type: decodedValue.objectType,
+        instance: decodedValue.instance
+    };
+    if (!baAsn1.decodeIsOpeningTagNumber(buffer, offset + len, 1))
+        return;
+    len++;
+    const _values = [];
+    while ((apduLen - len) > 1) {
+        const newEntry = {};
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        if (result.tagNumber !== 0)
+            return;
+        decodedValue = baAsn1.decodeEnumerated(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        const propertyId = decodedValue.value;
+        let arrayIndex = baEnum.ASN1_ARRAY_ALL;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        if (result.tagNumber === 1) {
+            decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+            len += decodedValue.len;
+            arrayIndex = decodedValue.value;
+            result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+            len += result.len;
+        }
+        newEntry.property = { id: propertyId, index: arrayIndex };
+        if ((result.tagNumber !== 2) || (!baAsn1.decodeIsOpeningTag(buffer, offset + len - 1)))
+            return;
+        const values = [];
+        while ((len + offset) <= buffer.length && !baAsn1.decodeIsClosingTag(buffer, offset + len)) {
+            const value = baAsn1.bacappDecodeApplicationData(buffer, offset + len, apduLen + offset, objectId.type, propertyId);
+            if (!value)
+                return;
+            len += value.len;
+            delete value.len;
+            values.push(value);
+        }
+        len++;
+        newEntry.value = values;
+        let priority = baEnum.ASN1_NO_PRIORITY;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        if (result.tagNumber === 3) {
+            decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+            len += decodedValue.len;
+            priority = decodedValue.value;
+        }
+        else {
+            len--;
+        }
+        newEntry.priority = priority;
+        _values.push(newEntry);
+    }
+    if (!baAsn1.decodeIsClosingTagNumber(buffer, offset + len, 1))
+        return;
+    len++;
+    return {
+        len: len,
+        objectId: objectId,
+        values: _values
+    };
+};
+exports.decode = decode;
+const encodeObject = (buffer, values) => {
+    values.forEach((object) => (0, exports.encode)(buffer, object.objectId, object.values));
+};
+exports.encodeObject = encodeObject;

package/resources/node-bacstack-ts/dist/lib/services/write-property.js

@@ -0,0 +1,90 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.encode = void 0;
+const baAsn1 = require("../asn1");
+const baEnum = require("../enum");
+const encode = (buffer, objectType, objectInstance, propertyId, arrayIndex, priority, values) => {
+    baAsn1.encodeContextObjectId(buffer, 0, objectType, objectInstance);
+    baAsn1.encodeContextEnumerated(buffer, 1, propertyId);
+    if (arrayIndex !== baEnum.ASN1_ARRAY_ALL) {
+        baAsn1.encodeContextUnsigned(buffer, 2, arrayIndex);
+    }
+    baAsn1.encodeOpeningTag(buffer, 3);
+    values.forEach((value) => baAsn1.bacappEncodeApplicationData(buffer, value));
+    baAsn1.encodeClosingTag(buffer, 3);
+    if (priority !== baEnum.ASN1_NO_PRIORITY) {
+        baAsn1.encodeContextUnsigned(buffer, 4, priority);
+    }
+};
+exports.encode = encode;
+const decode = (buffer, offset, apduLen) => {
+    let len = 0;
+    const value = {
+        property: {}
+    };
+    let decodedValue;
+    let result;
+    if (!baAsn1.decodeIsContextTag(buffer, offset + len, 0))
+        return;
+    len++;
+    decodedValue = baAsn1.decodeObjectId(buffer, offset + len);
+    const objectId = {
+        type: decodedValue.objectType,
+        instance: decodedValue.instance
+    };
+    len += decodedValue.len;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    if (result.tagNumber !== 1)
+        return;
+    decodedValue = baAsn1.decodeEnumerated(buffer, offset + len, result.value);
+    len += decodedValue.len;
+    value.property.id = decodedValue.value;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    if (result.tagNumber === 2) {
+        len += result.len;
+        decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        value.property.index = decodedValue.value;
+    }
+    else {
+        value.property.index = baEnum.ASN1_ARRAY_ALL;
+    }
+    if (!baAsn1.decodeIsOpeningTagNumber(buffer, offset + len, 3))
+        return;
+    len++;
+    const values = [];
+    while ((apduLen - len) > 1 && !baAsn1.decodeIsClosingTagNumber(buffer, offset + len, 3)) {
+        decodedValue = baAsn1.bacappDecodeApplicationData(buffer, offset + len, apduLen + offset, objectId.type, value.property.id);
+        if (!decodedValue)
+            return;
+        len += decodedValue.len;
+        delete decodedValue.len;
+        values.push(decodedValue);
+    }
+    value.value = values;
+    if (!baAsn1.decodeIsClosingTagNumber(buffer, offset + len, 3))
+        return;
+    len++;
+    value.priority = baEnum.ASN1_MAX_PRIORITY;
+    if (len < apduLen) {
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        if (result.tagNumber === 4) {
+            len += result.len;
+            decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+            len += decodedValue;
+            if ((decodedValue.value >= baEnum.ASN1_MIN_PRIORITY) && (decodedValue.value <= baEnum.ASN1_MAX_PRIORITY)) {
+                value.priority = decodedValue.value;
+            }
+            else {
+                return;
+            }
+        }
+    }
+    return {
+        len: len,
+        objectId: objectId,
+        value: value
+    };
+};
+exports.decode = decode;

package/resources/node-bacstack-ts/dist/lib/transport.js

@@ -0,0 +1,86 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transport = void 0;
+const dgram_1 = require("dgram");
+const events_1 = require("events");
+const DEFAULT_BACNET_PORT = 47808;
+class Transport extends events_1.EventEmitter {
+    constructor(settings) {
+        super();
+        try {
+            this._lastSendMessages = {};
+            this._settings = settings;
+            this._portRange = settings.portRangeMatrix;
+            this.serverList = {};
+            for (let i = 0; i < this._portRange.length; i++) {
+                let port = this._portRange[i];
+                this.serverList[port] = (0, dgram_1.createSocket)({ type: 'udp4', reuseAddr: true });
+                this.serverList[port].on('message', (msg, rinfo) => this.emit('message', msg, rinfo.address, rinfo.port));
+                this.serverList[port].on('error', (err) => this.emit('message', err));
+            };
+        } catch (e) {
+            console.log("Transport constructor error: ", e);
+        }
+    }
+    getBroadcastAddress() {
+        return this._settings.broadcastAddress;
+    }
+    getMaxPayload() {
+        return 1482;
+    }
+    send(buffer, offset, receiver, port) {
+        try {
+            if (!receiver) {
+                receiver = this.getBroadcastAddress();
+                const dataToSend = Buffer.alloc(offset);
+                // Sort out broadcasted messages that we also receive
+                // TODO Find a better way?
+                const hrTime = process.hrtime();
+                const messageKey = hrTime[0] * 1000000000 + hrTime[1];
+                buffer.copy(dataToSend, 0, 0, offset);
+                this._lastSendMessages[messageKey] = dataToSend;
+                setTimeout(() => {
+                    delete this._lastSendMessages[messageKey];
+                }, 10000); // delete after 10s, hopefully all cases are handled by that
+            }
+
+            const [address] = receiver.split(':');
+
+            if (port == null || port == undefined || port == '' || port == 'null' || port == 'undefined') port = DEFAULT_BACNET_PORT;
+
+            let serverExists = Object.keys(this.serverList).findIndex((existingPort) => port.toString() == existingPort);
+
+            if (serverExists !== -1) {
+                let server = this.serverList[port];
+                server.send(buffer, 0, offset, port, address);
+            }
+        } catch (e) {
+            console.log("Transport send error: ", e);
+        }
+    }
+    open() {
+        try {
+            for (let port in this.serverList) {
+                let server = this.serverList[port];
+                if (server) {
+                    server.bind(port, this._settings.interface, () => {
+                        server.setBroadcast(true);
+                    });
+                }
+            }
+        } catch (e) {
+            console.log("Transport open error: ", e);
+        }
+    }
+    close() {
+        try {
+            for (let port in this.serverList) {
+                let server = this.serverList[port];
+                if (server) server.close();
+            }
+        } catch (e) {
+            console.log("Transport close error: ", e);
+        }
+    }
+}
+exports.Transport = Transport;

package/resources/node-bacstack-ts/dist/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });