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() }
// 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 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 }
// 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 }
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 (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 }
// 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 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 }