hap-nodejs 1.1.1-beta.4 → 1.1.1-beta.6

package/dist/lib/util/eventedhttp.js

@@ -1,23 +1,26 @@
-import assert from 'node:assert';
-import { Buffer } from 'node:buffer';
-import { EventEmitter } from 'node:events';
-import { createServer as createHttpServer } from 'node:http';
-import { createConnection, createServer, isIPv4 } from 'node:net';
-import { networkInterfaces } from 'node:os';
-import { getNetAddress } from '@homebridge/ciao/dist/util/domain-formatter.js';
-import createDebug from 'debug';
-import { layerDecrypt, layerEncrypt } from './hapCrypto.js';
-import { getOSLoopbackAddressIfAvailable } from './net-utils.js';
-import { generate } from './uuid.js';
-const debug = createDebug('HAP-NodeJS:EventedHTTPServer');
-const debugCon = createDebug('HAP-NodeJS:EventedHTTPServer:Connection');
-const debugEvents = createDebug('HAP-NodeJS:EventEmitter');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HAPConnection = exports.HAPConnectionEvent = exports.HAPConnectionState = exports.EventedHTTPServer = exports.EventedHTTPServerEvent = exports.HAPEncryption = void 0;
+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
  */
-export class HAPEncryption {
+class HAPEncryption {
     clientPublicKey;
     secretKey;
     publicKey;
@@ -38,17 +41,17 @@ export class HAPEncryption {
         this.controllerToAccessoryKey = Buffer.alloc(0);
     }
 }
+exports.HAPEncryption = HAPEncryption;
 /**
  * @group HAP Accessory Server
  */
-// eslint-disable-next-line no-restricted-syntax
-export var EventedHTTPServerEvent;
+var EventedHTTPServerEvent;
 (function (EventedHTTPServerEvent) {
     EventedHTTPServerEvent["LISTENING"] = "listening";
     EventedHTTPServerEvent["CONNECTION_OPENED"] = "connection-opened";
     EventedHTTPServerEvent["REQUEST"] = "request";
     EventedHTTPServerEvent["CONNECTION_CLOSED"] = "connection-closed";
-})(EventedHTTPServerEvent || (EventedHTTPServerEvent = {}));
+})(EventedHTTPServerEvent || (exports.EventedHTTPServerEvent = EventedHTTPServerEvent = {}));
 /**
  * EventedHTTPServer provides an HTTP-like server that supports HAP "extensions" for security and events.
  *
@@ -68,8 +71,8 @@ export var EventedHTTPServerEvent;
  *
  * @group HAP Accessory Server
  */
-// eslint-disable-next-line ts/no-unsafe-declaration-merging
-export class EventedHTTPServer extends EventEmitter {
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+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;
@@ -86,20 +89,20 @@ export class EventedHTTPServer extends EventEmitter {
     connectionLoggingInterval;
     constructor() {
         super();
-        this.tcpServer = createServer();
+        this.tcpServer = net_1.default.createServer();
     }
     scheduleNextConnectionIdleTimeout() {
         this.connectionIdleTimeout = undefined;
         if (!this.tcpServer.listening) {
             return;
         }
-        debug('Running idle timeout timer...');
+        debug("Running idle timeout timer...");
         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`);
+                debug("[%s] Closing connection as it was inactive for " + timeDelta + "ms");
                 connection.close();
             }
             else {
@@ -116,17 +119,17 @@ export class EventedHTTPServer extends EventEmitter {
     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);
+            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);
+                    .join(", ");
+                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));
+        this.tcpServer.on("connection", this.onConnection.bind(this));
     }
     stop() {
         if (this.connectionLoggingInterval != null) {
@@ -155,28 +158,27 @@ export class EventedHTTPServer extends EventEmitter {
      * @param value - The newly set value of the characteristic.
      * @param originator - If specified, the connection will not get an event message.
      * @param immediateDelivery - The HAP spec requires some characteristics to be delivery immediately.
-     * Namely, for the {@link Characteristic.ButtonEvent} and the {@link Characteristic.ProgrammableSwitchEvent} characteristics.
+     *   Namely, for the {@link Characteristic.ButtonEvent} and the {@link Characteristic.ProgrammableSwitchEvent} characteristics.
      */
     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}`);
+                debug("[%s] Muting event '%s' notification for this connection since it originated here.", connection.remoteAddress, aid + "." + iid);
                 continue;
             }
             connection.sendEvent(aid, iid, value, immediateDelivery);
         }
     }
     onConnection(socket) {
-        /* eslint-disable ts/no-use-before-define */
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
         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));
-        /* eslint-enable ts/no-use-before-define */
         this.connections.add(connection);
-        debug('[%s] New connection from client on interface %s (%s)', connection.remoteAddress, connection.networkInterface, connection.localAddress);
+        debug("[%s] New connection from client on interface %s (%s)", connection.remoteAddress, connection.networkInterface, connection.localAddress);
         this.emit("connection-opened" /* EventedHTTPServerEvent.CONNECTION_OPENED */, connection);
         if (this.connections.size >= EventedHTTPServer.CONNECTION_TIMEOUT_LIMIT && !this.connectionIdleTimeout) {
             this.scheduleNextConnectionIdleTimeout();
@@ -226,12 +228,12 @@ export class EventedHTTPServer extends EventEmitter {
         }
     }
 }
+exports.EventedHTTPServer = EventedHTTPServer;
 /**
  * @private
  * @group HAP Accessory Server
  */
-// eslint-disable-next-line no-restricted-syntax
-export var HAPConnectionState;
+var HAPConnectionState;
 (function (HAPConnectionState) {
     HAPConnectionState[HAPConnectionState["CONNECTING"] = 0] = "CONNECTING";
     HAPConnectionState[HAPConnectionState["FULLY_SET_UP"] = 1] = "FULLY_SET_UP";
@@ -241,25 +243,24 @@ export var HAPConnectionState;
     HAPConnectionState[HAPConnectionState["TO_BE_TEARED_DOWN"] = 3] = "TO_BE_TEARED_DOWN";
     HAPConnectionState[HAPConnectionState["CLOSING"] = 4] = "CLOSING";
     HAPConnectionState[HAPConnectionState["CLOSED"] = 5] = "CLOSED";
-})(HAPConnectionState || (HAPConnectionState = {}));
+})(HAPConnectionState || (exports.HAPConnectionState = HAPConnectionState = {}));
 /**
  * @group HAP Accessory Server
  */
-// eslint-disable-next-line no-restricted-syntax
-export var HAPConnectionEvent;
+var HAPConnectionEvent;
 (function (HAPConnectionEvent) {
     HAPConnectionEvent["REQUEST"] = "request";
     HAPConnectionEvent["AUTHENTICATED"] = "authenticated";
     HAPConnectionEvent["CLOSED"] = "closed";
-})(HAPConnectionEvent || (HAPConnectionEvent = {}));
+})(HAPConnectionEvent || (exports.HAPConnectionEvent = HAPConnectionEvent = {}));
 /**
  * Manages a single iOS-initiated HTTP connection during its lifetime.
  * @group HAP Accessory Server
  */
-// eslint-disable-next-line ts/no-unsafe-declaration-merging
-export class HAPConnection extends EventEmitter {
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+class HAPConnection extends events_1.EventEmitter {
     /**
-     * @private
+     * @private file-private API
      */
     server;
     sessionID; // uuid unique to every HAP connection
@@ -293,53 +294,58 @@ export class HAPConnection extends EventEmitter {
     constructor(server, clientSocket) {
         super();
         this.server = server;
-        this.sessionID = generate(`${clientSocket.remoteAddress}:${clientSocket.remotePort}`);
+        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.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.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 = createHttpServer();
+        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.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 = getOSLoopbackAddressIfAvailable());
+        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]; // eslint-disable-line unicorn/error-message
+        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';
-        debugEvents(`[${this.remoteAddress}] ${registration ? 'Registered' : 'Unregistered'} event '${String(event).toUpperCase()}' ${tabs1}(total: ${eventCount}${!registration ? ` Before: ${beforeCount}` : ''}) ${tabs2}${stackTrace}`);
+        const tabs1 = event === "authenticated" /* HAPConnectionEvent.AUTHENTICATED */ ? "\t" : "\t\t";
+        const tabs2 = !registration ? "\t" : "\t\t";
+        // eslint-disable-next-line max-len
+        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
     on(event, listener) {
         const result = super.on(event, listener);
         this.debugListenerRegistration(event);
         return result;
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     addListener(event, listener) {
         const result = super.addListener(event, listener);
         this.debugListenerRegistration(event);
         return result;
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     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
     off(event, listener) {
         const result = super.off(event, listener);
         const beforeCount = this.listeners(event).length;
@@ -380,17 +386,17 @@ export class HAPConnection extends EventEmitter {
         }
     }
     sendEvent(aid, iid, value, immediateDelivery) {
-        assert(aid != null, 'HAPConnection.sendEvent: aid must be defined!');
-        assert(iid != null, 'HAPConnection.sendEvent: iid must be defined!');
-        const eventName = `${aid}.${iid}`;
+        (0, assert_1.default)(aid != null, "HAPConnection.sendEvent: aid must be defined!");
+        (0, assert_1.default)(iid != null, "HAPConnection.sendEvent: iid must be defined!");
+        const eventName = aid + "." + iid;
         if (!this.registeredEvents.has(eventName)) {
             // non verified connections can't register events, so this case is covered!
             return;
         }
         const event = {
-            aid,
-            iid,
-            value,
+            aid: aid,
+            iid: iid,
+            value: value,
         };
         if (immediateDelivery) {
             // some characteristics are required to deliver notifications immediately
@@ -444,7 +450,7 @@ export class HAPConnection extends EventEmitter {
             characteristics: [],
         };
         for (const queuedEvent of this.queuedEvents) {
-            if (!this.registeredEvents.has(`${queuedEvent.aid}.${queuedEvent.iid}`)) {
+            if (!this.registeredEvents.has(queuedEvent.aid + "." + queuedEvent.iid)) {
                 continue; // client unregistered that event in the meantime
             }
             eventData.characteristics.push(queuedEvent);
@@ -461,27 +467,27 @@ export class HAPConnection extends EventEmitter {
      * @param notification - The event which should be sent out
      */
     writeEventNotification(notification) {
-        debugCon('[%s] Sending HAP event notifications %o', this.remoteAddress, notification.characteristics);
-        assert(!this.handlingRequest, 'Can\'t write event notifications while handling a request!');
+        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();
-        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');
+        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");
         const buffer = Buffer.concat([header, dataBuffer]);
         this.tcpSocket.write(this.encrypt(buffer), this.handleTCPSocketWriteFulfilled.bind(this));
     }
     enableEventNotifications(aid, iid) {
-        this.registeredEvents.add(`${aid}.${iid}`);
+        this.registeredEvents.add(aid + "." + iid);
     }
     disableEventNotifications(aid, iid) {
-        this.registeredEvents.delete(`${aid}.${iid}`);
+        this.registeredEvents.delete(aid + "." + iid);
     }
     hasEventNotifications(aid, iid) {
-        return this.registeredEvents.has(`${aid}.${iid}`);
+        return this.registeredEvents.has(aid + "." + iid);
     }
     getRegisteredEvents() {
         return this.registeredEvents;
@@ -495,37 +501,37 @@ export class HAPConnection extends EventEmitter {
         // Since all communication calls are asynchronous, we could easily receive this 'encrypt' event for those bytes.
         // So we want to make sure that we aren't encrypting data until we have *received* some encrypted data from the client first.
         if (this.encryption && this.encryption.accessoryToControllerKey.length > 0 && this.encryption.controllerToAccessoryCount > 0) {
-            return layerEncrypt(data, this.encryption);
+            return hapCrypto.layerEncrypt(data, this.encryption);
         }
         return data; // otherwise, we don't encrypt and return plaintext
     }
     decrypt(data) {
         if (this.encryption && this.encryption.controllerToAccessoryKey.length > 0) {
             // below call may throw an error if decryption failed
-            return layerDecrypt(data, this.encryption);
+            return hapCrypto.layerDecrypt(data, this.encryption);
         }
         return data; // otherwise, we don't decrypt and return plaintext
     }
     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;
+        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));
+        debugCon("[%s] Internal HTTP server listening on %s:%s", this.remoteAddress, addressString, addressInfo.port);
+        this.internalHttpServer.on("close", this.onHttpServerClose.bind(this));
         // now we can establish a connection to this running HTTP server for proxying data
-        this.httpSocket = createConnection(this.internalHttpServerPort, this.internalHttpServerAddress); // previously we used addressInfo.address
+        this.httpSocket = net_1.default.createConnection(this.internalHttpServerPort, this.internalHttpServerAddress); // previously we used addressInfo.address
         this.httpSocket.setNoDelay(true); // disable Nagle algorithm
-        this.httpSocket.on('data', this.handleHttpServerResponse.bind(this));
+        this.httpSocket.on("data", this.handleHttpServerResponse.bind(this));
         // 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', () => {
+        this.httpSocket.on("error", this.onHttpSocketError.bind(this));
+        this.httpSocket.on("close", this.onHttpSocketClose.bind(this));
+        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);
+            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);
@@ -548,7 +554,7 @@ export class HAPConnection extends EventEmitter {
             data = this.decrypt(data);
         }
         catch (error) { // decryption and/or verification failed, disconnect the client
-            debugCon('[%s] Error occurred trying to decrypt incoming packet: %s', this.remoteAddress, error.message);
+            debugCon("[%s] Error occurred trying to decrypt incoming packet: %s", this.remoteAddress, error.message);
             this.close();
             return;
         }
@@ -569,7 +575,7 @@ export class HAPConnection extends EventEmitter {
             // don't accept data of a connection which is about to be closed or already closed
             return;
         }
-        debugCon('[%s] HTTP request: %s', this.remoteAddress, request.url);
+        debugCon("[%s] HTTP request: %s", this.remoteAddress, request.url);
         request.socket.setNoDelay(true);
         this.emit("request" /* HAPConnectionEvent.REQUEST */, request, response);
     }
@@ -581,7 +587,7 @@ export class HAPConnection extends EventEmitter {
     handleHttpServerResponse(data) {
         data = this.encrypt(data);
         this.tcpSocket.write(data, this.handleTCPSocketWriteFulfilled.bind(this));
-        debugCon('[%s] HTTP Response is finished', this.remoteAddress);
+        debugCon("[%s] HTTP Response is finished", this.remoteAddress);
         this.handlingRequest = false;
         if (this.state === 3 /* HAPConnectionState.TO_BE_TEARED_DOWN */) {
             setTimeout(() => this.close(), 10);
@@ -598,12 +604,12 @@ export class HAPConnection extends EventEmitter {
         this.lastSocketOperation = new Date().getTime();
     }
     onTCPSocketError(err) {
-        debugCon('[%s] Client connection error: %s', this.remoteAddress, err.message);
+        debugCon("[%s] Client connection error: %s", this.remoteAddress, err.message);
         // onTCPSocketClose will be called next
     }
     onTCPSocketClose() {
         this.state = 5 /* HAPConnectionState.CLOSED */;
-        debugCon('[%s] Client connection closed', this.remoteAddress);
+        debugCon("[%s] Client connection closed", this.remoteAddress);
         if (this.httpSocket) {
             this.httpSocket.destroy();
         }
@@ -612,43 +618,43 @@ export class HAPConnection extends EventEmitter {
         this.removeAllListeners(); // cleanup listeners, we are officially dead now
     }
     onHttpServerError(err) {
-        debugCon('[%s] HTTP server error: %s', this.remoteAddress, err.message);
-        if (err.code === 'EADDRINUSE') {
+        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 = getOSLoopbackAddressIfAvailable());
+            this.internalHttpServer.listen(0, this.internalHttpServerAddress = (0, net_utils_1.getOSLoopbackAddressIfAvailable)());
         }
     }
     onHttpServerClose() {
-        debugCon('[%s] HTTP server was closed', this.remoteAddress);
+        debugCon("[%s] HTTP server was closed", this.remoteAddress);
         // make sure the iOS side is closed as well
         this.close();
     }
     onHttpSocketError(err) {
-        debugCon('[%s] HTTP connection error: ', this.remoteAddress, err.message);
+        debugCon("[%s] HTTP connection error: ", this.remoteAddress, err.message);
         // onHttpSocketClose will be called next
     }
     onHttpSocketClose() {
-        debugCon('[%s] HTTP connection was closed', this.remoteAddress);
+        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();
     }
     getLocalAddress(ipVersion) {
-        const interfaceDetails = networkInterfaces()[this.networkInterface];
+        const interfaceDetails = os_1.default.networkInterfaces()[this.networkInterface];
         if (!interfaceDetails) {
-            throw new Error(`Could not find ${ipVersion} address for interface ${this.networkInterface}`);
+            throw new Error("Could not find " + ipVersion + " address for interface " + this.networkInterface);
         }
         // Find our first local IPv4 address.
-        if (ipVersion === 'ipv4') {
-            const ipv4Info = interfaceDetails.find(info => info.family === 'IPv4');
+        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}.`);
+            throw new Error("Could not find " + ipVersion + " address for interface " + this.networkInterface + ".");
         }
         let localUniqueAddress;
-        for (const v6entry of interfaceDetails.filter(entry => entry.family === 'IPv6')) {
+        for (const v6entry of interfaceDetails.filter(entry => entry.family === "IPv6")) {
             if (!v6entry.scopeid) {
                 return v6entry.address;
             }
@@ -657,26 +663,26 @@ export class HAPConnection extends EventEmitter {
         if (localUniqueAddress) {
             return localUniqueAddress;
         }
-        throw new Error(`Could not find ${ipVersion} address for interface ${this.networkInterface}`);
+        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 = networkInterfaces();
+        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';
+        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, '');
+        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(/^::/, '');
+            localAddress = localAddress.replace(/^::/, "");
         }
         // Handle link-local IPv6 addresses.
-        localAddress = localAddress.split('%')[0];
+        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)) {
@@ -684,16 +690,17 @@ export class HAPConnection extends EventEmitter {
             }
         }
         // 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 = isIPv4(localAddress) ? 'IPv4' : 'IPv6';
+        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 && getNetAddress(localAddress, entry.netmask) === getNetAddress(entry.address, entry.netmask))) {
+            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;
             }
         }
-        // eslint-disable-next-line no-console
-        console.log(`WARNING: unable to determine which interface to use for socket coming from ${socket.remoteAddress}:${socket.remotePort} to ${socket.localAddress}.`);
+        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