| // Copyright 2020 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Package fs defines basic interfaces to a file system. |
| // A file system can be provided by the host operating system |
| // but also by other packages. |
| package fs |
| |
| import ( |
| "internal/oserror" |
| "time" |
| ) |
| |
| // Generic file system errors. |
| // Errors returned by file systems can be tested against these errors |
| // using errors.Is. |
| var ( |
| ErrInvalid = errInvalid() // "invalid argument" |
| ErrPermission = errPermission() // "permission denied" |
| ErrExist = errExist() // "file already exists" |
| ErrNotExist = errNotExist() // "file does not exist" |
| ErrClosed = errClosed() // "file already closed" |
| ) |
| |
| func errInvalid() error { return oserror.ErrInvalid } |
| func errPermission() error { return oserror.ErrPermission } |
| func errExist() error { return oserror.ErrExist } |
| func errNotExist() error { return oserror.ErrNotExist } |
| func errClosed() error { return oserror.ErrClosed } |
| |
| // A FileInfo describes a file and is returned by Stat. |
| type FileInfo interface { |
| Name() string // base name of the file |
| Size() int64 // length in bytes for regular files; system-dependent for others |
| Mode() FileMode // file mode bits |
| ModTime() time.Time // modification time |
| IsDir() bool // abbreviation for Mode().IsDir() |
| Sys() interface{} // underlying data source (can return nil) |
| } |
| |
| // A FileMode represents a file's mode and permission bits. |
| // The bits have the same definition on all systems, so that |
| // information about files can be moved from one system |
| // to another portably. Not all bits apply to all systems. |
| // The only required bit is ModeDir for directories. |
| type FileMode uint32 |
| |
| // The defined file mode bits are the most significant bits of the FileMode. |
| // The nine least-significant bits are the standard Unix rwxrwxrwx permissions. |
| // The values of these bits should be considered part of the public API and |
| // may be used in wire protocols or disk representations: they must not be |
| // changed, although new bits might be added. |
| const ( |
| // The single letters are the abbreviations |
| // used by the String method's formatting. |
| ModeDir FileMode = 1 << (32 - 1 - iota) // d: is a directory |
| ModeAppend // a: append-only |
| ModeExclusive // l: exclusive use |
| ModeTemporary // T: temporary file; Plan 9 only |
| ModeSymlink // L: symbolic link |
| ModeDevice // D: device file |
| ModeNamedPipe // p: named pipe (FIFO) |
| ModeSocket // S: Unix domain socket |
| ModeSetuid // u: setuid |
| ModeSetgid // g: setgid |
| ModeCharDevice // c: Unix character device, when ModeDevice is set |
| ModeSticky // t: sticky |
| ModeIrregular // ?: non-regular file; nothing else is known about this file |
| |
| // Mask for the type bits. For regular files, none will be set. |
| ModeType = ModeDir | ModeSymlink | ModeNamedPipe | ModeSocket | ModeDevice | ModeCharDevice | ModeIrregular |
| |
| ModePerm FileMode = 0777 // Unix permission bits |
| ) |
| |
| func (m FileMode) String() string { |
| const str = "dalTLDpSugct?" |
| var buf [32]byte // Mode is uint32. |
| w := 0 |
| for i, c := range str { |
| if m&(1<<uint(32-1-i)) != 0 { |
| buf[w] = byte(c) |
| w++ |
| } |
| } |
| if w == 0 { |
| buf[w] = '-' |
| w++ |
| } |
| const rwx = "rwxrwxrwx" |
| for i, c := range rwx { |
| if m&(1<<uint(9-1-i)) != 0 { |
| buf[w] = byte(c) |
| } else { |
| buf[w] = '-' |
| } |
| w++ |
| } |
| return string(buf[:w]) |
| } |
| |
| // IsDir reports whether m describes a directory. |
| // That is, it tests for the ModeDir bit being set in m. |
| func (m FileMode) IsDir() bool { |
| return m&ModeDir != 0 |
| } |
| |
| // IsRegular reports whether m describes a regular file. |
| // That is, it tests that no mode type bits are set. |
| func (m FileMode) IsRegular() bool { |
| return m&ModeType == 0 |
| } |
| |
| // Perm returns the Unix permission bits in m (m & ModePerm). |
| func (m FileMode) Perm() FileMode { |
| return m & ModePerm |
| } |
| |
| // Type returns type bits in m (m & ModeType). |
| func (m FileMode) Type() FileMode { |
| return m & ModeType |
| } |
| |
| // PathError records an error and the operation and file path that caused it. |
| type PathError struct { |
| Op string |
| Path string |
| Err error |
| } |
| |
| func (e *PathError) Error() string { return e.Op + " " + e.Path + ": " + e.Err.Error() } |
| |
| func (e *PathError) Unwrap() error { return e.Err } |
| |
| // Timeout reports whether this error represents a timeout. |
| func (e *PathError) Timeout() bool { |
| t, ok := e.Err.(interface{ Timeout() bool }) |
| return ok && t.Timeout() |
| } |