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

package/dist/lib/util/eventedhttp.js

@@ -1,29 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HAPConnection = exports.HAPConnectionEvent = exports.HAPConnectionState = exports.EventedHTTPServer = exports.EventedHTTPServerEvent = exports.HAPEncryption = void 0;
-var tslib_1 = require("tslib");
-var domain_formatter_1 = require("@homebridge/ciao/lib/util/domain-formatter");
-var assert_1 = tslib_1.__importDefault(require("assert"));
-var debug_1 = tslib_1.__importDefault(require("debug"));
-var events_1 = require("events");
-var http_1 = tslib_1.__importDefault(require("http"));
-var net_1 = tslib_1.__importDefault(require("net"));
-var os_1 = tslib_1.__importDefault(require("os"));
-var hapCrypto = tslib_1.__importStar(require("./hapCrypto"));
-var net_utils_1 = require("./net-utils");
-var uuid = tslib_1.__importStar(require("./uuid"));
-var debug = (0, debug_1.default)("HAP-NodeJS:EventedHTTPServer");
-var debugCon = (0, debug_1.default)("HAP-NodeJS:EventedHTTPServer:Connection");
-var debugEvents = (0, debug_1.default)("HAP-NodeJS:EventEmitter");
+const tslib_1 = require("tslib");
+const domain_formatter_1 = require("@homebridge/ciao/lib/util/domain-formatter");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const events_1 = require("events");
+const http_1 = tslib_1.__importDefault(require("http"));
+const net_1 = tslib_1.__importDefault(require("net"));
+const os_1 = tslib_1.__importDefault(require("os"));
+const hapCrypto = tslib_1.__importStar(require("./hapCrypto"));
+const net_utils_1 = require("./net-utils");
+const uuid = tslib_1.__importStar(require("./uuid"));
+const debug = (0, debug_1.default)("HAP-NodeJS:EventedHTTPServer");
+const debugCon = (0, debug_1.default)("HAP-NodeJS:EventedHTTPServer:Connection");
+const debugEvents = (0, debug_1.default)("HAP-NodeJS:EventEmitter");
 /**
  * Simple struct to hold vars needed to support HAP encryption.
  *
  * @group Cryptography
  */
-var HAPEncryption = /** @class */ (function () {
-    function HAPEncryption(clientPublicKey, secretKey, publicKey, sharedSecret, hkdfPairEncryptionKey) {
-        this.accessoryToControllerCount = 0;
-        this.controllerToAccessoryCount = 0;
+class HAPEncryption {
+    clientPublicKey;
+    secretKey;
+    publicKey;
+    sharedSecret;
+    hkdfPairEncryptionKey;
+    accessoryToControllerCount = 0;
+    controllerToAccessoryCount = 0;
+    accessoryToControllerKey;
+    controllerToAccessoryKey;
+    incompleteFrame;
+    constructor(clientPublicKey, secretKey, publicKey, sharedSecret, hkdfPairEncryptionKey) {
         this.clientPublicKey = clientPublicKey;
         this.secretKey = secretKey;
         this.publicKey = publicKey;
@@ -32,8 +40,7 @@ var HAPEncryption = /** @class */ (function () {
         this.accessoryToControllerKey = Buffer.alloc(0);
         this.controllerToAccessoryKey = Buffer.alloc(0);
     }
-    return HAPEncryption;
-}());
+}
 exports.HAPEncryption = HAPEncryption;
 /**
  * @group HAP Accessory Server
@@ -65,75 +72,66 @@ var EventedHTTPServerEvent;
  * @group HAP Accessory Server
  */
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-var EventedHTTPServer = /** @class */ (function (_super) {
-    tslib_1.__extends(EventedHTTPServer, _super);
-    function EventedHTTPServer() {
-        var _this = _super.call(this) || this;
-        /**
-         * Set of all currently connected HAP connections.
-         */
-        _this.connections = new Set();
-        /**
-         * Session dictionary indexed by username/identifier. The username uniquely identifies every person added to the home.
-         * So there can be multiple sessions open for a single username (multiple devices connected to the same Apple ID).
-         */
-        _this.connectionsByUsername = new Map();
-        _this.tcpServer = net_1.default.createServer();
-        return _this;
-    }
-    EventedHTTPServer.prototype.scheduleNextConnectionIdleTimeout = function () {
-        var e_1, _a;
+class EventedHTTPServer extends events_1.EventEmitter {
+    static CONNECTION_TIMEOUT_LIMIT = 16; // if we have more (or equal) # connections we start the timeout
+    static MAX_CONNECTION_IDLE_TIME = 60 * 60 * 1000; // 1h
+    tcpServer;
+    /**
+     * Set of all currently connected HAP connections.
+     */
+    connections = new Set();
+    /**
+     * Session dictionary indexed by username/identifier. The username uniquely identifies every person added to the home.
+     * So there can be multiple sessions open for a single username (multiple devices connected to the same Apple ID).
+     */
+    connectionsByUsername = new Map();
+    connectionIdleTimeout;
+    connectionLoggingInterval;
+    constructor() {
+        super();
+        this.tcpServer = net_1.default.createServer();
+    }
+    scheduleNextConnectionIdleTimeout() {
         this.connectionIdleTimeout = undefined;
         if (!this.tcpServer.listening) {
             return;
         }
         debug("Running idle timeout timer...");
-        var currentTime = new Date().getTime();
-        var nextTimeout = -1;
-        try {
-            for (var _b = tslib_1.__values(this.connections), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var connection = _c.value;
-                var timeDelta = currentTime - connection.lastSocketOperation;
-                if (timeDelta >= EventedHTTPServer.MAX_CONNECTION_IDLE_TIME) {
-                    debug("[%s] Closing connection as it was inactive for " + timeDelta + "ms");
-                    connection.close();
-                }
-                else {
-                    nextTimeout = Math.max(nextTimeout, EventedHTTPServer.MAX_CONNECTION_IDLE_TIME - timeDelta);
-                }
+        const currentTime = new Date().getTime();
+        let nextTimeout = -1;
+        for (const connection of this.connections) {
+            const timeDelta = currentTime - connection.lastSocketOperation;
+            if (timeDelta >= EventedHTTPServer.MAX_CONNECTION_IDLE_TIME) {
+                debug("[%s] Closing connection as it was inactive for " + timeDelta + "ms");
+                connection.close();
             }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            else {
+                nextTimeout = Math.max(nextTimeout, EventedHTTPServer.MAX_CONNECTION_IDLE_TIME - timeDelta);
             }
-            finally { if (e_1) throw e_1.error; }
         }
         if (this.connections.size >= EventedHTTPServer.CONNECTION_TIMEOUT_LIMIT) {
             this.connectionIdleTimeout = setTimeout(this.scheduleNextConnectionIdleTimeout.bind(this), nextTimeout);
         }
-    };
-    EventedHTTPServer.prototype.address = function () {
+    }
+    address() {
         return this.tcpServer.address();
-    };
-    EventedHTTPServer.prototype.listen = function (targetPort, hostname) {
-        var _this = this;
-        this.tcpServer.listen(targetPort, hostname, function () {
-            var address = _this.tcpServer.address(); // address() is only a string when listening to unix domain sockets
-            debug("Server listening on %s:%s", address.family === "IPv6" ? "[".concat(address.address, "]") : address.address, address.port);
-            _this.connectionLoggingInterval = setInterval(function () {
-                var connectionInformation = tslib_1.__spreadArray([], tslib_1.__read(_this.connections), false).map(function (connection) { return "".concat(connection.remoteAddress, ":").concat(connection.remotePort); })
+    }
+    listen(targetPort, hostname) {
+        this.tcpServer.listen(targetPort, hostname, () => {
+            const address = this.tcpServer.address(); // address() is only a string when listening to unix domain sockets
+            debug("Server listening on %s:%s", address.family === "IPv6" ? `[${address.address}]` : address.address, address.port);
+            this.connectionLoggingInterval = setInterval(() => {
+                const connectionInformation = [...this.connections]
+                    .map(connection => `${connection.remoteAddress}:${connection.remotePort}`)
                     .join(", ");
-                debug("Currently %d hap connections open: %s", _this.connections.size, connectionInformation);
-            }, 60000);
-            _this.connectionLoggingInterval.unref();
-            _this.emit("listening" /* EventedHTTPServerEvent.LISTENING */, address.port, address.address);
+                debug("Currently %d hap connections open: %s", this.connections.size, connectionInformation);
+            }, 60_000);
+            this.connectionLoggingInterval.unref();
+            this.emit("listening" /* EventedHTTPServerEvent.LISTENING */, address.port, address.address);
         });
         this.tcpServer.on("connection", this.onConnection.bind(this));
-    };
-    EventedHTTPServer.prototype.stop = function () {
-        var e_2, _a;
+    }
+    stop() {
         if (this.connectionLoggingInterval != null) {
             clearInterval(this.connectionLoggingInterval);
             this.connectionLoggingInterval = undefined;
@@ -143,24 +141,14 @@ var EventedHTTPServer = /** @class */ (function (_super) {
             this.connectionIdleTimeout = undefined;
         }
         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_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_2) throw e_2.error; }
+        for (const connection of this.connections) {
+            connection.close();
         }
-    };
-    EventedHTTPServer.prototype.destroy = function () {
+    }
+    destroy() {
         this.stop();
         this.removeAllListeners();
-    };
+    }
     /**
      * Send an event notification for given characteristic and changed value to all connected clients.
      * If `originator` is specified, the given {@link HAPConnection} will be excluded from the broadcast.
@@ -172,32 +160,20 @@ var EventedHTTPServer = /** @class */ (function (_super) {
      * @param immediateDelivery - The HAP spec requires some characteristics to be delivery immediately.
      *   Namely, for the {@link Characteristic.ButtonEvent} and the {@link Characteristic.ProgrammableSwitchEvent} characteristics.
      */
-    EventedHTTPServer.prototype.broadcastEvent = function (aid, iid, value, originator, immediateDelivery) {
-        var e_3, _a;
-        try {
-            for (var _b = tslib_1.__values(this.connections), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var connection = _c.value;
-                if (connection === originator) {
-                    debug("[%s] Muting event '%s' notification for this connection since it originated here.", connection.remoteAddress, aid + "." + iid);
-                    continue;
-                }
-                connection.sendEvent(aid, iid, value, immediateDelivery);
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+    broadcastEvent(aid, iid, value, originator, immediateDelivery) {
+        for (const connection of this.connections) {
+            if (connection === originator) {
+                debug("[%s] Muting event '%s' notification for this connection since it originated here.", connection.remoteAddress, aid + "." + iid);
+                continue;
             }
-            finally { if (e_3) throw e_3.error; }
+            connection.sendEvent(aid, iid, value, immediateDelivery);
         }
-    };
-    EventedHTTPServer.prototype.onConnection = function (socket) {
-        var _this = this;
+    }
+    onConnection(socket) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        var connection = new HAPConnection(this, socket);
-        connection.on("request" /* HAPConnectionEvent.REQUEST */, function (request, response) {
-            _this.emit("request" /* EventedHTTPServerEvent.REQUEST */, connection, request, response);
+        const connection = new HAPConnection(this, socket);
+        connection.on("request" /* HAPConnectionEvent.REQUEST */, (request, response) => {
+            this.emit("request" /* EventedHTTPServerEvent.REQUEST */, connection, request, response);
         });
         connection.on("authenticated" /* HAPConnectionEvent.AUTHENTICATED */, this.handleConnectionAuthenticated.bind(this, connection));
         connection.on("closed" /* HAPConnectionEvent.CLOSED */, this.handleConnectionClose.bind(this, connection));
@@ -207,23 +183,23 @@ var EventedHTTPServer = /** @class */ (function (_super) {
         if (this.connections.size >= EventedHTTPServer.CONNECTION_TIMEOUT_LIMIT && !this.connectionIdleTimeout) {
             this.scheduleNextConnectionIdleTimeout();
         }
-    };
-    EventedHTTPServer.prototype.handleConnectionAuthenticated = function (connection, username) {
-        var connections = this.connectionsByUsername.get(username);
+    }
+    handleConnectionAuthenticated(connection, username) {
+        const connections = this.connectionsByUsername.get(username);
         if (!connections) {
             this.connectionsByUsername.set(username, [connection]);
         }
         else if (!connections.includes(connection)) { // ensure this doesn't get added more than one time
             connections.push(connection);
         }
-    };
-    EventedHTTPServer.prototype.handleConnectionClose = function (connection) {
+    }
+    handleConnectionClose(connection) {
         this.emit("connection-closed" /* EventedHTTPServerEvent.CONNECTION_CLOSED */, connection);
         this.connections.delete(connection);
         if (connection.username) { // aka connection was authenticated
-            var connections = this.connectionsByUsername.get(connection.username);
+            const connections = this.connectionsByUsername.get(connection.username);
             if (connections) {
-                var index = connections.indexOf(connection);
+                const index = connections.indexOf(connection);
                 if (index !== -1) {
                     connections.splice(index, 1);
                 }
@@ -232,7 +208,7 @@ var EventedHTTPServer = /** @class */ (function (_super) {
                 }
             }
         }
-    };
+    }
     /**
      * This method is to be called when a given {@link HAPConnection} performs a request that should result in the disconnection
      * of all other {@link HAPConnection} with the same {@link HAPUsername}.
@@ -243,29 +219,15 @@ var EventedHTTPServer = /** @class */ (function (_super) {
      * @param initiator - The connection that requested to disconnect all connections of the same username.
      * @param username - The username for which all connections shall be closed.
      */
-    EventedHTTPServer.destroyExistingConnectionsAfterUnpair = function (initiator, username) {
-        var e_4, _a;
-        var connections = initiator.server.connectionsByUsername.get(username);
+    static destroyExistingConnectionsAfterUnpair(initiator, username) {
+        const connections = initiator.server.connectionsByUsername.get(username);
         if (connections) {
-            try {
-                for (var connections_1 = tslib_1.__values(connections), connections_1_1 = connections_1.next(); !connections_1_1.done; connections_1_1 = connections_1.next()) {
-                    var connection = connections_1_1.value;
-                    connection.closeConnectionAsOfUnpair(initiator);
-                }
-            }
-            catch (e_4_1) { e_4 = { error: e_4_1 }; }
-            finally {
-                try {
-                    if (connections_1_1 && !connections_1_1.done && (_a = connections_1.return)) _a.call(connections_1);
-                }
-                finally { if (e_4) throw e_4.error; }
+            for (const connection of connections) {
+                connection.closeConnectionAsOfUnpair(initiator);
             }
         }
-    };
-    EventedHTTPServer.CONNECTION_TIMEOUT_LIMIT = 16; // if we have more (or equal) # connections we start the timeout
-    EventedHTTPServer.MAX_CONNECTION_IDLE_TIME = 60 * 60 * 1000; // 1h
-    return EventedHTTPServer;
-}(events_1.EventEmitter));
+    }
+}
 exports.EventedHTTPServer = EventedHTTPServer;
 /**
  * @private
@@ -296,82 +258,100 @@ var HAPConnectionEvent;
  * @group HAP Accessory Server
  */
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-var HAPConnection = /** @class */ (function (_super) {
-    tslib_1.__extends(HAPConnection, _super);
-    function HAPConnection(server, clientSocket) {
-        var _this = _super.call(this) || this;
-        _this.state = 0 /* HAPConnectionState.CONNECTING */;
-        _this.lastSocketOperation = new Date().getTime();
-        _this.pendingClientSocketData = Buffer.alloc(0); // data received from client before HTTP proxy is fully setup
-        _this.handlingRequest = false; // true while we are composing an HTTP response (so events can wait)
-        _this.registeredEvents = new Set();
-        _this.queuedEvents = [];
-        /**
-         * If true, the above {@link queuedEvents} contains events which are set to be delivered immediately!
-         */
-        _this.eventsQueuedForImmediateDelivery = false;
-        _this.server = server;
-        _this.sessionID = uuid.generate(clientSocket.remoteAddress + ":" + clientSocket.remotePort);
-        _this.localAddress = clientSocket.localAddress;
-        _this.remoteAddress = clientSocket.remoteAddress; // cache because it becomes undefined in 'onClientSocketClose'
-        _this.remotePort = clientSocket.remotePort;
-        _this.networkInterface = HAPConnection.getLocalNetworkInterface(clientSocket);
+class HAPConnection extends events_1.EventEmitter {
+    /**
+     * @private file-private API
+     */
+    server;
+    sessionID; // uuid unique to every HAP connection
+    state = 0 /* HAPConnectionState.CONNECTING */;
+    localAddress;
+    remoteAddress; // cache because it becomes undefined in 'onClientSocketClose'
+    remotePort;
+    networkInterface;
+    tcpSocket;
+    internalHttpServer;
+    httpSocket; // set when in state FULLY_SET_UP
+    internalHttpServerPort;
+    internalHttpServerAddress;
+    lastSocketOperation = new Date().getTime();
+    pendingClientSocketData = Buffer.alloc(0); // data received from client before HTTP proxy is fully setup
+    handlingRequest = false; // true while we are composing an HTTP response (so events can wait)
+    username; // username is unique to every user in the home, basically identifies an Apple ID
+    encryption; // created in handlePairVerifyStepOne
+    srpServer;
+    _pairSetupState; // TODO ensure those two states are always correctly reset?
+    _pairVerifyState;
+    registeredEvents = new Set();
+    eventsTimer;
+    queuedEvents = [];
+    /**
+     * If true, the above {@link queuedEvents} contains events which are set to be delivered immediately!
+     */
+    eventsQueuedForImmediateDelivery = false;
+    timedWritePid;
+    timedWriteTimeout;
+    constructor(server, clientSocket) {
+        super();
+        this.server = server;
+        this.sessionID = uuid.generate(clientSocket.remoteAddress + ":" + clientSocket.remotePort);
+        this.localAddress = clientSocket.localAddress;
+        this.remoteAddress = clientSocket.remoteAddress; // cache because it becomes undefined in 'onClientSocketClose'
+        this.remotePort = clientSocket.remotePort;
+        this.networkInterface = HAPConnection.getLocalNetworkInterface(clientSocket);
         // clientSocket is the socket connected to the actual iOS device
-        _this.tcpSocket = clientSocket;
-        _this.tcpSocket.on("data", _this.onTCPSocketData.bind(_this));
-        _this.tcpSocket.on("close", _this.onTCPSocketClose.bind(_this));
+        this.tcpSocket = clientSocket;
+        this.tcpSocket.on("data", this.onTCPSocketData.bind(this));
+        this.tcpSocket.on("close", this.onTCPSocketClose.bind(this));
         // we MUST register for this event, otherwise the error will bubble up to the top and crash the node process entirely.
-        _this.tcpSocket.on("error", _this.onTCPSocketError.bind(_this));
-        _this.tcpSocket.setNoDelay(true); // disable Nagle algorithm
+        this.tcpSocket.on("error", this.onTCPSocketError.bind(this));
+        this.tcpSocket.setNoDelay(true); // disable Nagle algorithm
         // "HAP accessory servers must not use keepalive messages, which periodically wake up iOS devices".
         // Thus, we don't configure any tcp keepalive
         // create our internal HTTP server for this connection that we will proxy data to and from
-        _this.internalHttpServer = http_1.default.createServer();
-        _this.internalHttpServer.timeout = 0; // clients expect to hold connections open as long as they want
-        _this.internalHttpServer.keepAliveTimeout = 0; // workaround for https://github.com/nodejs/node/issues/13391
-        _this.internalHttpServer.on("listening", _this.onHttpServerListening.bind(_this));
-        _this.internalHttpServer.on("request", _this.handleHttpServerRequest.bind(_this));
-        _this.internalHttpServer.on("error", _this.onHttpServerError.bind(_this));
+        this.internalHttpServer = http_1.default.createServer();
+        this.internalHttpServer.timeout = 0; // clients expect to hold connections open as long as they want
+        this.internalHttpServer.keepAliveTimeout = 0; // workaround for https://github.com/nodejs/node/issues/13391
+        this.internalHttpServer.on("listening", this.onHttpServerListening.bind(this));
+        this.internalHttpServer.on("request", this.handleHttpServerRequest.bind(this));
+        this.internalHttpServer.on("error", this.onHttpServerError.bind(this));
         // close event is added later on the "connect" event as possible listen retries would throw unnecessary close events
-        _this.internalHttpServer.listen(0, _this.internalHttpServerAddress = (0, net_utils_1.getOSLoopbackAddressIfAvailable)());
-        return _this;
-    }
-    HAPConnection.prototype.debugListenerRegistration = function (event, registration, beforeCount) {
-        if (registration === void 0) { registration = true; }
-        if (beforeCount === void 0) { beforeCount = -1; }
-        var stackTrace = new Error().stack.split("\n")[3];
-        var eventCount = this.listeners(event).length;
-        var tabs1 = event === "authenticated" /* HAPConnectionEvent.AUTHENTICATED */ ? "\t" : "\t\t";
-        var tabs2 = !registration ? "\t" : "\t\t";
+        this.internalHttpServer.listen(0, this.internalHttpServerAddress = (0, net_utils_1.getOSLoopbackAddressIfAvailable)());
+    }
+    debugListenerRegistration(event, registration = true, beforeCount = -1) {
+        const stackTrace = new Error().stack.split("\n")[3];
+        const eventCount = this.listeners(event).length;
+        const tabs1 = event === "authenticated" /* HAPConnectionEvent.AUTHENTICATED */ ? "\t" : "\t\t";
+        const tabs2 = !registration ? "\t" : "\t\t";
         // eslint-disable-next-line max-len
-        debugEvents("[".concat(this.remoteAddress, "] ").concat(registration ? "Registered" : "Unregistered", " event '").concat(String(event).toUpperCase(), "' ").concat(tabs1, "(total: ").concat(eventCount).concat(!registration ? " Before: " + beforeCount : "", ") ").concat(tabs2).concat(stackTrace));
-    };
+        debugEvents(`[${this.remoteAddress}] ${registration ? "Registered" : "Unregistered"} event '${String(event).toUpperCase()}' ${tabs1}(total: ${eventCount}${!registration ? " Before: " + beforeCount : ""}) ${tabs2}${stackTrace}`);
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    HAPConnection.prototype.on = function (event, listener) {
-        var result = _super.prototype.on.call(this, event, listener);
+    on(event, listener) {
+        const result = super.on(event, listener);
         this.debugListenerRegistration(event);
         return result;
-    };
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    HAPConnection.prototype.addListener = function (event, listener) {
-        var result = _super.prototype.addListener.call(this, event, listener);
+    addListener(event, listener) {
+        const result = super.addListener(event, listener);
         this.debugListenerRegistration(event);
         return result;
-    };
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    HAPConnection.prototype.removeListener = function (event, listener) {
-        var beforeCount = this.listeners(event).length;
-        var result = _super.prototype.removeListener.call(this, event, listener);
+    removeListener(event, listener) {
+        const beforeCount = this.listeners(event).length;
+        const result = super.removeListener(event, listener);
         this.debugListenerRegistration(event, false, beforeCount);
         return result;
-    };
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    HAPConnection.prototype.off = function (event, listener) {
-        var result = _super.prototype.off.call(this, event, listener);
-        var beforeCount = this.listeners(event).length;
+    off(event, listener) {
+        const result = super.off(event, listener);
+        const beforeCount = this.listeners(event).length;
         this.debugListenerRegistration(event, false, beforeCount);
         return result;
-    };
+    }
     /**
      * This method is called once the connection has gone through pair-verify.
      * As any HomeKit controller will initiate a pair-verify after the pair-setup procedure, this method gets
@@ -379,22 +359,22 @@ var HAPConnection = /** @class */ (function (_super) {
      *
      * Once this method has been called, the connection is authenticated and encryption is turned on.
      */
-    HAPConnection.prototype.connectionAuthenticated = function (username) {
+    connectionAuthenticated(username) {
         this.state = 2 /* HAPConnectionState.AUTHENTICATED */;
         this.username = username;
         this.emit("authenticated" /* HAPConnectionEvent.AUTHENTICATED */, username);
-    };
-    HAPConnection.prototype.isAuthenticated = function () {
+    }
+    isAuthenticated() {
         return this.state === 2 /* HAPConnectionState.AUTHENTICATED */;
-    };
-    HAPConnection.prototype.close = function () {
+    }
+    close() {
         if (this.state >= 4 /* HAPConnectionState.CLOSING */) {
             return; // already closed/closing
         }
         this.state = 4 /* HAPConnectionState.CLOSING */;
         this.tcpSocket.destroy();
-    };
-    HAPConnection.prototype.closeConnectionAsOfUnpair = function (initiator) {
+    }
+    closeConnectionAsOfUnpair(initiator) {
         if (this === initiator) {
             // the initiator of the unpair request is this connection, meaning it unpaired itself.
             // we still need to send the response packet to the unpair request.
@@ -404,16 +384,16 @@ var HAPConnection = /** @class */ (function (_super) {
             // as HomeKit requires it, destroy any active session which got unpaired
             this.close();
         }
-    };
-    HAPConnection.prototype.sendEvent = function (aid, iid, value, immediateDelivery) {
+    }
+    sendEvent(aid, iid, value, immediateDelivery) {
         (0, assert_1.default)(aid != null, "HAPConnection.sendEvent: aid must be defined!");
         (0, assert_1.default)(iid != null, "HAPConnection.sendEvent: iid must be defined!");
-        var eventName = aid + "." + iid;
+        const eventName = aid + "." + iid;
         if (!this.registeredEvents.has(eventName)) {
             // non verified connections can't register events, so this case is covered!
             return;
         }
-        var event = {
+        const event = {
             aid: aid,
             iid: iid,
             value: value,
@@ -433,8 +413,8 @@ var HAPConnection = /** @class */ (function (_super) {
         // we search the list of queued events in reverse order.
         // if the last element with the same aid and iid has the same value we don't want to send the event notification twice.
         // BUT, we do not want to override previous event notifications which have a different value. Automations must be executed!
-        for (var i = this.queuedEvents.length - 1; i >= 0; i--) {
-            var queuedEvent = this.queuedEvents[i];
+        for (let i = this.queuedEvents.length - 1; i >= 0; i--) {
+            const queuedEvent = this.queuedEvents[i];
             if (queuedEvent.aid === aid && queuedEvent.iid === iid) {
                 if (queuedEvent.value === value) {
                     return; // the same event was already queued. do not add it again!
@@ -448,17 +428,16 @@ var HAPConnection = /** @class */ (function (_super) {
             this.eventsTimer = setTimeout(this.handleEventsTimeout.bind(this), 250);
             this.eventsTimer.unref();
         }
-    };
-    HAPConnection.prototype.handleEventsTimeout = function () {
+    }
+    handleEventsTimeout() {
         this.eventsTimer = undefined;
         if (this.state > 2 /* HAPConnectionState.AUTHENTICATED */) {
             // connection is closed or about to be closed. no need to send any further events
             return;
         }
         this.writeQueuedEventNotifications();
-    };
-    HAPConnection.prototype.writeQueuedEventNotifications = function () {
-        var e_5, _a;
+    }
+    writeQueuedEventNotifications() {
         if (this.queuedEvents.length === 0 || this.handlingRequest) {
             return; // don't send empty event notifications or if we are currently handling a request
         }
@@ -467,29 +446,19 @@ var HAPConnection = /** @class */ (function (_super) {
             clearTimeout(this.eventsTimer);
             this.eventsTimer = undefined;
         }
-        var eventData = {
+        const eventData = {
             characteristics: [],
         };
-        try {
-            for (var _b = tslib_1.__values(this.queuedEvents), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var queuedEvent = _c.value;
-                if (!this.registeredEvents.has(queuedEvent.aid + "." + queuedEvent.iid)) {
-                    continue; // client unregistered that event in the meantime
-                }
-                eventData.characteristics.push(queuedEvent);
+        for (const queuedEvent of this.queuedEvents) {
+            if (!this.registeredEvents.has(queuedEvent.aid + "." + queuedEvent.iid)) {
+                continue; // client unregistered that event in the meantime
             }
-        }
-        catch (e_5_1) { e_5 = { error: e_5_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_5) throw e_5.error; }
+            eventData.characteristics.push(queuedEvent);
         }
         this.queuedEvents.splice(0, this.queuedEvents.length);
         this.eventsQueuedForImmediateDelivery = false;
         this.writeEventNotification(eventData);
-    };
+    }
     /**
      * This will create an EVENT/1.0 notification header with the provided event notification.
      * If currently an HTTP request is in progress the assembled packet will be
@@ -497,36 +466,36 @@ var HAPConnection = /** @class */ (function (_super) {
      *
      * @param notification - The event which should be sent out
      */
-    HAPConnection.prototype.writeEventNotification = function (notification) {
+    writeEventNotification(notification) {
         debugCon("[%s] Sending HAP event notifications %o", this.remoteAddress, notification.characteristics);
         (0, assert_1.default)(!this.handlingRequest, "Can't write event notifications while handling a request!");
         // Apple backend processes events in reverse order, so we need to reverse the array
         // so that events are processed in chronological order.
         notification.characteristics.reverse();
-        var dataBuffer = Buffer.from(JSON.stringify(notification), "utf8");
-        var header = Buffer.from("EVENT/1.0 200 OK\r\n" +
+        const dataBuffer = Buffer.from(JSON.stringify(notification), "utf8");
+        const header = Buffer.from("EVENT/1.0 200 OK\r\n" +
             "Content-Type: application/hap+json\r\n" +
             "Content-Length: " + dataBuffer.length + "\r\n" +
             "\r\n", "utf8");
-        var buffer = Buffer.concat([header, dataBuffer]);
+        const buffer = Buffer.concat([header, dataBuffer]);
         this.tcpSocket.write(this.encrypt(buffer), this.handleTCPSocketWriteFulfilled.bind(this));
-    };
-    HAPConnection.prototype.enableEventNotifications = function (aid, iid) {
+    }
+    enableEventNotifications(aid, iid) {
         this.registeredEvents.add(aid + "." + iid);
-    };
-    HAPConnection.prototype.disableEventNotifications = function (aid, iid) {
+    }
+    disableEventNotifications(aid, iid) {
         this.registeredEvents.delete(aid + "." + iid);
-    };
-    HAPConnection.prototype.hasEventNotifications = function (aid, iid) {
+    }
+    hasEventNotifications(aid, iid) {
         return this.registeredEvents.has(aid + "." + iid);
-    };
-    HAPConnection.prototype.getRegisteredEvents = function () {
+    }
+    getRegisteredEvents() {
         return this.registeredEvents;
-    };
-    HAPConnection.prototype.clearRegisteredEvents = function () {
+    }
+    clearRegisteredEvents() {
         this.registeredEvents.clear();
-    };
-    HAPConnection.prototype.encrypt = function (data) {
+    }
+    encrypt(data) {
         // if accessoryToControllerKey is not empty, then encryption is enabled for this connection. However, we'll
         // need to be careful to ensure that we don't encrypt the last few bytes of the response from handlePairVerifyStepTwo.
         // Since all communication calls are asynchronous, we could easily receive this 'encrypt' event for those bytes.
@@ -535,18 +504,17 @@ var HAPConnection = /** @class */ (function (_super) {
             return hapCrypto.layerEncrypt(data, this.encryption);
         }
         return data; // otherwise, we don't encrypt and return plaintext
-    };
-    HAPConnection.prototype.decrypt = function (data) {
+    }
+    decrypt(data) {
         if (this.encryption && this.encryption.controllerToAccessoryKey.length > 0) {
             // below call may throw an error if decryption failed
             return hapCrypto.layerDecrypt(data, this.encryption);
         }
         return data; // otherwise, we don't decrypt and return plaintext
-    };
-    HAPConnection.prototype.onHttpServerListening = function () {
-        var _this = this;
-        var addressInfo = this.internalHttpServer.address(); // address() is only a string when listening to unix domain sockets
-        var addressString = addressInfo.family === "IPv6" ? "[".concat(addressInfo.address, "]") : addressInfo.address;
+    }
+    onHttpServerListening() {
+        const addressInfo = this.internalHttpServer.address(); // address() is only a string when listening to unix domain sockets
+        const addressString = addressInfo.family === "IPv6" ? `[${addressInfo.address}]` : addressInfo.address;
         this.internalHttpServerPort = addressInfo.port;
         debugCon("[%s] Internal HTTP server listening on %s:%s", this.remoteAddress, addressString, addressInfo.port);
         this.internalHttpServer.on("close", this.onHttpServerClose.bind(this));
@@ -557,25 +525,25 @@ var HAPConnection = /** @class */ (function (_super) {
         // we MUST register for this event, otherwise the error will bubble up to the top and crash the node process entirely.
         this.httpSocket.on("error", this.onHttpSocketError.bind(this));
         this.httpSocket.on("close", this.onHttpSocketClose.bind(this));
-        this.httpSocket.on("connect", function () {
+        this.httpSocket.on("connect", () => {
             // we are now fully set up:
             //  - clientSocket is connected to the iOS device
             //  - serverSocket is connected to the httpServer
             //  - ready to proxy data!
-            _this.state = 1 /* HAPConnectionState.FULLY_SET_UP */;
-            debugCon("[%s] Internal HTTP socket connected. HAPConnection now fully set up!", _this.remoteAddress);
+            this.state = 1 /* HAPConnectionState.FULLY_SET_UP */;
+            debugCon("[%s] Internal HTTP socket connected. HAPConnection now fully set up!", this.remoteAddress);
             // start by flushing any pending buffered data received from the client while we were setting up
-            if (_this.pendingClientSocketData && _this.pendingClientSocketData.length > 0) {
-                _this.httpSocket.write(_this.pendingClientSocketData);
+            if (this.pendingClientSocketData && this.pendingClientSocketData.length > 0) {
+                this.httpSocket.write(this.pendingClientSocketData);
             }
-            _this.pendingClientSocketData = undefined;
+            this.pendingClientSocketData = undefined;
         });
-    };
+    }
     /**
      * This event handler is called when we receive data from a HomeKit controller on our tcp socket.
      * We store the data if the internal http server is not read yet, or forward it to the http server.
      */
-    HAPConnection.prototype.onTCPSocketData = function (data) {
+    onTCPSocketData(data) {
         if (this.state > 2 /* HAPConnectionState.AUTHENTICATED */) {
             // don't accept data of a connection which is about to be closed or already closed
             return;
@@ -596,13 +564,13 @@ var HAPConnection = /** @class */ (function (_super) {
         else {
             this.httpSocket.write(data); // proxy it along to the HTTP server
         }
-    };
+    }
     /**
      * This event handler is called when the internal http server receives a request.
      * Meaning we received data from the HomeKit controller in {@link onTCPSocketData}, which then send the
      * data unencrypted to the internal http server. And now it landed here, fully parsed as a http request.
      */
-    HAPConnection.prototype.handleHttpServerRequest = function (request, response) {
+    handleHttpServerRequest(request, response) {
         if (this.state > 2 /* HAPConnectionState.AUTHENTICATED */) {
             // don't accept data of a connection which is about to be closed or already closed
             return;
@@ -610,20 +578,19 @@ var HAPConnection = /** @class */ (function (_super) {
         debugCon("[%s] HTTP request: %s", this.remoteAddress, request.url);
         request.socket.setNoDelay(true);
         this.emit("request" /* HAPConnectionEvent.REQUEST */, request, response);
-    };
+    }
     /**
      * This event handler is called by the socket which is connected to our internal http server.
      * It is called with the response returned from the http server.
      * In this method we have to encrypt and forward the message back to the HomeKit controller.
      */
-    HAPConnection.prototype.handleHttpServerResponse = function (data) {
-        var _this = this;
+    handleHttpServerResponse(data) {
         data = this.encrypt(data);
         this.tcpSocket.write(data, this.handleTCPSocketWriteFulfilled.bind(this));
         debugCon("[%s] HTTP Response is finished", this.remoteAddress);
         this.handlingRequest = false;
         if (this.state === 3 /* HAPConnectionState.TO_BE_TEARED_DOWN */) {
-            setTimeout(function () { return _this.close(); }, 10);
+            setTimeout(() => this.close(), 10);
         }
         else if (this.state < 3 /* HAPConnectionState.TO_BE_TEARED_DOWN */) {
             if (!this.eventsTimer || this.eventsQueuedForImmediateDelivery) {
@@ -632,15 +599,15 @@ var HAPConnection = /** @class */ (function (_super) {
                 this.writeQueuedEventNotifications();
             }
         }
-    };
-    HAPConnection.prototype.handleTCPSocketWriteFulfilled = function () {
+    }
+    handleTCPSocketWriteFulfilled() {
         this.lastSocketOperation = new Date().getTime();
-    };
-    HAPConnection.prototype.onTCPSocketError = function (err) {
+    }
+    onTCPSocketError(err) {
         debugCon("[%s] Client connection error: %s", this.remoteAddress, err.message);
         // onTCPSocketClose will be called next
-    };
-    HAPConnection.prototype.onTCPSocketClose = function () {
+    }
+    onTCPSocketClose() {
         this.state = 5 /* HAPConnectionState.CLOSED */;
         debugCon("[%s] Client connection closed", this.remoteAddress);
         if (this.httpSocket) {
@@ -649,166 +616,91 @@ var HAPConnection = /** @class */ (function (_super) {
         this.internalHttpServer.close();
         this.emit("closed" /* HAPConnectionEvent.CLOSED */); // sending final closed event
         this.removeAllListeners(); // cleanup listeners, we are officially dead now
-    };
-    HAPConnection.prototype.onHttpServerError = function (err) {
+    }
+    onHttpServerError(err) {
         debugCon("[%s] HTTP server error: %s", this.remoteAddress, err.message);
         if (err.code === "EADDRINUSE") {
             this.internalHttpServerPort = undefined;
             this.internalHttpServer.close();
             this.internalHttpServer.listen(0, this.internalHttpServerAddress = (0, net_utils_1.getOSLoopbackAddressIfAvailable)());
         }
-    };
-    HAPConnection.prototype.onHttpServerClose = function () {
+    }
+    onHttpServerClose() {
         debugCon("[%s] HTTP server was closed", this.remoteAddress);
         // make sure the iOS side is closed as well
         this.close();
-    };
-    HAPConnection.prototype.onHttpSocketError = function (err) {
+    }
+    onHttpSocketError(err) {
         debugCon("[%s] HTTP connection error: ", this.remoteAddress, err.message);
         // onHttpSocketClose will be called next
-    };
-    HAPConnection.prototype.onHttpSocketClose = function () {
+    }
+    onHttpSocketClose() {
         debugCon("[%s] HTTP connection was closed", this.remoteAddress);
         // we only support a single long-lived connection to our internal HTTP server. Since it's closed,
         // we'll need to shut it down entirely.
         this.internalHttpServer.close();
-    };
-    HAPConnection.prototype.getLocalAddress = function (ipVersion) {
-        var e_6, _a, e_7, _b;
-        var infos = os_1.default.networkInterfaces()[this.networkInterface];
-        if (ipVersion === "ipv4") {
-            if (infos) {
-                try {
-                    for (var infos_1 = tslib_1.__values(infos), infos_1_1 = infos_1.next(); !infos_1_1.done; infos_1_1 = infos_1.next()) {
-                        var info = infos_1_1.value;
-                        // @ts-expect-error Nodejs 18+ uses the number 4 the string "IPv4"
-                        if (info.family === "IPv4" || info.family === 4) {
-                            return info.address;
-                        }
-                    }
-                }
-                catch (e_6_1) { e_6 = { error: e_6_1 }; }
-                finally {
-                    try {
-                        if (infos_1_1 && !infos_1_1.done && (_a = infos_1.return)) _a.call(infos_1);
-                    }
-                    finally { if (e_6) throw e_6.error; }
-                }
-            }
+    }
+    getLocalAddress(ipVersion) {
+        const interfaceDetails = os_1.default.networkInterfaces()[this.networkInterface];
+        if (!interfaceDetails) {
             throw new Error("Could not find " + ipVersion + " address for interface " + this.networkInterface);
         }
-        else {
-            var localUniqueAddress = undefined;
-            if (infos) {
-                try {
-                    for (var infos_2 = tslib_1.__values(infos), infos_2_1 = infos_2.next(); !infos_2_1.done; infos_2_1 = infos_2.next()) {
-                        var info = infos_2_1.value;
-                        // @ts-expect-error Nodejs 18+ uses the number 6 instead of the string "IPv6"
-                        if (info.family === "IPv6" || info.family === 6) {
-                            if (!info.scopeid) {
-                                return info.address;
-                            }
-                            else if (!localUniqueAddress) {
-                                localUniqueAddress = info.address;
-                            }
-                        }
-                    }
-                }
-                catch (e_7_1) { e_7 = { error: e_7_1 }; }
-                finally {
-                    try {
-                        if (infos_2_1 && !infos_2_1.done && (_b = infos_2.return)) _b.call(infos_2);
-                    }
-                    finally { if (e_7) throw e_7.error; }
-                }
-            }
-            if (!localUniqueAddress) {
-                throw new Error("Could not find " + ipVersion + " address for interface " + this.networkInterface);
-            }
-            return localUniqueAddress;
-        }
-    };
-    HAPConnection.getLocalNetworkInterface = function (socket) {
-        var e_8, _a, e_9, _b, e_10, _c, e_11, _d;
-        var localAddress = socket.localAddress;
-        if (localAddress.startsWith("::ffff:")) { // IPv4-Mapped IPv6 Address https://tools.ietf.org/html/rfc4291#section-2.5.5.2
-            localAddress = localAddress.substring(7);
-        }
-        else {
-            var index = localAddress.indexOf("%");
-            if (index !== -1) { // link-local ipv6
-                localAddress = localAddress.substring(0, index);
+        // Find our first local IPv4 address.
+        if (ipVersion === "ipv4") {
+            const ipv4Info = interfaceDetails.find(info => info.family === "IPv4");
+            if (ipv4Info) {
+                return ipv4Info.address;
             }
+            throw new Error("Could not find " + ipVersion + " address for interface " + this.networkInterface + ".");
         }
-        var interfaces = os_1.default.networkInterfaces();
-        try {
-            for (var _e = tslib_1.__values(Object.entries(interfaces)), _f = _e.next(); !_f.done; _f = _e.next()) {
-                var _g = tslib_1.__read(_f.value, 2), name = _g[0], infos = _g[1];
-                if (infos) {
-                    try {
-                        for (var infos_3 = (e_9 = void 0, tslib_1.__values(infos)), infos_3_1 = infos_3.next(); !infos_3_1.done; infos_3_1 = infos_3.next()) {
-                            var info = infos_3_1.value;
-                            if (info.address === localAddress) {
-                                return name;
-                            }
-                        }
-                    }
-                    catch (e_9_1) { e_9 = { error: e_9_1 }; }
-                    finally {
-                        try {
-                            if (infos_3_1 && !infos_3_1.done && (_b = infos_3.return)) _b.call(infos_3);
-                        }
-                        finally { if (e_9) throw e_9.error; }
-                    }
-                }
+        let localUniqueAddress;
+        for (const v6entry of interfaceDetails.filter(entry => entry.family === "IPv6")) {
+            if (!v6entry.scopeid) {
+                return v6entry.address;
             }
+            localUniqueAddress ??= v6entry.address;
         }
-        catch (e_8_1) { e_8 = { error: e_8_1 }; }
-        finally {
-            try {
-                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
-            }
-            finally { if (e_8) throw e_8.error; }
+        if (localUniqueAddress) {
+            return localUniqueAddress;
         }
-        // we couldn't map the address from above, we try now to match subnets (see https://github.com/homebridge/HAP-NodeJS/issues/847)
-        var family = net_1.default.isIPv4(localAddress) ? "IPv4" : "IPv6";
-        try {
-            for (var _h = tslib_1.__values(Object.entries(interfaces)), _j = _h.next(); !_j.done; _j = _h.next()) {
-                var _k = tslib_1.__read(_j.value, 2), name = _k[0], infos = _k[1];
-                if (infos) {
-                    try {
-                        for (var infos_4 = (e_11 = void 0, tslib_1.__values(infos)), infos_4_1 = infos_4.next(); !infos_4_1.done; infos_4_1 = infos_4.next()) {
-                            var info = infos_4_1.value;
-                            if (info.family !== family) {
-                                continue;
-                            }
-                            // check if the localAddress is in the same subnet
-                            if ((0, domain_formatter_1.getNetAddress)(localAddress, info.netmask) === (0, domain_formatter_1.getNetAddress)(info.address, info.netmask)) {
-                                return name;
-                            }
-                        }
-                    }
-                    catch (e_11_1) { e_11 = { error: e_11_1 }; }
-                    finally {
-                        try {
-                            if (infos_4_1 && !infos_4_1.done && (_d = infos_4.return)) _d.call(infos_4);
-                        }
-                        finally { if (e_11) throw e_11.error; }
-                    }
-                }
+        throw new Error("Could not find " + ipVersion + " address for interface " + this.networkInterface);
+    }
+    static getLocalNetworkInterface(socket) {
+        let localAddress = socket.localAddress;
+        // Grab the list of network interfaces.
+        const interfaces = os_1.default.networkInterfaces();
+        // Default to the first non-loopback interface we see.
+        const defaultInterface = () => Object.entries(interfaces).find(([, addresses]) => addresses?.some(address => !address.internal))?.[0] ?? "unknown";
+        // No local address return our default.
+        if (!localAddress) {
+            return defaultInterface();
+        }
+        // Handle IPv4-mapped IPv6 addresses.
+        localAddress = localAddress.replace(/^::ffff:/i, "");
+        // Handle edge cases where we have an IPv4-mapped IPv6 address without the requisite prefix.
+        if (/^::(?:\d{1,3}\.){3}\d{1,3}$/.test(localAddress)) {
+            localAddress = localAddress.replace(/^::/, "");
+        }
+        // Handle link-local IPv6 addresses.
+        localAddress = localAddress.split("%")[0];
+        // Let's find an exact match using the IP.
+        for (const [name, addresses] of Object.entries(interfaces)) {
+            if (addresses?.some(({ address }) => address === localAddress)) {
+                return name;
             }
         }
-        catch (e_10_1) { e_10 = { error: e_10_1 }; }
-        finally {
-            try {
-                if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+        // We couldn't find an interface to match the address from above, so we attempt to match subnets (see https://github.com/homebridge/HAP-NodeJS/issues/847).
+        const family = net_1.default.isIPv4(localAddress) ? "IPv4" : "IPv6";
+        // Let's find a match based on the subnet.
+        for (const [name, addresses] of Object.entries(interfaces)) {
+            if (addresses?.some(entry => entry.family === family && (0, domain_formatter_1.getNetAddress)(localAddress, entry.netmask) === (0, domain_formatter_1.getNetAddress)(entry.address, entry.netmask))) {
+                return name;
             }
-            finally { if (e_10) throw e_10.error; }
         }
-        console.log("WARNING couldn't map socket coming from remote address ".concat(socket.remoteAddress, ":").concat(socket.remotePort, "     at local address ").concat(socket.localAddress, " to a interface!"));
-        return Object.keys(interfaces)[1]; // just use the first interface after the loopback interface as fallback
-    };
-    return HAPConnection;
-}(events_1.EventEmitter));
+        console.log("WARNING: unable to determine which interface to use for socket coming from " + socket.remoteAddress + ":" + socket.remotePort + " to " +
+            socket.localAddress + ".");
+        return defaultInterface();
+    }
+}
 exports.HAPConnection = HAPConnection;
 //# sourceMappingURL=eventedhttp.js.map