feat: 🎸 imlement chown and chmod operations

streamich · streamich · commit de2086961733 · 2025-10-14T00:11:39.000+02:00
diff --git a/src/nfs/v4/client/Nfsv4FsClient.ts b/src/nfs/v4/client/Nfsv4FsClient.ts
@@ -294,6 +294,10 @@ export class Nfsv4FsClient implements NfsFsClient {
     );
   }
 
+  public async lstat(path: misc.PathLike, options?: opts.IStatOptions): Promise<misc.IStats> {
+    return this.stat(path, options);
+  }
+
   public async mkdir(path: misc.PathLike, options?: misc.TMode | opts.IMkdirOptions): Promise<string | undefined> {
     const pathStr = typeof path === 'string' ? path : path.toString();
     const parts = this.parsePath(pathStr);
@@ -713,31 +717,63 @@ export class Nfsv4FsClient implements NfsFsClient {
     return Buffer.from(dirName, 'utf8');
   }
 
-  public async lstat(path: misc.PathLike, options?: opts.IStatOptions): Promise<misc.IStats> {
-    return this.stat(path, options);
+  public async chmod(path: misc.PathLike, mode: misc.TMode): Promise<void> {
+    const pathStr = typeof path === 'string' ? path : path.toString();
+    const parts = this.parsePath(pathStr);
+    const operations = this.navigateToPath(parts);
+    const modeValue = typeof mode === 'number' ? mode : parseInt(mode.toString(), 8);
+    const writer = new Writer(8);
+    const xdr = new XdrEncoder(writer);
+    xdr.writeUnsignedInt(modeValue);
+    const attrVals = writer.flush();
+    const attrs = nfs.Fattr([Nfsv4Attr.FATTR4_MODE], attrVals);
+    const stateid = nfs.Stateid(0, new Uint8Array(12));
+    operations.push(nfs.SETATTR(stateid, attrs));
+    const response = await this.nfs.compound(operations);
+    if (response.status !== Nfsv4Stat.NFS4_OK) {
+      throw new Error(`Failed to chmod: ${response.status}`);
+    }
+    const setattrRes = response.resarray[response.resarray.length - 1] as msg.Nfsv4SetattrResponse;
+    if (setattrRes.status !== Nfsv4Stat.NFS4_OK) {
+      throw new Error(`Failed to chmod: ${setattrRes.status}`);
+    }
   }
 
-  public readonly open = (path: misc.PathLike, flags?: misc.TFlags, mode?: misc.TMode): Promise<misc.IFileHandle> => {
-    throw new Error('Not implemented.');
-  };
-
-  public readonly chmod = (path: misc.PathLike, mode: misc.TMode): Promise<void> => {
-    throw new Error('Not implemented.');
-  };
+  public async chown(path: misc.PathLike, uid: number, gid: number): Promise<void> {
+    const pathStr = typeof path === 'string' ? path : path.toString();
+    const parts = this.parsePath(pathStr);
+    const operations = this.navigateToPath(parts);
+    const writer = new Writer(64);
+    const xdr = new XdrEncoder(writer);
+    xdr.writeStr(uid.toString());
+    xdr.writeStr(gid.toString());
+    const attrVals = writer.flush();
+    const attrs = nfs.Fattr([Nfsv4Attr.FATTR4_OWNER, Nfsv4Attr.FATTR4_OWNER_GROUP], attrVals);
+    const stateid = nfs.Stateid(0, new Uint8Array(12));
+    operations.push(nfs.SETATTR(stateid, attrs));
+    const response = await this.nfs.compound(operations);
+    if (response.status !== Nfsv4Stat.NFS4_OK) {
+      throw new Error(`Failed to chown: ${response.status}`);
+    }
+    const setattrRes = response.resarray[response.resarray.length - 1] as msg.Nfsv4SetattrResponse;
+    if (setattrRes.status !== Nfsv4Stat.NFS4_OK) {
+      throw new Error(`Failed to chown: ${setattrRes.status}`);
+    }
+  }
 
-  public readonly chown = (path: misc.PathLike, uid: number, gid: number): Promise<void> => {
-    throw new Error('Not implemented.');
-  };
+  public async lchmod(path: misc.PathLike, mode: misc.TMode): Promise<void> {
+    return this.chmod(path, mode);
+  }
 
-  public readonly lchmod = (path: misc.PathLike, mode: misc.TMode): Promise<void> => {
-    throw new Error('Not implemented.');
-  };
+  public async lchown(path: misc.PathLike, uid: number, gid: number): Promise<void> {
+    return this.chown(path, uid, gid);
+  }
 
-  public readonly lchown = (path: misc.PathLike, uid: number, gid: number): Promise<void> => {
-    throw new Error('Not implemented.');
-  };
+  public async lutimes(path: misc.PathLike, atime: misc.TTime, mtime: misc.TTime): Promise<void> {
+    return this.utimes(path, atime, mtime);
+  }
 
-  public readonly lutimes = (path: misc.PathLike, atime: misc.TTime, mtime: misc.TTime): Promise<void> => {
+  public readonly open = (path: misc.PathLike, flags?: misc.TFlags, mode?: misc.TMode): Promise<misc.IFileHandle> => {
     throw new Error('Not implemented.');
   };
 
diff --git a/src/nfs/v4/client/__tests__/Nfsv4FsClient.spec.ts b/src/nfs/v4/client/__tests__/Nfsv4FsClient.spec.ts
@@ -705,3 +705,119 @@ describe('.opendir()', () => {
     await stop();
   });
 });
+
+describe('.chmod()', () => {
+  test('can change file mode', async () => {
+    const {client, stop} = await setupNfsClientServerTestbed();
+    const fs = new Nfsv4FsClient(client);
+    await fs.chmod('file.txt', 0o644);
+    const stats = await fs.stat('file.txt');
+    expect(Number(stats.mode) & 0o777).toBe(0o644);
+    await stop();
+  });
+
+  test('can change directory mode', async () => {
+    const {client, stop} = await setupNfsClientServerTestbed();
+    const fs = new Nfsv4FsClient(client);
+    await fs.chmod('subdir', 0o755);
+    const stats = await fs.stat('subdir');
+    expect(Number(stats.mode) & 0o777).toBe(0o755);
+    await stop();
+  });
+
+  test('can change nested file mode', async () => {
+    const {client, stop} = await setupNfsClientServerTestbed();
+    const fs = new Nfsv4FsClient(client);
+    await fs.chmod('subdir/nested.dat', 0o600);
+    const stats = await fs.stat('subdir/nested.dat');
+    expect(Number(stats.mode) & 0o777).toBe(0o600);
+    await stop();
+  });
+});
+
+describe('.chown()', () => {
+  test('can change file owner', async () => {
+    const {client, stop} = await setupNfsClientServerTestbed();
+    const fs = new Nfsv4FsClient(client);
+    await fs.chown('file.txt', 1001, 1001);
+    await stop();
+  });
+
+  test('can change directory owner', async () => {
+    const {client, stop} = await setupNfsClientServerTestbed();
+    const fs = new Nfsv4FsClient(client);
+    await fs.chown('subdir', 1002, 1002);
+    await stop();
+  });
+
+  test('can change nested file owner', async () => {
+    const {client, stop} = await setupNfsClientServerTestbed();
+    const fs = new Nfsv4FsClient(client);
+    await fs.chown('subdir/nested.dat', 1003, 1003);
+    await stop();
+  });
+});
+
+describe('.lchmod()', () => {
+  test('can change file mode without following symlinks', async () => {
+    const {client, stop, vol} = await setupNfsClientServerTestbed();
+    const fs = new Nfsv4FsClient(client);
+    vol.symlinkSync('file.txt', '/export/link.txt');
+    await fs.lchmod('link.txt', 0o777);
+    const stats = await fs.lstat('link.txt');
+    expect(stats.isSymbolicLink()).toBe(true);
+    await stop();
+  });
+
+  test('can change regular file mode with lchmod', async () => {
+    const {client, stop} = await setupNfsClientServerTestbed();
+    const fs = new Nfsv4FsClient(client);
+    await fs.lchmod('file.txt', 0o666);
+    const stats = await fs.stat('file.txt');
+    expect(Number(stats.mode) & 0o777).toBe(0o666);
+    await stop();
+  });
+});
+
+describe('.lchown()', () => {
+  test('can change file owner without following symlinks', async () => {
+    const {client, stop, vol} = await setupNfsClientServerTestbed();
+    const fs = new Nfsv4FsClient(client);
+    vol.symlinkSync('file.txt', '/export/link.txt');
+    await fs.lchown('link.txt', 2001, 2001);
+    await stop();
+  });
+
+  test('can change regular file owner with lchown', async () => {
+    const {client, stop} = await setupNfsClientServerTestbed();
+    const fs = new Nfsv4FsClient(client);
+    await fs.lchown('file.txt', 2002, 2002);
+    await stop();
+  });
+});
+
+describe('.lutimes()', () => {
+  test('can update symlink times without following', async () => {
+    const {client, stop, vol} = await setupNfsClientServerTestbed();
+    const fs = new Nfsv4FsClient(client);
+    vol.symlinkSync('file.txt', '/export/link.txt');
+    const now = Date.now();
+    const atime = new Date(now - 10000);
+    const mtime = new Date(now - 5000);
+    await fs.lutimes('link.txt', atime, mtime);
+    await stop();
+  });
+
+  test('can update regular file times with lutimes', async () => {
+    const {client, stop} = await setupNfsClientServerTestbed();
+    const fs = new Nfsv4FsClient(client);
+    const now = Date.now();
+    const atime = new Date(now - 10000);
+    const mtime = new Date(now - 5000);
+    await fs.lutimes('file.txt', atime, mtime);
+    const stats = await fs.stat('file.txt');
+    expect(Math.abs(Number(stats.atimeMs) - atime.getTime())).toBeLessThan(2000);
+    expect(Math.abs(Number(stats.mtimeMs) - mtime.getTime())).toBeLessThan(2000);
+    await stop();
+  });
+});
diff --git a/src/nfs/v4/server/operations/node/Nfsv4OperationsNode.ts b/src/nfs/v4/server/operations/node/Nfsv4OperationsNode.ts
@@ -1079,6 +1079,8 @@ export class Nfsv4OperationsNode implements Nfsv4Operations {
       const mask = inFattr.attrmask.mask;
       let atime: Date | undefined;
       let mtime: Date | undefined;
+      let uid: number | undefined;
+      let gid: number | undefined;
       for (let i = 0; i < mask.length; i++) {
         const word = mask[i];
         for (let bit = 0; bit < 32; bit++) {
@@ -1091,6 +1093,22 @@ export class Nfsv4OperationsNode implements Nfsv4Operations {
               await this.promises.chmod(currentPathAbsolute, mode & 0o7777);
               break;
             }
+            case Nfsv4Attr.FATTR4_OWNER: {
+              const owner = dec.readString();
+              const parsedUid = parseInt(owner, 10);
+              if (!isNaN(parsedUid)) {
+                uid = parsedUid;
+              }
+              break;
+            }
+            case Nfsv4Attr.FATTR4_OWNER_GROUP: {
+              const group = dec.readString();
+              const parsedGid = parseInt(group, 10);
+              if (!isNaN(parsedGid)) {
+                gid = parsedGid;
+              }
+              break;
+            }
             case Nfsv4Attr.FATTR4_SIZE: {
               const size = dec.readUnsignedHyper();
               await this.promises.truncate(currentPathAbsolute, Number(size));
@@ -1147,6 +1165,12 @@ export class Nfsv4OperationsNode implements Nfsv4Operations {
           }
         }
       }
+      if (uid !== undefined || gid !== undefined) {
+        const stats = await this.promises.lstat(currentPathAbsolute);
+        const uidToSet = uid !== undefined ? uid : stats.uid;
+        const gidToSet = gid !== undefined ? gid : stats.gid;
+        await this.promises.chown(currentPathAbsolute, uidToSet, gidToSet);
+      }
       if (atime || mtime) {
         const stats = await this.promises.lstat(currentPathAbsolute);
         const atimeToSet = atime || stats.atime;
