pubface 1.0.0

package/.eslintrc

@@ -0,0 +1,17 @@
+{
+    "rules": {
+        "indent": 0,
+        "no-await-in-loop": 0,
+        "require-atomic-updates": 0
+    },
+    "globals": {
+        "BigInt": true
+    },
+    "extends": ["nodemailer", "prettier"],
+    "parser": "@babel/eslint-parser",
+    "parserOptions": {
+        "ecmaVersion": 2018,
+        "sourceType": "script"
+    },
+    "plugins": ["@babel"]
+}

package/.prettierrc.js

@@ -0,0 +1,8 @@
+module.exports = {
+    printWidth: 160,
+    tabWidth: 4,
+    singleQuote: true,
+    endOfLine: 'lf',
+    trailingComma: 'none',
+    arrowParens: 'avoid'
+};

package/LICENSE.txt

@@ -0,0 +1,16 @@
+Copyright (c) 2020-2021 Postal Systems OÜ
+
+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 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,66 @@
+# pubface
+
+Detect public network interfaces for current machine.
+
+### Usage as a module
+
+Install the dependency
+
+```
+$ npm install pubface
+```
+
+Use it to get an array of interfaces
+
+```js
+const { resolvePublicInterfaces } = require('pubface');
+...
+let interfaces = await resolvePublicInterfaces();
+console.log(interfaces);
+```
+
+### Usage as a command
+
+Install the command
+
+```
+$ npm install -g pubface
+```
+
+Use it to get an array of interfaces
+
+```
+$ pubface
+```
+
+### Output
+
+Output is an array of interfaces:
+
+```
+[
+  {
+    "localAddress": "192.168.3.4",
+    "ip": "1.2.3.4",
+    "name": "ec2-1-2-3-4.eu-central-1.compute.amazonaws.com",
+    "family": "IPv4",
+    "defaultInterface": true
+  },
+  {
+    "localAddress": "10.240.128.227",
+    "ip": "101.102.103.104",
+    "name": "104-103-102-101.sta.estpak.ee",
+    "family": "IPv4"
+  }
+]
+```
+
+-   **localAddress** is the local IP address
+-   **ip** is the public IP address that servers see as your IP address when you make a connection
+-   **name** is the reverse record for **ip**
+-   **family** is either _IPv4_ or _IPv6_ depending on the **ip**
+-   **defaultInterface** is a boolean that indicates if this is the default interface used when making connections and not specifying a local address
+
+## License
+
+**MIT**

package/bin/pubface.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const { resolvePublicInterfaces } = require('../index.js');
+resolvePublicInterfaces()
+    .then(results => {
+        console.log(JSON.stringify(results, false, 2));
+        process.exit(0);
+    })
+    .catch(err => {
+        console.error(err);
+        process.exit(1);
+    });

package/index.js

@@ -0,0 +1,215 @@
+'use strict';
+
+const fetch = require('nodemailer/lib/fetch');
+const packageData = require('./package.json');
+const dns = require('dns').promises;
+const os = require('os');
+const net = require('net');
+
+const RESOLV_URL = process.env.RESOLV_URL || 'https://api.nodemailer.com/';
+const RESOLV_TIMEOUT = Number(process.env.RESOLV_TIMEOUT) || 5;
+
+const RESOLV_TIMEOUT_SEC = RESOLV_TIMEOUT * 1000;
+const DNS_CACHE = {};
+
+async function updateDns() {
+    let now = new Date();
+
+    let url = new URL(RESOLV_URL);
+    if (net.isIPv4(url.hostname)) {
+        DNS_CACHE.AAAA = false;
+        DNS_CACHE.A = {
+            host: url.hostname,
+            expires: new Date(Date.now() + 10 * 60 * 1000)
+        };
+        return;
+    }
+
+    if (net.isIPv6(url.hostname)) {
+        DNS_CACHE.A = false;
+        DNS_CACHE.AAAA = {
+            host: url.hostname,
+            expires: new Date(Date.now() + 10 * 60 * 1000)
+        };
+        return;
+    }
+
+    let shouldCheckIPv4 = !DNS_CACHE.A || !DNS_CACHE.A.expires || !DNS_CACHE.A.expires < now;
+    let shouldCheckIPv6 = !DNS_CACHE.AAAA || !DNS_CACHE.AAAA.expires || !DNS_CACHE.AAAA.expires < now;
+
+    if (shouldCheckIPv4) {
+        try {
+            let results = await dns.resolve4(url.hostname);
+            if (results && results.length) {
+                DNS_CACHE.A = {
+                    host: results[0],
+                    expires: new Date(Date.now() + 10 * 60 * 1000)
+                };
+            }
+        } catch (err) {
+            if (!DNS_CACHE.A) {
+                DNS_CACHE.A = {};
+            }
+            DNS_CACHE.A.error = err;
+        }
+    }
+
+    if (shouldCheckIPv6) {
+        try {
+            let results = await dns.resolve6(url.hostname);
+            if (results && results.length) {
+                DNS_CACHE.AAAA = {
+                    host: results[0],
+                    expires: new Date(Date.now() + 10 * 60 * 1000)
+                };
+            }
+        } catch (err) {
+            if (!DNS_CACHE.AAAA) {
+                DNS_CACHE.AAAA = {};
+            }
+            DNS_CACHE.AAAA.error = err;
+        }
+    }
+}
+
+function getPublicInterfaces() {
+    let interfaces = os.networkInterfaces();
+    let publicInterfaces = { IPv4: [], IPv6: [] };
+    Object.keys(interfaces)
+        .flatMap(iface => interfaces[iface].filter(entry => !entry.internal).map(entry => Object.assign({ iface }, entry)))
+        .forEach(entry => {
+            if (Array.isArray(publicInterfaces[entry.family])) {
+                publicInterfaces[entry.family].push(entry);
+            }
+        });
+    return publicInterfaces;
+}
+
+async function timedFunction(prom, timeout, localAddress) {
+    return new Promise((resolve, reject) => {
+        setTimeout(() => {
+            let err = new Error('Resolving requested resource timed out');
+            if (localAddress) {
+                err._source = localAddress;
+            }
+            reject(err);
+        }, timeout).unref();
+        prom.then(resolve).catch(reject);
+    });
+}
+
+async function resolveIP(localAddress, family) {
+    let data = await new Promise((resolve, reject) => {
+        let req = fetch(RESOLV_URL, {
+            userAgent: `${packageData.name}/${packageData.version}`,
+            tls: {
+                host: DNS_CACHE[family] && DNS_CACHE[family].host,
+                rejectUnauthorized: false,
+                localAddress
+            }
+        });
+
+        let buf = [];
+        req.on('readable', () => {
+            let chunk;
+            while ((chunk = req.read()) !== null) {
+                buf.push(chunk);
+            }
+        });
+
+        req.on('error', err => {
+            reject(err);
+        });
+
+        req.on('end', () => {
+            try {
+                let data = JSON.parse(Buffer.concat(buf).toString());
+                resolve(data);
+            } catch (err) {
+                reject(err);
+            }
+        });
+    });
+
+    if (!data || !data.ip) {
+        throw new Error('No response from IP server');
+    }
+
+    try {
+        let name = await dns.reverse(data.ip);
+        if (name && name.length) {
+            data.name = name[0];
+        }
+    } catch (err) {
+        // can ignore this
+    }
+
+    return Object.assign({ localAddress }, data);
+}
+
+async function resolvePublicInterfaces() {
+    let interfaces = getPublicInterfaces();
+    let promises = [];
+
+    // update resolver IP4/6 addresses
+    await updateDns();
+
+    if (DNS_CACHE.A && DNS_CACHE.A.host) {
+        // default
+        promises.push(timedFunction(resolveIP(false, 'A'), RESOLV_TIMEOUT_SEC, false));
+        interfaces.IPv4.forEach(iface => {
+            promises.push(timedFunction(resolveIP(iface.address, 'A'), RESOLV_TIMEOUT_SEC, iface.address));
+        });
+    }
+
+    if (DNS_CACHE.AAAA && DNS_CACHE.AAAA.host) {
+        promises.push(timedFunction(resolveIP(false, 'AAAA'), RESOLV_TIMEOUT_SEC, false));
+        interfaces.IPv6.forEach(iface => {
+            promises.push(timedFunction(resolveIP(iface.address, 'AAAA'), RESOLV_TIMEOUT_SEC, iface.address));
+        });
+    }
+
+    let defaults = {};
+    let results = (await Promise.allSettled(promises))
+        .filter(entry => entry.status === 'fulfilled')
+        .map(entry => Object.assign(entry.value, { family: net.isIPv6(entry.value.ip || entry.value.localAddress) ? 'IPv6' : 'IPv4' }))
+        .filter(entry => {
+            if (!entry.localAddress) {
+                defaults[entry.family] = entry;
+                return false;
+            }
+            return true;
+        });
+
+    results.forEach(entry => {
+        if (defaults[entry.family] && defaults[entry.family].ip === entry.ip) {
+            entry.defaultInterface = true;
+            defaults[entry.family] = false;
+        }
+    });
+
+    if (defaults.IPv4) {
+        results.push(Object.assign(defaults.IPv4, { defaultInterface: true }));
+    }
+
+    if (defaults.IPv6) {
+        results.push(Object.assign(defaults.IPv6, { defaultInterface: true }));
+    }
+
+    results = results.sort((a, b) => {
+        if (a.family !== b.family) {
+            return a.family.localeCompare(b.family);
+        }
+        if (a.defaultInterface) {
+            return -1;
+        }
+        if (b.defaultInterface) {
+            return 1;
+        }
+        return (a.name || a.ip).localeCompare(b.name || b.ip);
+    });
+
+    return results;
+}
+
+module.exports = { resolvePublicInterfaces };

package/package.json

@@ -0,0 +1,18 @@
+{
+    "name": "pubface",
+    "version": "1.0.0",
+    "description": "Resolve public network interfaces for current machine",
+    "main": "index.js",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "keywords": [],
+    "author": "Postal Systems OÜ",
+    "license": "MIT",
+    "bin": {
+        "pubface": "bin/pubface.js"
+    },
+    "dependencies": {
+        "nodemailer": "6.7.1"
+    }
+}