feat: 🎸 implement locking operations

Author: streamich

src/nfs/v4/builder.ts

@@ -269,6 +269,67 @@ export const nfs = {
     return new msg.Nfsv4OpenattrRequest(createdir);
   },
 
+  /**
+   * SECINFO - Get security information for a file.
+   * @param name - Filename to get security info for
+   */
+  SECINFO(name: string): msg.Nfsv4SecinfoRequest {
+    return new msg.Nfsv4SecinfoRequest(name);
+  },
+
+  /**
+   * DELEGPURGE - Purge delegations (not supported).
+   * @param clientid - Client ID
+   */
+  DELEGPURGE(clientid: bigint): msg.Nfsv4DelegpurgeRequest {
+    return new msg.Nfsv4DelegpurgeRequest(clientid);
+  },
+
+  /**
+   * DELEGRETURN - Return delegation (not supported).
+   * @param stateid - Delegation stateid
+   */
+  DELEGRETURN(stateid: structs.Nfsv4Stateid): msg.Nfsv4DelegreturnRequest {
+    return new msg.Nfsv4DelegreturnRequest(stateid);
+  },
+
+  /**
+   * LOCKT - Test for conflicting lock (non-blocking).
+   * @param locktype - Lock type (READ_LT or WRITE_LT)
+   * @param offset - Starting byte offset
+   * @param length - Length in bytes (0xFFFFFFFFFFFFFFFF for EOF)
+   * @param owner - Lock owner
+   */
+  LOCKT(locktype: number, offset: bigint, length: bigint, owner: structs.Nfsv4LockOwner): msg.Nfsv4LocktRequest {
+    return new msg.Nfsv4LocktRequest(locktype, offset, length, owner);
+  },
+
+  /**
+   * LOCKU - Unlock byte range.
+   * @param locktype - Lock type (READ_LT or WRITE_LT)
+   * @param seqid - Sequence number
+   * @param lockStateid - Lock stateid from LOCK operation
+   * @param offset - Starting byte offset
+   * @param length - Length in bytes
+   */
+  LOCKU(
+    locktype: number,
+    seqid: number,
+    lockStateid: structs.Nfsv4Stateid,
+    offset: bigint,
+    length: bigint,
+  ): msg.Nfsv4LockuRequest {
+    return new msg.Nfsv4LockuRequest(locktype, seqid, lockStateid, offset, length);
+  },
+
+  /**
+   * RELEASE_LOCKOWNER - Release all locks for a lock-owner.
+   * @param lockOwner - Lock owner to release
+   */
+  RELEASE_LOCKOWNER(lockOwner: structs.Nfsv4LockOwner): msg.Nfsv4ReleaseLockOwnerRequest {
+    return new msg.Nfsv4ReleaseLockOwnerRequest(lockOwner);
+  },
+
   /**
    * Create an Nfsv4Verifier (8-byte opaque data).
    * @param data - 8-byte Uint8Array, defaults to zeros
@@ -340,4 +401,13 @@ export const nfs = {
   OpenClaimNull(filename: string): structs.Nfsv4OpenClaim {
     return new structs.Nfsv4OpenClaim(0, new structs.Nfsv4OpenClaimNull(filename));
   },
+
+  /**
+   * Create Nfsv4LockOwner (lock owner identifier).
+   * @param clientid - Client ID
+   * @param owner - Owner bytes (unique identifier)
+   */
+  LockOwner(clientid: bigint, owner: Uint8Array): structs.Nfsv4LockOwner {
+    return new structs.Nfsv4LockOwner(clientid, owner);
+  },
 };

src/nfs/v4/server/operations/ByteRangeLock.ts

@@ -0,0 +1,60 @@
+import type * as struct from '../../structs';
+
+/**
+ * Byte-range lock record for NFSv4 LOCK operations.
+ * Represents a single byte-range lock held by a lock-owner on a file.
+ */
+export class ByteRangeLock {
+  constructor(
+    /**
+     * Stateid associated with this lock.
+     * Used by client to identify this lock in subsequent operations (LOCKU, etc.).
+     */
+    public readonly stateid: struct.Nfsv4Stateid,
+
+    /**
+     * Absolute file system path of the locked file.
+     * Used to identify which file this lock applies to.
+     */
+    public readonly path: string,
+
+    /**
+     * Lock type - READ or WRITE lock.
+     * READ locks (shared) can coexist with other READ locks.
+     * WRITE locks (exclusive) conflict with all other locks.
+     */
+    public readonly locktype: number,
+
+    /**
+     * Starting byte offset of the locked range.
+     * 0-based offset from start of file.
+     */
+    public readonly offset: bigint,
+
+    /**
+     * Length of the locked range in bytes.
+     * Special value 0xFFFFFFFFFFFFFFFF means "to end of file".
+     */
+    public readonly length: bigint,
+
+    /**
+     * Key identifying the lock-owner that holds this lock.
+     * Format: `${clientid}:${base64(owner)}`.
+     * Links this lock back to the owner for cleanup and conflict checking.
+     */
+    public readonly lockOwnerKey: string,
+  ) {}
+
+  /**
+   * Check if this lock overlaps with a given byte range.
+   * @param offset - Start offset to check
+   * @param length - Length to check
+   * @returns true if ranges overlap
+   */
+  public overlaps(offset: bigint, length: bigint): boolean {
+    const MAX_UINT64 = BigInt('0xFFFFFFFFFFFFFFFF');
+    const thisEnd = this.length === MAX_UINT64 ? MAX_UINT64 : this.offset + this.length;
+    const otherEnd = length === MAX_UINT64 ? MAX_UINT64 : offset + length;
+    return this.offset < otherEnd && offset < thisEnd;
+  }
+}

src/nfs/v4/server/operations/LockOwnerState.ts

@@ -0,0 +1,36 @@
+/**
+ * Lock-owner state record for NFSv4 LOCK operations.
+ * A lock-owner represents a single entity (process, thread) on a client
+ * that can acquire byte-range locks on files. Tracks all locks held by this owner.
+ */
+export class LockOwnerState {
+  constructor(
+    /**
+     * Client ID that owns this lock-owner.
+     * Links the owner back to the specific NFS client that created it.
+     */
+    public readonly clientid: bigint,
+
+    /**
+     * Opaque lock-owner identifier provided by the client.
+     * Typically represents a process or thread ID on the client.
+     * Combined with clientid, uniquely identifies this lock-owner.
+     */
+    public readonly owner: Uint8Array,
+
+    /**
+     * Sequence number for operations from this lock-owner.
+     * Used to serialize LOCK/LOCKU operations.
+     * Incremented after each successful stateful operation.
+     * Server rejects operations with incorrect sequence numbers to prevent replays.
+     */
+    public seqid: number,
+
+    /**
+     * Set of lock keys for all byte-range locks currently held by this owner.
+     * Format: lock keys are `${stateid}:${offset}:${length}`.
+     * Used to track all active locks and clean them up if the owner goes away.
+     */
+    public readonly locks: Set<string> = new Set(),
+  ) {}
+}