package fs import ( "fmt" "os" "os/user" "path" "strconv" "strings" "syscall" "github.com/op/go-logging" "github.com/subgraph/oz" ) type directory struct { path string empty bool } type Filesystem struct { log *logging.Logger home string base string root string userID string noDefaults bool noSysAndProc bool whitelist []*mountItem blacklist []*mountItem } func (fs *Filesystem) Root() string { return fs.root } func (fs *Filesystem) addWhitelist(path, target string, readonly bool) error { item, err := fs.newItem(path, target, readonly) if err != nil { return err } fs.whitelist = append(fs.whitelist, item) return nil } func (fs *Filesystem) addBlacklist(path string) error { item, err := fs.newItem(path, "", false) if err != nil { return err } fs.blacklist = append(fs.blacklist, item) return nil } func (fs *Filesystem) newItem(path, target string, readonly bool) (*mountItem, error) { p, err := fs.resolveVars(path) if err != nil { return nil, err } return &mountItem{ path: p, target: target, //readonly: readonly, fs: fs, }, nil } func NewFromProfile(profile *oz.Profile, log *logging.Logger) *Filesystem { fs := NewFilesystem(profile.Name, log) for _,wl := range profile.Whitelist { fs.addWhitelist(wl.Path, wl.Path, wl.ReadOnly) } for _,bl := range profile.Blacklist { fs.addBlacklist(bl.Path) } fs.noDefaults = profile.NoDefaults fs.noSysAndProc = profile.NoSysProc return fs } func NewFilesystem(name string, log *logging.Logger) *Filesystem { fs := new(Filesystem) fs.log = log if log == nil { fs.log = logging.MustGetLogger("oz") } fs.base = path.Join("/srv/oz", name) fs.root = path.Join(fs.base, "rootfs") u, err := user.Current() if err != nil { panic("Failed to look up current user: " + err.Error()) } fs.home = u.HomeDir fs.userID = strconv.Itoa(os.Getuid()) return fs } /* func xcreateEmptyDirectories(base string, paths []string) error { for _, p := range paths { target := path.Join(base, p) if err := createEmptyDir(p, target); err != nil { return err } } return nil } func createEmptyDir(source, target string) error { return nil } func createSubdirs(base string, subdirs []string) error { for _, sdir := range subdirs { path := path.Join(base, sdir) if err := createDirTree(path); err != nil { return err } } return nil } func createDirTree(path string) error { st, err := os.Stat(path) if err == nil { if !st.IsDir() { return fmt.Errorf("cannot create directory %s because path already exists and is not directory", path) } return nil } if !os.IsNotExist(err) { return fmt.Errorf("unexpected error attempting Stat() on path %s: %v", path, err) } if err := os.MkdirAll(path, 0755); err != nil { return fmt.Errorf("error creating directory tree %s: %v", path, err) } return nil } */ // bindMount performs a bind mount of the source path item so that it is visible // at the target path. By default the mount is flagged MS_NOSUID and MS_NODEV // but additional flags can be passed in extraFlags. If the readonly flag is // set the bind mount is remounted as MS_RDONLY. func bindMount(source, target string, readonly bool, extraFlags uintptr) error { flags := syscall.MS_BIND | syscall.MS_NOSUID | syscall.MS_NODEV | extraFlags if err := syscall.Mount(source, target, "", flags, ""); err != nil { return fmt.Errorf("failed to bind mount %s to %s: %v", source, target, err) } if readonly { flags |= syscall.MS_RDONLY | syscall.MS_REMOUNT if err := syscall.Mount("", target, "", flags, ""); err != nil { return fmt.Errorf("failed to remount %s as RDONLY: %v", target, err) } } return nil } func createEmptyFile(name string, mode os.FileMode) error { if err := os.MkdirAll(path.Dir(name), 0750); err != nil { return err } fd, err := os.Create(name) if err != nil { return err } if err := fd.Close(); err != nil { return err } if err := os.Chmod(name, mode); err != nil { return err } return nil } func copyPathPermissions(root, src string) error { current := "/" for _, part := range strings.Split(src, "/") { if part == "" { continue } current = path.Join(current, part) target := path.Join(root, current) if err := copyFilePermissions(current, target); err != nil { return err } } return nil } func copyFilePermissions(src, target string) error { fi, err := os.Stat(src) if err != nil { return err } return copyFileInfo(fi, target) } func copyFileInfo(info os.FileInfo, target string) error { st := info.Sys().(*syscall.Stat_t) os.Chown(target, int(st.Uid), int(st.Gid)) os.Chmod(target, info.Mode().Perm()) return nil }