nfs

type AuthError struct {
	AuthStat
}

type AuthFlavor uint32

type AuthStat uint32

type CachingHandler interface {
	VerifierFor(path string, contents []fs.FileInfo) uint64

	// fs.FileInfo needs to be sorted by Name(), nil in case of a cache-miss
	DataForVerifier(path string, verifier uint64) []fs.FileInfo
}

type DefaultLogger struct {
	Level LogLevel
}

type DirOpArg struct {
	Handle   []byte
	Filename []byte
}

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
}

type FileAttribute struct {
	Type                FileType
	FileMode            uint32
	Nlink               uint32
	UID                 uint32
	GID                 uint32
	Filesize            uint64
	Used                uint64
	SpecData            [2]uint32
	FSID                uint64
	Fileid              uint64
	Atime, Mtime, Ctime FileTime
}

type FileCacheAttribute struct {
	Filesize     uint64
	Mtime, Ctime FileTime
}

type FileHandle []byte

type FileTime struct {
	Seconds  uint32
	Nseconds uint32
}

type FileType uint32

type HandleFunc func(ctx context.Context, w *response, userHandler Handler) error

type Handler interface {
	Mount(context.Context, net.Conn, MountRequest) (MountStatus, billy.Filesystem, []AuthFlavor)

	// Change can return 'nil' if filesystem is read-only
	// If the returned value can be cast to `UnixChange`, mknod and link RPCs will be available.
	Change(billy.Filesystem) billy.Change

	// Fill in information about a file system's free space.
	FSStat(context.Context, billy.Filesystem, *FSStat) error

	// represent file objects as opaque references
	// Can be safely implemented via helpers/cachinghandler.
	ToHandle(fs billy.Filesystem, path []string) []byte
	FromHandle(fh []byte) (billy.Filesystem, []string, error)
	InvalidateHandle(billy.Filesystem, []byte) error

	// How many handles can be safely maintained by the handler.
	HandleLimit() int
}

type LogLevel int

type Logger interface {
	SetLevel(level LogLevel)
	GetLevel() LogLevel
	ParseLevel(level string) (LogLevel, error)

	Panic(args ...interface{})
	Fatal(args ...interface{})
	Error(args ...interface{})
	Warn(args ...interface{})
	Info(args ...interface{})
	Debug(args ...interface{})
	Trace(args ...interface{})
	Print(args ...interface{})

	Panicf(format string, args ...interface{})
	Fatalf(format string, args ...interface{})
	Errorf(format string, args ...interface{})
	Warnf(format string, args ...interface{})
	Infof(format string, args ...interface{})
	Debugf(format string, args ...interface{})
	Tracef(format string, args ...interface{})
	Printf(format string, args ...interface{})
}

type MountProcedure uint32

type MountRequest struct {
	rpc.Header
	Dirpath []byte
}

type MountResponse struct {
	rpc.Header
	FileHandle
	AuthFlavors []int
}

type MountStatus uint32

type NFSProcedure uint32

type NFSStatus uint32

type NFSStatusError struct {
	NFSStatus
	WrappedErr error
}

type RPCError interface {
	// An RPCError is an `error` with this method
	Error() string
	// Code is the RPC Response code to send
	Code() ResponseCode
	// BinaryMarshaler is the on-wire representation of this error
	encoding.BinaryMarshaler
}

type RPCMismatchError struct {
	Low  uint32
	High uint32
}

type ReadDirStreamer interface {
	// ReadDirStream returns a page of directory entries for the given path.
	//
	// Parameters:
	//   - fs: The billy.Filesystem for this mount
	//   - path: Directory path components (e.g., ["dir", "subdir"])
	//   - cookie: Opaque pagination token from previous call (0 for first request)
	//   - count: Suggested maximum entries to return
	//
	// Returns:
	//   - entries: Directory entries for this page (may be fewer than count)
	//   - verifier: Cookie verifier for directory change detection (0 to disable)
	//   - nextCookie: Token for next page (0 indicates this is the last page)
	//   - err: Any error encountered
	//
	// Cookie semantics:
	//   - Cookie 0 always means "start from beginning"
	//   - Cookie values are opaque to go-nfs but must be less than 2^63
	//     (bit 63 is reserved internally for synthetic NFS cookies)
	//   - Returning nextCookie=0 signals end of directory (EOF)
	//
	// When cookie is 0, go-nfs will prepend "." and ".." entries automatically.
	// Implementations should NOT include "." and ".." in their returned entries.
	//
	// Error handling:
	//   - Return &NFSStatusError{NFSStatusBadCookie, err} if cookie is invalid/stale
	//   - Return &NFSStatusError{NFSStatusIO, err} for backend errors
	//   - Return &NFSStatusError{NFSStatusNoEnt, err} if directory doesn't exist
	//
	// Ordering note: go-nfs calls ReadDirStream before validating the cookie
	// verifier (because the verifier comes from this method's return value).
	// If the verifier check then fails, the response is discarded. This means
	// any state consumed during the call (e.g., continuation tokens) is lost.
	// Implementations should make state consumption recoverable — for example,
	// by deferring deletion of continuation tokens until after the page is
	// successfully served, or by allowing tokens to be re-fetched.
	ReadDirStream(
		fs billy.Filesystem,
		path []string,
		cookie uint64,
		count int,
	) (entries []os.FileInfo, verifier uint64, nextCookie uint64, err error)
}

type ResponseCode uint32

type ResponseCodeProcUnavailableError struct {
}

type ResponseCodeSystemError struct {
}

type Server struct {
	Handler
	ID [8]byte
	context.Context
}

type SetFileAttributes struct {
	SetMode  *uint32
	SetUID   *uint32
	SetGID   *uint32
	SetSize  *uint64
	SetAtime *time.Time
	SetMtime *time.Time
}

type StatusErrorWithBody struct {
	NFSStatusError
	Body []byte
}

type UnixChange interface {
	billy.Change
	Mknod(path string, mode uint32, major uint32, minor uint32) error
	Mkfifo(path string, mode uint32) error
	Socket(path string) error
	Link(path string, link string) error
}