@bytecodealliance/preview2-shim 0.14.1 → 0.14.2

package/lib/nodejs/filesystem.js

@@ -70,13 +70,12 @@ class Descriptor {
   static _createPreopen(hostPreopen) {
     const descriptor = new Descriptor();
     descriptor.#hostPreopen = hostPreopen.endsWith("/")
-      ? hostPreopen.slice(0, -1) || '/'
+      ? hostPreopen.slice(0, -1) || "/"
       : hostPreopen;
     // Windows requires UNC paths at minimum
     if (isWindows) {
-      descriptor.#hostPreopen = descriptor.#hostPreopen.replace(/\\/g, '/');
-      if (descriptor.#hostPreopen === '/')
-        descriptor.#hostPreopen = '//';
+      descriptor.#hostPreopen = descriptor.#hostPreopen.replace(/\\/g, "/");
+      if (descriptor.#hostPreopen === "/") descriptor.#hostPreopen = "//";
     }
     return descriptor;
   }
@@ -85,7 +84,6 @@ class Descriptor {
     const descriptor = new Descriptor();
     descriptor.#fd = fd;
     descriptor.#mode = mode;
-    if (fullPath.endsWith("/")) throw new Error("bad full path");
     descriptor.#fullPath = fullPath;
     return descriptor;
   }
@@ -118,7 +116,9 @@ class Descriptor {
     return this.writeViaStream(this.stat().size);
   }
 
-  advise(_offset, _length, _advice) { }
+  advise(_offset, _length, _advice) {
+    if (this.getType() === "directory") throw "bad-descriptor";
+  }
 
   syncData() {
     if (this.#hostPreopen) throw "invalid";
@@ -130,7 +130,6 @@ class Descriptor {
   }
 
   getFlags() {
-    if (this.#hostPreopen) throw "invalid";
     return this.#mode;
   }
 
@@ -164,7 +163,7 @@ class Descriptor {
     const mtime = this.#getNewTimestamp(
       dataModificationTimestamp,
       dataModificationTimestamp.tag === "no-change" &&
-      stats.dataModificationTimestamp
+        stats.dataModificationTimestamp
     );
     try {
       futimesSync(this.#fd, atime, mtime);
@@ -186,8 +185,14 @@ class Descriptor {
 
   read(length, offset) {
     if (!this.#fullPath) throw "bad-descriptor";
-    const buf = new Uint8Array(length);
-    const bytesRead = readSync(this.#fd, buf, Number(offset), length, 0);
+    const buf = new Uint8Array(Number(length));
+    const bytesRead = readSync(
+      this.#fd,
+      buf,
+      0,
+      Number(length),
+      Number(offset)
+    );
     const out = new Uint8Array(buf.buffer, 0, bytesRead);
     return [out, bytesRead === 0 ? "ended" : "open"];
   }
@@ -195,7 +200,7 @@ class Descriptor {
   write(buffer, offset) {
     if (!this.#fullPath) throw "bad-descriptor";
     return BigInt(
-      writeSync(this.#fd, buffer, Number(offset), buffer.byteLength - offset, 0)
+      writeSync(this.#fd, buffer, 0, buffer.byteLength, Number(offset))
     );
   }
 
@@ -250,7 +255,9 @@ class Descriptor {
     const fullPath = this.#getFullPath(path, false);
     let stats;
     try {
-      stats = (pathFlags.symlinkFollow ? statSync : lstatSync)(fullPath, { bigint: true });
+      stats = (pathFlags.symlinkFollow ? statSync : lstatSync)(fullPath, {
+        bigint: true,
+      });
     } catch (e) {
       throw convertFsError(e);
     }
@@ -280,7 +287,7 @@ class Descriptor {
     const mtime = this.#getNewTimestamp(
       dataModificationTimestamp,
       dataModificationTimestamp.tag === "no-change" &&
-      stats.dataModificationTimestamp
+        stats.dataModificationTimestamp
     );
     try {
       (pathFlags.symlinkFollow ? utimesSync : lutimesSync)(
@@ -297,8 +304,7 @@ class Descriptor {
     const oldFullPath = this.#getFullPath(oldPath, oldPathFlags.symlinkFollow);
     const newFullPath = newDescriptor.#getFullPath(newPath, false);
     // Windows doesn't automatically fail on trailing slashes
-    if (isWindows && newFullPath.endsWith('/'))
-      throw 'no-entry';
+    if (isWindows && newFullPath.endsWith("/")) throw "no-entry";
     try {
       linkSync(oldFullPath, newFullPath);
     } catch (e) {
@@ -320,14 +326,26 @@ class Descriptor {
     else if (descriptorFlags.read) fsOpenFlags |= constants.O_RDONLY;
     if (descriptorFlags.fileIntegritySync) fsOpenFlags |= constants.O_SYNC;
     if (descriptorFlags.dataIntegritySync) fsOpenFlags |= constants.O_DSYNC;
+    if (!pathFlags.symlinkFollow) fsOpenFlags |= constants.O_NOFOLLOW;
+
     // Unsupported:
     // if (descriptorFlags.requestedWriteSync)
     // if (descriptorFlags.mutateDirectory)
-
     try {
       const fd = openSync(fullPath, fsOpenFlags);
-      return descriptorCreate(fd, descriptorFlags, fullPath, preopenEntries);
+      const descriptor = descriptorCreate(
+        fd,
+        descriptorFlags,
+        fullPath,
+        preopenEntries
+      );
+      if (fullPath.endsWith("/")) {
+        // check if its a directory
+        if (!descriptor.getType() === "directory") throw "not-directory";
+      }
+      return descriptor;
     } catch (e) {
+      if (e.code === "ERR_INVALID_ARG_VALUE") throw "invalid";
       throw convertFsError(e);
     }
   }
@@ -346,8 +364,7 @@ class Descriptor {
     try {
       rmdirSync(fullPath);
     } catch (e) {
-      if (isWindows && e.code === 'ENOENT')
-        throw 'not-directory';
+      if (isWindows && e.code === "ENOENT") throw "not-directory";
       throw convertFsError(e);
     }
   }
@@ -358,19 +375,19 @@ class Descriptor {
     try {
       renameSync(oldFullPath, newFullPath);
     } catch (e) {
-      if (isWindows && e.code === 'EPERM')
-        throw 'access';
+      if (isWindows && e.code === "EPERM") throw "access";
       throw convertFsError(e);
     }
   }
 
   symlinkAt(target, path) {
     const fullPath = this.#getFullPath(path, false);
+    if (target.startsWith("/")) throw "not-permitted";
     try {
       symlinkSync(target, fullPath);
     } catch (e) {
-      if (isWindows && (e.code === 'EPERM' || e.code === 'EEXIST'))
-        throw 'no-entry'
+      if (isWindows && (e.code === "EPERM" || e.code === "EEXIST"))
+        throw "no-entry";
       throw convertFsError(e);
     }
   }
@@ -401,7 +418,9 @@ class Descriptor {
   metadataHashAt(pathFlags, path) {
     const fullPath = this.#getFullPath(path, false);
     try {
-      const stats = (pathFlags.symlinkFollow ? statSync : lstatSync)(fullPath, { bigint: true });
+      const stats = (pathFlags.symlinkFollow ? statSync : lstatSync)(fullPath, {
+        bigint: true,
+      });
       return { upper: stats.mtimeNs, lower: stats.ino };
     } catch (e) {
       throw convertFsError(e);
@@ -412,27 +431,56 @@ class Descriptor {
   #getFullPath(subpath, _followSymlinks) {
     let descriptor = this;
     if (subpath.indexOf("\\") !== -1) subpath = subpath.replace(/\\/g, "/");
-    if (subpath[0] === '/') {
-      let bestPreopenMatch = "";
-      for (const preopenEntry of preopenEntries) {
+    if (subpath.indexOf("//") !== -1) subpath = subpath.replace(/\/\/+/g, "/");
+    if (subpath[0] === "/") throw "not-permitted";
+
+    // segment resolution
+    const segments = [];
+    let segmentIndex = -1;
+    for (let i = 0; i < subpath.length; i++) {
+      // busy reading a segment - only terminate on '/'
+      if (segmentIndex !== -1) {
+        if (subpath[i] === "/") {
+          segments.push(subpath.slice(segmentIndex, i + 1));
+          segmentIndex = -1;
+        }
+        continue;
+      }
+      // new segment - check if it is relative
+      else if (subpath[i] === ".") {
+        // ../ segment
         if (
-          subpath.startsWith(preopenEntry[1]) &&
-          (!bestPreopenMatch ||
-            bestPreopenMatch.length < preopenEntry[1].length)
+          subpath[i + 1] === "." &&
+          (subpath[i + 2] === "/" || i + 2 === subpath.length)
         ) {
-          bestPreopenMatch = preopenEntry;
+          if (segments.pop() === undefined) throw "not-permitted";
+          i += 2;
+          continue;
+        }
+        // ./ segment
+        else if (subpath[i + 1] === "/" || i + 1 === subpath.length) {
+          i += 1;
+          continue;
         }
       }
-      if (!bestPreopenMatch) throw "no-entry";
-      descriptor = bestPreopenMatch[0];
-      subpath = subpath.slice(bestPreopenMatch[1]);
-      if (subpath[0] === "/") subpath = subpath.slice(1);
+      // it is the start of a new segment
+      while (subpath[i] === "/") i++;
+      segmentIndex = i;
     }
-    if (subpath.startsWith("."))
-      subpath = subpath.slice(subpath[1] === "/" ? 2 : 1);
+    // finish reading out the last segment
+    if (segmentIndex !== -1) segments.push(subpath.slice(segmentIndex));
+
+    subpath = segments.join("");
+
     if (descriptor.#hostPreopen)
       return (
-        descriptor.#hostPreopen + (descriptor.#hostPreopen.endsWith('/') ? '' : (subpath.length > 0 ? "/" : "")) + subpath
+        descriptor.#hostPreopen +
+        (descriptor.#hostPreopen.endsWith("/")
+          ? ""
+          : subpath.length > 0
+          ? "/"
+          : "") +
+        subpath
       );
     return descriptor.#fullPath + (subpath.length > 0 ? "/" : "") + subpath;
   }
@@ -489,6 +537,9 @@ _addPreopen("/", isWindows ? "//" : "/");
 export const types = {
   Descriptor,
   DirectoryEntryStream,
+  filesystemErrorCode(err) {
+    return convertFsError(err.payload);
+  },
 };
 
 export function _setPreopens(preopens) {