hfs 3.1.4 → 3.2.0-alpha1.1

package/plugins/antibrute/plugin.js

@@ -1,4 +1,4 @@
-exports.version = 3.1
+exports.version = 3.2
 exports.description = "Introduce increasing delays between login attempts."
 exports.apiRequired = 9.6 // addBlock
 
@@ -8,42 +8,173 @@ exports.config = {
     blockAfter: { type: 'number', xs: 6, min: 1, max: 9999, defaultValue: 100, label: "Block IP after", unit: "attempts", helperText: "localhost excluded" },
     blockForHours: { type: 'number', xs: 6, min: 0, defaultValue: 24, label: "Block for", unit: "hours" },
     exclude: { type: 'string', defaultValue: '', label: "Exclude IPs", helperText: "Net mask syntax" },
+    maxQueuePerIp: { type: 'number', min: 1, max: 9999, defaultValue: 32, label: "Max queued per IP" },
+    maxQueuePerAccount: { type: 'number', min: 1, max: 9999, defaultValue: 16, label: "Max queued per account" },
+    maxQueueGlobal: { type: 'number', min: 1, max: 999999, defaultValue: 512, label: "Max queued globally" },
 }
 exports.configDialog = {
     maxWidth: 'xs',
 }
 
 const byIp = {}
+const byAccount = {}
+const laneByIp = {}
+const laneByAccount = {}
+const UNKNOWN_ACCOUNT = 'unknown\t'
 
 exports.init = api => {
     const { isLocalHost, HOUR, netMatches } = api.misc
+    const { makeQ } = api.require('./makeQ')
+    const gateQ = makeQ(1)
+    let waitingGlobal = 0
+    const QUEUE_FULL = Symbol('queue_full')
     api.events.multi({
-        async attemptingLogin({ ctx }) {
+        async attemptingLogin({ ctx, username }) {
             const { ip } = ctx
-            const now = new Date
-            const rec = byIp[ip] ||= { attempts: 0, next: now }
-            const max = api.getConfig('max') * 1000
-            const delay = Math.min(max, 1000 * api.getConfig('increment') * ++rec.attempts)
-            const wait = rec.next - now
-            rec.next = new Date(+rec.next + delay)
-            if (rec.attempts > api.getConfig('blockAfter') && !isLocalHost(ctx) && !isExcluded(ip)) {
-                const hours = api.getConfig('blockForHours')
-                api.addBlock({ ip, comment: "From antibrute plugin", expire: hours ? new Date(now.getTime() + hours * HOUR) : undefined })
+            const account = getAccountKey(username)
+            const ipRec = getRecord(byIp, ip)
+            const accountRec = getRecord(byAccount, account)
+            let admitted = false
+            try {
+                await runGate(() => {
+                    if (ipRec.waiting >= api.getConfig('maxQueuePerIp')
+                    || accountRec.waiting >= api.getConfig('maxQueuePerAccount')
+                    || waitingGlobal >= api.getConfig('maxQueueGlobal'))
+                        throw QUEUE_FULL
+                    // reserve all buckets atomically so we never exceed limits due to parallel requests
+                    ipRec.waiting++
+                    accountRec.waiting++
+                    waitingGlobal++
+                    admitted = true
+                })
+                // serialize waits per ip and per account so parallel bursts can't consume the same penalty window
+                await runInLane(getLane(laneByIp, ip), () =>
+                    runInLane(getLane(laneByAccount, account), async () => {
+                        const now = Date.now()
+                        const wait = Math.max(0, ipRec.next - now, accountRec.next - now)
+                        if (wait <= 0) return
+                        api.log('delaying', ip, 'for', Math.round(wait / 1000))
+                        ctx.set('x-anti-brute-force', wait)
+                        await new Promise(resolve => setTimeout(resolve, wait))
+                    }))
+            }
+            catch (e) {
+                if (e === QUEUE_FULL) {
+                    ctx.status = 429
+                        return api.events.stop
+                }
+                throw e
             }
-            clearTimeout(rec.timer)
-            if (wait > 0) {
-                api.log('delaying', ip, 'for', Math.round(wait / 1000))
-                ctx.set('x-anti-brute-force', wait)
-                await new Promise(resolve => setTimeout(resolve, wait))
+            finally {
+                if (admitted) {
+                    ipRec.waiting--
+                    accountRec.waiting--
+                    waitingGlobal--
+                }
+                armCleanup(byIp, ip, ipRec)
+                armCleanup(byAccount, account, accountRec)
+                dropLaneIfIdle(laneByIp, ip)
+                dropLaneIfIdle(laneByAccount, account)
             }
-            rec.timer = setTimeout(() => delete byIp[ip], 24 * HOUR) // no memory leak
+        },
+        failedLogin({ ctx, username }) {
+            const { ip } = ctx
+            const account = getAccountKey(username)
+            const now = Date.now()
+            const ipRec = getRecord(byIp, ip)
+            const accountRec = getRecord(byAccount, account)
+            const ipAttempts = increasePenalty(ipRec, now)
+            increasePenalty(accountRec, now)
+            if (ipAttempts > api.getConfig('blockAfter') && !isLocalHost(ctx) && !isExcluded(ip)) {
+                const hours = api.getConfig('blockForHours')
+                api.addBlock({ ip, comment: "From antibrute plugin", expire: hours ? new Date(now + hours * HOUR) : undefined })
+            }
+            armCleanup(byIp, ip, ipRec)
+            armCleanup(byAccount, account, accountRec)
+            dropLaneIfIdle(laneByIp, ip)
+            dropLaneIfIdle(laneByAccount, account)
         },
         login(ctx) {
-            if (ctx.state.account)
-                delete byIp[ctx.ip] // reset if login was successful
+            if (ctx.state.account) {
+                const { ip } = ctx
+                const account = getAccountKey(ctx.state.account.username)
+                resetRecord(byIp, ip)
+                resetRecord(byAccount, account)
+                dropLaneIfIdle(laneByIp, ip)
+                dropLaneIfIdle(laneByAccount, account)
+            }
         }
     })
 
+    function getRecord(container, key) {
+        return container[key] ||= { failures: 0, next: 0, waiting: 0 }
+    }
+
+    function increasePenalty(rec, now) {
+        const attempts = ++rec.failures
+        const max = api.getConfig('max') * 1000
+        const delay = Math.min(max, attempts * api.getConfig('increment') * 1000)
+        rec.next = Math.max(now, rec.next) + delay
+        return attempts
+    }
+
+    function armCleanup(records, key, rec) {
+        clearTimeout(rec.timer)
+        rec.timer = setTimeout(() => {
+            // keep records while there are in-flight admissions, otherwise later releases may touch deleted state
+            if (rec.waiting)
+                return armCleanup(records, key, rec)
+            delete records[key]
+        }, 24 * HOUR) // no memory leak
+    }
+
+    function runGate(job) {
+        return new Promise((resolve, reject) => {
+            gateQ.add(async () => {
+                try { resolve(await job()) }
+                catch (e) { reject(e) }
+            })
+        })
+    }
+
+    function getLane(container, key) {
+        return container[key] ||= makeQ(1)
+    }
+
+    function runInLane(q, job) {
+        return new Promise((resolve, reject) => {
+            q.add(async () => {
+                try { resolve(await job()) }
+                catch (e) { reject(e) }
+            })
+        })
+    }
+
+    function dropLaneIfIdle(container, key) {
+        const q = container[key]
+        if (q?.isWorking() || q?.queueSize()) return
+        delete container[key]
+    }
+
+    function resetRecord(container, key) {
+        const rec = container[key]
+        if (!rec) return
+        if (rec.waiting) {
+            // successful login must clear penalties without dropping admission counters still needed by concurrent requests
+            rec.failures = 0
+            rec.next = 0
+            return
+        }
+        delete container[key]
+    }
+
+    function getAccountKey(username) {
+        // fold unknown usernames together to avoid unbounded memory growth from random names
+        if (!username || !api.getAccount(String(username)))
+            return UNKNOWN_ACCOUNT
+        return String(username).toLowerCase()
+    }
+
     function isExcluded(ip) {
         const mask = api.getConfig('exclude')
         if (!mask) return false

package/plugins/list-uploader/public/main.js

@@ -6,7 +6,7 @@
         HFS.h(Uploader, entry))
 
     function Uploader({ uri }) {
-        const { data } = HFS.useBatch(getDetails, uri)
+        const { data } = HFS.useBatch(getDetails, uri, { depend: HFS.state.isAdmin })
         const text = React.useMemo(() => {
             if (!data || data === true) return ''
             const { upload: x } = data

package/src/acme.js

@@ -32,17 +32,21 @@ const acmeMiddleware = (ctx, next) => {
         return next();
 };
 exports.acmeMiddleware = acmeMiddleware;
-const TEMP_MAP = { private: 80, public: { host: '', port: 80 }, description: 'hfs temporary', ttl: 5000 }; // from my tests (zyxel VMG8825), lower values won't make a working mapping
+const TEMP_MAP = (0, nat_1.upnpMappingParam)(80, 80, 'hfs temporary', 5000); // from my tests (zyxel VMG8825), lower values won't make a working mapping
+// remove temporary port mapping, if any is left from previous execution
 (0, misc_1.repeat)(misc_1.MINUTE, async (stop) => {
-    await nat_1.upnpClient.getGateway(); // without this, the next call will break upnp support
-    const res = await nat_1.upnpClient.getMappings();
+    if (!await nat_1.upnpEnabled.getWhenReady())
+        return stop();
+    const client = (0, nat_1.getUpnpClient)();
+    await client.getGateway(); // without this, the next call will break upnp support
+    const res = await client.getMappings();
     const leftover = res.find(x => x.description === TEMP_MAP.description); // in case the process is interrupted
     if (!leftover)
         return void stop(); // we are good
     if (acmeOngoing)
         return; // it doesn't count, as we are in the middle of something. Retry later
     stop();
-    return nat_1.upnpClient.removeMapping(TEMP_MAP);
+    return client.removeMapping(TEMP_MAP);
 });
 async function generateSSLCert(domain, email, altNames) {
     // will answer the challenge through our koa app (if on port 80) or must we spawn a dedicated server?
@@ -63,7 +67,7 @@ async function generateSSLCert(domain, email, altNames) {
         let check = await (0, selfCheck_1.selfCheck)(checkUrl); // some check services may not consider the domain, but we already verified that
         if (check?.success === false && nat.upnp && !nat.mapped80) {
             console.debug("Setting temporary port forward");
-            tempMap = await (0, misc_1.haveTimeout)(10_000, nat_1.upnpClient.createMapping(TEMP_MAP).catch(() => { })).catch(() => { });
+            tempMap = await (0, misc_1.haveTimeout)(10_000, (0, nat_1.getUpnpClient)().createMapping(TEMP_MAP)).catch(() => { });
             check = await (0, selfCheck_1.selfCheck)(checkUrl); // repeat test
         }
         //if (!check) throw new ApiError(HTTP_FAILED_DEPENDENCY, "couldn't test port 80")
@@ -88,9 +92,9 @@ async function generateSSLCert(domain, email, altNames) {
         return { key, cert };
     }
     finally {
-        if (tempMap) {
+        if (tempMap && nat_1.upnpEnabled.get()) {
             console.debug("Removing temporary port forward");
-            nat_1.upnpClient.removeMapping(TEMP_MAP).catch(() => { }); // clean after ourselves
+            (0, nat_1.getUpnpClient)().removeMapping(TEMP_MAP).catch(() => { }); // clean after ourselves
         }
         acmeOngoing = false;
         if (tempSrv)

package/src/api.accounts.js

@@ -16,9 +16,9 @@ function prepareAccount(ac) {
         ...lodash_1.default.omit(ac, ['password', 'hashed_password', 'srp']),
         username: ac.username, // omit won't copy it because it's a hidden prop
         hasPassword: (0, perm_1.accountHasPassword)(ac),
-        isGroup: !ac.plugin?.auth && !(0, perm_1.accountHasPassword)(ac),
+        isGroup: !(0, perm_1.accountHasLoginMethod)(ac),
         adminActualAccess: (0, perm_1.accountCanLoginAdmin)(ac),
-        canLogin: (0, perm_1.accountHasPassword)(ac) ? (0, perm_1.accountCanLogin)(ac) : undefined,
+        canLogin: (0, perm_1.accountHasLoginMethod)(ac) ? (0, perm_1.accountCanLogin)(ac) : undefined,
         canChangePassword: (0, perm_1.accountCanChangePassword)(ac),
         invalidated: auth_1.invalidateSessionBefore.get(ac.username),
         directMembers: Object.values(perm_1.accounts.get()).filter(a => a.belongs?.includes(ac.username)).map(x => x.username),
@@ -33,7 +33,7 @@ function prepareAccount(ac) {
         })
     };
 }
-const ALLOWED_KEYS = ['admin', 'allow_net', 'belongs', 'days_to_live', 'disable_password_change',
+const ALLOWED_KEYS = ['admin', 'allow_net', 'auto_login_net', 'belongs', 'days_to_live', 'disable_password_change',
     'disabled', 'expire', 'ignore_limits', 'notes', 'password', 'redirect', 'require_password_change', 'username'];
 exports.default = {
     get_usernames() {

package/src/api.auth.js

@@ -18,10 +18,12 @@ const ongoingLogins = {}; // store data that doesn't fit session object
 const keepSessionAlive = (0, config_1.defineConfig)('keep_session_alive', true);
 const refresh_session = async ({}, ctx) => {
     const username = (0, auth_1.getCurrentUsername)(ctx);
+    const isAdmin = (0, adminApis_1.ctxAdminAccess)(ctx) || undefined;
     return !ctx.session ? new apiMiddleware_1.ApiError(const_1.HTTP_SERVER_ERROR) : {
         username,
         expandedUsername: Array.from((0, perm_1.expandUsername)(username)),
-        adminUrl: (0, adminApis_1.ctxAdminAccess)(ctx) ? ctx.state.revProxyPath + const_1.ADMIN_URI : undefined,
+        isAdmin,
+        adminUrl: isAdmin && ctx.state.revProxyPath + const_1.ADMIN_URI,
         canChangePassword: (0, perm_1.accountCanChangePassword)(ctx.state.account),
         requireChangePassword: ctx.state.account?.require_password_change,
         exp: username && keepSessionAlive.get() ? new Date(Date.now() + middlewares_1.sessionDuration.compiled()) : undefined,

package/src/api.get_file_list.js

@@ -44,7 +44,7 @@ const get_file_list = async ({ uri = '/', offset, limit, c, onlyFolders, onlyFil
     limit = Number(limit);
     const { filterName, filterComment, fileMask, depth } = paramsToFilter(rest);
     const walker = (0, vfs_1.walkNode)(node, { ctx: admin ? undefined : ctx, onlyFolders, onlyFiles, depth });
-    const onDirEntryHandlers = (0, plugins_1.mapPlugins)(plug => plug.onDirEntry);
+    const onDirEntryHandlers = (0, plugins_1.mapPlugins)((plug, id) => plug.onDirEntry && { id, cb: plug.onDirEntry });
     const can_upload = admin || (0, vfs_1.hasPermission)(node, 'can_upload', ctx);
     const can_delete = admin || (0, vfs_1.hasPermission)(node, 'can_delete', ctx);
     const fakeChild = await (0, vfs_1.applyParentToChild)({ source: 'dummy-file', original: undefined }, node); // used to check permission; simple but can produce false results; 'original' to simulate a non-vfs node
@@ -74,7 +74,7 @@ const get_file_list = async ({ uri = '/', offset, limit, c, onlyFolders, onlyFil
     async function* produceEntries() {
         for await (const sub of walker) {
             let name = (0, vfs_1.getNodeName)(sub);
-            name = (0, path_1.basename)(name) || name; // on windows, basename('C:') === ''
+            name = (0, path_1.basename)(name) || name; // on Windows, basename('C:') === ''
             if (filterName && !filterName(name) || fileMask && !(0, vfs_1.nodeIsFolder)(sub) && !fileMask(name)
                 || filterComment && !filterComment(await (0, comments_1.getCommentFor)(sub.source) || ''))
                 continue;
@@ -83,15 +83,15 @@ const get_file_list = async ({ uri = '/', offset, limit, c, onlyFolders, onlyFil
                 continue;
             const cbParams = { entry, ctx, listUri: uri, node: sub };
             try {
-                const res = await Promise.all(onDirEntryHandlers.map(cb => cb(cbParams)));
+                const res = await Promise.all(onDirEntryHandlers.map(({ id, cb }) => Promise.resolve().then(() => cb(cbParams)).catch(error => { throw { id, error }; })));
                 if (res.some(x => x === false))
                     continue;
-                if ((await events_1.default.emitAsync('dirEntry', cbParams))?.isDefaultPrevented())
-                    continue;
             }
             catch (e) {
-                console.warn("A plugin is causing problems on dirEntry:", e);
+                console.warn(`Plugin ${e?.id || '?'} is causing problems on onDirEntry:`, e?.error ?? e);
             }
+            if ((await events_1.default.emitAsync('dirEntry', cbParams))?.isDefaultPrevented())
+                continue;
             if (offset) {
                 --offset;
                 continue;
@@ -111,10 +111,14 @@ const get_file_list = async ({ uri = '/', offset, limit, c, onlyFolders, onlyFil
         const name = (0, vfs_1.getNodeName)(node);
         const isFolder = (0, vfs_1.nodeIsFolder)(node);
         try {
-            const st = source ? await (node.stats || (0, misc_1.statWithTimeout)(source).catch(e => {
-                if (!isFolder || !node.children?.length) // folders with virtual children, keep them
-                    throw e;
-            })) : undefined;
+            const [web, comment, st] = await Promise.all([
+                (0, vfs_1.hasDefaultFile)(node, ctx).then(x => x ? true : undefined),
+                node.comment ?? (0, comments_1.getCommentFor)(source),
+                (0, vfs_1.nodeStats)(node).catch(e => {
+                    if (!isFolder || !node.children?.length) // folders with virtual children, keep them
+                        throw e;
+                })
+            ]);
             // permissions of entries are sent as a difference with permissions of parent
             const pl = node.can_list === misc_1.WHO_NO_ONE ? 'l'
                 : !(0, vfs_1.hasPermission)(node, 'can_list', ctx) ? 'L'
@@ -136,9 +140,9 @@ const get_file_list = async ({ uri = '/', offset, limit, c, onlyFolders, onlyFil
                 url,
                 target: node.target,
                 order: node.order,
-                comment: node.comment ?? await (0, comments_1.getCommentFor)(source),
+                comment,
                 icon: getNodeIcon(node),
-                web: await (0, vfs_1.hasDefaultFile)(node, ctx) ? true : undefined,
+                web,
             };
         }
         catch {

package/src/api.monitor.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeConnection = serializeConnection;
+exports.inferOperation = inferOperation;
 const lodash_1 = __importDefault(require("lodash"));
 const connections_1 = require("./connections");
 const misc_1 = require("./misc");
@@ -11,6 +13,7 @@ const throttler_1 = require("./throttler");
 const auth_1 = require("./auth");
 const SendList_1 = require("./SendList");
 const persistence_1 = require("./persistence");
+const cross_1 = require("./cross");
 exports.default = {
     async disconnect({ ip, port, allButLocalhost }) {
         (0, misc_1.apiAssertTypes)({
@@ -28,25 +31,21 @@ exports.default = {
     get_connections({}, ctx) {
         const list = new SendList_1.SendListReadable({
             diff: true,
-            addAtStart: (0, connections_1.getConnections)().map(c => !ignore(c) && serializeConnection(c)).filter(Boolean),
+            addAtStart: (0, connections_1.getConnections)().map(serializeConnection),
         });
         list.props({ you: ctx.ip });
         return list.events(ctx, {
             connection(conn) {
-                if (ignore(conn))
-                    return;
                 list.add(serializeConnection(conn));
             },
             connectionClosed(conn) {
-                if (ignore(conn))
-                    return;
                 list.remove(getConnAddress(conn));
             },
             connectionNewIp(conn, oldIp, newIp) {
                 list.update(getConnAddress(conn, oldIp), { ip: newIp });
             },
             connectionUpdated(conn, change) {
-                if (conn.socket.closed || ignore(conn) || ignore(change) || lodash_1.default.isEmpty(change))
+                if (conn.socket.closed || lodash_1.default.isEmpty(change))
                     return;
                 if (change.ctx) {
                     Object.assign(change, fromCtx(change.ctx));
@@ -55,48 +54,16 @@ exports.default = {
                 list.update(getConnAddress(conn), change);
             },
         });
-        function serializeConnection(conn) {
-            const { socket, started, secure } = conn;
-            return {
-                ...getConnAddress(conn),
-                v: (socket.remoteFamily?.endsWith('6') ? 6 : 4),
-                got: socket.bytesRead,
-                sent: socket.bytesWritten,
-                country: conn.country,
-                started,
-                secure: (secure || undefined), // undefined will save some space once json-ed
-                ...fromCtx(conn.ctx),
-            };
-        }
-        function fromCtx(ctx) {
-            if (!ctx)
-                return;
-            const s = ctx.state; // short alias
-            return {
-                user: (0, auth_1.getCurrentUsername)(ctx),
-                agent: (0, misc_1.shortenAgent)(ctx.get('user-agent')),
-                archive: s.archive,
-                ...s.browsing ? { op: 'browsing', path: (0, misc_1.safeDecodeURIComponent)(s.browsing) }
-                    : s.uploadPath ? { op: 'upload', path: (0, misc_1.safeDecodeURIComponent)(s.uploadPath) }
-                        : {
-                            op: !s.considerAsGui && (ctx.state.archive || ctx.state.vfsNode) ? 'download' : undefined,
-                            path: (0, misc_1.safeDecodeURIComponent)(ctx.originalUrl),
-                        },
-                opProgress: lodash_1.default.isNumber(s.opProgress) ? lodash_1.default.round(s.opProgress, 3) : undefined,
-                opTotal: s.opTotal,
-                opOffset: s.opOffset,
-            };
-        }
     },
     async *get_connection_stats() {
         while (1) {
-            const filtered = (0, connections_1.getConnections)().filter(x => !ignore(x));
+            const connections = (0, connections_1.getConnections)();
             yield {
                 outSpeedKb: throttler_1.totalOutSpeedKb,
                 inSpeedKb: throttler_1.totalInSpeedKb,
                 sent_got: [throttler_1.totalSent.get(), throttler_1.totalGot.get(), totalGotSentResetTime.get()],
-                connections: filtered.length,
-                ips: lodash_1.default.uniqBy(filtered, x => x.ip).length,
+                connections: connections.length,
+                ips: (0, cross_1.countUniqueBy)(connections, conn => conn.ip),
             };
             await (0, misc_1.wait)(1000);
         }
@@ -108,8 +75,45 @@ exports.default = {
             void persistence_1.storedMap.del(x);
     },
 };
-function ignore(conn) {
-    return false; //conn.socket && isLocalHost(conn)
+function serializeConnection(conn) {
+    const { socket, started, secure } = conn;
+    return {
+        ...getConnAddress(conn),
+        v: (socket.remoteFamily?.endsWith('6') ? 6 : 4),
+        // connection fields are request-scoped once transfer tracking starts; socket counters cover earlier snapshots
+        got: conn.got || socket.bytesRead,
+        sent: conn.sent || socket.bytesWritten,
+        outSpeedKb: conn.outSpeedKb,
+        inSpeedKb: conn.inSpeedKb,
+        country: conn.country,
+        started,
+        secure: (secure || undefined), // undefined will save some space once json-ed
+        ...fromCtx(conn.ctx),
+    };
+}
+function fromCtx(ctx) {
+    if (!ctx)
+        return;
+    return {
+        user: (0, auth_1.getCurrentUsername)(ctx),
+        agent: (0, misc_1.shortenAgent)(ctx.get('user-agent')),
+        ...inferOperation(ctx)
+    };
+}
+function inferOperation(ctx) {
+    const s = ctx.state; // short alias
+    return {
+        archive: s.archive,
+        ...s.browsing ? { op: 'browsing', path: (0, misc_1.safeDecodeURIComponent)(s.browsing) }
+            : s.uploadPath ? { op: 'upload', path: (0, misc_1.safeDecodeURIComponent)(s.uploadPath) }
+                : {
+                    op: !s.considerAsGui && (ctx.state.archive || ctx.state.vfsNode) ? 'download' : undefined,
+                    path: (0, misc_1.safeDecodeURIComponent)(ctx.originalUrl),
+                },
+        opProgress: lodash_1.default.isNumber(s.opProgress) ? lodash_1.default.round(s.opProgress, 3) : undefined,
+        opTotal: s.opTotal,
+        opOffset: s.opOffset,
+    };
 }
 function getConnAddress(conn, overrideIp) {
     return {

package/src/api.net.js

@@ -52,16 +52,17 @@ exports.default = {
             return new apiMiddleware_1.ApiError(const_1.HTTP_FAILED_DEPENDENCY, "no internal port");
         if (externalPort)
             try {
-                await nat_1.upnpClient.removeMapping({ public: { host: '', port: externalPort } });
+                await (0, nat_1.getUpnpClient)().removeMapping({ public: { host: '', port: externalPort } });
             }
             catch (e) {
                 return new apiMiddleware_1.ApiError(const_1.HTTP_SERVER_ERROR, "removeMapping failed: " + String(e));
             }
-        if (external) // must use the object form of 'public' to work around a bug of the library
-            await nat_1.upnpClient.createMapping({ private: internal || internalPort, public: { host: '', port: external }, description: 'hfs', ttl: 0 })
+        if (external)
+            await (0, nat_1.getUpnpClient)().createMapping((0, nat_1.upnpMappingParam)(internal || internalPort, external))
                 .catch(res => {
                 throw new apiMiddleware_1.ApiError(res.errorCode || const_1.HTTP_SERVER_ERROR, res.errorCode === 718 ? "Port not available" : res.errorDescription || res.message || "unknown error");
             });
+        nat_1.mappedPort.set(external || 0); // remember only successful HFS mappings
         return {};
     },
     async self_check({ url }) {

package/src/api.vfs.js

@@ -225,7 +225,7 @@ exports.default = {
         for (const k of ['*', 'Directory']) {
             await (0, util_os_1.reg)('add', WINDOWS_REG_KEY.replace('*', k), '/ve', '/f', '/d', 'Add to HFS (new)');
             await (0, util_os_1.reg)('add', WINDOWS_REG_KEY.replace('*', k), '/v', 'icon', '/f', '/d', const_1.IS_BINARY ? process.execPath : const_1.APP_PATH + '\\hfs.ico');
-            await (0, util_os_1.reg)('add', WINDOWS_REG_KEY.replace('*', k) + '\\command', '/ve', '/f', '/d', `powershell -WindowStyle Hidden -Command "
+            await (0, util_os_1.reg)('add', WINDOWS_REG_KEY.replace('*', k) + '\\command', '/ve', '/f', '/d', `powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -WindowStyle Hidden -Command "
             [Net.ServicePointManager]::SecurityProtocol = [Net.ServicePointManager]::SecurityProtocol -bor [Net.SecurityProtocolType]::Tls12;
             $wsh = New-Object -ComObject Wscript.Shell;
             $j = @{parent=@'\n${parent}\n'@; source=@'\n%1\n'@} | ConvertTo-Json -Compress

package/src/commands.js

@@ -1,5 +1,38 @@
 "use strict";
 // This file is part of HFS - Copyright 2021-2023, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -17,7 +50,8 @@ const plugins_1 = require("./plugins");
 const fileAttr_1 = require("./fileAttr");
 const github_1 = require("./github");
 const cross_1 = require("./cross");
-const api_monitor_1 = __importDefault(require("./api.monitor"));
+const api_monitor_1 = __importStar(require("./api.monitor"));
+const connections_1 = require("./connections");
 const argv_1 = require("./argv");
 const listen_2 = require("./listen");
 let debugEnabled = argv_1.argv.debug || process.env.HFS_DEBUG || const_1.DEV;
@@ -191,11 +225,30 @@ const commands = {
         params: '',
         cb: fileAttr_1.purgeFileAttr,
     },
+    transfers: {
+        params: '',
+        cb() {
+            const transfers = (0, connections_1.getConnections)().map(api_monitor_1.serializeConnection).filter(x => x.op === 'upload' || x.op === 'download');
+            if (!transfers.length)
+                return console.log("No ongoing uploads/downloads");
+            console.table(transfers.map(x => ({
+                type: x.op,
+                progress: (0, cross_1.with_)(x.opProgress ?? x.opOffset, v => v == null ? '' : (0, cross_1.formatPerc)(v)),
+                transferred: (0, cross_1.formatBytes)(Math.max(x.sent || 0, x.got || 0)),
+                total: x.opTotal == null ? '' : (0, cross_1.formatBytes)(x.opTotal),
+                speed: (0, cross_1.formatSpeed)(Math.max(x.outSpeedKb || 0, x.inSpeedKb || 0) * 1000),
+                user: x.user,
+                path: x.path,
+            })));
+        }
+    },
     status: {
         params: '',
         async cb() {
             const ports = await (0, listen_2.getServerStatus)(false);
             console.log(lodash_1.default.map(ports, (x, k) => `${k.toUpperCase()} ${x.configuredPort < 0 ? "disabled" : x.listening ? `on port ${x.port}` : (x.error || "not working")}`).join(" – "));
+            const operations = lodash_1.default.countBy((0, connections_1.getConnections)(), x => x.ctx && (0, api_monitor_1.inferOperation)(x.ctx).op);
+            console.log(`Active downloads ↑ ${operations.download || 0} – uploads ↓ ${operations.upload || 0}`);
             const conn = (await api_monitor_1.default.get_connection_stats().next()).value;
             if (conn) {
                 const { sent_got: sg } = conn;