iobroker.javascript 9.0.9 → 9.0.11

package/build-backend/lib/protectFs.js

@@ -40,8 +40,11 @@ class ProtectFs {
     ioBrokerDataDir;
     promises;
     constants;
+    static log = null;
+    static staticIoBrokerDataDir = '';
     constructor(log, ioBrokerDataDir) {
         this.ioBrokerDataDir = ioBrokerDataDir;
+        ProtectFs.staticIoBrokerDataDir = ioBrokerDataDir;
         this.log = log || {
             silly: (message) => console.log(message),
             debug: (message) => console.debug(message),
@@ -50,114 +53,115 @@ class ProtectFs {
             error: (message) => console.error(message),
             level: 'info',
         };
+        ProtectFs.log = this.log;
         this.promises = {
             access: async (path, mode) => {
-                this.#checkProtected(path, true);
+                ProtectFs.checkProtected(path, true);
                 return nodeFS.promises.access(path, mode);
             },
             cp: async (source, destination, opts) => {
-                this.#checkProtected(source, false);
-                this.#checkProtected(destination, false);
+                ProtectFs.checkProtected(source, false);
+                ProtectFs.checkProtected(destination, false);
                 return nodeFS.promises.cp(source, destination, opts);
             },
             readFile: async (path, options) => {
-                this.#checkProtected(path, true);
+                ProtectFs.checkProtected(path, true);
                 return nodeFS.promises.readFile(path, options); // async function readFile(path, options) {
             },
             readlink: async (path, options) => {
-                this.#checkProtected(path, true);
+                ProtectFs.checkProtected(path, true);
                 return nodeFS.promises.readlink(path, options); // async function readlink(path, options) {
             },
             symlink: async (target, path, type) => {
-                this.#checkProtected(target, true);
-                this.#checkProtected(path, false);
+                ProtectFs.checkProtected(target, true);
+                ProtectFs.checkProtected(path, false);
                 return nodeFS.promises.symlink(target, path, type); // async function symlink(target, path, type_) {
             },
             writeFile: async (file, data, options) => {
-                this.#checkProtected(file, true);
+                ProtectFs.checkProtected(file, true);
                 return nodeFS.promises.writeFile.call(this, file, data, options); // async function writeFile(path, data, options) {
             },
             unlink: async (path) => {
-                this.#checkProtected(path, false);
+                ProtectFs.checkProtected(path, false);
                 return nodeFS.promises.unlink.call(this, path); // async function unlink(path) {
             },
             appendFile: async (path, data, options) => {
-                this.#checkProtected(path, false);
+                ProtectFs.checkProtected(path, false);
                 return nodeFS.promises.appendFile.call(this, path, data, options); // async function appendFile(path, data, options) {
             },
             chmod: async (path, mode) => {
-                this.#checkProtected(path, false);
+                ProtectFs.checkProtected(path, false);
                 return nodeFS.promises.chmod.call(this, path, mode); // async function chmod(path, mode) {
             },
             copyFile: async (src, dest, mode) => {
-                this.#checkProtected(src, false);
-                this.#checkProtected(dest, false);
+                ProtectFs.checkProtected(src, false);
+                ProtectFs.checkProtected(dest, false);
                 return nodeFS.promises.copyFile.call(this, src, dest, mode); // async function copyFile(src, dest, mode) {
             },
             rename: async (oldPath, newPath) => {
-                this.#checkProtected(oldPath, false);
-                this.#checkProtected(newPath, false);
+                ProtectFs.checkProtected(oldPath, false);
+                ProtectFs.checkProtected(newPath, false);
                 return nodeFS.promises.rename.call(this, oldPath, newPath); // async function rename(oldPath, newPath) {
             },
             open: async (path, flags, mode) => {
-                this.#checkProtected(path, true);
+                ProtectFs.checkProtected(path, true);
                 return nodeFS.promises.open.call(this, path, flags, mode); // async function open(path, flags, mode) {
             },
             truncate: async (path, len) => {
-                this.#checkProtected(path, false);
+                ProtectFs.checkProtected(path, false);
                 return nodeFS.promises.truncate.call(this, path, len); // async function truncate(path, len = 0) {
             },
             stat: async (path, opts) => {
-                this.#checkProtected(path, true);
+                ProtectFs.checkProtected(path, true);
                 const result = await nodeFS.promises.stat.call(this, path, opts); // async function stat(path, options = { bigint: false }) {
                 return result;
             },
             utimes: async (path, atime, mtime) => {
-                this.#checkProtected(path, false);
+                ProtectFs.checkProtected(path, false);
                 return nodeFS.promises.utimes.call(this, path, atime, mtime); // async function utimes(path, atime, mtime) {
             },
             readdir: async (path, options) => {
-                this.#checkProtected(path, true);
+                ProtectFs.checkProtected(path, true);
                 // @ts-expect-error fix later
                 return nodeFS.promises.readdir.call(this, path, options || { encoding: null, withFileTypes: true }); // async function readdir(path, options) {
             },
             lchmod: async (path, mode) => {
-                this.#checkProtected(path, false);
+                ProtectFs.checkProtected(path, false);
                 return nodeFS.promises.lchmod.call(this, path, mode); // async function lchmod(path, mode) {
             },
             lchown: async (path, uid, gid) => {
-                this.#checkProtected(path, false);
+                ProtectFs.checkProtected(path, false);
                 return nodeFS.promises.lchown.call(this, path, uid, gid); // async function lchown(path, uid, gid) {
             },
             link: async (existingPath, newPath) => {
-                this.#checkProtected(existingPath, false);
-                this.#checkProtected(newPath, false);
+                ProtectFs.checkProtected(existingPath, false);
+                ProtectFs.checkProtected(newPath, false);
                 return nodeFS.promises.link.call(this, existingPath, newPath); // async function link(existingPath, newPath) {
             },
             lstat: async (path, opts) => {
-                this.#checkProtected(path, true);
+                ProtectFs.checkProtected(path, true);
                 const res = await nodeFS.promises.lstat.call(this, path, opts); // async function lstat(path, options = { bigint: false }) {
                 return res;
             },
             lutimes: async (path, atime, mtime) => {
-                this.#checkProtected(path, false);
+                ProtectFs.checkProtected(path, false);
                 return nodeFS.promises.lutimes.call(this, path, atime, mtime); // async function lutimes(path, atime, mtime) {
             },
             mkdir: async (path, options) => {
-                this.#checkProtected(path, false);
+                ProtectFs.checkProtected(path, false);
                 return nodeFS.promises.mkdir.call(this, path, options); // async function mkdir(path, options) {
             },
             mkdtemp: async (prefix, options) => {
-                this.#checkProtected(prefix, false);
+                ProtectFs.checkProtected(prefix, false);
                 const tmp = await nodeFS.promises.mkdtemp.call(this, prefix, options); // async function mkdtemp(prefix, options) {
                 return tmp.toString();
             },
             rm: async (path, options) => {
-                this.#checkProtected(path, false);
+                ProtectFs.checkProtected(path, false);
                 return nodeFS.promises.rm.call(this, path, options); // async function rm(path, options) {
             },
             rmdir: async (path, options) => {
-                this.#checkProtected(path, false);
+                ProtectFs.checkProtected(path, false);
                 return nodeFS.promises.rmdir.call(this, path, options); // async function rmdir(path, options) {
             },
         };
@@ -183,35 +187,38 @@ class ProtectFs {
             }
         }
     }
-    #checkProtected(file, readOnly) {
+    static checkProtected(file, readOnly) {
         if (file.fd) {
             return;
         }
         const filePath = (0, node_path_1.normalize)(file.toString());
-        // todo: protect against file://...
         if (filePath.endsWith(`-data${node_path_1.sep}objects.json`) || filePath.endsWith(`-data${node_path_1.sep}objects.jsonl`)) {
-            this.log.error(`May not read ${file.toString()}`);
+            ProtectFs.log?.error(`May not read ${file.toString()}`);
             throw new Error('Permission denied');
         }
-        if (!readOnly && filePath.startsWith((0, node_path_1.join)(this.ioBrokerDataDir, 'files'))) {
-            this.log.error(`May not read ${file.toString()} - use writeFile instead`);
+        if (!readOnly && filePath.startsWith((0, node_path_1.join)(ProtectFs.staticIoBrokerDataDir, 'files'))) {
+            ProtectFs.log?.error(`May not read ${file.toString()} - use writeFile instead`);
+            throw new Error('Permission denied');
+        }
+        if (!readOnly && filePath.startsWith(`file://${(0, node_path_1.join)(ProtectFs.staticIoBrokerDataDir, 'files')}`)) {
+            ProtectFs.log?.error(`May not read ${file.toString()} - use writeFile instead`);
             throw new Error('Permission denied');
         }
     }
     access(path, mode, callback) {
-        this.#checkProtected(path, true);
+        ProtectFs.checkProtected(path, true);
         if (typeof callback === 'function') {
             return nodeFS.access(path, mode, callback);
         }
         return nodeFS.access(path, mode);
     }
     accessSync(path, mode) {
-        this.#checkProtected(path, true);
+        ProtectFs.checkProtected(path, true);
         return nodeFS.accessSync(path, mode);
     }
     cp(source, destination, opts, callback) {
-        this.#checkProtected(source, false);
-        this.#checkProtected(destination, false);
+        ProtectFs.checkProtected(source, false);
+        ProtectFs.checkProtected(destination, false);
         if (callback) {
             return nodeFS.cp(source, destination, opts, callback);
         }
@@ -221,13 +228,13 @@ class ProtectFs {
         return nodeFS.cp(source, destination, opts);
     }
     cpSync(source, destination, opts) {
-        this.#checkProtected(source, false);
-        this.#checkProtected(destination, false);
+        ProtectFs.checkProtected(source, false);
+        ProtectFs.checkProtected(destination, false);
         return nodeFS.cpSync.call(this, source, destination, opts);
     }
     readFile(path, options, callback) {
         if (typeof path !== 'number') {
-            this.#checkProtected(path, true);
+            ProtectFs.checkProtected(path, true);
         }
         if (typeof callback === 'function') {
             return nodeFS.readFile.call(this, path, options, 
@@ -238,12 +245,12 @@ class ProtectFs {
     }
     readFileSync(path, options) {
         if (typeof path !== 'number') {
-            this.#checkProtected(path, true);
+            ProtectFs.checkProtected(path, true);
         }
         return nodeFS.readFileSync.call(this, path, options);
     }
     readlink(path, options, callback) {
-        this.#checkProtected(path, true);
+        ProtectFs.checkProtected(path, true);
         if (typeof callback === 'function') {
             // @ts-expect-error should work
             return nodeFS.readlink.call(this, path, options, callback); //
@@ -251,12 +258,12 @@ class ProtectFs {
         return nodeFS.readlink.call(this, path, options);
     }
     readlinkSync(path, options) {
-        this.#checkProtected(path, true);
+        ProtectFs.checkProtected(path, true);
         return nodeFS.readlinkSync.call(this, path, options);
     }
     symlink(target, path, type, callback) {
-        this.#checkProtected(target, true);
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(target, true);
+        ProtectFs.checkProtected(path, false);
         if (typeof callback === 'function') {
             // @ts-expect-error should work
             return nodeFS.symlink.call(this, target, path, type, callback);
@@ -264,13 +271,13 @@ class ProtectFs {
         return nodeFS.symlink.call(this, target, path, type);
     }
     symlinkSync(target, path, type) {
-        this.#checkProtected(target, true);
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(target, true);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.symlinkSync.call(this, target, path, type);
     }
     writeFile(file, data, options, callback) {
         if (typeof file !== 'number') {
-            this.#checkProtected(file, false);
+            ProtectFs.checkProtected(file, false);
         }
         if (typeof callback === 'function') {
             // @ts-expect-error should work
@@ -280,21 +287,21 @@ class ProtectFs {
     }
     writeFileSync(file, data, options) {
         if (typeof file !== 'number') {
-            this.#checkProtected(file, false);
+            ProtectFs.checkProtected(file, false);
         }
         return nodeFS.writeFileSync.call(this, file, data, options);
     }
     unlink(path, callback) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.unlink.call(this, path, callback || ((_err) => { }));
     }
     unlinkSync(path) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.unlinkSync.call(this, path);
     }
     appendFile(file, data, options, callback) {
         if (typeof file !== 'number') {
-            this.#checkProtected(file, false);
+            ProtectFs.checkProtected(file, false);
         }
         if (typeof callback === 'function') {
             // @ts-expect-error should work
@@ -304,73 +311,73 @@ class ProtectFs {
     }
     appendFileSync(file, data, options) {
         if (typeof file !== 'number') {
-            this.#checkProtected(file, false);
+            ProtectFs.checkProtected(file, false);
         }
         return nodeFS.appendFileSync.call(this, file, data, options);
     }
     chmod(path, mode, callback) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.chmod.call(this, path, mode, callback || ((_err) => { }));
     }
     chmodSync(path, mode) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.chmodSync.call(this, path, mode);
     }
     chown(path, uid, gid, callback) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.chown.call(this, path, uid, gid, callback || ((_err) => { }));
     }
     chownSync(path, uid, gid) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.chownSync.call(this, path, uid, gid);
     }
     copyFile(src, dest, mode, callback) {
-        this.#checkProtected(src, true);
-        this.#checkProtected(dest, false);
+        ProtectFs.checkProtected(src, true);
+        ProtectFs.checkProtected(dest, false);
         // @ts-expect-error should work
         return nodeFS.copyFile.call(this, src, dest, mode, callback);
     }
     copyFileSync(src, dest, mode) {
-        this.#checkProtected(src, true);
-        this.#checkProtected(dest, false);
+        ProtectFs.checkProtected(src, true);
+        ProtectFs.checkProtected(dest, false);
         return nodeFS.copyFileSync.call(this, src, dest, mode);
     }
     rename(oldPath, newPath, callback) {
-        this.#checkProtected(oldPath, false);
-        this.#checkProtected(newPath, false);
+        ProtectFs.checkProtected(oldPath, false);
+        ProtectFs.checkProtected(newPath, false);
         return nodeFS.rename.call(this, oldPath, newPath, callback || ((_err) => { }));
     }
     renameSync(oldPath, newPath) {
-        this.#checkProtected(oldPath, false);
-        this.#checkProtected(newPath, false);
+        ProtectFs.checkProtected(oldPath, false);
+        ProtectFs.checkProtected(newPath, false);
         return nodeFS.renameSync.call(this, oldPath, newPath);
     }
     open(path, callback) {
-        this.#checkProtected(path, true);
+        ProtectFs.checkProtected(path, true);
         return nodeFS.open.call(this, path, callback);
     }
     openSync(path, flags, mode) {
-        this.#checkProtected(path, true);
+        ProtectFs.checkProtected(path, true);
         return nodeFS.openSync.call(this, path, flags, mode);
     }
     truncate(path, callback) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.truncate.call(this, path, callback || ((_err) => { }));
     }
     truncateSync(path) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.truncateSync.call(this, path);
     }
     exists(path, callback) {
-        this.#checkProtected(path, true);
+        ProtectFs.checkProtected(path, true);
         return nodeFS.exists.call(this, path, callback);
     }
     existsSync(path) {
-        this.#checkProtected(path, true);
+        ProtectFs.checkProtected(path, true);
         return nodeFS.existsSync.call(this, path);
     }
     stat(path, options, callback) {
-        this.#checkProtected(path, true);
+        ProtectFs.checkProtected(path, true);
         if (typeof callback === 'function') {
             // @ts-expect-error should work
             return nodeFS.stat.call(this, path, options, callback);
@@ -379,19 +386,19 @@ class ProtectFs {
         return nodeFS.stat.call(this, path, options);
     }
     statSync(path, options) {
-        this.#checkProtected(path, true);
+        ProtectFs.checkProtected(path, true);
         return nodeFS.statSync.call(this, path, options);
     }
     utimes(path, atime, mtime, callback) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.utimes.call(this, path, atime, mtime, callback || ((_err) => { }));
     }
     utimesSync(path, atime, mtime) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.utimesSync.call(this, path, atime, mtime);
     }
     readdir(path, options, callback) {
-        this.#checkProtected(path, true);
+        ProtectFs.checkProtected(path, true);
         if (typeof callback === 'function') {
             return nodeFS.readdir.call(this, path, options, callback);
         }
@@ -399,46 +406,46 @@ class ProtectFs {
         return nodeFS.readdir.call(this, path, options);
     }
     readdirSync(path, options) {
-        this.#checkProtected(path, true);
+        ProtectFs.checkProtected(path, true);
         // @ts-expect-error should work
         return nodeFS.readdirSync.call(this, path, options);
     }
     createReadStream(path, options) {
-        this.#checkProtected(path, true);
+        ProtectFs.checkProtected(path, true);
         return nodeFS.createReadStream.call(this, path, options);
     }
     createWriteStream(path, options) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.createWriteStream.call(this, path, options);
     }
     lchmod(path, mode, callback) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.lchmod.call(this, path, mode, callback || ((_err) => { }));
     }
     lchmodSync(path, mode) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.lchmodSync.call(this, path, mode);
     }
     lchown(path, uid, gid, callback) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.lchown.call(this, path, uid, gid, callback || ((_err) => { }));
     }
     lchownSync(path, uid, gid) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.lchownSync.call(this, path, uid, gid);
     }
     link(existingPath, newPath, callback) {
-        this.#checkProtected(existingPath, false);
-        this.#checkProtected(newPath, false);
+        ProtectFs.checkProtected(existingPath, false);
+        ProtectFs.checkProtected(newPath, false);
         return nodeFS.link.call(this, existingPath, newPath, callback || ((_err) => { }));
     }
     linkSync(existingPath, newPath) {
-        this.#checkProtected(existingPath, false);
-        this.#checkProtected(newPath, false);
+        ProtectFs.checkProtected(existingPath, false);
+        ProtectFs.checkProtected(newPath, false);
         return nodeFS.linkSync.call(this, existingPath, newPath);
     }
     lstat(path, options, callback) {
-        this.#checkProtected(path, true);
+        ProtectFs.checkProtected(path, true);
         if (typeof callback === 'function') {
             // @ts-expect-error should work
             return nodeFS.lstat.call(this, path, options, callback);
@@ -447,19 +454,19 @@ class ProtectFs {
         return nodeFS.lstat.call(this, path, options);
     }
     lstatSync(path, options) {
-        this.#checkProtected(path, true);
+        ProtectFs.checkProtected(path, true);
         return nodeFS.lstatSync.call(this, path, options);
     }
     lutimes(path, atime, mtime, callback) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.lutimes.call(this, path, atime, mtime, callback || ((_err) => { }));
     }
     lutimesSync(path, atime, mtime) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.lutimesSync.call(this, path, atime, mtime);
     }
     mkdir(path, options, callback) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         if (typeof callback === 'function') {
             // @ts-expect-error should work
             return nodeFS.mkdir.call(this, path, options, callback);
@@ -467,11 +474,11 @@ class ProtectFs {
         return nodeFS.mkdir.call(this, path, options);
     }
     mkdirSync(path, options) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.mkdirSync.call(this, path, options);
     }
     mkdtemp(prefix, options, callback) {
-        this.#checkProtected(prefix, false);
+        ProtectFs.checkProtected(prefix, false);
         if (typeof callback === 'function') {
             // @ts-expect-error should work
             return nodeFS.mkdtemp.call(this, prefix, options, callback);
@@ -479,11 +486,11 @@ class ProtectFs {
         return nodeFS.mkdtemp.call(this, prefix, options);
     }
     mkdtempSync(prefix, options) {
-        this.#checkProtected(prefix, false);
+        ProtectFs.checkProtected(prefix, false);
         return nodeFS.mkdtempSync.call(this, prefix, options);
     }
     rm(path, options, callback) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         if (typeof callback === 'function') {
             return nodeFS.rm.call(this, path, options, callback);
         }
@@ -491,11 +498,11 @@ class ProtectFs {
         return nodeFS.rm.call(this, path, options);
     }
     rmSync(path, options) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.rmSync.call(this, path, options);
     }
     rmdir(path, options, callback) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         if (typeof callback === 'function') {
             return nodeFS.rmdir.call(this, path, options, callback);
         }
@@ -503,11 +510,11 @@ class ProtectFs {
         return nodeFS.rmdir.call(this, path, options);
     }
     rmdirSync(path, options) {
-        this.#checkProtected(path, false);
+        ProtectFs.checkProtected(path, false);
         return nodeFS.rmdirSync.call(this, path, options);
     }
     watch(filename, options, listener) {
-        this.#checkProtected(filename, true);
+        ProtectFs.checkProtected(filename, true);
         if (typeof listener === 'function') {
             // @ts-expect-error should work
             return nodeFS.watch.call(this, filename, options, listener);
@@ -515,11 +522,11 @@ class ProtectFs {
         return nodeFS.watch.call(this, filename, options);
     }
     watchFile(filename, listener) {
-        this.#checkProtected(filename, true);
+        ProtectFs.checkProtected(filename, true);
         return nodeFS.watchFile.call(this, filename, listener);
     }
     unwatchFile(filename, listener) {
-        this.#checkProtected(filename, true);
+        ProtectFs.checkProtected(filename, true);
         return nodeFS.unwatchFile.call(this, filename, listener);
     }
 }