vfs: reject operations on closed ZipProvider handles

Author: trivikr

lib/internal/vfs/providers/ziparchive.js

@@ -23,6 +23,7 @@ const {
 const { VirtualProvider } = require('internal/vfs/provider');
 const { VirtualFileHandle } = require('internal/vfs/file_handle');
 const {
+  createEBADF,
   createEEXIST,
   createEISDIR,
   createEINVAL,
@@ -136,10 +137,15 @@ class ZipFileHandle extends VirtualFileHandle {
     if (isAppend(flags)) this.position = this.#size;
   }
 
-  #checkReadable() {
+  #checkClosed(syscall) {
+    if (this.closed) throw createEBADF(syscall);
+  }
+  #checkReadable(syscall = 'read') {
+    this.#checkClosed(syscall);
     if (!isReadableFlag(this.flags)) throw createEISDIR('read', this.path);
   }
-  #checkWritable() {
+  #checkWritable(syscall = 'write') {
+    this.#checkClosed(syscall);
     if (!isWritableFlag(this.flags)) throw createEISDIR('write', this.path);
   }
   #ensureCapacity(size) {
@@ -223,6 +229,7 @@ class ZipFileHandle extends VirtualFileHandle {
   }
 
   #doStat() {
+    this.#checkClosed('fstat');
     return createFileStats(this.#size, { mode: this.mode });
   }
   async stat(options) {
@@ -233,7 +240,7 @@ class ZipFileHandle extends VirtualFileHandle {
   }
 
   #doTruncate(len) {
-    this.#checkWritable();
+    this.#checkWritable('ftruncate');
     this.#ensureCapacity(len);
     this.#size = len;
     this.#dirty = true;
@@ -246,12 +253,14 @@ class ZipFileHandle extends VirtualFileHandle {
   }
 
   async close() {
+    if (this.closed) return;
     if (this.#dirty && isWritableFlag(this.flags)) {
       await this.#source.add(this.#name, this.#buffer.subarray(0, this.#size), { mode: this.mode });
     }
     await super.close();
   }
   closeSync() {
+    if (this.closed) return;
     if (this.#dirty && isWritableFlag(this.flags)) {
       this.#source.addSync(this.#name, this.#buffer.subarray(0, this.#size), { mode: this.mode });
     }

test/parallel/test-vfs-zip-provider-handle.js

@@ -443,6 +443,32 @@ function buildArchiveSync(entries, comment) {
   await zip.close();
 })().then(common.mustCall());
 
+// --- operations on closed handles fail with EBADF -------------------------
+(async () => {
+  const archive = await buildArchive([await zlib.ZipEntry.create('a.txt', Buffer.from('x'))]);
+  const provider = new vfs.ZipProvider(new zlib.ZipBuffer(archive));
+
+  const handle = await provider.open('/a.txt', 'r+');
+  await handle.close();
+  await assert.rejects(handle.read(Buffer.alloc(1), 0, 1, 0), { code: 'EBADF' });
+  await assert.rejects(handle.write(Buffer.from('x'), 0, 1, 0), { code: 'EBADF' });
+  await assert.rejects(handle.readFile(), { code: 'EBADF' });
+  await assert.rejects(handle.writeFile('x'), { code: 'EBADF' });
+  await assert.rejects(handle.stat(), { code: 'EBADF' });
+  await assert.rejects(handle.truncate(), { code: 'EBADF' });
+  await handle.close(); // Closing an already-closed handle is a no-op.
+
+  const syncHandle = provider.openSync('/a.txt', 'r+');
+  syncHandle.closeSync();
+  assert.throws(() => syncHandle.readSync(Buffer.alloc(1), 0, 1, 0), { code: 'EBADF' });
+  assert.throws(() => syncHandle.writeSync(Buffer.from('x'), 0, 1, 0), { code: 'EBADF' });
+  assert.throws(() => syncHandle.readFileSync(), { code: 'EBADF' });
+  assert.throws(() => syncHandle.writeFileSync('x'), { code: 'EBADF' });
+  assert.throws(() => syncHandle.statSync(), { code: 'EBADF' });
+  assert.throws(() => syncHandle.truncateSync(), { code: 'EBADF' });
+  syncHandle.closeSync();
+})().then(common.mustCall());
+
 // --- numeric open flags are normalized like node:fs (O_* constants) --------
 (async () => {
   const { O_RDONLY, O_WRONLY, O_CREAT, O_TRUNC } = fs.constants;