v2api/reverse: move old fusefrontend_reverse out of the way

fusefrontend_reverse -> fusefrontend_reverse_v1api

1 files changed, 0 insertions, 472 deletions

diff --git a/internal/fusefrontend_reverse/rfs.go b/internal/fusefrontend_reverse/rfs.go
deleted file mode 100644
index 9f7d1f6..0000000
--- a/internal/fusefrontend_reverse/rfs.go
+++ /dev/null
@@ -1,472 +0,0 @@
-package fusefrontend_reverse
-
-import (
-	"fmt"
-	"path/filepath"
-	"syscall"
-
-	"golang.org/x/sys/unix"
-
-	"github.com/hanwen/go-fuse/v2/fuse"
-	"github.com/hanwen/go-fuse/v2/fuse/nodefs"
-	"github.com/hanwen/go-fuse/v2/fuse/pathfs"
-
-	"github.com/rfjakob/gocryptfs/internal/configfile"
-	"github.com/rfjakob/gocryptfs/internal/contentenc"
-	"github.com/rfjakob/gocryptfs/internal/cryptocore"
-	"github.com/rfjakob/gocryptfs/internal/fusefrontend"
-	"github.com/rfjakob/gocryptfs/internal/inomap"
-	"github.com/rfjakob/gocryptfs/internal/nametransform"
-	"github.com/rfjakob/gocryptfs/internal/pathiv"
-	"github.com/rfjakob/gocryptfs/internal/syscallcompat"
-	"github.com/rfjakob/gocryptfs/internal/tlog"
-
-	"github.com/sabhiram/go-gitignore"
-)
-
-// ReverseFS implements the pathfs.FileSystem interface and provides an
-// encrypted view of a plaintext directory.
-type ReverseFS struct {
-	// Embed pathfs.defaultFileSystem for a ENOSYS implementation of all methods
-	pathfs.FileSystem
-	// pathfs.loopbackFileSystem, see go-fuse/fuse/pathfs/loopback.go
-	loopbackfs pathfs.FileSystem
-	// Stores configuration arguments
-	args fusefrontend.Args
-	// Filename encryption helper
-	nameTransform nametransform.NameTransformer
-	// Content encryption helper
-	contentEnc *contentenc.ContentEnc
-	// Tests whether a path is excluded (hiden) from the user. Used by -exclude.
-	excluder ignore.IgnoreParser
-	// inoMap translates inode numbers from different devices to unique inode
-	// numbers.
-	inoMap *inomap.InoMap
-}
-
-var _ pathfs.FileSystem = &ReverseFS{}
-
-// NewFS returns an encrypted FUSE overlay filesystem.
-// In this case (reverse mode) the backing directory is plain-text and
-// ReverseFS provides an encrypted view.
-func NewFS(args fusefrontend.Args, c *contentenc.ContentEnc, n nametransform.NameTransformer) *ReverseFS {
-	initLongnameCache()
-	fs := &ReverseFS{
-		// pathfs.defaultFileSystem returns ENOSYS for all operations
-		FileSystem:    pathfs.NewDefaultFileSystem(),
-		loopbackfs:    pathfs.NewLoopbackFileSystem(args.Cipherdir),
-		args:          args,
-		nameTransform: n,
-		contentEnc:    c,
-		inoMap:        inomap.New(),
-	}
-	fs.prepareExcluder(args)
-	return fs
-}
-
-// relDir is identical to filepath.Dir excepts that it returns "" when
-// filepath.Dir would return ".".
-// In the FUSE API, the root directory is called "", and we actually want that.
-func relDir(path string) string {
-	dir := filepath.Dir(path)
-	if dir == "." {
-		return ""
-	}
-	return dir
-}
-
-// getFileInfo returns information on a ciphertext path "relPath":
-// - ftype: file type (as returned by getFileType)
-// - excluded: if the path is excluded
-// - pPath: if it's not a special file, the decrypted path
-// - err: non nil if any error happens
-func (rfs *ReverseFS) getFileInfo(relPath string) (ftype fileType, excluded bool, pPath string, err error) {
-	ftype = rfs.getFileType(relPath)
-	if ftype == typeConfig {
-		excluded, pPath, err = false, "", nil
-		return
-	}
-	if ftype == typeDiriv {
-		parentDir := nametransform.Dir(relPath)
-		_, excluded, _, err = rfs.getFileInfo(parentDir)
-		pPath = ""
-		return
-	}
-	if ftype == typeName {
-		parentDir := nametransform.Dir(relPath)
-		var parentExcluded bool
-		_, parentExcluded, _, err = rfs.getFileInfo(parentDir)
-		if parentExcluded || err != nil {
-			excluded, pPath = parentExcluded, ""
-			return
-		}
-		relPath = nametransform.RemoveLongNameSuffix(relPath)
-	}
-	pPath, err = rfs.decryptPath(relPath)
-	excluded = err == nil && rfs.isExcludedPlain(pPath)
-	return
-}
-
-type fileType int
-
-// Values returned by getFileType
-const (
-	// A regular file/directory/symlink
-	typeRegular fileType = iota
-	// A DirIV (gocryptfs.diriv) file
-	typeDiriv
-	// A gocryptfs.longname.*.name file for a file with a long name
-	typeName
-	// The config file gocryptfs.conf
-	typeConfig
-)
-
-// getFileType returns the type of file (one of the fileType constants above).
-func (rfs *ReverseFS) getFileType(cPath string) fileType {
-	if !rfs.args.PlaintextNames {
-		cName := filepath.Base(cPath)
-		// Is it a gocryptfs.diriv file?
-		if cName == nametransform.DirIVFilename {
-			return typeDiriv
-		}
-		// Is it a gocryptfs.longname.*.name file?
-		if t := nametransform.NameType(cName); t == nametransform.LongNameFilename {
-			return typeName
-		}
-	}
-	if rfs.isTranslatedConfig(cPath) {
-		return typeConfig
-	}
-	return typeRegular
-}
-
-// isTranslatedConfig returns true if the default config file name is in use
-// and the ciphertext path is "gocryptfs.conf".
-// "gocryptfs.conf" then maps to ".gocryptfs.reverse.conf" in the plaintext
-// directory.
-func (rfs *ReverseFS) isTranslatedConfig(relPath string) bool {
-	if rfs.args.ConfigCustom {
-		return false
-	}
-	if relPath == configfile.ConfDefaultName {
-		return true
-	}
-	return false
-}
-
-// GetAttr - FUSE call
-// "relPath" is the relative ciphertext path
-func (rfs *ReverseFS) GetAttr(relPath string, context *fuse.Context) (*fuse.Attr, fuse.Status) {
-	ftype, excluded, pPath, err := rfs.getFileInfo(relPath)
-	if excluded {
-		return nil, fuse.ENOENT
-	}
-	if err != nil {
-		return nil, fuse.ToStatus(err)
-	}
-	// Handle "gocryptfs.conf"
-	if ftype == typeConfig {
-		absConfPath, _ := rfs.abs(configfile.ConfReverseName, nil)
-		var st syscall.Stat_t
-		err = syscall.Lstat(absConfPath, &st)
-		if err != nil {
-			return nil, fuse.ToStatus(err)
-		}
-		rfs.inoMap.TranslateStat(&st)
-		var a fuse.Attr
-		a.FromStat(&st)
-		if rfs.args.ForceOwner != nil {
-			a.Owner = *rfs.args.ForceOwner
-		}
-		return &a, fuse.OK
-	}
-	// Handle virtual files (gocryptfs.diriv, *.name)
-	var f nodefs.File
-	var status fuse.Status
-	virtual := false
-	if ftype == typeDiriv {
-		virtual = true
-		f, status = rfs.newDirIVFile(relPath)
-	}
-	if ftype == typeName {
-		virtual = true
-		f, status = rfs.newNameFile(relPath)
-	}
-	if virtual {
-		if !status.Ok() {
-			tlog.Warn.Printf("GetAttr %q: newXFile failed: %v\n", relPath, status)
-			return nil, status
-		}
-		var a fuse.Attr
-		status = f.GetAttr(&a)
-		if rfs.args.ForceOwner != nil {
-			a.Owner = *rfs.args.ForceOwner
-		}
-		return &a, status
-	}
-	// Normal file / directory
-	dirfd, name, err := rfs.openBackingDir(pPath)
-	if err != nil {
-		return nil, fuse.ToStatus(err)
-	}
-	// Stat the backing file/dir using Fstatat
-	var st syscall.Stat_t
-	{
-		var st2 unix.Stat_t
-		err = syscallcompat.Fstatat(dirfd, name, &st2, unix.AT_SYMLINK_NOFOLLOW)
-		syscall.Close(dirfd)
-		if err != nil {
-			return nil, fuse.ToStatus(err)
-		}
-		st = syscallcompat.Unix2syscall(st2)
-	}
-	rfs.inoMap.TranslateStat(&st)
-	var a fuse.Attr
-	a.FromStat(&st)
-	// Calculate encrypted file size
-	if a.IsRegular() {
-		a.Size = rfs.contentEnc.PlainSizeToCipherSize(a.Size)
-	} else if a.IsSymlink() {
-		var linkTarget string
-		var readlinkStatus fuse.Status
-
-		linkTarget, readlinkStatus = rfs.Readlink(relPath, context)
-		if !readlinkStatus.Ok() {
-			return nil, readlinkStatus
-		}
-
-		a.Size = uint64(len(linkTarget))
-	}
-	if rfs.args.ForceOwner != nil {
-		a.Owner = *rfs.args.ForceOwner
-	}
-	return &a, fuse.OK
-}
-
-// Access - FUSE call
-func (rfs *ReverseFS) Access(relPath string, mode uint32, context *fuse.Context) fuse.Status {
-	ftype, excluded, pPath, err := rfs.getFileInfo(relPath)
-	if excluded {
-		return fuse.ENOENT
-	}
-	if err != nil {
-		return fuse.ToStatus(err)
-	}
-	if ftype != typeRegular {
-		// access(2) R_OK flag for checking if the file is readable, always 4 as defined in POSIX.
-		ROK := uint32(0x4)
-		// Virtual files can always be read and never written
-		if mode == ROK || mode == 0 {
-			return fuse.OK
-		}
-		return fuse.EPERM
-	}
-	dirfd, name, err := rfs.openBackingDir(pPath)
-	if err != nil {
-		return fuse.ToStatus(err)
-	}
-	err = syscallcompat.Faccessat(dirfd, name, mode)
-	syscall.Close(dirfd)
-	return fuse.ToStatus(err)
-}
-
-// Open - FUSE call
-func (rfs *ReverseFS) Open(relPath string, flags uint32, context *fuse.Context) (fuseFile nodefs.File, status fuse.Status) {
-	ftype, excluded, pPath, err := rfs.getFileInfo(relPath)
-	if excluded {
-		return nil, fuse.ENOENT
-	}
-	if err != nil {
-		return nil, fuse.ToStatus(err)
-	}
-	if ftype == typeConfig {
-		return rfs.loopbackfs.Open(configfile.ConfReverseName, flags, context)
-	}
-	if ftype == typeDiriv {
-		return rfs.newDirIVFile(relPath)
-	}
-	if ftype == typeName {
-		return rfs.newNameFile(relPath)
-	}
-	return rfs.newFile(relPath, pPath)
-}
-
-func (rfs *ReverseFS) openDirPlaintextnames(relPath string, entries []fuse.DirEntry) ([]fuse.DirEntry, fuse.Status) {
-	if relPath != "" || rfs.args.ConfigCustom {
-		return entries, fuse.OK
-	}
-	// We are in the root dir and the default config file name
-	// ".gocryptfs.reverse.conf" is used. We map it to "gocryptfs.conf".
-	dupe := -1
-	status := fuse.OK
-	for i := range entries {
-		if entries[i].Name == configfile.ConfReverseName {
-			entries[i].Name = configfile.ConfDefaultName
-		} else if entries[i].Name == configfile.ConfDefaultName {
-			dupe = i
-		}
-	}
-	if dupe >= 0 {
-		// Warn the user loudly: The gocryptfs.conf_NAME_COLLISION file will
-		// throw ENOENT errors that are hard to miss.
-		tlog.Warn.Printf("The file %q is mapped to %q and shadows another file. Please rename %q in directory %q.",
-			configfile.ConfReverseName, configfile.ConfDefaultName, configfile.ConfDefaultName, rfs.args.Cipherdir)
-		entries[dupe].Name = "gocryptfs.conf_NAME_COLLISION_" + fmt.Sprintf("%d", cryptocore.RandUint64())
-	}
-	return entries, status
-}
-
-// OpenDir - FUSE readdir call
-func (rfs *ReverseFS) OpenDir(cipherPath string, context *fuse.Context) ([]fuse.DirEntry, fuse.Status) {
-	ftype, excluded, relPath, err := rfs.getFileInfo(cipherPath)
-	if excluded {
-		return nil, fuse.ENOENT
-	}
-	if err != nil {
-		return nil, fuse.ToStatus(err)
-	}
-	if ftype != typeRegular {
-		return nil, fuse.ENOTDIR
-	}
-	// Read plaintext dir
-	dirfd, err := syscallcompat.OpenDirNofollow(rfs.args.Cipherdir, filepath.Dir(relPath))
-	if err != nil {
-		return nil, fuse.ToStatus(err)
-	}
-	fd, err := syscallcompat.Openat(dirfd, filepath.Base(relPath), syscall.O_RDONLY|syscall.O_DIRECTORY|syscall.O_NOFOLLOW, 0)
-	syscall.Close(dirfd)
-	if err != nil {
-		return nil, fuse.ToStatus(err)
-	}
-	entries, err := syscallcompat.Getdents(fd)
-	syscall.Close(fd)
-	if err != nil {
-		return nil, fuse.ToStatus(err)
-	}
-	if rfs.args.PlaintextNames {
-		var status fuse.Status
-		entries, status = rfs.openDirPlaintextnames(cipherPath, entries)
-		if !status.Ok() {
-			return nil, status
-		}
-		entries = rfs.excludeDirEntries(relPath, entries)
-		return entries, fuse.OK
-	}
-	// Filter out excluded entries
-	entries = rfs.excludeDirEntries(relPath, entries)
-	// Allocate maximum possible number of virtual files.
-	// If all files have long names we need a virtual ".name" file for each,
-	// plus one for gocryptfs.diriv.
-	virtualFiles := make([]fuse.DirEntry, len(entries)+1)
-	// Virtual gocryptfs.diriv file
-	virtualFiles[0] = fuse.DirEntry{
-		Mode: virtualFileMode,
-		Name: nametransform.DirIVFilename,
-	}
-	// Actually used entries
-	nVirtual := 1
-
-	// Encrypt names
-	dirIV := pathiv.Derive(cipherPath, pathiv.PurposeDirIV)
-	for i := range entries {
-		var cName string
-		// ".gocryptfs.reverse.conf" in the root directory is mapped to "gocryptfs.conf"
-		if cipherPath == "" && entries[i].Name == configfile.ConfReverseName &&
-			!rfs.args.ConfigCustom {
-			cName = configfile.ConfDefaultName
-		} else {
-			cName = rfs.nameTransform.EncryptName(entries[i].Name, dirIV)
-			if len(cName) > unix.NAME_MAX {
-				cName = rfs.nameTransform.HashLongName(cName)
-				dotNameFile := fuse.DirEntry{
-					Mode: virtualFileMode,
-					Name: cName + nametransform.LongNameSuffix,
-				}
-				virtualFiles[nVirtual] = dotNameFile
-				nVirtual++
-			}
-		}
-		entries[i].Name = cName
-	}
-	// Add virtual files
-	entries = append(entries, virtualFiles[:nVirtual]...)
-	return entries, fuse.OK
-}
-
-// excludeDirEntries filters out directory entries that are "-exclude"d.
-// pDir is the relative plaintext path to the directory these entries are
-// from. The entries should be plaintext files.
-func (rfs *ReverseFS) excludeDirEntries(pDir string, entries []fuse.DirEntry) (filtered []fuse.DirEntry) {
-	if rfs.excluder == nil {
-		return entries
-	}
-	filtered = make([]fuse.DirEntry, 0, len(entries))
-	for _, entry := range entries {
-		// filepath.Join handles the case of pDir="" correctly:
-		// Join("", "foo") -> "foo". This does not: pDir + "/" + name"
-		p := filepath.Join(pDir, entry.Name)
-		if rfs.isExcludedPlain(p) {
-			// Skip file
-			continue
-		}
-		filtered = append(filtered, entry)
-	}
-	return filtered
-}
-
-// StatFs - FUSE call. Returns information about the filesystem (free space
-// etc).
-// Securing statfs against symlink races seems to be more trouble than
-// it's worth, so we just ignore the path and always return info about the
-// backing storage root dir.
-func (rfs *ReverseFS) StatFs(relPath string) *fuse.StatfsOut {
-	_, excluded, _, err := rfs.getFileInfo(relPath)
-	if excluded || err != nil {
-		return nil
-	}
-	var s syscall.Statfs_t
-	err = syscall.Statfs(rfs.args.Cipherdir, &s)
-	if err != nil {
-		return nil
-	}
-	out := &fuse.StatfsOut{}
-	out.FromStatfsT(&s)
-	return out
-}
-
-// Readlink - FUSE call
-func (rfs *ReverseFS) Readlink(relPath string, context *fuse.Context) (string, fuse.Status) {
-	ftype, excluded, pPath, err := rfs.getFileInfo(relPath)
-	if excluded {
-		return "", fuse.ENOENT
-	}
-	if err != nil {
-		return "", fuse.ToStatus(err)
-	}
-	if ftype != typeRegular {
-		return "", fuse.EINVAL
-	}
-	dirfd, name, err := rfs.openBackingDir(pPath)
-	if err != nil {
-		return "", fuse.ToStatus(err)
-	}
-	// read the link target using Readlinkat
-	plainTarget, err := syscallcompat.Readlinkat(dirfd, name)
-	syscall.Close(dirfd)
-	if err != nil {
-		return "", fuse.ToStatus(err)
-	}
-	if rfs.args.PlaintextNames {
-		return plainTarget, fuse.OK
-	}
-	nonce := pathiv.Derive(relPath, pathiv.PurposeSymlinkIV)
-	// Symlinks are encrypted like file contents and base64-encoded
-	cBinTarget := rfs.contentEnc.EncryptBlockNonce([]byte(plainTarget), 0, nil, nonce)
-	cTarget := rfs.nameTransform.B64EncodeToString(cBinTarget)
-	// The kernel will reject a symlink target above 4096 chars and return
-	// and I/O error to the user. Better emit the proper error ourselves.
-	if len(cTarget) > syscallcompat.PATH_MAX {
-		return "", fuse.Status(syscall.ENAMETOOLONG)
-	}
-	return cTarget, fuse.OK
-}