nat-upnp-rejetto 2.0.1

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/nat-upnp-ts.iml" filepath="$PROJECT_DIR$/.idea/nat-upnp-ts.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/nat-upnp-ts.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/vcs.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GitSharedSettings">
+    <option name="FORCE_PUSH_PROHIBITED_PATTERNS">
+      <list />
+    </option>
+  </component>
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Kaden Sharpin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,51 @@
+# UPnP TS
+
+Port mapping via UPnP APIs
+
+## Installation
+
+```bash
+npm i nat-upnp-ts
+OR
+npm i git+https://github.com/kaden-sharpin/nat-upnp-ts.git
+```
+
+## Usage
+
+```javascript
+// using ES modules
+import { Client } from "nat-upnp-ts";
+const client = new Client();
+
+// using node require
+const upnp = require("nat-upnp-ts");
+const client = new upnp.Client();
+
+client
+  .createMapping({
+    public: 12345,
+    private: 54321,
+    ttl: 10,
+  })
+  .then(() => {
+    // Will be called once finished
+  })
+  .catch(() => {
+    // Will be called on error
+  });
+
+async () => {
+  await client.removeMapping({
+    public: 12345,
+  });
+};
+
+client.getMappings();
+
+client.getMappings({
+  local: true,
+  description: "both of these fields are optional",
+});
+
+client.getPublicIp();
+```

package/build/src/index.d.ts

@@ -0,0 +1,27 @@
+import { Device as impDevice } from "./nat-upnp-ts/device";
+import { Client as impClient } from "./nat-upnp-ts/client";
+import { Ssdp as impSsdp } from "./nat-upnp-ts/ssdp";
+declare namespace natupnp {
+    const Ssdp: typeof impSsdp;
+    const Device: typeof impDevice;
+    const Client: typeof impClient;
+}
+export { Device } from "./nat-upnp-ts/device";
+export type { Service, RawService, RawDevice } from "./nat-upnp-ts/device";
+export { Ssdp } from "./nat-upnp-ts/ssdp";
+export type { SearchCallback, ISsdp, SsdpEmitter } from "./nat-upnp-ts/ssdp";
+export { Client } from "./nat-upnp-ts/client";
+export type { GetMappingOpts, Mapping, DeletePortMappingOpts, NewPortMappingOpts, StandardOpts, } from "./nat-upnp-ts/client";
+export default natupnp;
+/**
+ * Raw SSDP/UPNP repsonse
+ * Entire SSDP/UPNP schema is beyond the scope of these typings.
+ * Please look up the protol documentation if you wanna do
+ * lower level communication.
+ */
+export type RawResponse = Partial<Record<string, {
+    "@": {
+        "xmlns:u": string;
+    };
+    [key: string]: unknown;
+}>>;

package/build/src/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = exports.Ssdp = exports.Device = void 0;
+const device_1 = require("./nat-upnp-ts/device");
+const client_1 = require("./nat-upnp-ts/client");
+const ssdp_1 = require("./nat-upnp-ts/ssdp");
+var natupnp;
+(function (natupnp) {
+    natupnp.Ssdp = ssdp_1.Ssdp;
+    natupnp.Device = device_1.Device;
+    natupnp.Client = client_1.Client;
+})(natupnp || (natupnp = {}));
+var device_2 = require("./nat-upnp-ts/device");
+Object.defineProperty(exports, "Device", { enumerable: true, get: function () { return device_2.Device; } });
+var ssdp_2 = require("./nat-upnp-ts/ssdp");
+Object.defineProperty(exports, "Ssdp", { enumerable: true, get: function () { return ssdp_2.Ssdp; } });
+var client_2 = require("./nat-upnp-ts/client");
+Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_2.Client; } });
+exports.default = natupnp;

package/build/src/nat-upnp-ts/client.d.ts

@@ -0,0 +1,93 @@
+import { RawResponse } from "../index";
+import Device from "./device";
+import Ssdp from "./ssdp";
+export declare class Client implements IClient {
+    readonly timeout: number;
+    readonly ssdp: Ssdp;
+    constructor(options?: {
+        timeout?: number;
+    });
+    createMapping(options: NewPortMappingOpts): Promise<RawResponse>;
+    removeMapping(options: DeletePortMappingOpts): Promise<RawResponse>;
+    getMappings(options?: GetMappingOpts): Promise<Mapping[]>;
+    getPublicIp(): Promise<string>;
+    getGateway(): Promise<{
+        gateway: Device;
+        address: string;
+    }>;
+    close(): void;
+}
+export default Client;
+export interface Mapping {
+    public: {
+        host: string;
+        port: number;
+    };
+    private: {
+        host: string;
+        port: number;
+    };
+    protocol: string;
+    enabled: boolean;
+    description: string;
+    ttl: number;
+    local: boolean;
+}
+/**
+ * Standard options that many options use.
+ */
+export interface StandardOpts {
+    public?: number | {
+        port?: number;
+        host?: string;
+    };
+    private?: number | {
+        port?: number;
+        host?: string;
+    };
+    protocol?: string;
+}
+export interface NewPortMappingOpts extends StandardOpts {
+    description?: string;
+    ttl?: number;
+}
+export type DeletePortMappingOpts = StandardOpts;
+export interface GetMappingOpts {
+    local?: boolean;
+    description?: RegExp | string;
+}
+/**
+ * Main client interface.
+ */
+export interface IClient {
+    /**
+     * Create a new port mapping
+     * @param options Options for the new port mapping
+     */
+    createMapping(options: NewPortMappingOpts): Promise<RawResponse>;
+    /**
+     * Remove a port mapping
+     * @param options Specify which port mapping to remove
+     */
+    removeMapping(options: DeletePortMappingOpts): Promise<RawResponse>;
+    /**
+     * Get a list of existing mappings
+     * @param options Filter mappings based on these options
+     */
+    getMappings(options?: GetMappingOpts): Promise<Mapping[]>;
+    /**
+     * Fetch the external/public IP from the gateway
+     */
+    getPublicIp(): Promise<string>;
+    /**
+     * Get the gateway device for communication
+     */
+    getGateway(): Promise<{
+        gateway: Device;
+        address: string;
+    }>;
+    /**
+     * Close the underlaying sockets and resources
+     */
+    close(): void;
+}

package/build/src/nat-upnp-ts/client.js

@@ -0,0 +1,164 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const device_1 = __importDefault(require("./device"));
+const ssdp_1 = __importDefault(require("./ssdp"));
+class Client {
+    constructor(options = {}) {
+        this.ssdp = new ssdp_1.default();
+        this.timeout = options.timeout || 1800;
+    }
+    createMapping(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getGateway().then(({ gateway, address }) => {
+                var _a;
+                const ports = normalizeOptions(options);
+                return gateway.run("AddPortMapping", [
+                    ["NewRemoteHost", ports.remote.host + ""],
+                    ["NewExternalPort", ports.remote.port + ""],
+                    [
+                        "NewProtocol",
+                        options.protocol ? options.protocol.toUpperCase() : "TCP",
+                    ],
+                    ["NewInternalPort", ports.internal.port + ""],
+                    ["NewInternalClient", ports.internal.host || address],
+                    ["NewEnabled", 1],
+                    ["NewPortMappingDescription", options.description || "node:nat:upnp"],
+                    ["NewLeaseDuration", (_a = options.ttl) !== null && _a !== void 0 ? _a : 60 * 30],
+                ]);
+            });
+        });
+    }
+    removeMapping(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getGateway().then(({ gateway }) => {
+                const ports = normalizeOptions(options);
+                return gateway.run("DeletePortMapping", [
+                    ["NewRemoteHost", ports.remote.host + ""],
+                    ["NewExternalPort", ports.remote.port + ""],
+                    [
+                        "NewProtocol",
+                        options.protocol ? options.protocol.toUpperCase() : "TCP",
+                    ],
+                ]);
+            });
+        });
+    }
+    getMappings(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { gateway, address } = yield this.getGateway();
+            let i = 0;
+            const results = [];
+            while (true) {
+                const data = yield gateway.run("GetGenericPortMappingEntry", [["NewPortMappingIndex", i++]])
+                    .catch(() => { });
+                if (!data)
+                    break; // finished
+                const key = Object.keys(data).find((k) => k.startsWith('GetGenericPortMappingEntryResponse'));
+                if (!key) {
+                    throw new Error("Incorrect response");
+                }
+                const res = data[key];
+                const result = {
+                    public: {
+                        host: res.NewRemoteHost || "",
+                        port: Number(res.NewExternalPort),
+                    },
+                    private: {
+                        host: res.NewInternalClient,
+                        port: Number(res.NewInternalPort),
+                    },
+                    protocol: res.NewProtocol.toLowerCase(),
+                    enabled: res.NewEnabled == 1,
+                    description: res.NewPortMappingDescription,
+                    ttl: Number(res.NewLeaseDuration),
+                    // temporary, so typescript will compile
+                    local: false,
+                };
+                result.local = result.private.host === address;
+                if (options.local && !result.local) {
+                    continue;
+                }
+                if (options.description) {
+                    if (typeof result.description !== "string")
+                        continue;
+                    if (options.description instanceof RegExp) {
+                        if (!options.description.test(result.description))
+                            continue;
+                    }
+                    else {
+                        if (result.description.indexOf(options.description) === -1)
+                            continue;
+                    }
+                }
+                results.push(result);
+            }
+            return results;
+        });
+    }
+    getPublicIp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getGateway().then(({ gateway, address }) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const data = yield gateway.run("GetExternalIPAddress", []);
+                const key = Object.keys(data || {}).find((k) => /^GetExternalIPAddressResponse$/.test(k));
+                if (!key)
+                    throw new Error("Incorrect response");
+                return ((_a = data[key]) === null || _a === void 0 ? void 0 : _a.NewExternalIPAddress) + "";
+            }));
+        });
+    }
+    getGateway() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let timeouted = false;
+            const p = this.ssdp.search("urn:schemas-upnp-org:device:InternetGatewayDevice:1");
+            return new Promise((s, r) => {
+                const timeout = setTimeout(() => {
+                    timeouted = true;
+                    p.emit("end");
+                    r(new Error("Connection timed out while searching for the gateway."));
+                }, this.timeout);
+                p.on("device", (info, address) => {
+                    if (timeouted)
+                        return;
+                    p.emit("end");
+                    clearTimeout(timeout);
+                    // Create gateway
+                    s({ gateway: new device_1.default(info.location), address });
+                });
+            });
+        });
+    }
+    close() {
+        this.ssdp.close();
+    }
+}
+exports.Client = Client;
+function normalizeOptions(options) {
+    function toObject(addr) {
+        if (typeof addr === "number")
+            return { port: addr };
+        if (typeof addr === "string" && !isNaN(addr))
+            return { port: Number(addr) };
+        if (typeof addr === "object")
+            return addr;
+        return {};
+    }
+    return {
+        remote: toObject(options.public),
+        internal: toObject(options.private),
+    };
+}
+exports.default = Client;

package/build/src/nat-upnp-ts/device.d.ts

@@ -0,0 +1,77 @@
+import { RawResponse } from "../index";
+export declare class Device implements IDevice {
+    readonly description: string;
+    readonly services: string[];
+    constructor(url: string);
+    private getXML;
+    getService(types: string[]): Promise<{
+        service: string;
+        SCPDURL: string;
+        controlURL: string;
+    }>;
+    run(action: string, args: (string | number)[][]): Promise<RawResponse>;
+    parseDescription(info: {
+        device?: RawDevice;
+    }): {
+        services: RawService[];
+        devices: RawDevice[];
+    };
+}
+export default Device;
+export interface Service {
+    service: string;
+    SCPDURL: string;
+    controlURL: string;
+}
+export interface RawService {
+    serviceType: string;
+    serviceId: string;
+    controlURL?: string;
+    eventSubURL?: string;
+    SCPDURL?: string;
+}
+export interface RawDevice {
+    deviceType: string;
+    presentationURL: string;
+    friendlyName: string;
+    manufacturer: string;
+    manufacturerURL: string;
+    modelDescription: string;
+    modelName: string;
+    modelNumber: string;
+    modelURL: string;
+    serialNumber: string;
+    UDN: string;
+    UPC: string;
+    serviceList?: {
+        service: RawService | RawService[];
+    };
+    deviceList?: {
+        device: RawDevice | RawDevice[];
+    };
+}
+export interface IDevice {
+    /**
+     * Get the available services on the network device
+     * @param types List of service types to look for
+     */
+    getService(types: string[]): Promise<Service>;
+    /**
+     * Parse out available services
+     * and devices from a root device
+     * @param info
+     * @returns the available devices and services in array form
+     */
+    parseDescription(info: {
+        device?: RawDevice;
+    }): {
+        services: RawService[];
+        devices: RawDevice[];
+    };
+    /**
+     * Perform a SSDP/UPNP request
+     * @param action the action to perform
+     * @param kvpairs arguments of said action
+     */
+    run(action: string, kvpairs: (string | number)[][]): Promise<RawResponse>;
+}

package/build/src/nat-upnp-ts/device.js

@@ -0,0 +1,120 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Device = void 0;
+const node_http_1 = __importDefault(require("node:http"));
+const node_https_1 = __importDefault(require("node:https"));
+const consumers_1 = require("node:stream/consumers");
+const url_1 = require("url");
+const fast_xml_parser_1 = require("fast-xml-parser");
+class Device {
+    constructor(url) {
+        this.description = url;
+        this.services = [
+            "urn:schemas-upnp-org:service:WANIPConnection:1",
+            "urn:schemas-upnp-org:service:WANIPConnection:2",
+            "urn:schemas-upnp-org:service:WANPPPConnection:1",
+        ];
+    }
+    getXML(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return httpRequest(url).then(consumers_1.text).then(data => new fast_xml_parser_1.XMLParser().parse(data))
+                .catch(() => new Error("Failed to lookup device description"));
+        });
+    }
+    getService(types) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getXML(this.description).then(({ root: xml }) => {
+                const services = this.parseDescription(xml).services.filter(({ serviceType }) => types.includes(serviceType));
+                if (services.length === 0 ||
+                    !services[0].controlURL ||
+                    !services[0].SCPDURL) {
+                    throw new Error("Service not found");
+                }
+                const baseUrl = new url_1.URL(xml.baseURL, this.description);
+                const prefix = (url) => new url_1.URL(url, baseUrl.toString()).toString();
+                return {
+                    service: services[0].serviceType,
+                    SCPDURL: prefix(services[0].SCPDURL),
+                    controlURL: prefix(services[0].controlURL),
+                };
+            });
+        });
+    }
+    run(action, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const info = yield this.getService(this.services);
+            const body = '<?xml version="1.0"?>' +
+                "<s:Envelope " +
+                'xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" ' +
+                's:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">' +
+                "<s:Body>" +
+                "<u:" +
+                action +
+                " xmlns:u=" +
+                JSON.stringify(info.service) +
+                ">" +
+                args.reduce((p, [a, b]) => p + `<${a !== null && a !== void 0 ? a : ""}>${b !== null && b !== void 0 ? b : ""}</${a !== null && a !== void 0 ? a : ""}>`, "") +
+                "</u:" +
+                action +
+                ">" +
+                "</s:Body>" +
+                "</s:Envelope>";
+            return httpRequest(info.controlURL, {
+                method: 'post',
+                headers: {
+                    "Content-Type": 'text/xml; charset="utf-8"',
+                    "Content-Length": "" + Buffer.byteLength(body),
+                    Connection: "close",
+                    SOAPAction: JSON.stringify(info.service + "#" + action),
+                },
+            }, body)
+                .then(consumers_1.text).then(data => new fast_xml_parser_1.XMLParser({ removeNSPrefix: true }).parse(data).Envelope.Body);
+        });
+    }
+    parseDescription(info) {
+        const services = [];
+        const devices = [];
+        function traverseDevices(device) {
+            var _a, _b, _c, _d;
+            if (!device)
+                return;
+            const serviceList = (_b = (_a = device.serviceList) === null || _a === void 0 ? void 0 : _a.service) !== null && _b !== void 0 ? _b : [];
+            const deviceList = (_d = (_c = device.deviceList) === null || _c === void 0 ? void 0 : _c.device) !== null && _d !== void 0 ? _d : [];
+            devices.push(device);
+            if (Array.isArray(serviceList)) {
+                services.push(...serviceList);
+            }
+            else {
+                services.push(serviceList);
+            }
+            if (Array.isArray(deviceList)) {
+                deviceList.forEach(traverseDevices);
+            }
+            else {
+                traverseDevices(deviceList);
+            }
+        }
+        traverseDevices(info.device);
+        return {
+            services,
+            devices,
+        };
+    }
+}
+exports.Device = Device;
+exports.default = Device;
+function httpRequest(url, options = {}, body = '') {
+    return new Promise((resolve, reject) => (url.startsWith('https:') ? node_https_1.default : node_http_1.default).request(url, options, (res) => __awaiter(this, void 0, void 0, function* () { return !res.statusCode || res.statusCode >= 400 ? reject(res) : resolve(res); })).on('error', reject).end(body));
+}

package/build/src/nat-upnp-ts/ssdp.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="node" />
+import EventEmitter from "events";
+export declare class Ssdp implements ISsdp {
+    private options?;
+    private sourcePort;
+    private bound;
+    private boundCount;
+    private closed;
+    private readonly queue;
+    private readonly multicast;
+    private readonly port;
+    private readonly sockets;
+    private readonly ssdpEmitter;
+    constructor(options?: {
+        sourcePort?: number | undefined;
+    } | undefined);
+    private createSocket;
+    private parseResponse;
+    search(device: string, emitter?: SsdpEmitter): SsdpEmitter;
+    close(): void;
+}
+export default Ssdp;
+type SearchArgs = [Record<string, string>, string];
+export type SearchCallback = (...args: SearchArgs) => void;
+type SearchEvent = <E extends Events>(ev: E, ...args: E extends "device" ? SearchArgs : []) => boolean;
+type Events = "device" | "end";
+type Event<E extends Events> = E extends "device" ? SearchCallback : () => void;
+type EventListener<T> = <E extends Events>(ev: E, callback: Event<E>) => T;
+export interface SsdpEmitter extends EventEmitter {
+    removeListener: EventListener<this>;
+    addListener: EventListener<this>;
+    once: EventListener<this>;
+    on: EventListener<this>;
+    emit: SearchEvent;
+    _ended?: boolean;
+}
+export interface ISsdp {
+    /**
+     * Search for a SSDP compatible server on the network
+     * @param device Search Type (ST) header, specifying which device to search for
+     * @param emitter An existing EventEmitter to emit event on
+     * @returns The event emitter provided in Promise, or a newly instantiated one.
+     */
+    search(device: string, emitter?: SsdpEmitter): SsdpEmitter;
+    /**
+     * Close all sockets
+     */
+    close(): void;
+}

package/build/src/nat-upnp-ts/ssdp.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ssdp = void 0;
+const dgram_1 = __importDefault(require("dgram"));
+const os_1 = __importDefault(require("os"));
+const events_1 = __importDefault(require("events"));
+class Ssdp {
+    constructor(options) {
+        var _a;
+        this.options = options;
+        this.sourcePort = ((_a = this.options) === null || _a === void 0 ? void 0 : _a.sourcePort) || 0;
+        this.bound = false;
+        this.boundCount = 0;
+        this.closed = false;
+        this.queue = [];
+        this.multicast = "239.255.255.250";
+        this.port = 1900;
+        this.ssdpEmitter = new events_1.default();
+        // Create sockets on all external interfaces
+        const interfaces = os_1.default.networkInterfaces();
+        this.sockets = Object.keys(interfaces).reduce((arr, key) => {
+            var _a, _b;
+            return arr.concat((_b = (_a = interfaces[key]) === null || _a === void 0 ? void 0 : _a.filter((item) => !item.internal).map((item) => this.createSocket(item))) !== null && _b !== void 0 ? _b : []);
+        }, []);
+    }
+    createSocket(iface) {
+        const socket = dgram_1.default.createSocket(iface.family === "IPv4" ? "udp4" : "udp6");
+        socket.on("message", (message) => {
+            // Ignore messages after closing sockets
+            if (this.closed)
+                return;
+            // Parse response
+            this.parseResponse(message.toString(), socket.address);
+        });
+        // Bind in next tick (sockets should be me in this.sockets array)
+        process.nextTick(() => {
+            // Unqueue this._queue once all sockets are ready
+            const onready = () => {
+                if (this.boundCount < this.sockets.length)
+                    return;
+                this.bound = true;
+                this.queue.forEach(([device, emitter]) => this.search(device, emitter));
+            };
+            socket.on("listening", () => {
+                this.boundCount += 1;
+                onready();
+            });
+            // On error - remove socket from list and execute items from queue
+            socket.once("error", () => {
+                socket.close();
+                this.sockets.splice(this.sockets.indexOf(socket), 1);
+                onready();
+            });
+            socket.address = iface.address;
+            socket.bind(this.sourcePort, iface.address);
+        });
+        return socket;
+    }
+    parseResponse(response, addr) {
+        // Ignore incorrect packets
+        if (!/^(HTTP|NOTIFY)/m.test(response))
+            return;
+        const headers = parseMimeHeader(response);
+        // We are only interested in messages that can be matched against the original
+        // search target
+        if (!headers.st)
+            return;
+        this.ssdpEmitter.emit("device", headers, addr);
+    }
+    search(device, emitter) {
+        if (!emitter) {
+            emitter = new events_1.default();
+            emitter._ended = false;
+            emitter.once("end", () => {
+                emitter._ended = true;
+            });
+        }
+        if (!this.bound) {
+            this.queue.push([device, emitter]);
+            return emitter;
+        }
+        const query = Buffer.from("M-SEARCH * HTTP/1.1\r\n" +
+            "HOST: " +
+            this.multicast +
+            ":" +
+            this.port +
+            "\r\n" +
+            'MAN: "ssdp:discover"\r\n' +
+            "MX: 1\r\n" +
+            "ST: " +
+            device +
+            "\r\n" +
+            "\r\n");
+        // Send query on each socket
+        this.sockets.forEach((socket) => socket.send(query, 0, query.length, this.port, this.multicast));
+        const ondevice = (headers, address) => {
+            if (!emitter || emitter._ended || headers.st !== device)
+                return;
+            emitter.emit("device", headers, address);
+        };
+        this.ssdpEmitter.on("device", ondevice);
+        // Detach listener after receiving 'end' event
+        emitter.once("end", () => this.ssdpEmitter.removeListener("device", ondevice));
+        return emitter;
+    }
+    close() {
+        this.sockets.forEach((socket) => socket.close());
+        this.closed = true;
+    }
+}
+exports.Ssdp = Ssdp;
+function parseMimeHeader(headerStr) {
+    const lines = headerStr.split(/\r\n/g);
+    // Parse headers from lines to hashmap
+    return lines.reduce((headers, line) => {
+        var _a;
+        const [_, key, value] = (_a = line.match(/^([^:]*)\s*:\s*(.*)$/)) !== null && _a !== void 0 ? _a : [];
+        if (key && value) {
+            headers[key.toLowerCase()] = value;
+        }
+        return headers;
+    }, {});
+}
+exports.default = Ssdp;

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "nat-upnp-rejetto",
+  "version": "2.0.1",
+  "main": "build/src/index",
+  "author": "Fedor Indutny <fedor@indutny.com>, SimplyLinn <https://github.com/SimplyLinn>, Kaden Sharpin <http://github.com/kaden-sharpin>, Massimo Melina <a@rejetto.com>",
+  "homepage": "https://github.com/kaden-sharpin/nat-upnp-ts",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/rejetto/nat-upnp-ts.git"
+  },
+  "devDependencies": {
+    "@types/node": "^17.0.6",
+    "typescript": "^4.5.4"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "test": "node ./build/test/index.test.js"
+  },
+  "dependencies": {
+    "fast-xml-parser": "^4.0.0-beta.8"
+  }
+}