2020-02-26 17:28:55 +01:00
|
|
|
// +build linux,go1.13 darwin,go1.13 freebsd,go1.13
|
2016-07-18 00:03:23 +02:00
|
|
|
|
|
|
|
package mount
|
|
|
|
|
|
|
|
import (
|
2019-05-07 14:53:16 +02:00
|
|
|
"context"
|
2016-07-18 00:03:23 +02:00
|
|
|
"os"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"bazil.org/fuse"
|
|
|
|
fusefs "bazil.org/fuse/fs"
|
|
|
|
"github.com/pkg/errors"
|
2019-07-28 19:47:38 +02:00
|
|
|
"github.com/rclone/rclone/cmd/mountlib"
|
2019-10-18 11:53:07 +02:00
|
|
|
"github.com/rclone/rclone/fs"
|
2019-07-28 19:47:38 +02:00
|
|
|
"github.com/rclone/rclone/fs/log"
|
|
|
|
"github.com/rclone/rclone/vfs"
|
2016-07-18 00:03:23 +02:00
|
|
|
)
|
|
|
|
|
|
|
|
// Dir represents a directory entry
|
|
|
|
type Dir struct {
|
2017-10-28 21:01:34 +02:00
|
|
|
*vfs.Dir
|
2016-07-18 00:03:23 +02:00
|
|
|
}
|
|
|
|
|
2019-04-30 14:06:24 +02:00
|
|
|
// Check interface satisfied
|
2016-07-18 00:03:23 +02:00
|
|
|
var _ fusefs.Node = (*Dir)(nil)
|
|
|
|
|
2017-03-23 20:41:21 +01:00
|
|
|
// Attr updates the attributes of a directory
|
2017-05-09 12:39:33 +02:00
|
|
|
func (d *Dir) Attr(ctx context.Context, a *fuse.Attr) (err error) {
|
2018-01-12 17:30:54 +01:00
|
|
|
defer log.Trace(d, "")("attr=%+v, err=%v", a, &err)
|
2018-03-02 17:39:42 +01:00
|
|
|
a.Valid = mountlib.AttrTimeout
|
2017-10-29 12:00:56 +01:00
|
|
|
a.Gid = d.VFS().Opt.GID
|
|
|
|
a.Uid = d.VFS().Opt.UID
|
|
|
|
a.Mode = os.ModeDir | d.VFS().Opt.DirPerms
|
2017-05-02 23:35:07 +02:00
|
|
|
modTime := d.ModTime()
|
|
|
|
a.Atime = modTime
|
|
|
|
a.Mtime = modTime
|
|
|
|
a.Ctime = modTime
|
|
|
|
a.Crtime = modTime
|
2017-02-06 22:17:45 +01:00
|
|
|
// FIXME include Valid so get some caching?
|
2017-05-02 23:35:07 +02:00
|
|
|
// FIXME fs.Debugf(d.path, "Dir.Attr %+v", a)
|
2016-07-18 00:03:23 +02:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-03-23 20:41:21 +01:00
|
|
|
// Check interface satisfied
|
|
|
|
var _ fusefs.NodeSetattrer = (*Dir)(nil)
|
|
|
|
|
|
|
|
// Setattr handles attribute changes from FUSE. Currently supports ModTime only.
|
2017-05-02 23:35:07 +02:00
|
|
|
func (d *Dir) Setattr(ctx context.Context, req *fuse.SetattrRequest, resp *fuse.SetattrResponse) (err error) {
|
2018-01-12 17:30:54 +01:00
|
|
|
defer log.Trace(d, "stat=%+v", req)("err=%v", &err)
|
2017-10-29 12:00:56 +01:00
|
|
|
if d.VFS().Opt.NoModTime {
|
2017-03-23 20:41:21 +01:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
if req.Valid.MtimeNow() {
|
2017-05-02 23:35:07 +02:00
|
|
|
err = d.SetModTime(time.Now())
|
2017-03-23 20:41:21 +01:00
|
|
|
} else if req.Valid.Mtime() {
|
2017-05-02 23:35:07 +02:00
|
|
|
err = d.SetModTime(req.Mtime)
|
2017-03-23 20:41:21 +01:00
|
|
|
}
|
|
|
|
|
2017-05-02 23:35:07 +02:00
|
|
|
return translateError(err)
|
2016-07-18 00:03:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Check interface satisfied
|
|
|
|
var _ fusefs.NodeRequestLookuper = (*Dir)(nil)
|
|
|
|
|
|
|
|
// Lookup looks up a specific entry in the receiver.
|
|
|
|
//
|
|
|
|
// Lookup should return a Node corresponding to the entry. If the
|
|
|
|
// name does not exist in the directory, Lookup should return ENOENT.
|
|
|
|
//
|
|
|
|
// Lookup need not to handle the names "." and "..".
|
|
|
|
func (d *Dir) Lookup(ctx context.Context, req *fuse.LookupRequest, resp *fuse.LookupResponse) (node fusefs.Node, err error) {
|
2018-01-12 17:30:54 +01:00
|
|
|
defer log.Trace(d, "name=%q", req.Name)("node=%+v, err=%v", &node, &err)
|
2017-10-29 12:36:38 +01:00
|
|
|
mnode, err := d.Dir.Stat(req.Name)
|
2016-07-18 00:03:23 +02:00
|
|
|
if err != nil {
|
2017-05-02 23:35:07 +02:00
|
|
|
return nil, translateError(err)
|
2016-07-18 00:03:23 +02:00
|
|
|
}
|
2018-03-02 17:39:42 +01:00
|
|
|
resp.EntryValid = mountlib.AttrTimeout
|
2020-05-01 19:31:19 +02:00
|
|
|
// Check the mnode to see if it has a fuse Node cached
|
|
|
|
// We must return the same fuse nodes for vfs Nodes
|
|
|
|
node, ok := mnode.Sys().(fusefs.Node)
|
|
|
|
if ok {
|
|
|
|
return node, nil
|
|
|
|
}
|
2017-05-02 23:35:07 +02:00
|
|
|
switch x := mnode.(type) {
|
2017-10-28 21:01:34 +02:00
|
|
|
case *vfs.File:
|
2020-05-01 19:31:19 +02:00
|
|
|
node = &File{x}
|
2017-10-28 21:01:34 +02:00
|
|
|
case *vfs.Dir:
|
2020-05-01 19:31:19 +02:00
|
|
|
node = &Dir{x}
|
|
|
|
default:
|
|
|
|
panic("bad type")
|
2017-05-02 23:35:07 +02:00
|
|
|
}
|
2020-05-01 19:31:19 +02:00
|
|
|
// Cache the node for later
|
|
|
|
mnode.SetSys(node)
|
|
|
|
return node, nil
|
2016-07-18 00:03:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Check interface satisfied
|
|
|
|
var _ fusefs.HandleReadDirAller = (*Dir)(nil)
|
|
|
|
|
|
|
|
// ReadDirAll reads the contents of the directory
|
|
|
|
func (d *Dir) ReadDirAll(ctx context.Context) (dirents []fuse.Dirent, err error) {
|
2017-05-09 12:39:33 +02:00
|
|
|
itemsRead := -1
|
2018-01-12 17:30:54 +01:00
|
|
|
defer log.Trace(d, "")("item=%d, err=%v", &itemsRead, &err)
|
2017-05-02 23:35:07 +02:00
|
|
|
items, err := d.Dir.ReadDirAll()
|
2016-07-18 00:03:23 +02:00
|
|
|
if err != nil {
|
2017-05-02 23:35:07 +02:00
|
|
|
return nil, translateError(err)
|
2016-07-18 00:03:23 +02:00
|
|
|
}
|
2017-11-18 12:47:21 +01:00
|
|
|
for _, node := range items {
|
2019-10-18 11:53:07 +02:00
|
|
|
name := node.Name()
|
|
|
|
if len(name) >= mountlib.MaxLeafSize {
|
|
|
|
fs.Errorf(d, "Name too long (%d bytes) for FUSE, skipping: %s", len(name), name)
|
|
|
|
continue
|
|
|
|
}
|
2017-11-18 12:47:21 +01:00
|
|
|
var dirent = fuse.Dirent{
|
|
|
|
// Inode FIXME ???
|
|
|
|
Type: fuse.DT_File,
|
2019-10-18 11:53:07 +02:00
|
|
|
Name: name,
|
2017-11-18 12:47:21 +01:00
|
|
|
}
|
|
|
|
if node.IsDir() {
|
|
|
|
dirent.Type = fuse.DT_Dir
|
2016-07-18 00:03:23 +02:00
|
|
|
}
|
|
|
|
dirents = append(dirents, dirent)
|
|
|
|
}
|
2017-05-09 12:39:33 +02:00
|
|
|
itemsRead = len(dirents)
|
2016-07-18 00:03:23 +02:00
|
|
|
return dirents, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
var _ fusefs.NodeCreater = (*Dir)(nil)
|
|
|
|
|
|
|
|
// Create makes a new file
|
2017-05-09 12:39:33 +02:00
|
|
|
func (d *Dir) Create(ctx context.Context, req *fuse.CreateRequest, resp *fuse.CreateResponse) (node fusefs.Node, handle fusefs.Handle, err error) {
|
2018-01-12 17:30:54 +01:00
|
|
|
defer log.Trace(d, "name=%q", req.Name)("node=%v, handle=%v, err=%v", &node, &handle, &err)
|
2017-12-07 13:34:18 +01:00
|
|
|
file, err := d.Dir.Create(req.Name, int(req.Flags))
|
2017-11-06 13:22:45 +01:00
|
|
|
if err != nil {
|
|
|
|
return nil, nil, translateError(err)
|
|
|
|
}
|
2017-11-18 12:50:58 +01:00
|
|
|
fh, err := file.Open(int(req.Flags) | os.O_CREATE)
|
2016-07-18 00:03:23 +02:00
|
|
|
if err != nil {
|
2017-05-02 23:35:07 +02:00
|
|
|
return nil, nil, translateError(err)
|
2016-07-18 00:03:23 +02:00
|
|
|
}
|
2020-05-01 19:31:19 +02:00
|
|
|
node = &File{file}
|
|
|
|
file.SetSys(node) // cache the FUSE node for later
|
|
|
|
return node, &FileHandle{fh}, err
|
2016-07-18 00:03:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
var _ fusefs.NodeMkdirer = (*Dir)(nil)
|
|
|
|
|
|
|
|
// Mkdir creates a new directory
|
2017-05-09 12:39:33 +02:00
|
|
|
func (d *Dir) Mkdir(ctx context.Context, req *fuse.MkdirRequest) (node fusefs.Node, err error) {
|
2018-01-12 17:30:54 +01:00
|
|
|
defer log.Trace(d, "name=%q", req.Name)("node=%+v, err=%v", &node, &err)
|
2017-05-02 23:35:07 +02:00
|
|
|
dir, err := d.Dir.Mkdir(req.Name)
|
2017-01-06 12:24:22 +01:00
|
|
|
if err != nil {
|
2017-05-02 23:35:07 +02:00
|
|
|
return nil, translateError(err)
|
2016-07-18 00:03:23 +02:00
|
|
|
}
|
2020-05-01 19:31:19 +02:00
|
|
|
node = &Dir{dir}
|
|
|
|
dir.SetSys(node) // cache the FUSE node for later
|
|
|
|
return node, nil
|
2016-07-18 00:03:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
var _ fusefs.NodeRemover = (*Dir)(nil)
|
|
|
|
|
|
|
|
// Remove removes the entry with the given name from
|
|
|
|
// the receiver, which must be a directory. The entry to be removed
|
|
|
|
// may correspond to a file (unlink) or to a directory (rmdir).
|
2017-05-09 12:39:33 +02:00
|
|
|
func (d *Dir) Remove(ctx context.Context, req *fuse.RemoveRequest) (err error) {
|
2018-01-12 17:30:54 +01:00
|
|
|
defer log.Trace(d, "name=%q", req.Name)("err=%v", &err)
|
2017-10-26 16:37:45 +02:00
|
|
|
err = d.Dir.RemoveName(req.Name)
|
2016-07-18 00:03:23 +02:00
|
|
|
if err != nil {
|
2017-05-02 23:35:07 +02:00
|
|
|
return translateError(err)
|
2016-07-18 00:03:23 +02:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check interface satisfied
|
|
|
|
var _ fusefs.NodeRenamer = (*Dir)(nil)
|
|
|
|
|
|
|
|
// Rename the file
|
2017-05-09 12:39:33 +02:00
|
|
|
func (d *Dir) Rename(ctx context.Context, req *fuse.RenameRequest, newDir fusefs.Node) (err error) {
|
2018-01-12 17:30:54 +01:00
|
|
|
defer log.Trace(d, "oldName=%q, newName=%q, newDir=%+v", req.OldName, req.NewName, newDir)("err=%v", &err)
|
2016-07-18 00:03:23 +02:00
|
|
|
destDir, ok := newDir.(*Dir)
|
|
|
|
if !ok {
|
2017-05-02 23:35:07 +02:00
|
|
|
return errors.Errorf("Unknown Dir type %T", newDir)
|
2016-07-18 00:03:23 +02:00
|
|
|
}
|
2017-05-02 23:35:07 +02:00
|
|
|
|
2017-05-09 12:39:33 +02:00
|
|
|
err = d.Dir.Rename(req.OldName, req.NewName, destDir.Dir)
|
2016-07-18 00:03:23 +02:00
|
|
|
if err != nil {
|
2017-05-02 23:35:07 +02:00
|
|
|
return translateError(err)
|
2016-07-18 00:03:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
2017-02-02 22:30:32 +01:00
|
|
|
|
|
|
|
// Check interface satisfied
|
|
|
|
var _ fusefs.NodeFsyncer = (*Dir)(nil)
|
|
|
|
|
|
|
|
// Fsync the directory
|
2017-05-09 12:39:33 +02:00
|
|
|
func (d *Dir) Fsync(ctx context.Context, req *fuse.FsyncRequest) (err error) {
|
2018-01-12 17:30:54 +01:00
|
|
|
defer log.Trace(d, "")("err=%v", &err)
|
2017-11-18 16:48:49 +01:00
|
|
|
err = d.Dir.Sync()
|
2017-05-02 23:35:07 +02:00
|
|
|
if err != nil {
|
|
|
|
return translateError(err)
|
|
|
|
}
|
2017-02-02 22:30:32 +01:00
|
|
|
return nil
|
|
|
|
}
|
2018-03-13 13:31:46 +01:00
|
|
|
|
|
|
|
// Check interface satisfied
|
|
|
|
var _ fusefs.NodeLinker = (*Dir)(nil)
|
|
|
|
|
|
|
|
// Link creates a new directory entry in the receiver based on an
|
|
|
|
// existing Node. Receiver must be a directory.
|
2018-08-04 12:16:43 +02:00
|
|
|
func (d *Dir) Link(ctx context.Context, req *fuse.LinkRequest, old fusefs.Node) (newNode fusefs.Node, err error) {
|
|
|
|
defer log.Trace(d, "req=%v, old=%v", req, old)("new=%v, err=%v", &newNode, &err)
|
2018-03-13 13:31:46 +01:00
|
|
|
return nil, fuse.ENOSYS
|
|
|
|
}
|