hap-nodejs 0.12.3-beta.2 → 0.12.3-beta.21

package/dist/lib/datastream/DataStreamServer.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataStreamConnection = exports.HDSConnectionError = exports.HDSConnectionErrorType = exports.DataStreamConnectionEvent = exports.DataStreamServer = exports.DataStreamServerEvent = exports.MessageType = exports.HDSProtocolError = exports.HDSProtocolSpecificErrorReason = exports.HDSStatus = exports.Topics = exports.Protocols = void 0;
-var tslib_1 = require("tslib");
-var assert_1 = tslib_1.__importDefault(require("assert"));
-var crypto_1 = tslib_1.__importDefault(require("crypto"));
-var debug_1 = tslib_1.__importDefault(require("debug"));
-var events_1 = require("events");
-var net_1 = tslib_1.__importDefault(require("net"));
-var hapCrypto = tslib_1.__importStar(require("../util/hapCrypto"));
-var DataStreamParser_1 = require("./DataStreamParser");
-var debug = (0, debug_1.default)("HAP-NodeJS:DataStream:Server");
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const crypto_1 = tslib_1.__importDefault(require("crypto"));
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const events_1 = require("events");
+const net_1 = tslib_1.__importDefault(require("net"));
+const hapCrypto = tslib_1.__importStar(require("../util/hapCrypto"));
+const DataStreamParser_1 = require("./DataStreamParser");
+const debug = (0, debug_1.default)("HAP-NodeJS:DataStream:Server");
 /**
  * @group HomeKit Data Streams (HDS)
  */
@@ -70,21 +70,19 @@ var HDSProtocolSpecificErrorReason;
  * E.g. it may be used to encode a {@link HDSStatus.PROTOCOL_SPECIFIC_ERROR} in the {@link Protocols.DATA_SEND} protocol.
  * @group HomeKit Data Streams (HDS)
  */
-var HDSProtocolError = /** @class */ (function (_super) {
-    tslib_1.__extends(HDSProtocolError, _super);
+class HDSProtocolError extends Error {
+    reason;
     /**
      * Initializes a new `HDSProtocolError`
      * @param reason - The {@link HDSProtocolSpecificErrorReason}.
      *  Values MUST NOT be {@link HDSProtocolSpecificErrorReason.NORMAL}.
      */
-    function HDSProtocolError(reason) {
-        var _this = _super.call(this, "HDSProtocolError: " + reason) || this;
+    constructor(reason) {
+        super("HDSProtocolError: " + reason);
         (0, assert_1.default)(reason !== 0 /* HDSProtocolSpecificErrorReason.NORMAL */, "Cannot initialize a HDSProtocolError with NORMAL!");
-        _this.reason = reason;
-        return _this;
+        this.reason = reason;
     }
-    return HDSProtocolError;
-}(Error));
+}
 exports.HDSProtocolError = HDSProtocolError;
 var ServerState;
 (function (ServerState) {
@@ -130,16 +128,19 @@ var DataStreamServerEvent;
  * @group HomeKit Data Streams (HDS)
  */
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-var DataStreamServer = /** @class */ (function (_super) {
-    tslib_1.__extends(DataStreamServer, _super);
-    function DataStreamServer() {
-        var _this = _super.call(this) || this;
-        _this.state = 0 /* ServerState.UNINITIALIZED */;
-        _this.preparedSessions = [];
-        _this.connections = [];
-        _this.removeListenersOnceClosed = false;
-        _this.internalEventEmitter = new events_1.EventEmitter(); // used for message event and message request handlers
-        return _this;
+class DataStreamServer extends events_1.EventEmitter {
+    static version = "1.0";
+    state = 0 /* ServerState.UNINITIALIZED */;
+    static accessoryToControllerInfo = Buffer.from("HDS-Read-Encryption-Key");
+    static controllerToAccessoryInfo = Buffer.from("HDS-Write-Encryption-Key");
+    tcpServer;
+    tcpPort;
+    preparedSessions = [];
+    connections = [];
+    removeListenersOnceClosed = false;
+    internalEventEmitter = new events_1.EventEmitter(); // used for message event and message request handlers
+    constructor() {
+        super();
     }
     /**
      * Registers a new event handler to handle incoming event messages.
@@ -150,10 +151,10 @@ var DataStreamServer = /** @class */ (function (_super) {
      * @param event - name of the event (also referred to as topic. See {@link Topics} for some known ones)
      * @param handler - function to be called for every occurring event
      */
-    DataStreamServer.prototype.onEventMessage = function (protocol, event, handler) {
+    onEventMessage(protocol, event, handler) {
         this.internalEventEmitter.on(protocol + "-e-" + event, handler);
         return this;
-    };
+    }
     /**
      * Removes a registered event handler.
      *
@@ -161,10 +162,10 @@ var DataStreamServer = /** @class */ (function (_super) {
      * @param event - name of the event (also referred to as topic. See {@link Topics} for some known ones)
      * @param handler - registered event handler
      */
-    DataStreamServer.prototype.removeEventHandler = function (protocol, event, handler) {
+    removeEventHandler(protocol, event, handler) {
         this.internalEventEmitter.removeListener(protocol + "-e-" + event, handler);
         return this;
-    };
+    }
     /**
      * Registers a new request handler to handle incoming request messages.
      * The handler is only called for a connection if for the give protocol no ProtocolHandler
@@ -174,10 +175,10 @@ var DataStreamServer = /** @class */ (function (_super) {
      * @param request - name of the request (also referred to as topic. See {@link Topics} for some known ones)
      * @param handler - function to be called for every occurring request
      */
-    DataStreamServer.prototype.onRequestMessage = function (protocol, request, handler) {
+    onRequestMessage(protocol, request, handler) {
         this.internalEventEmitter.on(protocol + "-r-" + request, handler);
         return this;
-    };
+    }
     /**
      * Removes a registered request handler.
      *
@@ -185,27 +186,26 @@ var DataStreamServer = /** @class */ (function (_super) {
      * @param request - name of the request (also referred to as topic. See {@link Topics} for some known ones)
      * @param handler - registered request handler
      */
-    DataStreamServer.prototype.removeRequestHandler = function (protocol, request, handler) {
+    removeRequestHandler(protocol, request, handler) {
         this.internalEventEmitter.removeListener(protocol + "-r-" + request, handler);
         return this;
-    };
-    DataStreamServer.prototype.prepareSession = function (connection, controllerKeySalt, callback) {
-        var _this = this;
+    }
+    prepareSession(connection, controllerKeySalt, callback) {
         debug("Preparing for incoming HDS connection from %s", connection.sessionID);
-        var accessoryKeySalt = crypto_1.default.randomBytes(32);
-        var salt = Buffer.concat([controllerKeySalt, accessoryKeySalt]);
-        var accessoryToControllerEncryptionKey = hapCrypto.HKDF("sha512", salt, connection.encryption.sharedSecret, DataStreamServer.accessoryToControllerInfo, 32);
-        var controllerToAccessoryEncryptionKey = hapCrypto.HKDF("sha512", salt, connection.encryption.sharedSecret, DataStreamServer.controllerToAccessoryInfo, 32);
-        var preparedSession = {
+        const accessoryKeySalt = crypto_1.default.randomBytes(32);
+        const salt = Buffer.concat([controllerKeySalt, accessoryKeySalt]);
+        const accessoryToControllerEncryptionKey = hapCrypto.HKDF("sha512", salt, connection.encryption.sharedSecret, DataStreamServer.accessoryToControllerInfo, 32);
+        const controllerToAccessoryEncryptionKey = hapCrypto.HKDF("sha512", salt, connection.encryption.sharedSecret, DataStreamServer.controllerToAccessoryInfo, 32);
+        const preparedSession = {
             connection: connection,
             accessoryToControllerEncryptionKey: accessoryToControllerEncryptionKey,
             controllerToAccessoryEncryptionKey: controllerToAccessoryEncryptionKey,
             accessoryKeySalt: accessoryKeySalt,
-            connectTimeout: setTimeout(function () { return _this.timeoutPreparedSession(preparedSession); }, 10000),
+            connectTimeout: setTimeout(() => this.timeoutPreparedSession(preparedSession), 10000),
         };
         preparedSession.connectTimeout.unref();
         this.preparedSessions.push(preparedSession);
-        this.checkTCPServerEstablished(preparedSession, function (error) {
+        this.checkTCPServerEstablished(preparedSession, (error) => {
             if (error) {
                 callback(error);
             }
@@ -213,17 +213,16 @@ var DataStreamServer = /** @class */ (function (_super) {
                 callback(undefined, preparedSession);
             }
         });
-    };
-    DataStreamServer.prototype.timeoutPreparedSession = function (preparedSession) {
+    }
+    timeoutPreparedSession(preparedSession) {
         debug("Prepared HDS session timed out out since no connection was opened for 10 seconds (%s)", preparedSession.connection.sessionID);
-        var index = this.preparedSessions.indexOf(preparedSession);
+        const index = this.preparedSessions.indexOf(preparedSession);
         if (index >= 0) {
             this.preparedSessions.splice(index, 1);
         }
         this.checkCloseable();
-    };
-    DataStreamServer.prototype.checkTCPServerEstablished = function (preparedSession, callback) {
-        var _this = this;
+    }
+    checkTCPServerEstablished(preparedSession, callback) {
         switch (this.state) {
             case 0 /* ServerState.UNINITIALIZED */:
                 debug("Starting up TCP server.");
@@ -245,34 +244,34 @@ var DataStreamServer = /** @class */ (function (_super) {
                 break;
             case 3 /* ServerState.CLOSING */:
                 debug("TCP socket is currently closing. Trying again when server is fully closed and opening a new one then.");
-                this.tcpServer.once("close", function () { return setTimeout(function () { return _this.checkTCPServerEstablished(preparedSession, callback); }, 10); });
+                this.tcpServer.once("close", () => setTimeout(() => this.checkTCPServerEstablished(preparedSession, callback), 10));
                 break;
         }
-    };
-    DataStreamServer.prototype.listening = function (preparedSession, callback) {
+    }
+    listening(preparedSession, callback) {
         this.state = 2 /* ServerState.LISTENING */;
-        var address = this.tcpServer.address();
+        const address = this.tcpServer.address();
         if (address && typeof address !== "string") { // address is only typeof string when listening to a pipe or unix socket
             this.tcpPort = address.port;
             preparedSession.port = address.port;
             debug("TCP server is now listening for new data stream connections on port %s", address.port);
             callback();
         }
-    };
-    DataStreamServer.prototype.onConnection = function (socket) {
+    }
+    onConnection(socket) {
         debug("[%s] New DataStream connection was established", socket.remoteAddress);
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        var connection = new DataStreamConnection(socket);
+        const connection = new DataStreamConnection(socket);
         connection.on("identification" /* DataStreamConnectionEvent.IDENTIFICATION */, this.handleSessionIdentification.bind(this, connection));
         connection.on("handle-message-globally" /* DataStreamConnectionEvent.HANDLE_MESSAGE_GLOBALLY */, this.handleMessageGlobally.bind(this, connection));
         connection.on("closed" /* DataStreamConnectionEvent.CLOSED */, this.connectionClosed.bind(this, connection));
         this.connections.push(connection);
         this.emit("connection-opened" /* DataStreamServerEvent.CONNECTION_OPENED */, connection);
-    };
-    DataStreamServer.prototype.handleSessionIdentification = function (connection, firstFrame, callback) {
-        var identifiedSession = undefined;
-        for (var i = 0; i < this.preparedSessions.length; i++) {
-            var preparedSession = this.preparedSessions[i];
+    }
+    handleSessionIdentification(connection, firstFrame, callback) {
+        let identifiedSession = undefined;
+        for (let i = 0; i < this.preparedSessions.length; i++) {
+            const preparedSession = this.preparedSessions[i];
             // if we successfully decrypt the first frame with this key we know to which session this connection belongs
             if (connection.decryptHDSFrame(firstFrame, preparedSession.controllerToAccessoryEncryptionKey)) {
                 identifiedSession = preparedSession;
@@ -282,7 +281,7 @@ var DataStreamServer = /** @class */ (function (_super) {
         callback(identifiedSession);
         if (identifiedSession) {
             debug("[%s] Connection was successfully identified (linked with sessionId: %s)", connection.remoteAddress, identifiedSession.connection.sessionID);
-            var index = this.preparedSessions.indexOf(identifiedSession);
+            const index = this.preparedSessions.indexOf(identifiedSession);
             if (index >= 0) {
                 this.preparedSessions.splice(index, 1);
             }
@@ -296,12 +295,11 @@ var DataStreamServer = /** @class */ (function (_super) {
             debug("[%s] Could not identify connection. Terminating.", connection.remoteAddress);
             connection.close(); // disconnecting since first message was not a valid hello
         }
-    };
-    DataStreamServer.prototype.handleMessageGlobally = function (connection, message) {
-        var _a;
+    }
+    handleMessageGlobally(connection, message) {
         assert_1.default.notStrictEqual(message.type, 3 /* MessageType.RESPONSE */); // responses can't physically get here
-        var separator = "";
-        var args = [];
+        let separator = "";
+        const args = [];
         if (message.type === 1 /* MessageType.EVENT */) {
             separator = "-e-";
         }
@@ -310,9 +308,9 @@ var DataStreamServer = /** @class */ (function (_super) {
             args.push(message.id);
         }
         args.push(message.message);
-        var hadListeners;
+        let hadListeners;
         try {
-            hadListeners = (_a = this.internalEventEmitter).emit.apply(_a, tslib_1.__spreadArray([message.protocol + separator + message.topic, connection], tslib_1.__read(args), false));
+            hadListeners = this.internalEventEmitter.emit(message.protocol + separator + message.topic, connection, ...args);
         }
         catch (error) {
             hadListeners = true;
@@ -322,8 +320,8 @@ var DataStreamServer = /** @class */ (function (_super) {
         if (!hadListeners) {
             debug("[%s] WARNING no handler was found for message: %o", connection.remoteAddress, message);
         }
-    };
-    DataStreamServer.prototype.connectionClosed = function (connection) {
+    }
+    connectionClosed(connection) {
         debug("[%s] DataStream connection closed", connection.remoteAddress);
         this.connections.splice(this.connections.indexOf(connection), 1);
         this.emit("connection-closed" /* DataStreamServerEvent.CONNECTION_CLOSED */, connection);
@@ -331,49 +329,34 @@ var DataStreamServer = /** @class */ (function (_super) {
         if (this.state === 3 /* ServerState.CLOSING */ && this.removeListenersOnceClosed && this.connections.length === 0) {
             this.removeAllListeners(); // see this.destroy()
         }
-    };
-    DataStreamServer.prototype.checkCloseable = function () {
+    }
+    checkCloseable() {
         if (this.connections.length === 0 && this.preparedSessions.length === 0 && this.state < 3 /* ServerState.CLOSING */) {
             debug("Last connection disconnected. Closing the server now.");
             this.state = 3 /* ServerState.CLOSING */;
             this.tcpServer.close();
         }
-    };
+    }
     /**
      * This method will fully stop the DataStreamServer
      */
-    DataStreamServer.prototype.destroy = function () {
-        var e_1, _a;
+    destroy() {
         if (this.state > 0 /* ServerState.UNINITIALIZED */ && this.state < 3 /* ServerState.CLOSING */) {
             this.tcpServer.close();
-            try {
-                for (var _b = tslib_1.__values(this.connections), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var connection = _c.value;
-                    connection.close();
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_1) throw e_1.error; }
+            for (const connection of this.connections) {
+                connection.close();
             }
         }
         this.state = 3 /* ServerState.CLOSING */;
         this.removeListenersOnceClosed = true;
         this.internalEventEmitter.removeAllListeners();
-    };
-    DataStreamServer.prototype.closed = function () {
+    }
+    closed() {
         this.tcpServer = undefined;
         this.tcpPort = undefined;
         this.state = 0 /* ServerState.UNINITIALIZED */;
-    };
-    DataStreamServer.version = "1.0";
-    DataStreamServer.accessoryToControllerInfo = Buffer.from("HDS-Read-Encryption-Key");
-    DataStreamServer.controllerToAccessoryInfo = Buffer.from("HDS-Write-Encryption-Key");
-    return DataStreamServer;
-}(events_1.EventEmitter));
+    }
+}
 exports.DataStreamServer = DataStreamServer;
 /**
  * @group HomeKit Data Streams (HDS)
@@ -408,15 +391,13 @@ var HDSConnectionErrorType;
 /**
  * @group HomeKit Data Streams (HDS)
  */
-var HDSConnectionError = /** @class */ (function (_super) {
-    tslib_1.__extends(HDSConnectionError, _super);
-    function HDSConnectionError(message, type) {
-        var _this = _super.call(this, message) || this;
-        _this.type = type;
-        return _this;
-    }
-    return HDSConnectionError;
-}(Error));
+class HDSConnectionError extends Error {
+    type;
+    constructor(message, type) {
+        super(message);
+        this.type = type;
+    }
+}
 exports.HDSConnectionError = HDSConnectionError;
 /**
  * DataStream connection which holds any necessary state information, encryption and decryption keys, manages
@@ -425,59 +406,69 @@ exports.HDSConnectionError = HDSConnectionError;
  * @group HomeKit Data Streams (HDS)
  */
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-var DataStreamConnection = /** @class */ (function (_super) {
-    tslib_1.__extends(DataStreamConnection, _super);
-    function DataStreamConnection(socket) {
-        var _a;
-        var _this = _super.call(this) || this;
-        /*
-              Since our DataStream server does only listen on one port and this port is supplied to every client
-              which wants to connect, we do not really know which client is who when we receive a tcp connection.
-              Thus, we find the correct PreparedDataStreamSession object by testing the encryption keys of all available
-              prepared sessions. Then we can reference this hds connection with the correct hap connection and mark it as identified.
-           */
-        _this.state = 0 /* ConnectionState.UNIDENTIFIED */;
-        _this.protocolHandlers = {}; // used to store protocolHandlers identified by their protocol name
-        _this.responseHandlers = {}; // used to store responseHandlers indexed by their respective requestId
-        _this.responseTimers = {}; // used to store response timeouts indexed by their respective requestId
-        _this.socket = socket;
-        _this.remoteAddress = socket.remoteAddress;
-        _this.socket.setNoDelay(true); // disable Nagle algorithm
-        _this.socket.setKeepAlive(true);
-        _this.accessoryToControllerNonce = 0;
-        _this.accessoryToControllerNonceBuffer = Buffer.alloc(8);
-        _this.controllerToAccessoryNonce = 0;
-        _this.controllerToAccessoryNonceBuffer = Buffer.alloc(8);
-        _this.hapConnectionClosedListener = _this.onHAPSessionClosed.bind(_this);
-        _this.addProtocolHandler("control" /* Protocols.CONTROL */, {
-            requestHandler: (_a = {},
-                _a["hello" /* Topics.HELLO */] = _this.handleHello.bind(_this),
-                _a),
+class DataStreamConnection extends events_1.EventEmitter {
+    static MAX_PAYLOAD_LENGTH = 0b11111111111111111111;
+    socket;
+    connection; // reference to the hap connection. is present when state > UNIDENTIFIED
+    remoteAddress;
+    /*
+          Since our DataStream server does only listen on one port and this port is supplied to every client
+          which wants to connect, we do not really know which client is who when we receive a tcp connection.
+          Thus, we find the correct PreparedDataStreamSession object by testing the encryption keys of all available
+          prepared sessions. Then we can reference this hds connection with the correct hap connection and mark it as identified.
+       */
+    state = 0 /* ConnectionState.UNIDENTIFIED */;
+    accessoryToControllerEncryptionKey;
+    controllerToAccessoryEncryptionKey;
+    accessoryToControllerNonce;
+    accessoryToControllerNonceBuffer;
+    controllerToAccessoryNonce;
+    controllerToAccessoryNonceBuffer;
+    frameBuffer; // used to store incomplete HDS frames
+    hapConnectionClosedListener;
+    protocolHandlers = {}; // used to store protocolHandlers identified by their protocol name
+    responseHandlers = {}; // used to store responseHandlers indexed by their respective requestId
+    responseTimers = {}; // used to store response timeouts indexed by their respective requestId
+    helloTimer;
+    constructor(socket) {
+        super();
+        this.socket = socket;
+        this.remoteAddress = socket.remoteAddress;
+        this.socket.setNoDelay(true); // disable Nagle algorithm
+        this.socket.setKeepAlive(true);
+        this.accessoryToControllerNonce = 0;
+        this.accessoryToControllerNonceBuffer = Buffer.alloc(8);
+        this.controllerToAccessoryNonce = 0;
+        this.controllerToAccessoryNonceBuffer = Buffer.alloc(8);
+        this.hapConnectionClosedListener = this.onHAPSessionClosed.bind(this);
+        this.addProtocolHandler("control" /* Protocols.CONTROL */, {
+            requestHandler: {
+                ["hello" /* Topics.HELLO */]: this.handleHello.bind(this),
+            },
         });
-        _this.helloTimer = setTimeout(function () {
-            debug("[%s] Hello message did not arrive in time. Killing the connection", _this.remoteAddress);
-            _this.close();
+        this.helloTimer = setTimeout(() => {
+            debug("[%s] Hello message did not arrive in time. Killing the connection", this.remoteAddress);
+            this.close();
         }, 10000);
-        _this.socket.on("data", _this.onSocketData.bind(_this));
-        _this.socket.on("error", _this.onSocketError.bind(_this));
-        _this.socket.on("close", _this.onSocketClose.bind(_this));
+        this.socket.on("data", this.onSocketData.bind(this));
+        this.socket.on("error", this.onSocketError.bind(this));
+        this.socket.on("close", this.onSocketClose.bind(this));
         // this is to mitigate the event emitter "memory leak warning".
         // e.g. with HSV there might be multiple cameras subscribing to the CLOSE event. one subscription for
         // every active recording stream on a camera. The default limit of 10 might be easily reached.
         // Setting a high limit isn't the prefect solution, but will avoid false positives but ensures that
         // a warning is still be printed if running long enough.
-        _this.setMaxListeners(100);
-        return _this;
+        this.setMaxListeners(100);
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    DataStreamConnection.prototype.handleHello = function (id, message) {
+    handleHello(id, message) {
         // that hello is indeed the _first_ message received is verified in onSocketData(...)
         debug("[%s] Received hello message from client: %o", this.remoteAddress, message);
         clearTimeout(this.helloTimer);
         this.helloTimer = undefined;
         this.state = 2 /* ConnectionState.READY */;
         this.sendResponse("control" /* Protocols.CONTROL */, "hello" /* Topics.HELLO */, id);
-    };
+    }
     /**
      * Registers a new protocol handler to handle incoming messages.
      * The same protocol cannot be registered multiple times.
@@ -485,25 +476,25 @@ var DataStreamConnection = /** @class */ (function (_super) {
      * @param protocol - name of the protocol to register the handler for
      * @param protocolHandler - object to be registered as protocol handler
      */
-    DataStreamConnection.prototype.addProtocolHandler = function (protocol, protocolHandler) {
+    addProtocolHandler(protocol, protocolHandler) {
         if (this.protocolHandlers[protocol] !== undefined) {
             return false;
         }
         this.protocolHandlers[protocol] = protocolHandler;
         return true;
-    };
+    }
     /**
      * Removes a protocol handler if it is registered.
      *
      * @param protocol - name of the protocol to unregister the handler for
      * @param protocolHandler - object which will be unregistered
      */
-    DataStreamConnection.prototype.removeProtocolHandler = function (protocol, protocolHandler) {
-        var current = this.protocolHandlers[protocol];
+    removeProtocolHandler(protocol, protocolHandler) {
+        const current = this.protocolHandlers[protocol];
         if (current === protocolHandler) {
             delete this.protocolHandlers[protocol];
         }
-    };
+    }
     /**
      * Sends a new event message to the connected client.
      *
@@ -512,14 +503,15 @@ var DataStreamConnection = /** @class */ (function (_super) {
      * @param message - message dictionary which gets sent along the event
      */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    DataStreamConnection.prototype.sendEvent = function (protocol, event, message) {
-        if (message === void 0) { message = {}; }
+    sendEvent(protocol, event, message = {}) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        var header = {};
+        const header = {};
         header.protocol = protocol;
         header.event = event;
-        this.sendHDSFrame(header, message);
-    };
+        if (this.state === 2 /* ConnectionState.READY */) {
+            this.sendHDSFrame(header, message);
+        }
+    }
     /**
      * Sends a new request message to the connected client.
      *
@@ -530,31 +522,29 @@ var DataStreamConnection = /** @class */ (function (_super) {
      *                   arrive in time or the status and the message dictionary from the response
      */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    DataStreamConnection.prototype.sendRequest = function (protocol, request, message, callback) {
-        var _this = this;
-        if (message === void 0) { message = {}; }
-        var requestId;
+    sendRequest(protocol, request, message = {}, callback) {
+        let requestId;
         do { // generate unused requestId
             // currently writing int64 to data stream is not really supported, so 32-bit int will be the max
             requestId = Math.floor(Math.random() * 4294967295);
         } while (this.responseHandlers[requestId] !== undefined);
         this.responseHandlers[requestId] = callback;
-        this.responseTimers[requestId] = setTimeout(function () {
+        this.responseTimers[requestId] = setTimeout(() => {
             // we did not receive a response => close socket
-            _this.close();
-            var handler = _this.responseHandlers[requestId];
-            delete _this.responseHandlers[requestId];
-            delete _this.responseTimers[requestId];
+            this.close();
+            const handler = this.responseHandlers[requestId];
+            delete this.responseHandlers[requestId];
+            delete this.responseTimers[requestId];
             // handler should be able to clean up their stuff
             handler(new Error("timeout"), undefined, {});
         }, 10000); // 10s timer
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        var header = {};
+        const header = {};
         header.protocol = protocol;
         header.request = request;
         header.id = new DataStreamParser_1.Int64(requestId);
         this.sendHDSFrame(header, message);
-    };
+    }
     /**
      * Send a new response message to a received request message to the client.
      *
@@ -564,43 +554,40 @@ var DataStreamConnection = /** @class */ (function (_super) {
      * @param status - status indication if the request was successful. A status of zero indicates success.
      * @param message - message dictionary which gets sent along the response
      */
-    DataStreamConnection.prototype.sendResponse = function (protocol, response, id, status, 
+    sendResponse(protocol, response, id, status = HDSStatus.SUCCESS, 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    message) {
-        if (status === void 0) { status = HDSStatus.SUCCESS; }
-        if (message === void 0) { message = {}; }
+    message = {}) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        var header = {};
+        const header = {};
         header.protocol = protocol;
         header.response = response;
         header.id = new DataStreamParser_1.Int64(id);
         header.status = new DataStreamParser_1.Int64(status);
         this.sendHDSFrame(header, message);
-    };
-    DataStreamConnection.prototype.onSocketData = function (data) {
-        var _this = this;
+    }
+    onSocketData(data) {
         if (this.state >= 3 /* ConnectionState.CLOSING */) {
             return;
         }
-        var frameIndex = 0;
-        var frames = this.decodeHDSFrames(data);
+        let frameIndex = 0;
+        const frames = this.decodeHDSFrames(data);
         if (frames.length === 0) { // not enough data
             return;
         }
         if (this.state === 0 /* ConnectionState.UNIDENTIFIED */) {
             // at the beginning we are only interested in trying to decrypt the first frame in order to test decryption keys
-            var firstFrame = frames[frameIndex++];
-            this.emit("identification" /* DataStreamConnectionEvent.IDENTIFICATION */, firstFrame, function (identifiedSession) {
+            const firstFrame = frames[frameIndex++];
+            this.emit("identification" /* DataStreamConnectionEvent.IDENTIFICATION */, firstFrame, (identifiedSession) => {
                 if (identifiedSession) {
                     // horray, we found our connection
-                    _this.connection = identifiedSession.connection;
-                    _this.accessoryToControllerEncryptionKey = identifiedSession.accessoryToControllerEncryptionKey;
-                    _this.controllerToAccessoryEncryptionKey = identifiedSession.controllerToAccessoryEncryptionKey;
-                    _this.state = 1 /* ConnectionState.EXPECTING_HELLO */;
+                    this.connection = identifiedSession.connection;
+                    this.accessoryToControllerEncryptionKey = identifiedSession.accessoryToControllerEncryptionKey;
+                    this.controllerToAccessoryEncryptionKey = identifiedSession.controllerToAccessoryEncryptionKey;
+                    this.state = 1 /* ConnectionState.EXPECTING_HELLO */;
                     // below listener is removed in .close()
-                    _this.connection.setMaxListeners(_this.connection.getMaxListeners() + 1);
-                    _this.connection.on("closed" /* HAPConnectionEvent.CLOSED */, _this.hapConnectionClosedListener); // register close listener
-                    debug("[%s] Registering CLOSED handler to HAP connection. Connection currently has %d close handlers!", _this.remoteAddress, _this.connection.listeners("closed" /* HAPConnectionEvent.CLOSED */).length);
+                    this.connection.setMaxListeners(this.connection.getMaxListeners() + 1);
+                    this.connection.on("closed" /* HAPConnectionEvent.CLOSED */, this.hapConnectionClosedListener); // register close listener
+                    debug("[%s] Registering CLOSED handler to HAP connection. Connection currently has %d close handlers!", this.remoteAddress, this.connection.listeners("closed" /* HAPConnectionEvent.CLOSED */).length);
                 }
             });
             if (this.state === 0 /* ConnectionState.UNIDENTIFIED */) {
@@ -615,9 +602,9 @@ var DataStreamConnection = /** @class */ (function (_super) {
                 return;
             }
         }
-        var messages = this.decodePayloads(frames); // decode contents of payload
+        const messages = this.decodePayloads(frames); // decode contents of payload
         if (this.state === 1 /* ConnectionState.EXPECTING_HELLO */) {
-            var firstMessage = messages[0];
+            const firstMessage = messages[0];
             if (firstMessage.protocol !== "control" /* Protocols.CONTROL */ || firstMessage.type !== 2 /* MessageType.REQUEST */ || firstMessage.topic !== "hello" /* Topics.HELLO */) {
                 // first message is not the expected hello request
                 debug("[%s] First message received was not the expected hello message. Instead got: %o", this.remoteAddress, firstMessage);
@@ -625,15 +612,15 @@ var DataStreamConnection = /** @class */ (function (_super) {
                 return;
             }
         }
-        messages.forEach(function (message) {
+        messages.forEach(message => {
             if (message.type === 3 /* MessageType.RESPONSE */) {
                 // protocol and topic are currently not tested here; just assumed they are correct;
                 // probably they are as the requestId is unique per connection no matter what protocol is used
-                var responseHandler = _this.responseHandlers[message.id];
-                var responseTimer = _this.responseTimers[message.id];
+                const responseHandler = this.responseHandlers[message.id];
+                const responseTimer = this.responseTimers[message.id];
                 if (responseTimer) {
                     clearTimeout(responseTimer);
-                    delete _this.responseTimers[message.id];
+                    delete this.responseTimers[message.id];
                 }
                 if (!responseHandler) {
                     // we got a response to a request we did not send; we ignore it for now, since nobody will be hurt
@@ -644,88 +631,88 @@ var DataStreamConnection = /** @class */ (function (_super) {
                     responseHandler(undefined, message.status, message.message);
                 }
                 catch (error) {
-                    debug("[%s] Error occurred while dispatching response handler for HDS message: %o", _this.remoteAddress, message);
+                    debug("[%s] Error occurred while dispatching response handler for HDS message: %o", this.remoteAddress, message);
                     debug(error.stack);
                 }
-                delete _this.responseHandlers[message.id];
+                delete this.responseHandlers[message.id];
             }
             else {
-                var handler = _this.protocolHandlers[message.protocol];
+                const handler = this.protocolHandlers[message.protocol];
                 if (handler === undefined) {
                     // send message to the server to check if there are some global handlers for it
-                    _this.emit("handle-message-globally" /* DataStreamConnectionEvent.HANDLE_MESSAGE_GLOBALLY */, message);
+                    this.emit("handle-message-globally" /* DataStreamConnectionEvent.HANDLE_MESSAGE_GLOBALLY */, message);
                     return;
                 }
                 if (message.type === 1 /* MessageType.EVENT */) {
-                    var eventHandler = void 0;
+                    let eventHandler;
                     if (!handler.eventHandler || !(eventHandler = handler.eventHandler[message.topic])) {
-                        debug("[%s] WARNING no event handler was found for message: %o", _this.remoteAddress, message);
+                        debug("[%s] WARNING no event handler was found for message: %o", this.remoteAddress, message);
                         return;
                     }
                     try {
                         eventHandler(message.message);
                     }
                     catch (error) {
-                        debug("[%s] Error occurred while dispatching event handler for HDS message: %o", _this.remoteAddress, message);
+                        debug("[%s] Error occurred while dispatching event handler for HDS message: %o", this.remoteAddress, message);
                         debug(error.stack);
                     }
                 }
                 else if (message.type === 2 /* MessageType.REQUEST */) {
-                    var requestHandler = void 0;
+                    let requestHandler;
                     if (!handler.requestHandler || !(requestHandler = handler.requestHandler[message.topic])) {
-                        debug("[%s] WARNING no request handler was found for message: %o", _this.remoteAddress, message);
+                        debug("[%s] WARNING no request handler was found for message: %o", this.remoteAddress, message);
                         return;
                     }
                     try {
                         requestHandler(message.id, message.message);
                     }
                     catch (error) {
-                        debug("[%s] Error occurred while dispatching request handler for HDS message: %o", _this.remoteAddress, message);
+                        debug("[%s] Error occurred while dispatching request handler for HDS message: %o", this.remoteAddress, message);
                         debug(error.stack);
                     }
                 }
                 else {
-                    debug("[%s] Encountered unknown message type with id %d", _this.remoteAddress, message.type);
+                    debug("[%s] Encountered unknown message type with id %d", this.remoteAddress, message.type);
                 }
             }
         });
-    };
-    DataStreamConnection.prototype.decodeHDSFrames = function (data) {
+    }
+    decodeHDSFrames(data) {
         if (this.frameBuffer !== undefined) {
             data = Buffer.concat([this.frameBuffer, data]);
             this.frameBuffer = undefined;
         }
-        var totalBufferLength = data.length;
-        var frames = [];
-        for (var frameBegin = 0; frameBegin < totalBufferLength;) {
+        const totalBufferLength = data.length;
+        const frames = [];
+        for (let frameBegin = 0; frameBegin < totalBufferLength;) {
             if (frameBegin + 4 > totalBufferLength) {
                 // we don't have enough data in the buffer for the next header
                 this.frameBuffer = data.slice(frameBegin);
                 break;
             }
-            var payloadType = data.readUInt8(frameBegin); // type defining structure of payload; 8-bit; currently expected to be 1
-            var payloadLength = data.readUIntBE(frameBegin + 1, 3); // read 24-bit big-endian uint length field
+            const payloadType = data.readUInt8(frameBegin); // type defining structure of payload; 8-bit; currently expected to be 1
+            const payloadLength = data.readUIntBE(frameBegin + 1, 3); // read 24-bit big-endian uint length field
             if (payloadLength > DataStreamConnection.MAX_PAYLOAD_LENGTH) {
                 debug("[%s] Connection send payload with size bigger than the maximum allow for data stream", this.remoteAddress);
                 this.close();
                 return [];
             }
-            var remainingBufferLength = totalBufferLength - frameBegin - 4; // subtract 4 for payloadType (1-byte) and payloadLength (3-byte)
+            const remainingBufferLength = totalBufferLength - frameBegin - 4; // subtract 4 for payloadType (1-byte) and payloadLength (3-byte)
             // check if the data from this frame is already there (payload + 16-byte authTag)
             if (payloadLength + 16 > remainingBufferLength) {
                 // Frame is fragmented, so we wait until we receive more
                 this.frameBuffer = data.slice(frameBegin);
                 break;
             }
-            var payloadBegin = frameBegin + 4;
-            var authTagBegin = payloadBegin + payloadLength;
-            var header = data.slice(frameBegin, payloadBegin); // header is also authenticated using authTag
-            var cipheredPayload = data.slice(payloadBegin, authTagBegin);
-            var plaintextPayload = Buffer.alloc(payloadLength);
-            var authTag = data.slice(authTagBegin, authTagBegin + 16);
+            const payloadBegin = frameBegin + 4;
+            const authTagBegin = payloadBegin + payloadLength;
+            const header = data.slice(frameBegin, payloadBegin); // header is also authenticated using authTag
+            const cipheredPayload = data.slice(payloadBegin, authTagBegin);
+            const plaintextPayload = Buffer.alloc(payloadLength);
+            const authTag = data.slice(authTagBegin, authTagBegin + 16);
             frameBegin = authTagBegin + 16; // move to next frame
             if (payloadType === 1) {
-                var hdsFrame = {
+                const hdsFrame = {
                     header: header,
                     cipheredPayload: cipheredPayload,
                     authTag: authTag,
@@ -737,13 +724,13 @@ var DataStreamConnection = /** @class */ (function (_super) {
             }
         }
         return frames;
-    };
+    }
     /**
      * @private file-private API
      */
-    DataStreamConnection.prototype.decryptHDSFrame = function (frame, keyOverwrite) {
+    decryptHDSFrame(frame, keyOverwrite) {
         hapCrypto.writeUInt64LE(this.controllerToAccessoryNonce, this.controllerToAccessoryNonceBuffer, 0); // update nonce buffer
-        var key = keyOverwrite || this.controllerToAccessoryEncryptionKey;
+        const key = keyOverwrite || this.controllerToAccessoryEncryptionKey;
         try {
             frame.plaintextPayload = hapCrypto.chacha20_poly1305_decryptAndVerify(key, this.controllerToAccessoryNonceBuffer, frame.header, frame.cipheredPayload, frame.authTag);
             this.controllerToAccessoryNonce++; // we had a successful encryption, increment the nonce
@@ -753,31 +740,30 @@ var DataStreamConnection = /** @class */ (function (_super) {
             // frame decryption or authentication failed. Could happen when our guess for a PreparedDataStreamSession is wrong
             return false;
         }
-    };
-    DataStreamConnection.prototype.decodePayloads = function (frames) {
-        var _this = this;
-        var messages = [];
-        frames.forEach(function (frame) {
-            var payload = frame.plaintextPayload;
+    }
+    decodePayloads(frames) {
+        const messages = [];
+        frames.forEach(frame => {
+            const payload = frame.plaintextPayload;
             if (!payload) {
                 throw new HDSConnectionError("Reached illegal state. Encountered HDSFrame with wasn't decrypted yet!", 1 /* HDSConnectionErrorType.ILLEGAL_STATE */);
             }
-            var headerLength = payload.readUInt8(0);
-            var messageLength = payload.length - headerLength - 1;
-            var headerBegin = 1;
-            var messageBegin = headerBegin + headerLength;
-            var headerPayload = new DataStreamParser_1.DataStreamReader(payload.slice(headerBegin, headerBegin + headerLength));
-            var messagePayload = new DataStreamParser_1.DataStreamReader(payload.slice(messageBegin, messageBegin + messageLength));
+            const headerLength = payload.readUInt8(0);
+            const messageLength = payload.length - headerLength - 1;
+            const headerBegin = 1;
+            const messageBegin = headerBegin + headerLength;
+            const headerPayload = new DataStreamParser_1.DataStreamReader(payload.slice(headerBegin, headerBegin + headerLength));
+            const messagePayload = new DataStreamParser_1.DataStreamReader(payload.slice(messageBegin, messageBegin + messageLength));
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            var headerDictionary;
+            let headerDictionary;
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            var messageDictionary;
+            let messageDictionary;
             try {
                 headerDictionary = DataStreamParser_1.DataStreamParser.decode(headerPayload);
                 headerPayload.finished();
             }
             catch (error) {
-                debug("[%s] Failed to decode header payload: %s", _this.remoteAddress, error.message);
+                debug("[%s] Failed to decode header payload: %s", this.remoteAddress, error.message);
                 return;
             }
             try {
@@ -785,14 +771,14 @@ var DataStreamConnection = /** @class */ (function (_super) {
                 messagePayload.finished();
             }
             catch (error) {
-                debug("[%s] Failed to decode message payload: %s (header: %o)", _this.remoteAddress, error.message, headerDictionary);
+                debug("[%s] Failed to decode message payload: %s (header: %o)", this.remoteAddress, error.message, headerDictionary);
                 return;
             }
-            var type;
-            var protocol = headerDictionary.protocol;
-            var topic;
-            var id = undefined;
-            var status = undefined;
+            let type;
+            const protocol = headerDictionary.protocol;
+            let topic;
+            let id = undefined;
+            let status = undefined;
             if (headerDictionary.event !== undefined) {
                 type = 1 /* MessageType.EVENT */;
                 topic = headerDictionary.event;
@@ -809,10 +795,10 @@ var DataStreamConnection = /** @class */ (function (_super) {
                 status = headerDictionary.status;
             }
             else {
-                debug("[%s] Encountered unknown payload header format: %o (message: %o)", _this.remoteAddress, headerDictionary, messageDictionary);
+                debug("[%s] Encountered unknown payload header format: %o (message: %o)", this.remoteAddress, headerDictionary, messageDictionary);
                 return;
             }
-            var message = {
+            const message = {
                 type: type,
                 protocol: protocol,
                 topic: topic,
@@ -823,30 +809,30 @@ var DataStreamConnection = /** @class */ (function (_super) {
             messages.push(message);
         });
         return messages;
-    };
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    DataStreamConnection.prototype.sendHDSFrame = function (header, message) {
+    sendHDSFrame(header, message) {
         if (this.state >= 3 /* ConnectionState.CLOSING */) {
             throw new HDSConnectionError("Cannot send message on closing/closed socket!", 2 /* HDSConnectionErrorType.CLOSED_SOCKET */);
         }
-        var headerWriter = new DataStreamParser_1.DataStreamWriter();
-        var messageWriter = new DataStreamParser_1.DataStreamWriter();
+        const headerWriter = new DataStreamParser_1.DataStreamWriter();
+        const messageWriter = new DataStreamParser_1.DataStreamWriter();
         DataStreamParser_1.DataStreamParser.encode(header, headerWriter);
         DataStreamParser_1.DataStreamParser.encode(message, messageWriter);
-        var payloadHeaderBuffer = Buffer.alloc(1);
+        const payloadHeaderBuffer = Buffer.alloc(1);
         payloadHeaderBuffer.writeUInt8(headerWriter.length(), 0);
-        var payloadBuffer = Buffer.concat([payloadHeaderBuffer, headerWriter.getData(), messageWriter.getData()]);
+        const payloadBuffer = Buffer.concat([payloadHeaderBuffer, headerWriter.getData(), messageWriter.getData()]);
         if (payloadBuffer.length > DataStreamConnection.MAX_PAYLOAD_LENGTH) {
             throw new HDSConnectionError("Tried sending payload with length larger than the maximum allowed for data stream", 3 /* HDSConnectionErrorType.MAX_PAYLOAD_LENGTH */);
         }
-        var frameTypeBuffer = Buffer.alloc(1);
+        const frameTypeBuffer = Buffer.alloc(1);
         frameTypeBuffer.writeUInt8(1, 0);
-        var frameLengthBuffer = Buffer.alloc(4);
+        let frameLengthBuffer = Buffer.alloc(4);
         frameLengthBuffer.writeUInt32BE(payloadBuffer.length, 0);
         frameLengthBuffer = frameLengthBuffer.slice(1, 4); // a bit hacky but the only real way to write 24-bit int in node
-        var frameHeader = Buffer.concat([frameTypeBuffer, frameLengthBuffer]);
+        const frameHeader = Buffer.concat([frameTypeBuffer, frameLengthBuffer]);
         hapCrypto.writeUInt64LE(this.accessoryToControllerNonce++, this.accessoryToControllerNonceBuffer);
-        var encrypted = hapCrypto.chacha20_poly1305_encryptAndSeal(this.accessoryToControllerEncryptionKey, this.accessoryToControllerNonceBuffer, frameHeader, payloadBuffer);
+        const encrypted = hapCrypto.chacha20_poly1305_encryptAndSeal(this.accessoryToControllerEncryptionKey, this.accessoryToControllerNonceBuffer, frameHeader, payloadBuffer);
         this.socket.write(Buffer.concat([frameHeader, encrypted.ciphertext, encrypted.authTag]));
         /* Useful for debugging outgoing packages and detecting encoding errors
             console.log("SENT DATA: " + payloadBuffer.toString("hex"));
@@ -859,37 +845,34 @@ var DataStreamConnection = /** @class */ (function (_super) {
             const sentMessage = this.decodePayloads([frame])[0];
             console.log("Sent message: " + JSON.stringify(sentMessage, null, 4));
             //*/
-    };
-    DataStreamConnection.prototype.close = function () {
+    }
+    close() {
         if (this.state >= 3 /* ConnectionState.CLOSING */) {
             return; // connection is already closing/closed
         }
         this.state = 3 /* ConnectionState.CLOSING */;
         this.socket.end();
-    };
-    DataStreamConnection.prototype.isConsideredClosed = function () {
+    }
+    isConsideredClosed() {
         return this.state >= 3 /* ConnectionState.CLOSING */;
-    };
-    DataStreamConnection.prototype.onHAPSessionClosed = function () {
+    }
+    onHAPSessionClosed() {
         // If the hap connection is closed it is probably also a good idea to close the data stream connection
         debug("[%s] HAP connection disconnected. Also closing DataStream connection now.", this.remoteAddress);
         this.close();
-    };
-    DataStreamConnection.prototype.onSocketError = function (error) {
+    }
+    onSocketError(error) {
         debug("[%s] Encountered socket error: %s", this.remoteAddress, error.message);
         // onSocketClose will be called next
-    };
-    DataStreamConnection.prototype.onSocketClose = function () {
-        var _a, _b;
+    }
+    onSocketClose() {
         // this instance is now considered completely dead
         this.state = 4 /* ConnectionState.CLOSED */;
         this.emit("closed" /* DataStreamConnectionEvent.CLOSED */);
-        (_a = this.connection) === null || _a === void 0 ? void 0 : _a.removeListener("closed" /* HAPConnectionEvent.CLOSED */, this.hapConnectionClosedListener);
-        (_b = this.connection) === null || _b === void 0 ? void 0 : _b.setMaxListeners(this.connection.getMaxListeners() - 1);
+        this.connection?.removeListener("closed" /* HAPConnectionEvent.CLOSED */, this.hapConnectionClosedListener);
+        this.connection?.setMaxListeners(this.connection.getMaxListeners() - 1);
         this.removeAllListeners();
-    };
-    DataStreamConnection.MAX_PAYLOAD_LENGTH = 1048575;
-    return DataStreamConnection;
-}(events_1.EventEmitter));
+    }
+}
 exports.DataStreamConnection = DataStreamConnection;
 //# sourceMappingURL=DataStreamServer.js.map