@zenfs/core 0.17.0 → 0.18.0

package/dist/backends/store/fs.js

@@ -43,10 +43,11 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { R_OK, S_IFDIR, S_IFREG, W_OK } from '../../emulation/constants.js';
+import { credentials } from '../../credentials.js';
+import { S_IFDIR, S_IFREG } from '../../emulation/constants.js';
 import { basename, dirname, join, resolve } from '../../emulation/path.js';
 import { Errno, ErrnoError } from '../../error.js';
-import { PreloadFile, flagToMode } from '../../file.js';
+import { PreloadFile } from '../../file.js';
 import { FileSystem } from '../../filesystem.js';
 import { Inode, randomIno, rootIno } from '../../inode.js';
 import { decodeDirListing, encode, encodeDirListing } from '../../utils.js';
@@ -99,16 +100,13 @@ export class StoreFS extends FileSystem {
     /**
      * @todo Make rename compatible with the cache.
      */
-    async rename(oldPath, newPath, cred) {
+    async rename(oldPath, newPath) {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_1, this.store.transaction(), true);
             const oldParent = dirname(oldPath), oldName = basename(oldPath), newParent = dirname(newPath), newName = basename(newPath), 
             // Remove oldPath from parent's directory listing.
             oldDirNode = await this.findINode(tx, oldParent), oldDirList = await this.getDirListing(tx, oldDirNode, oldParent);
-            if (!oldDirNode.toStats().hasAccess(W_OK, cred)) {
-                throw ErrnoError.With('EACCES', oldPath, 'rename');
-            }
             if (!oldDirList[oldName]) {
                 throw ErrnoError.With('ENOENT', oldPath, 'rename');
             }
@@ -134,16 +132,13 @@ export class StoreFS extends FileSystem {
                 newDirList = await this.getDirListing(tx, newDirNode, newParent);
             }
             if (newDirList[newName]) {
-                // If it's a file, delete it.
+                // If it's a file, delete it, if it's a directory, throw a permissions error.
                 const newNameNode = await this.getINode(tx, newDirList[newName], newPath);
-                if (newNameNode.toStats().isFile()) {
-                    await tx.remove(newNameNode.ino);
-                    await tx.remove(newDirList[newName]);
-                }
-                else {
-                    // If it's a directory, throw a permissions error.
+                if (!newNameNode.toStats().isFile()) {
                     throw ErrnoError.With('EPERM', newPath, 'rename');
                 }
+                await tx.remove(newNameNode.ino);
+                await tx.remove(newDirList[newName]);
             }
             newDirList[newName] = nodeId;
             // Commit the two changed directory listings.
@@ -161,16 +156,13 @@ export class StoreFS extends FileSystem {
                 await result_1;
         }
     }
-    renameSync(oldPath, newPath, cred) {
+    renameSync(oldPath, newPath) {
         const env_2 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_2, this.store.transaction(), false);
             const oldParent = dirname(oldPath), oldName = basename(oldPath), newParent = dirname(newPath), newName = basename(newPath), 
             // Remove oldPath from parent's directory listing.
             oldDirNode = this.findINodeSync(tx, oldParent), oldDirList = this.getDirListingSync(tx, oldDirNode, oldParent);
-            if (!oldDirNode.toStats().hasAccess(W_OK, cred)) {
-                throw ErrnoError.With('EACCES', oldPath, 'rename');
-            }
             if (!oldDirList[oldName]) {
                 throw ErrnoError.With('ENOENT', oldPath, 'rename');
             }
@@ -196,16 +188,13 @@ export class StoreFS extends FileSystem {
                 newDirList = this.getDirListingSync(tx, newDirNode, newParent);
             }
             if (newDirList[newName]) {
-                // If it's a file, delete it.
+                // If it's a file, delete it, if it's a directory, throw a permissions error.
                 const newNameNode = this.getINodeSync(tx, newDirList[newName], newPath);
-                if (newNameNode.toStats().isFile()) {
-                    tx.removeSync(newNameNode.ino);
-                    tx.removeSync(newDirList[newName]);
-                }
-                else {
-                    // If it's a directory, throw a permissions error.
+                if (!newNameNode.toStats().isFile()) {
                     throw ErrnoError.With('EPERM', newPath, 'rename');
                 }
+                tx.removeSync(newNameNode.ino);
+                tx.removeSync(newDirList[newName]);
             }
             newDirList[newName] = ino;
             // Commit the two changed directory listings.
@@ -221,7 +210,7 @@ export class StoreFS extends FileSystem {
             __disposeResources(env_2);
         }
     }
-    async stat(path, cred) {
+    async stat(path) {
         const env_3 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_3, this.store.transaction(), true);
@@ -229,11 +218,7 @@ export class StoreFS extends FileSystem {
             if (!inode) {
                 throw ErrnoError.With('ENOENT', path, 'stat');
             }
-            const stats = inode.toStats();
-            if (!stats.hasAccess(R_OK, cred)) {
-                throw ErrnoError.With('EACCES', path, 'stat');
-            }
-            return stats;
+            return inode.toStats();
         }
         catch (e_3) {
             env_3.error = e_3;
@@ -245,16 +230,12 @@ export class StoreFS extends FileSystem {
                 await result_2;
         }
     }
-    statSync(path, cred) {
+    statSync(path) {
         const env_4 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_4, this.store.transaction(), false);
             // Get the inode to the item, convert it into a Stats object.
-            const stats = this.findINodeSync(tx, path).toStats();
-            if (!stats.hasAccess(R_OK, cred)) {
-                throw ErrnoError.With('EACCES', path, 'stat');
-            }
-            return stats;
+            return this.findINodeSync(tx, path).toStats();
         }
         catch (e_4) {
             env_4.error = e_4;
@@ -264,22 +245,19 @@ export class StoreFS extends FileSystem {
             __disposeResources(env_4);
         }
     }
-    async createFile(path, flag, mode, cred) {
-        const node = await this.commitNew(path, S_IFREG, mode, cred, new Uint8Array(0));
+    async createFile(path, flag, mode) {
+        const node = await this.commitNew(path, S_IFREG, mode, new Uint8Array(0));
         return new PreloadFile(this, path, flag, node.toStats(), new Uint8Array(0));
     }
-    createFileSync(path, flag, mode, cred) {
-        this.commitNewSync(path, S_IFREG, mode, cred);
-        return this.openFileSync(path, flag, cred);
+    createFileSync(path, flag, mode) {
+        this.commitNewSync(path, S_IFREG, mode);
+        return this.openFileSync(path, flag);
     }
-    async openFile(path, flag, cred) {
+    async openFile(path, flag) {
         const env_5 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_5, this.store.transaction(), true);
             const node = await this.findINode(tx, path), data = await tx.get(node.ino);
-            if (!node.toStats().hasAccess(flagToMode(flag), cred)) {
-                throw ErrnoError.With('EACCES', path, 'openFile');
-            }
             if (!data) {
                 throw ErrnoError.With('ENOENT', path, 'openFile');
             }
@@ -295,14 +273,11 @@ export class StoreFS extends FileSystem {
                 await result_3;
         }
     }
-    openFileSync(path, flag, cred) {
+    openFileSync(path, flag) {
         const env_6 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_6, this.store.transaction(), false);
             const node = this.findINodeSync(tx, path), data = tx.getSync(node.ino);
-            if (!node.toStats().hasAccess(flagToMode(flag), cred)) {
-                throw ErrnoError.With('EACCES', path, 'openFile');
-            }
             if (!data) {
                 throw ErrnoError.With('ENOENT', path, 'openFile');
             }
@@ -316,43 +291,37 @@ export class StoreFS extends FileSystem {
             __disposeResources(env_6);
         }
     }
-    async unlink(path, cred) {
-        return this.remove(path, false, cred);
+    async unlink(path) {
+        return this.remove(path, false);
     }
-    unlinkSync(path, cred) {
-        this.removeSync(path, false, cred);
+    unlinkSync(path) {
+        this.removeSync(path, false);
     }
-    async rmdir(path, cred) {
+    async rmdir(path) {
         // Check first if directory is empty.
-        const list = await this.readdir(path, cred);
-        if (list.length > 0) {
+        if ((await this.readdir(path)).length) {
             throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
         }
-        await this.remove(path, true, cred);
+        await this.remove(path, true);
     }
-    rmdirSync(path, cred) {
+    rmdirSync(path) {
         // Check first if directory is empty.
-        if (this.readdirSync(path, cred).length > 0) {
+        if (this.readdirSync(path).length) {
             throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
         }
-        else {
-            this.removeSync(path, true, cred);
-        }
+        this.removeSync(path, true);
     }
-    async mkdir(path, mode, cred) {
-        await this.commitNew(path, S_IFDIR, mode, cred, encode('{}'));
+    async mkdir(path, mode) {
+        await this.commitNew(path, S_IFDIR, mode, encode('{}'));
     }
-    mkdirSync(path, mode, cred) {
-        this.commitNewSync(path, S_IFDIR, mode, cred, encode('{}'));
+    mkdirSync(path, mode) {
+        this.commitNewSync(path, S_IFDIR, mode, encode('{}'));
     }
-    async readdir(path, cred) {
+    async readdir(path) {
         const env_7 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_7, this.store.transaction(), true);
             const node = await this.findINode(tx, path);
-            if (!node.toStats().hasAccess(R_OK, cred)) {
-                throw ErrnoError.With('EACCES', path, 'readdur');
-            }
             return Object.keys(await this.getDirListing(tx, node, path));
         }
         catch (e_7) {
@@ -365,14 +334,11 @@ export class StoreFS extends FileSystem {
                 await result_4;
         }
     }
-    readdirSync(path, cred) {
+    readdirSync(path) {
         const env_8 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_8, this.store.transaction(), false);
             const node = this.findINodeSync(tx, path);
-            if (!node.toStats().hasAccess(R_OK, cred)) {
-                throw ErrnoError.With('EACCES', path, 'readdir');
-            }
             return Object.keys(this.getDirListingSync(tx, node, path));
         }
         catch (e_8) {
@@ -437,27 +403,17 @@ export class StoreFS extends FileSystem {
             __disposeResources(env_10);
         }
     }
-    async link(existing, newpath, cred) {
+    async link(target, link) {
         const env_11 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_11, this.store.transaction(), true);
-            const existingDir = dirname(existing), existingDirNode = await this.findINode(tx, existingDir);
-            if (!existingDirNode.toStats().hasAccess(R_OK, cred)) {
-                throw ErrnoError.With('EACCES', existingDir, 'link');
-            }
-            const newDir = dirname(newpath), newDirNode = await this.findINode(tx, newDir), newListing = await this.getDirListing(tx, newDirNode, newDir);
-            if (!newDirNode.toStats().hasAccess(W_OK, cred)) {
-                throw ErrnoError.With('EACCES', newDir, 'link');
-            }
-            const ino = await this._findINode(tx, existingDir, basename(existing));
-            const node = await this.getINode(tx, ino, existing);
-            if (!node.toStats().hasAccess(W_OK, cred)) {
-                throw ErrnoError.With('EACCES', newpath, 'link');
-            }
+            const newDir = dirname(link), newDirNode = await this.findINode(tx, newDir), listing = await this.getDirListing(tx, newDirNode, newDir);
+            const ino = await this._findINode(tx, dirname(target), basename(target));
+            const node = await this.getINode(tx, ino, target);
             node.nlink++;
-            newListing[basename(newpath)] = ino;
+            listing[basename(link)] = ino;
             tx.setSync(ino, node.data);
-            tx.setSync(newDirNode.ino, encodeDirListing(newListing));
+            tx.setSync(newDirNode.ino, encodeDirListing(listing));
             tx.commitSync();
         }
         catch (e_11) {
@@ -470,27 +426,17 @@ export class StoreFS extends FileSystem {
                 await result_6;
         }
     }
-    linkSync(existing, newpath, cred) {
+    linkSync(target, link) {
         const env_12 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_12, this.store.transaction(), false);
-            const existingDir = dirname(existing), existingDirNode = this.findINodeSync(tx, existingDir);
-            if (!existingDirNode.toStats().hasAccess(R_OK, cred)) {
-                throw ErrnoError.With('EACCES', existingDir, 'link');
-            }
-            const newDir = dirname(newpath), newDirNode = this.findINodeSync(tx, newDir), newListing = this.getDirListingSync(tx, newDirNode, newDir);
-            if (!newDirNode.toStats().hasAccess(W_OK, cred)) {
-                throw ErrnoError.With('EACCES', newDir, 'link');
-            }
-            const ino = this._findINodeSync(tx, existingDir, basename(existing));
-            const node = this.getINodeSync(tx, ino, existing);
-            if (!node.toStats().hasAccess(W_OK, cred)) {
-                throw ErrnoError.With('EACCES', newpath, 'link');
-            }
+            const newDir = dirname(link), newDirNode = this.findINodeSync(tx, newDir), listing = this.getDirListingSync(tx, newDirNode, newDir);
+            const ino = this._findINodeSync(tx, dirname(target), basename(target));
+            const node = this.getINodeSync(tx, ino, target);
             node.nlink++;
-            newListing[basename(newpath)] = ino;
+            listing[basename(link)] = ino;
             tx.setSync(ino, node.data);
-            tx.setSync(newDirNode.ino, encodeDirListing(newListing));
+            tx.setSync(newDirNode.ino, encodeDirListing(listing));
             tx.commitSync();
         }
         catch (e_12) {
@@ -719,15 +665,11 @@ export class StoreFS extends FileSystem {
      * @param cred The UID/GID to create the file with
      * @param data The data to store at the file's data node.
      */
-    async commitNew(path, type, mode, cred, data) {
+    async commitNew(path, type, mode, data) {
         const env_15 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_15, this.store.transaction(), true);
             const parentPath = dirname(path), parent = await this.findINode(tx, parentPath);
-            //Check that the creater has correct access
-            if (!parent.toStats().hasAccess(W_OK, cred)) {
-                throw ErrnoError.With('EACCES', path, 'commitNewFile');
-            }
             const fname = basename(path), listing = await this.getDirListing(tx, parent, parentPath);
             /*
                 The root always exists.
@@ -735,19 +677,19 @@ export class StoreFS extends FileSystem {
                 we will create a file with name '' in root should path == '/'.
             */
             if (path === '/') {
-                throw ErrnoError.With('EEXIST', path, 'commitNewFile');
+                throw ErrnoError.With('EEXIST', path, 'commitNew');
             }
             // Check if file already exists.
             if (listing[fname]) {
                 await tx.abort();
-                throw ErrnoError.With('EEXIST', path, 'commitNewFile');
+                throw ErrnoError.With('EEXIST', path, 'commitNew');
             }
             // Commit data.
             const inode = new Inode();
             inode.ino = await this.addNew(tx, data, path);
             inode.mode = mode | type;
-            inode.uid = cred.uid;
-            inode.gid = cred.gid;
+            inode.uid = credentials.uid;
+            inode.gid = credentials.gid;
             inode.size = data.length;
             // Update and commit parent directory listing.
             listing[fname] = await this.addNew(tx, inode.data, path);
@@ -774,15 +716,11 @@ export class StoreFS extends FileSystem {
      * @param data The data to store at the file's data node.
      * @return The Inode for the new file.
      */
-    commitNewSync(path, type, mode, cred, data = new Uint8Array()) {
+    commitNewSync(path, type, mode, data = new Uint8Array()) {
         const env_16 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_16, this.store.transaction(), false);
             const parentPath = dirname(path), parent = this.findINodeSync(tx, parentPath);
-            //Check that the creater has correct access
-            if (!parent.toStats().hasAccess(W_OK, cred)) {
-                throw ErrnoError.With('EACCES', path, 'commitNewFile');
-            }
             const fname = basename(path), listing = this.getDirListingSync(tx, parent, parentPath);
             /*
                 The root always exists.
@@ -790,19 +728,19 @@ export class StoreFS extends FileSystem {
                 we will create a file with name '' in root should p == '/'.
             */
             if (path === '/') {
-                throw ErrnoError.With('EEXIST', path, 'commitNewFile');
+                throw ErrnoError.With('EEXIST', path, 'commitNew');
             }
             // Check if file already exists.
             if (listing[fname]) {
-                throw ErrnoError.With('EEXIST', path, 'commitNewFile');
+                throw ErrnoError.With('EEXIST', path, 'commitNew');
             }
             // Commit data.
             const node = new Inode();
             node.ino = this.addNewSync(tx, data, path);
             node.size = data.length;
             node.mode = mode | type;
-            node.uid = cred.uid;
-            node.gid = cred.gid;
+            node.uid = credentials.uid;
+            node.gid = credentials.gid;
             // Update and commit parent directory listing.
             listing[fname] = this.addNewSync(tx, node.data, path);
             tx.setSync(parent.ino, encodeDirListing(listing));
@@ -823,27 +761,24 @@ export class StoreFS extends FileSystem {
      * @param isDir Does the path belong to a directory, or a file?
      * @todo Update mtime.
      */
-    async remove(path, isDir, cred) {
+    async remove(path, isDir) {
         const env_17 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_17, this.store.transaction(), true);
             const parent = dirname(path), parentNode = await this.findINode(tx, parent), listing = await this.getDirListing(tx, parentNode, parent), fileName = basename(path);
             if (!listing[fileName]) {
-                throw ErrnoError.With('ENOENT', path, 'removeEntry');
+                throw ErrnoError.With('ENOENT', path, 'remove');
             }
             const fileIno = listing[fileName];
             // Get file inode.
             const fileNode = await this.getINode(tx, fileIno, path);
-            if (!fileNode.toStats().hasAccess(W_OK, cred)) {
-                throw ErrnoError.With('EACCES', path, 'removeEntry');
-            }
             // Remove from directory listing of parent.
             delete listing[fileName];
             if (!isDir && fileNode.toStats().isDirectory()) {
-                throw ErrnoError.With('EISDIR', path, 'removeEntry');
+                throw ErrnoError.With('EISDIR', path, 'remove');
             }
             if (isDir && !fileNode.toStats().isDirectory()) {
-                throw ErrnoError.With('ENOTDIR', path, 'removeEntry');
+                throw ErrnoError.With('ENOTDIR', path, 'remove');
             }
             await tx.set(parentNode.ino, encodeDirListing(listing));
             if (--fileNode.nlink < 1) {
@@ -870,26 +805,23 @@ export class StoreFS extends FileSystem {
      * @param isDir Does the path belong to a directory, or a file?
      * @todo Update mtime.
      */
-    removeSync(path, isDir, cred) {
+    removeSync(path, isDir) {
         const env_18 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_18, this.store.transaction(), false);
             const parent = dirname(path), parentNode = this.findINodeSync(tx, parent), listing = this.getDirListingSync(tx, parentNode, parent), fileName = basename(path), fileIno = listing[fileName];
             if (!fileIno) {
-                throw ErrnoError.With('ENOENT', path, 'removeEntry');
+                throw ErrnoError.With('ENOENT', path, 'remove');
             }
             // Get file inode.
             const fileNode = this.getINodeSync(tx, fileIno, path);
-            if (!fileNode.toStats().hasAccess(W_OK, cred)) {
-                throw ErrnoError.With('EACCES', path, 'removeEntry');
-            }
             // Remove from directory listing of parent.
             delete listing[fileName];
             if (!isDir && fileNode.toStats().isDirectory()) {
-                throw ErrnoError.With('EISDIR', path, 'removeEntry');
+                throw ErrnoError.With('EISDIR', path, 'remove');
             }
             if (isDir && !fileNode.toStats().isDirectory()) {
-                throw ErrnoError.With('ENOTDIR', path, 'removeEntry');
+                throw ErrnoError.With('ENOTDIR', path, 'remove');
             }
             // Update directory listing.
             tx.setSync(parentNode.ino, encodeDirListing(listing));