feat: full NFSv4.2 server and client in pure Go

Assisted-by: GLM 5.3 Flash

internal/nfs4/lock.go

@@ -0,0 +1,158 @@
+// Copyright (c) 2026 Petr Balvín <opensource@petrbalvin.org> (https://petrbalvin.org)
+// SPDX-License-Identifier: MIT
+
+// The byte range locking layer of RFC 8881 sections 15.10 to 15.13 and
+// 18.11 to 18.13: LOCK, LOCKT and LOCKU with their share of unions.
+
+package nfs4
+
+import (
+	"sourcedock.dev/petrbalvin/nfs/internal/xdr"
+)
+
+// Lock types of the nfs_lock_type4 enum.
+const (
+	LockTypeRead  = 1
+	LockTypeWrite = 2
+)
+
+// AppendLockArgsNew encodes the LOCK4args for the first LOCK of a new
+// lock owner: the locker union carries the open stateid the lock hangs
+// from and the identity of the lock owner.
+func AppendLockArgsNew(b []byte, openStateid Stateid, lockClientid uint64, lockOwner []byte, lockType uint32, reclaim bool, offset, length uint64) []byte {
+	b = xdr.AppendUint32(b, OpLock)
+	b = xdr.AppendUint32(b, lockType)
+	b = xdr.AppendBool(b, reclaim)
+	b = xdr.AppendUint64(b, offset)
+	b = xdr.AppendUint64(b, length)
+	b = xdr.AppendBool(b, true) // new_lock_owner
+	b = xdr.AppendUint32(b, 0)  // open_seqid, deprecated
+	b = openStateid.Append(b)
+	b = xdr.AppendUint32(b, 0) // lock_seqid, deprecated
+	b = xdr.AppendUint64(b, lockClientid)
+	return xdr.AppendVarOpaque(b, lockOwner)
+}
+
+// AppendLockArgsExisting encodes the LOCK4args for a lock owner that
+// already holds a lock stateid.
+func AppendLockArgsExisting(b []byte, lockStateid Stateid, lockType uint32, offset, length uint64) []byte {
+	b = xdr.AppendUint32(b, OpLock)
+	b = xdr.AppendUint32(b, lockType)
+	b = xdr.AppendBool(b, reclaimMarker)
+	b = xdr.AppendUint64(b, offset)
+	b = xdr.AppendUint64(b, length)
+	b = xdr.AppendBool(b, false) // not a new lock owner
+	b = lockStateid.Append(b)
+	return xdr.AppendUint32(b, 0) // lock_seqid, deprecated
+}
+
+// reclaimMarker keeps the bool arguments of the locker union readable.
+const reclaimMarker = false
+
+// AppendLockuArgs encodes the LOCKU argop: the release of one range of a
+// lock stateid.
+func AppendLockuArgs(b []byte, lockStateid Stateid, offset, length uint64) []byte {
+	b = xdr.AppendUint32(b, OpLocku)
+	b = xdr.AppendUint32(b, LockTypeWrite) // the standard echoes a type; the stateid rules
+	b = xdr.AppendUint32(b, 0)             // seqid, deprecated
+	b = lockStateid.Append(b)
+	b = xdr.AppendUint64(b, offset)
+	return xdr.AppendUint64(b, length)
+}
+
+// AppendLocktArgs encodes the LOCKT argop: a probe whether a lock of the
+// type over the range would conflict, for the named owner.
+func AppendLocktArgs(b []byte, lockType uint32, offset, length uint64, clientid uint64, owner []byte) []byte {
+	b = xdr.AppendUint32(b, OpLockt)
+	b = xdr.AppendUint32(b, lockType)
+	b = xdr.AppendUint64(b, offset)
+	b = xdr.AppendUint64(b, length)
+	b = xdr.AppendUint64(b, clientid)
+	return xdr.AppendVarOpaque(b, owner)
+}
+
+// AppendLockRes encodes a successful LOCK4res: the lock stateid.
+func AppendLockRes(b []byte, stateid Stateid) []byte {
+	return stateid.Append(b)
+}
+
+// AppendLockuRes encodes a successful LOCKU4res: the lock stateid, with
+// its sequence bumped.
+func AppendLockuRes(b []byte, stateid Stateid) []byte {
+	return stateid.Append(b)
+}
+
+// AppendLocktResOK appends a LOCKT result for the OK status, which carries
+// nothing: no conflict was found.
+func AppendLocktResOK(b []byte) []byte {
+	return b
+}
+
+// AppendLocktResDenied appends a LOCKT result body for the DENIED status:
+// the conflicting lock, with its holder.
+func AppendLocktResDenied(b []byte, offset, length uint64, lockType uint32, clientid uint64, owner []byte) []byte {
+	b = xdr.AppendUint64(b, offset)
+	b = xdr.AppendUint64(b, length)
+	b = xdr.AppendUint32(b, lockType)
+	b = xdr.AppendUint64(b, clientid)
+	return xdr.AppendVarOpaque(b, owner)
+}
+
+// A LockDenied is the conflicting lock a LOCKT answers.
+type LockDenied struct {
+	Offset   uint64
+	Length   uint64
+	LockType uint32
+	ClientID uint64
+	Owner    []byte
+}
+
+// DecodeLocktResBody decodes a LOCKT body. On the DENIED status it returns
+// the conflicting lock; on OK the body is empty.
+func DecodeLocktResBody(status uint32, body []byte) (LockDenied, error) {
+	if status != ErrDenied {
+		return LockDenied{}, nil
+	}
+	d := xdr.NewDecoder(body)
+	var denied LockDenied
+	var err error
+	if denied.Offset, err = d.Uint64(); err != nil {
+		return denied, err
+	}
+	if denied.Length, err = d.Uint64(); err != nil {
+		return denied, err
+	}
+	if denied.LockType, err = d.Uint32(); err != nil {
+		return denied, err
+	}
+	if denied.ClientID, err = d.Uint64(); err != nil {
+		return denied, err
+	}
+	denied.Owner, err = d.VarOpaque()
+	return denied, err
+}
+
+// resBodyLenLockt measures the LOCKT body: empty on OK, a full LOCK4denied
+// on DENIED.
+func resBodyLenLockt(status uint32, body []byte) (int, error) {
+	if status != ErrDenied {
+		return 0, nil
+	}
+	d := xdr.NewDecoder(body)
+	if _, err := d.Uint64(); err != nil {
+		return 0, err
+	}
+	if _, err := d.Uint64(); err != nil {
+		return 0, err
+	}
+	if _, err := d.Uint32(); err != nil {
+		return 0, err
+	}
+	if _, err := d.Uint64(); err != nil {
+		return 0, err
+	}
+	if _, err := d.VarOpaque(); err != nil {
+		return 0, err
+	}
+	return len(body) - d.Remaining(), nil
+}