mounting, directory listing work

Author: willscott

errors.go

@@ -170,6 +170,28 @@ func (s *NFSStatusError) Code() ResponseCode {
 // MarshalBinary - The binary form of the code.
 func (s *NFSStatusError) MarshalBinary() (data []byte, err error) {
 	var resp [4]byte
-	binary.LittleEndian.PutUint32(resp[0:4], uint32(s.NFSStatus))
+	binary.BigEndian.PutUint32(resp[0:4], uint32(s.NFSStatus))
+	return resp[:], nil
+}
+
+// NFSStatusErrorWithOpAttr is an NFS error where a 'post_op_attr' is expected
+type NFSStatusErrorWithOpAttr struct {
+	NFSStatus
+}
+
+// Error is The wrapped error
+func (s *NFSStatusErrorWithOpAttr) Error() string {
+	return s.NFSStatus.String()
+}
+
+// Code for NFS issues are successful RPC responses
+func (s *NFSStatusErrorWithOpAttr) Code() ResponseCode {
+	return ResponseCodeSuccess
+}
+
+// MarshalBinary - The binary form of the code.
+func (s *NFSStatusErrorWithOpAttr) MarshalBinary() (data []byte, err error) {
+	var resp [8]byte
+	binary.BigEndian.PutUint32(resp[0:4], uint32(s.NFSStatus))
 	return resp[:], nil
 }

example/helloworld/main.go

@@ -25,14 +25,19 @@ func (h *HelloWorldHandler) Mount(ctx context.Context, conn net.Conn, req nfs.Mo
 	return
 }
 
+// FSStat provides information about a filesystem.
+func (h *HelloWorldHandler) FSStat(ctx context.Context, f billy.Filesystem, s *nfs.FSStat) error {
+	return nil
+}
+
 // ToHandle handled by CachingHandler
-func (h *HelloWorldHandler) ToHandle(f billy.Filesystem, s string) []byte {
+func (h *HelloWorldHandler) ToHandle(f billy.Filesystem, s []string) []byte {
 	return []byte{}
 }
 
 // FromHandle handled by CachingHandler
-func (h *HelloWorldHandler) FromHandle([]byte) (billy.Filesystem, string, error) {
-	return nil, "", nil
+func (h *HelloWorldHandler) FromHandle([]byte) (billy.Filesystem, []string, error) {
+	return nil, []string{}, nil
 }
 
 func main() {

file.go

@@ -92,8 +92,8 @@ func ToFileAttribute(info os.FileInfo) FileAttribute {
 }
 
 // WritePostOpAttrs writes the `post_op_attr` representation of a files attributes
-func WritePostOpAttrs(writer io.Writer, fs billy.Filesystem, path string) {
-	attrs, err := fs.Stat(path)
+func WritePostOpAttrs(writer io.Writer, fs billy.Filesystem, path []string) {
+	attrs, err := fs.Stat(fs.Join(path...))
 	if err != nil {
 		_ = xdr.Write(writer, uint32(0))
 	}

filesystem.go

@@ -0,0 +1,15 @@
+package nfs
+
+import "time"
+
+// FSStat returns metadata about a file system
+type FSStat struct {
+	TotalSize      uint64
+	FreeSize       uint64
+	AvailableSize  uint64
+	TotalFiles     uint64
+	FreeFiles      uint64
+	AvailableFiles uint64
+	// CacheHint is called "invarsec" in the nfs standard
+	CacheHint time.Duration
+}

handler.go

@@ -9,9 +9,17 @@ import (
 
 // Handler represents the interface of the file system / vfs being exposed over NFS
 type Handler interface {
+	// Required methods
+
 	Mount(context.Context, net.Conn, MountRequest) (MountStatus, billy.Filesystem, []AuthFlavor)
 
+	// Optional methods - generic helpers or trivial implementations can be sufficient depending on use case.
+
+	// Fill in information about a file system's free space.
+	FSStat(context.Context, billy.Filesystem, *FSStat) error
+
 	// represent file objects as opaque references
-	ToHandle(fs billy.Filesystem, path string) []byte
-	FromHandle(fh []byte) (billy.Filesystem, string, error)
+	// Can be safely implemented via helpers/cachinghandler.
+	ToHandle(fs billy.Filesystem, path []string) []byte
+	FromHandle(fh []byte) (billy.Filesystem, []string, error)
 }

helpers/cachinghandler.go

@@ -25,24 +25,24 @@ type CachingHandler struct {
 
 type entry struct {
 	f billy.Filesystem
-	p string
+	p []string
 }
 
 // ToHandle takes a file and represents it with an opaque handle to reference it.
 // In stateless nfs (when it's serving a unix fs) this can be the device + inode
 // but we can generalize with a stateful local cache of handed out IDs.
-func (c *CachingHandler) ToHandle(f billy.Filesystem, path string) []byte {
+func (c *CachingHandler) ToHandle(f billy.Filesystem, path []string) []byte {
 	id := uuid.New()
 	c.activeHandles.Add(id, entry{f, path})
 	b, _ := id.MarshalBinary()
 	return b
 }
 
 // FromHandle converts from an opaque handle to the file it represents
-func (c *CachingHandler) FromHandle(fh []byte) (billy.Filesystem, string, error) {
+func (c *CachingHandler) FromHandle(fh []byte) (billy.Filesystem, []string, error) {
 	id, err := uuid.FromBytes(fh)
 	if err != nil {
-		return nil, "", err
+		return nil, []string{}, err
 	}
 
 	if cache, ok := c.activeHandles.Get(id); ok {
@@ -51,5 +51,5 @@ func (c *CachingHandler) FromHandle(fh []byte) (billy.Filesystem, string, error)
 			return f.f, f.p, nil
 		}
 	}
-	return nil, "", &nfs.NFSStatusError{NFSStatus: nfs.NFSStatusStale}
+	return nil, []string{}, &nfs.NFSStatusError{NFSStatus: nfs.NFSStatusStale}
 }

mount.go

@@ -13,6 +13,7 @@ const (
 
 func init() {
 	RegisterMessageHandler(mountServiceID, uint32(MountProcMount), onMount)
+	RegisterMessageHandler(mountServiceID, uint32(MountProcUmnt), onUMount)
 }
 
 func onMount(ctx context.Context, w *response, userHandle Handler) error {
@@ -31,11 +32,21 @@ func onMount(ctx context.Context, w *response, userHandle Handler) error {
 		return err
 	}
 
-	rootHndl := userHandle.ToHandle(handle, "/")
+	rootHndl := userHandle.ToHandle(handle, []string{})
 
 	if status == MountStatusOk {
 		xdr.Write(writer, rootHndl)
 		xdr.Write(writer, flavors)
 	}
 	return w.Write(writer.Bytes())
 }
+
+func onUMount(ctx context.Context, w *response, userHandle Handler) error {
+	_, err := xdr.ReadOpaque(w.req.Body)
+	if err != nil {
+		return err
+	}
+
+	w.writeHeader(ResponseCodeSuccess)
+	return nil
+}

nfs.go

@@ -1,11 +1,7 @@
 package nfs
 
 import (
-	"bytes"
 	"context"
-
-	"github.com/go-git/go-billy/v5"
-	"github.com/vmware/go-nfs-client/nfs/xdr"
 )
 
 const (
@@ -14,115 +10,15 @@ const (
 
 func init() {
 	RegisterMessageHandler(nfsServiceID, uint32(NFSProcedureNull), onNull)
+	RegisterMessageHandler(nfsServiceID, uint32(NFSProcedureLookup), onLookup)
 	RegisterMessageHandler(nfsServiceID, uint32(NFSProcedureGetAttr), onGetAttr)
+	RegisterMessageHandler(nfsServiceID, uint32(NFSProcedureAccess), onAccess)
+	RegisterMessageHandler(nfsServiceID, uint32(NFSProcedureReadDirPlus), onReadDirPlus)
+	RegisterMessageHandler(nfsServiceID, uint32(NFSProcedureFSStat), onFSStat)
 	RegisterMessageHandler(nfsServiceID, uint32(NFSProcedureFSInfo), onFSInfo)
+	RegisterMessageHandler(nfsServiceID, uint32(NFSProcedurePathConf), onPathConf)
 }
 
 func onNull(ctx context.Context, w *response, userHandle Handler) error {
 	return w.Write([]byte{})
 }
-
-func onGetAttr(ctx context.Context, w *response, userHandle Handler) error {
-	handle, err := xdr.ReadOpaque(w.req.Body)
-	if err != nil {
-		// TODO: wrap
-		return err
-	}
-
-	fs, path, err := userHandle.FromHandle(handle)
-	if err != nil {
-		return &NFSStatusError{NFSStatusStale}
-	}
-
-	info, err := fs.Stat(path)
-	if err != nil {
-		// TODO: wrap
-		return err
-	}
-	attr := ToFileAttribute(info)
-
-	writer := bytes.NewBuffer([]byte{})
-	if err := xdr.Write(writer, uint32(NFSStatusOk)); err != nil {
-		return err
-	}
-	if err := xdr.Write(writer, attr); err != nil {
-		return err
-	}
-
-	return w.Write(writer.Bytes())
-}
-
-const (
-	// FSInfoPropertyLink does the FS support hard links?
-	FSInfoPropertyLink = 0x0001
-	// FSInfoPropertySymlink does the FS support soft links?
-	FSInfoPropertySymlink = 0x0002
-	// FSInfoPropertyHomogeneous does the FS need PATHCONF calls for each file
-	FSInfoPropertyHomogeneous = 0x0008
-	// FSInfoPropertyCanSetTime can the FS support setting access/mod times?
-	FSInfoPropertyCanSetTime = 0x0010
-)
-
-func onFSInfo(ctx context.Context, w *response, userHandle Handler) error {
-	roothandle, err := xdr.ReadOpaque(w.req.Body)
-	if err != nil {
-		// TODO: wrap
-		return err
-	}
-	fs, path, err := userHandle.FromHandle(roothandle)
-	if err != nil {
-		// TODO: wrap
-		return err
-	}
-
-	writer := bytes.NewBuffer([]byte{})
-	if err := xdr.Write(writer, uint32(NFSStatusOk)); err != nil {
-		return err
-	}
-	WritePostOpAttrs(writer, fs, path)
-
-	type fsinfores struct {
-		Rtmax       uint32
-		Rtpref      uint32
-		Rtmult      uint32
-		Wtmax       uint32
-		Wtpref      uint32
-		Wtmult      uint32
-		Dtpref      uint32
-		Maxfilesize uint64
-		TimeDelta   uint64
-		Properties  uint32
-	}
-
-	res := fsinfores{
-		Rtmax:       1 << 30,
-		Rtpref:      1 << 30,
-		Rtmult:      4096,
-		Wtmax:       1 << 30,
-		Wtpref:      1 << 30,
-		Wtmult:      4096,
-		Dtpref:      8192,
-		Maxfilesize: 1 << 62, // wild guess. this seems big.
-		TimeDelta:   1,       // nanosecond precision.
-		Properties:  0,
-	}
-
-	// TODO: these aren't great indications of support, really.
-	if _, ok := fs.(billy.Symlink); ok {
-		res.Properties |= FSInfoPropertyLink
-		res.Properties |= FSInfoPropertySymlink
-	}
-	// TODO: if the nfs share spans multiple virtual mounts, may need
-	// to support granular PATHINFO responses.
-	res.Properties |= FSInfoPropertyHomogeneous
-	// TODO: not a perfect indicator
-	if billy.CapabilityCheck(fs, billy.WriteCapability) {
-		res.Properties |= FSInfoPropertyCanSetTime
-	}
-	// TODO: this whole struct should be specifiable by the userhandler.
-
-	if err := xdr.Write(writer, res); err != nil {
-		return err
-	}
-	return w.Write(writer.Bytes())
-}

nfs_onaccess.go

@@ -0,0 +1,42 @@
+package nfs
+
+import (
+	"bytes"
+	"context"
+
+	"github.com/go-git/go-billy/v5"
+	"github.com/vmware/go-nfs-client/nfs/xdr"
+)
+
+func onAccess(ctx context.Context, w *response, userHandle Handler) error {
+	roothandle, err := xdr.ReadOpaque(w.req.Body)
+	if err != nil {
+		// TODO: wrap
+		return err
+	}
+	fs, path, err := userHandle.FromHandle(roothandle)
+	if err != nil {
+		// TODO: wrap
+		return err
+	}
+	mask, err := xdr.ReadUint32(w.req.Body)
+	if err != nil {
+		// TODO: wrap
+		return err
+	}
+
+	writer := bytes.NewBuffer([]byte{})
+	if err := xdr.Write(writer, uint32(NFSStatusOk)); err != nil {
+		return err
+	}
+	WritePostOpAttrs(writer, fs, path)
+
+	if !billy.CapabilityCheck(fs, billy.WriteCapability) {
+		mask = mask & (1 | 2 | 0x20)
+	}
+
+	if err := xdr.Write(writer, mask); err != nil {
+		return err
+	}
+	return w.Write(writer.Bytes())
+}