// permToACL - convert perm to meaningful ACL func permToACL(mode os.FileMode) BucketACL { switch mode.Perm() { case os.FileMode(0700): return BucketACL("private") case os.FileMode(0500): return BucketACL("public-read") case os.FileMode(0777): return BucketACL("public-read-write") default: return BucketACL("private") } }
func copyDir(src, dst string, mode os.FileMode) error { srcf, err := os.Open(src) if err != nil { return err } defer srcf.Close() if mode&0500 == 0 { // The source directory doesn't have write permission, // so give the new directory write permission anyway // so that we have permission to create its contents. // We'll make the permissions match at the end. mode |= 0500 } if err := os.Mkdir(dst, mode.Perm()); err != nil { return err } for { names, err := srcf.Readdirnames(100) for _, name := range names { if err := Copy(filepath.Join(src, name), filepath.Join(dst, name)); err != nil { return err } } if err == io.EOF { break } if err != nil { return fmt.Errorf("error reading directory %q: %v", src, err) } } if err := os.Chmod(dst, mode.Perm()); err != nil { return err } return nil }
// mode converts an os.FileMode to a go9p mode. func mode(m os.FileMode, dotu bool) uint32 { other := uint32(m & 0777) if m.IsDir() { other |= go9p.DMDIR } if !dotu { return other } if m&os.ModeSymlink != 0 { other |= go9p.DMSYMLINK } if m&os.ModeSocket != 0 { other |= go9p.DMSOCKET } if m&os.ModeNamedPipe != 0 { other |= go9p.DMNAMEDPIPE } if m&os.ModeDevice != 0 { other |= go9p.DMDEVICE } if m&os.ModeSetuid != 0 { other |= go9p.DMSETUID } if m&os.ModeSetgid != 0 { other |= go9p.DMSETGID } return other }
func visit(path string, f os.FileInfo, err error) error { var fMod os.FileMode fMod = f.Mode() if fMod.IsDir() { fmt.Printf("Entering Folder: %s\n", f.Name()) return nil } fmt.Printf("Saving log: %s\n", path) file, err := os.Open(path) if err != nil { fmt.Printf("trouble opening file: %s\n", err) return nil } b := make([]byte, f.Size()) n, err := file.Read(b) if int64(n) != f.Size() { fmt.Printf("Error reading entire file: %s\n", err) } var finalkey = KEY_PREFIX + f.Name() var kmsg KafkaMsg = KafkaMsg{ Topic: FolderTopic, Key: finalkey, Value: string(b), } sendMsg(kmsg) return nil }
func (nd *Node) Chmod(newMode os.FileMode) error { if nd.Size() > 0 && newMode.IsDir() { return errors.New("File has size, cannot change to directory") } nd.mode = newMode return nd.save() }
// put single file func put(args []string) error { fs := flag.NewFlagSet("put", flag.ContinueOnError) fs.Usage = func() { fmt.Fprintln(os.Stderr, "create usage: gomote put [put-opts] <buildlet-name> <source or '-' for stdin> [destination]") fs.PrintDefaults() os.Exit(1) } modeStr := fs.String("mode", "", "Unix file mode (octal); default to source file mode") fs.Parse(args) if n := fs.NArg(); n < 2 || n > 3 { fs.Usage() } bc, err := namedClient(fs.Arg(0)) if err != nil { return err } var r io.Reader = os.Stdin var mode os.FileMode = 0666 src := fs.Arg(1) if src != "-" { f, err := os.Open(src) if err != nil { return err } defer f.Close() r = f if *modeStr == "" { fi, err := f.Stat() if err != nil { return err } mode = fi.Mode() } } if *modeStr != "" { modeInt, err := strconv.ParseInt(*modeStr, 8, 64) if err != nil { return err } mode = os.FileMode(modeInt) if !mode.IsRegular() { return fmt.Errorf("bad mode: %v", mode) } } dest := fs.Arg(2) if dest == "" { if src == "-" { return errors.New("must specify destination file name when source is standard input") } dest = filepath.Base(src) } return bc.Put(r, dest, mode) }
func (fs *memFS) OpenFile(name string, flag int, perm os.FileMode) (File, error) { fs.mu.Lock() defer fs.mu.Unlock() dir, frag, err := fs.find("open", name) if err != nil { return nil, err } var n *memFSNode if dir == nil { // We're opening the root. if flag&(os.O_WRONLY|os.O_RDWR) != 0 { return nil, os.ErrPermission } n, frag = &fs.root, "/" } else { n = dir.children[frag] if flag&(os.O_SYNC|os.O_APPEND) != 0 { // memFile doesn't support these flags yet. return nil, os.ErrInvalid } if flag&os.O_CREATE != 0 { if flag&os.O_EXCL != 0 && n != nil { return nil, os.ErrExist } if n == nil { n = &memFSNode{ mode: perm.Perm(), } dir.children[frag] = n } } if n == nil { return nil, os.ErrNotExist } if flag&(os.O_WRONLY|os.O_RDWR) != 0 && flag&os.O_TRUNC != 0 { n.mu.Lock() n.data = nil n.mu.Unlock() } } children := make([]os.FileInfo, 0, len(n.children)) for cName, c := range n.children { children = append(children, c.stat(cName)) } return &memFile{ n: n, nameSnapshot: frag, childrenSnapshot: children, }, nil }
func (pb *Packbuilder) WriteToFile(name string, mode os.FileMode) error { cname := C.CString(name) defer C.free(unsafe.Pointer(cname)) runtime.LockOSThread() defer runtime.UnlockOSThread() ret := C.git_packbuilder_write(pb.ptr, cname, C.uint(mode.Perm()), nil, nil) if ret != 0 { return MakeGitError(ret) } return nil }
func categorizeEntry(path string, mode os.FileMode, list *filelist.Lists) error { switch { case mode.IsDir(): list.Dirs = append(list.Dirs, path) case mode.IsRegular(): list.Files = append(list.Files, path) case isSymlink(mode): list.Symlinks = append(list.Symlinks, path) default: return fmt.Errorf("unsupported file mode: %d (not a file, directory or symlink)", mode&os.ModeType) } return nil }
// posixMode() returns the posix specific mode bits from Go's portable mode bits // // Copied from the syscallMode() function in file_posix.go in the Go source func posixMode(i os.FileMode) (o uint32) { o |= uint32(i.Perm()) if i&os.ModeSetuid != 0 { o |= syscall.S_ISUID } if i&os.ModeSetgid != 0 { o |= syscall.S_ISGID } if i&os.ModeSticky != 0 { o |= syscall.S_ISVTX } return }
// https://github.com/jnwhiteh/golang/blob/master/src/pkg/os/file_posix.go#L61 func syscallMode(i os.FileMode) (o uint32) { o |= uint32(i.Perm()) if i&os.ModeSetuid != 0 { o |= syscall.S_ISUID } if i&os.ModeSetgid != 0 { o |= syscall.S_ISGID } if i&os.ModeSticky != 0 { o |= syscall.S_ISVTX } // No mapping for Go's ModeTemporary (plan9 only). return }
// Given a FileMode from the os package, get it's permission bits func FileMode(fm os.FileMode) PermissionBits { perm := PermissionBits(fm.Perm()) if fm&os.ModeSetuid != 0 { perm.SetSetuid(true) } if fm&os.ModeSetgid != 0 { perm.SetSetgid(true) } if fm&os.ModeSticky != 0 { perm.SetSticky(true) } return perm }
func (fs *memFS) OpenFile(name string, flag int, perm os.FileMode) (File, error) { var ret *memFile err := fs.walk("open", name, func(dir *memFSNode, frag string, final bool) error { if !final { return nil } if frag == "" { return os.ErrInvalid } if flag&(os.O_SYNC|os.O_APPEND) != 0 { return os.ErrInvalid } n := dir.children[frag] if flag&os.O_CREATE != 0 { if flag&os.O_EXCL != 0 && n != nil { return os.ErrExist } if n == nil { n = &memFSNode{ name: frag, mode: perm.Perm(), } dir.children[frag] = n } } if n == nil { return os.ErrNotExist } if flag&(os.O_WRONLY|os.O_RDWR) != 0 && flag&os.O_TRUNC != 0 { n.mu.Lock() n.data = nil n.mu.Unlock() } children := make([]os.FileInfo, 0, len(n.children)) for _, c := range n.children { children = append(children, c) } ret = &memFile{ n: n, children: children, } return nil }) if err != nil { return nil, err } return ret, nil }
func Command(rootfsPath string, uid, gid int, mode os.FileMode, recreate bool, paths ...string) *exec.Cmd { flags := []string{ name, "-rootfsPath", rootfsPath, "-uid", strconv.Itoa(uid), "-gid", strconv.Itoa(gid), "-perm", strconv.Itoa(int(mode.Perm())), } if recreate { flags = append(flags, "-recreate=true") } return reexec.Command(append(flags, paths...)...) }
func (fs *memFS) Mkdir(name string, perm os.FileMode) error { return fs.walk("mkdir", name, func(dir *memFSNode, frag string, final bool) error { if !final { return nil } if frag == "" { return os.ErrInvalid } if _, ok := dir.children[frag]; ok { return os.ErrExist } dir.children[frag] = &memFSNode{ name: frag, children: make(map[string]*memFSNode), mode: perm.Perm() | os.ModeDir, modTime: time.Now(), } return nil }) }
// mknod provides a shortcut for syscall.Mknod func mknod(p string, mode os.FileMode, maj, min int) error { var ( m = syscallMode(mode.Perm()) dev int ) if mode&os.ModeDevice != 0 { dev = makedev(maj, min) if mode&os.ModeCharDevice != 0 { m |= syscall.S_IFCHR } else { m |= syscall.S_IFBLK } } else if mode&os.ModeNamedPipe != 0 { m |= syscall.S_IFIFO } return syscall.Mknod(p, m, dev) }
func modeToType(mode os.FileMode) byte { switch { case mode.IsDir(): return 'd' case mode.IsRegular(): return 'f' case mode&os.ModeSymlink != 0: return 'l' case mode&os.ModeSocket != 0: return 's' case mode&os.ModeNamedPipe != 0: return 'p' case mode&os.ModeDevice != 0 && mode&os.ModeCharDevice != 0: return 'C' case mode&os.ModeDevice != 0 && mode&os.ModeCharDevice == 0: return 'D' default: return 'u' } }
func copyFile(src, dst string, mode os.FileMode) error { srcf, err := os.Open(src) if err != nil { return err } defer srcf.Close() dstf, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, mode.Perm()) if err != nil { return err } defer dstf.Close() // Make the actual permissions match the source permissions // even in the presence of umask. if err := os.Chmod(dstf.Name(), mode.Perm()); err != nil { return err } if _, err := io.Copy(dstf, srcf); err != nil { return fmt.Errorf("cannot copy %q to %q: %v", src, dst, err) } return nil }
func (c *Client) PushFile(container string, p string, gid int, uid int, mode os.FileMode, buf io.ReadSeeker) error { query := url.Values{"path": []string{p}} uri := c.url(shared.APIVersion, "containers", container, "files") + "?" + query.Encode() req, err := http.NewRequest("POST", uri, buf) if err != nil { return err } req.Header.Set("User-Agent", shared.UserAgent) req.Header.Set("X-LXD-mode", fmt.Sprintf("%04o", mode.Perm())) req.Header.Set("X-LXD-uid", strconv.FormatUint(uint64(uid), 10)) req.Header.Set("X-LXD-gid", strconv.FormatUint(uint64(gid), 10)) raw, err := c.Http.Do(req) if err != nil { return err } _, err = HoistResponse(raw, Sync) return err }
func (fs *memFS) Mkdir(name string, perm os.FileMode) error { fs.mu.Lock() defer fs.mu.Unlock() dir, frag, err := fs.find("mkdir", name) if err != nil { return err } if dir == nil { // We can't create the root. return os.ErrInvalid } if _, ok := dir.children[frag]; ok { return os.ErrExist } dir.children[frag] = &memFSNode{ children: make(map[string]*memFSNode), mode: perm.Perm() | os.ModeDir, modTime: time.Now(), } return nil }
func (w *Workspace) WriteEntry(name string, mode os.FileMode, modTime time.Time, r io.Reader, replace bool) error { os.MkdirAll(w.Root, 0755) filePath := w.getEntry(name) info, err := os.Stat(filePath) if err != nil { if mode.IsDir() { if err := os.MkdirAll(filePath, mode|0700); err != nil { return err } } else { if err := w.writeRegFile(filePath, mode|0600, modTime, r); err != nil { return err } } } else { if info.IsDir() { if mode.IsDir() { if err := os.Chmod(filePath, (mode&0777555)|0700); err != nil { return err } } else { if info.ModTime().Before(modTime) || replace { os.RemoveAll(filePath) if err := w.writeRegFile(filePath, mode|0600, modTime, r); err != nil { return err } } else { // pass } } } else { if mode.IsDir() { if info.ModTime().Before(modTime) || replace { os.RemoveAll(filePath) if err := os.MkdirAll(filePath, mode|0700); err != nil { return err } } else { // pass } } else { if info.ModTime().Before(modTime) || replace { if err := w.writeRegFile(filePath, mode|0600, modTime, r); err != nil { return err } } else { // pass } } } } return nil }
func (r *Remote) DirPerms(dir string, mode os.FileMode) (bool, error) { resp, err := r.RunCmd("ls -ld %s | awk '{printf $1}'", r.path(dir)) if err != nil { return false, err } fmt.Println(resp, []byte(mode.String()), string(resp), mode.String()) if string(resp) == mode.String()+"\n" { return true, nil } return false, nil }
// osFileModeToFuseFileMode converts a standard os.FileMode to the bit array used // by the fuse package. Permissions, regular/dir modes, symlinks, and named pipes // are the only bits that are converted. func osFileModeToFuseFileMode(inMode os.FileMode) (outMode uint32) { if inMode.IsRegular() { outMode |= fuse.S_IFREG } if inMode.IsDir() { outMode |= fuse.S_IFDIR } if inMode&os.ModeSymlink == os.ModeSymlink { outMode |= fuse.S_IFLNK } if inMode&os.ModeNamedPipe == os.ModeNamedPipe { outMode |= fuse.S_IFIFO } outMode |= uint32(inMode.Perm()) return }
// an entry looks something like this: // type=file;size=12;modify=20150216084148;UNIX.mode=0644;unique=1000004g1187ec7; lorem.txt func parseMLST(entry string, skipSelfParent bool) (os.FileInfo, error) { parseError := ftpError{err: fmt.Errorf(`failed parsing MLST entry: %s`, entry)} incompleteError := ftpError{err: fmt.Errorf(`MLST entry incomplete: %s`, entry)} parts := strings.Split(entry, "; ") if len(parts) != 2 { return nil, parseError } facts := make(map[string]string) for _, factPair := range strings.Split(parts[0], ";") { factParts := strings.SplitN(factPair, "=", 2) if len(factParts) != 2 { return nil, parseError } facts[strings.ToLower(factParts[0])] = strings.ToLower(factParts[1]) } typ := facts["type"] if typ == "" { return nil, incompleteError } if skipSelfParent && (typ == "cdir" || typ == "pdir" || typ == "." || typ == "..") { return nil, nil } var mode os.FileMode if facts["unix.mode"] != "" { m, err := strconv.ParseInt(facts["unix.mode"], 8, 32) if err != nil { return nil, parseError } mode = os.FileMode(m) } else if facts["perm"] != "" { // see http://tools.ietf.org/html/rfc3659#section-7.5.5 for _, c := range facts["perm"] { switch c { case 'a', 'd', 'c', 'f', 'm', 'p', 'w': // these suggest you have write permissions mode |= 0200 case 'l': // can list dir entries means readable and executable mode |= 0500 case 'r': // readable file mode |= 0400 } } } else { // no mode info, just say it's readable to us mode = 0400 } if typ == "dir" || typ == "cdir" || typ == "pdir" { mode |= os.ModeDir } else if strings.HasPrefix(typ, "os.unix=slink") || strings.HasPrefix(typ, "os.unix=symlink") { // note: there is no general way to determine whether a symlink points to a dir or a file mode |= os.ModeSymlink } var ( size int64 err error ) if facts["size"] != "" { size, err = strconv.ParseInt(facts["size"], 10, 64) } else if mode.IsDir() && facts["sizd"] != "" { size, err = strconv.ParseInt(facts["sizd"], 10, 64) } else if facts["type"] == "file" { return nil, incompleteError } if err != nil { return nil, parseError } if facts["modify"] == "" { return nil, incompleteError } mtime, err := time.ParseInLocation(timeFormat, facts["modify"], time.UTC) if err != nil { return nil, incompleteError } info := &ftpFile{ name: filepath.Base(parts[1]), size: size, mtime: mtime, raw: entry, mode: mode, } return info, nil }
func (s *IntegrationTestSuite) assertFilePresent(c *chk.C, path string, perm os.FileMode, readableByNobodyUser bool) { info, err := os.Stat(path) c.Assert(err, chk.IsNil) if (info.Mode() & os.ModeSymlink) != 0 { linkedFile, err := os.Readlink(path) c.Assert(err, chk.IsNil) s.assertFilePresent(c, linkedFile, perm, readableByNobodyUser) } else { if info.Mode().Perm() != perm { c.Errorf("File %s has permission \"%s\" but expected \"%s\"", path, info.Mode().String(), perm.String()) } } if readableByNobodyUser { for i := path; i != "/"; i = filepath.Dir(i) { info, err = os.Stat(i) c.Assert(err, chk.IsNil) c.Assert(info.Mode().Perm()&0005, chk.Not(chk.Equals), 0) } } }
func hasPerm(mode os.FileMode, idx int, rOrW string) bool { return string(mode.String()[idx]) == rOrW }
func parseModeSymbolic(s string, base os.FileMode) (os.FileMode, error) { // log.Println("-- " + s) perm := uint32(base.Perm()) sbitsMask := uint32(os.ModeSetuid | os.ModeSetgid | os.ModeSticky) sbits := uint32(base) & sbitsMask for i := 0; i < len(s); { // user, group, other, or all var whom uint32 for j, c := range s[i:] { // log.Printf("whom: %d %s\n", i, string(s[i])) if c == 'u' { whom = whom | 0700 } else if c == 'g' { whom = whom | 0070 } else if c == 'o' { whom = whom | 0007 } else if c == 'a' { whom = whom | 0777 } else { if j == 0 { whom = 0777 } break } i++ } if i >= len(s) { return 0, errors.New("failed to parse the mode, operator is not found") } for i < len(s) { // operator // log.Printf("op: %d %s\n", i, string(s[i])) op := 0 switch s[i] { case '-': op = '-' case '+': op = '+' case '=': op = '=' default: return 0, errors.New("failed to parse the mode, invalid operator") } i++ // permission bits to modify var smod uint32 var mod uint32 if i < len(s) { // log.Printf("mod: %d %s\n", i, string(s[i])) switch s[i] { case 'u': mod = (perm & 0700) >> 6 i++ case 'g': mod = (perm & 0070) >> 3 i++ case 'o': mod = (perm & 0007) >> 0 i++ default: for i < len(s) { // log.Printf("mod-f: %d %s\n", i, string(s[i])) if s[i] == 'r' { mod = mod | 4 } else if s[i] == 'w' { mod = mod | 2 } else if s[i] == 'x' { mod = mod | 1 } else if s[i] == 'X' { if base.IsDir() { mod = mod | 1 } } else if s[i] == 's' { if (whom & 0700) > 0 { smod = smod | uint32(os.ModeSetuid) } if (whom & 0070) > 0 { smod = smod | uint32(os.ModeSetgid) } } else if s[i] == 't' { smod = smod | uint32(os.ModeSticky) } else { break } i++ } } mod = mod<<6 | mod<<3 | mod<<0 } // if i < len(s) { // log.Printf("mod-e: %d %s\n", i, string(s[i])) //} switch op { case '-': perm = perm - (whom & mod) sbits = sbits - smod case '+': perm = perm | (whom & mod) sbits = sbits | smod case '=': perm = (perm & (0777 ^ whom)) | (whom & mod) sbits = smod } if i < len(s) { // log.Printf(",: %d %s\n", i, string(s[i])) if s[i] == ',' { i++ break } } } } mode := uint32(base)&((1<<32-1)-0777-sbitsMask) | sbits&sbitsMask | perm&0777 return os.FileMode(mode), nil }