summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--cryptfs/fs.go2
-rw-r--r--frontend/fs.go13
-rw-r--r--main.go395
3 files changed, 408 insertions, 2 deletions
diff --git a/cryptfs/fs.go b/cryptfs/fs.go
index b40dcf3..9050b30 100644
--- a/cryptfs/fs.go
+++ b/cryptfs/fs.go
@@ -26,7 +26,7 @@ type FS struct {
cipherBS int64
}
-func New(key [16]byte) *FS {
+func NewFS(key [16]byte) *FS {
b, err := aes.NewCipher(key[:])
if err != nil {
diff --git a/frontend/fs.go b/frontend/fs.go
index 464c19f..4ce3e5c 100644
--- a/frontend/fs.go
+++ b/frontend/fs.go
@@ -2,8 +2,19 @@ package frontend
import (
"github.com/rfjakob/gocryptfs/cryptfs"
+ "bazil.org/fuse/fs"
)
type FS struct {
- cryptfs.FS
+ *cryptfs.FS
+}
+
+func New(key [16]byte) *FS {
+ return &FS {
+ FS: cryptfs.NewFS(key),
+ }
+}
+
+func (fs *FS) Root() (fs.Node, error) {
+ return nil, nil
}
diff --git a/main.go b/main.go
new file mode 100644
index 0000000..1183fec
--- /dev/null
+++ b/main.go
@@ -0,0 +1,395 @@
+// Memfs implements an in-memory file system.
+package main
+
+import (
+ "flag"
+ "fmt"
+ "log"
+ "os"
+ "sync"
+ "sync/atomic"
+ "time"
+
+ "bazil.org/fuse"
+ "bazil.org/fuse/fs"
+ "golang.org/x/net/context"
+
+ "github.com/rfjakob/gocryptfs/frontend"
+)
+
+// debug flag enables logging of debug messages to stderr.
+var debug = flag.Bool("debug", false, "enable debug log messages to stderr")
+
+func usage() {
+ fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
+ fmt.Fprintf(os.Stderr, " %s MOUNTPOINT\n", os.Args[0])
+ flag.PrintDefaults()
+}
+
+func debugLog(msg interface{}) {
+ fmt.Fprintf(os.Stderr, "%v\n", msg)
+}
+
+func main() {
+ flag.Usage = usage
+ flag.Parse()
+
+ if flag.NArg() != 1 {
+ usage()
+ os.Exit(2)
+ }
+
+ mountpoint := flag.Arg(0)
+ c, err := fuse.Mount(
+ mountpoint,
+ fuse.FSName("memfs"),
+ fuse.Subtype("memfs"),
+ fuse.LocalVolume(),
+ fuse.VolumeName("Memory FS"),
+ )
+ if err != nil {
+ log.Fatal(err)
+ }
+ defer c.Close()
+
+ cfg := &fs.Config{}
+ if *debug {
+ cfg.Debug = debugLog
+ }
+
+ srv := fs.New(c, cfg)
+ var key [16]byte
+ filesys := frontend.New(key)
+
+ if err := srv.Serve(filesys); err != nil {
+ log.Fatal(err)
+ }
+
+ // Check if the mount process has an error to report.
+ <-c.Ready
+ if err := c.MountError; err != nil {
+ log.Fatal(err)
+ }
+}
+
+type MemFS struct {
+ root *Dir
+ nodeId uint64
+
+ nodeCount uint64
+ size int64
+}
+
+// Compile-time interface checks.
+var _ fs.FS = (*MemFS)(nil)
+var _ fs.FSStatfser = (*MemFS)(nil)
+
+var _ fs.Node = (*Dir)(nil)
+var _ fs.NodeCreater = (*Dir)(nil)
+var _ fs.NodeMkdirer = (*Dir)(nil)
+var _ fs.NodeRemover = (*Dir)(nil)
+var _ fs.NodeRenamer = (*Dir)(nil)
+var _ fs.NodeStringLookuper = (*Dir)(nil)
+
+var _ fs.HandleReadAller = (*File)(nil)
+var _ fs.HandleWriter = (*File)(nil)
+var _ fs.Node = (*File)(nil)
+var _ fs.NodeOpener = (*File)(nil)
+var _ fs.NodeSetattrer = (*File)(nil)
+
+func NewMemFS() *MemFS {
+ fs := &MemFS{
+ nodeCount: 1,
+ }
+ fs.root = fs.newDir(os.ModeDir | 0777)
+ if fs.root.attr.Inode != 1 {
+ panic("Root node should have been assigned id 1")
+ }
+ return fs
+}
+
+func (m *MemFS) nextId() uint64 {
+ return atomic.AddUint64(&m.nodeId, 1)
+}
+
+func (m *MemFS) newDir(mode os.FileMode) *Dir {
+ n := time.Now()
+ return &Dir{
+ attr: fuse.Attr{
+ Inode: m.nextId(),
+ Atime: n,
+ Mtime: n,
+ Ctime: n,
+ Crtime: n,
+ Mode: os.ModeDir | mode,
+ },
+ fs: m,
+ nodes: make(map[string]fs.Node),
+ }
+}
+
+func (m *MemFS) newFile(mode os.FileMode) *File {
+ n := time.Now()
+ return &File{
+ attr: fuse.Attr{
+ Inode: m.nextId(),
+ Atime: n,
+ Mtime: n,
+ Ctime: n,
+ Crtime: n,
+ Mode: mode,
+ },
+ data: make([]byte, 0),
+ }
+}
+
+type Dir struct {
+ sync.RWMutex
+ attr fuse.Attr
+
+ fs *MemFS
+ parent *Dir
+ nodes map[string]fs.Node
+}
+
+type File struct {
+ sync.RWMutex
+ attr fuse.Attr
+
+ fs *MemFS
+ data []byte
+}
+
+func (f *MemFS) Root() (fs.Node, error) {
+ return f.root, nil
+}
+
+func (f *MemFS) Statfs(ctx context.Context, req *fuse.StatfsRequest,
+ resp *fuse.StatfsResponse) error {
+ resp.Blocks = uint64((atomic.LoadInt64(&f.size) + 511) / 512)
+ resp.Bsize = 512
+ resp.Files = atomic.LoadUint64(&f.nodeCount)
+ return nil
+}
+
+func (f *File) Attr(ctx context.Context, o *fuse.Attr) error {
+ f.RLock()
+ *o = f.attr
+ f.RUnlock()
+ return nil
+}
+
+func (d *Dir) Attr(ctx context.Context, o *fuse.Attr) error {
+ d.RLock()
+ *o = d.attr
+ d.RUnlock()
+ return nil
+}
+
+func (d *Dir) Lookup(ctx context.Context, name string) (fs.Node, error) {
+ d.RLock()
+ n, exist := d.nodes[name]
+ d.RUnlock()
+
+ if !exist {
+ return nil, fuse.ENOENT
+ }
+ return n, nil
+}
+
+func (d *Dir) ReadDirAll(ctx context.Context) ([]fuse.Dirent, error) {
+ d.RLock()
+ dirs := make([]fuse.Dirent, len(d.nodes)+2)
+
+ // Add special references.
+ dirs[0] = fuse.Dirent{
+ Name: ".",
+ Inode: d.attr.Inode,
+ Type: fuse.DT_Dir,
+ }
+ dirs[1] = fuse.Dirent{
+ Name: "..",
+ Type: fuse.DT_Dir,
+ }
+ if d.parent != nil {
+ dirs[1].Inode = d.parent.attr.Inode
+ } else {
+ dirs[1].Inode = d.attr.Inode
+ }
+
+ // Add remaining files.
+ idx := 2
+ for name, node := range d.nodes {
+ ent := fuse.Dirent{
+ Name: name,
+ }
+ switch n := node.(type) {
+ case *File:
+ ent.Inode = n.attr.Inode
+ ent.Type = fuse.DT_File
+ case *Dir:
+ ent.Inode = n.attr.Inode
+ ent.Type = fuse.DT_Dir
+ }
+ dirs[idx] = ent
+ idx++
+ }
+ d.RUnlock()
+ return dirs, nil
+}
+
+func (d *Dir) Mkdir(ctx context.Context, req *fuse.MkdirRequest) (fs.Node, error) {
+ d.Lock()
+ defer d.Unlock()
+
+ if _, exists := d.nodes[req.Name]; exists {
+ return nil, fuse.EEXIST
+ }
+
+ n := d.fs.newDir(req.Mode)
+ d.nodes[req.Name] = n
+ atomic.AddUint64(&d.fs.nodeCount, 1)
+
+ return n, nil
+}
+
+func (d *Dir) Create(ctx context.Context, req *fuse.CreateRequest,
+ resp *fuse.CreateResponse) (fs.Node, fs.Handle, error) {
+ d.Lock()
+ defer d.Unlock()
+
+ if _, exists := d.nodes[req.Name]; exists {
+ return nil, nil, fuse.EEXIST
+ }
+
+ n := d.fs.newFile(req.Mode)
+ n.fs = d.fs
+ d.nodes[req.Name] = n
+ atomic.AddUint64(&d.fs.nodeCount, 1)
+
+ resp.Attr = n.attr
+
+ return n, n, nil
+}
+
+func (d *Dir) Rename(ctx context.Context, req *fuse.RenameRequest, newDir fs.Node) error {
+ nd := newDir.(*Dir)
+ if d.attr.Inode == nd.attr.Inode {
+ d.Lock()
+ defer d.Unlock()
+ } else if d.attr.Inode < nd.attr.Inode {
+ d.Lock()
+ defer d.Unlock()
+ nd.Lock()
+ defer nd.Unlock()
+ } else {
+ nd.Lock()
+ defer nd.Unlock()
+ d.Lock()
+ defer d.Unlock()
+ }
+
+ if _, exists := d.nodes[req.OldName]; !exists {
+ return fuse.ENOENT
+ }
+
+ // Rename can be used as an atomic replace, override an existing file.
+ if old, exists := nd.nodes[req.NewName]; exists {
+ atomic.AddUint64(&d.fs.nodeCount, ^uint64(0)) // decrement by one
+ if oldFile, ok := old.(*File); !ok {
+ atomic.AddInt64(&d.fs.size, -int64(oldFile.attr.Size))
+ }
+ }
+
+ nd.nodes[req.NewName] = d.nodes[req.OldName]
+ delete(d.nodes, req.OldName)
+ return nil
+}
+
+func (d *Dir) Remove(ctx context.Context, req *fuse.RemoveRequest) error {
+ d.Lock()
+ defer d.Unlock()
+
+ if n, exists := d.nodes[req.Name]; !exists {
+ return fuse.ENOENT
+ } else if req.Dir && len(n.(*Dir).nodes) > 0 {
+ return fuse.ENOTEMPTY
+ }
+
+ delete(d.nodes, req.Name)
+ atomic.AddUint64(&d.fs.nodeCount, ^uint64(0)) // decrement by one
+ return nil
+}
+
+func (f *File) Open(ctx context.Context, req *fuse.OpenRequest, resp *fuse.OpenResponse) (fs.Handle,
+ error) {
+ return f, nil
+}
+
+func (f *File) ReadAll(ctx context.Context) ([]byte, error) {
+ f.RLock()
+ out := make([]byte, len(f.data))
+ copy(out, f.data)
+ f.RUnlock()
+
+ return out, nil
+}
+
+func (f *File) Write(ctx context.Context, req *fuse.WriteRequest, resp *fuse.WriteResponse) error {
+ f.Lock()
+
+ l := len(req.Data)
+ end := int(req.Offset) + l
+ if end > len(f.data) {
+ delta := end - len(f.data)
+ f.data = append(f.data, make([]byte, delta)...)
+ f.attr.Size = uint64(len(f.data))
+ atomic.AddInt64(&f.fs.size, int64(delta))
+ }
+ copy(f.data[req.Offset:end], req.Data)
+ resp.Size = l
+
+ f.Unlock()
+ return nil
+}
+
+func (f *File) Setattr(ctx context.Context, req *fuse.SetattrRequest,
+ resp *fuse.SetattrResponse) error {
+ f.Lock()
+
+ if req.Valid.Size() {
+ delta := int(req.Size) - len(f.data)
+ if delta > 0 {
+ f.data = append(f.data, make([]byte, delta)...)
+ } else {
+ f.data = f.data[0:req.Size]
+ }
+ f.attr.Size = req.Size
+ atomic.AddInt64(&f.fs.size, int64(delta))
+ }
+
+ if req.Valid.Mode() {
+ f.attr.Mode = req.Mode
+ }
+
+ if req.Valid.Atime() {
+ f.attr.Atime = req.Atime
+ }
+
+ if req.Valid.AtimeNow() {
+ f.attr.Atime = time.Now()
+ }
+
+ if req.Valid.Mtime() {
+ f.attr.Mtime = req.Mtime
+ }
+
+ if req.Valid.MtimeNow() {
+ f.attr.Mtime = time.Now()
+ }
+
+ resp.Attr = f.attr
+
+ f.Unlock()
+ return nil
+}