1 |
747 |
jeremybenn |
// Copyright 2009 The Go Authors. All rights reserved.
|
2 |
|
|
// Use of this source code is governed by a BSD-style
|
3 |
|
|
// license that can be found in the LICENSE file.
|
4 |
|
|
|
5 |
|
|
package os
|
6 |
|
|
|
7 |
|
|
import (
|
8 |
|
|
"syscall"
|
9 |
|
|
"time"
|
10 |
|
|
)
|
11 |
|
|
|
12 |
|
|
// Getpagesize returns the underlying system's memory page size.
|
13 |
|
|
func Getpagesize() int { return syscall.Getpagesize() }
|
14 |
|
|
|
15 |
|
|
// A FileInfo describes a file and is returned by Stat and Lstat
|
16 |
|
|
type FileInfo interface {
|
17 |
|
|
Name() string // base name of the file
|
18 |
|
|
Size() int64 // length in bytes
|
19 |
|
|
Mode() FileMode // file mode bits
|
20 |
|
|
ModTime() time.Time // modification time
|
21 |
|
|
IsDir() bool // abbreviation for Mode().IsDir()
|
22 |
|
|
Sys() interface{} // underlying data source (can return nil)
|
23 |
|
|
}
|
24 |
|
|
|
25 |
|
|
// A FileMode represents a file's mode and permission bits.
|
26 |
|
|
// The bits have the same definition on all systems, so that
|
27 |
|
|
// information about files can be moved from one system
|
28 |
|
|
// to another portably. Not all bits apply to all systems.
|
29 |
|
|
// The only required bit is ModeDir for directories.
|
30 |
|
|
type FileMode uint32
|
31 |
|
|
|
32 |
|
|
// The defined file mode bits are the most significant bits of the FileMode.
|
33 |
|
|
// The nine least-significant bits are the standard Unix rwxrwxrwx permissions.
|
34 |
|
|
// The values of these bits should be considered part of the public API and
|
35 |
|
|
// may be used in wire protocols or disk representations: they must not be
|
36 |
|
|
// changed, although new bits might be added.
|
37 |
|
|
const (
|
38 |
|
|
// The single letters are the abbreviations
|
39 |
|
|
// used by the String method's formatting.
|
40 |
|
|
ModeDir FileMode = 1 << (32 - 1 - iota) // d: is a directory
|
41 |
|
|
ModeAppend // a: append-only
|
42 |
|
|
ModeExclusive // l: exclusive use
|
43 |
|
|
ModeTemporary // T: temporary file (not backed up)
|
44 |
|
|
ModeSymlink // L: symbolic link
|
45 |
|
|
ModeDevice // D: device file
|
46 |
|
|
ModeNamedPipe // p: named pipe (FIFO)
|
47 |
|
|
ModeSocket // S: Unix domain socket
|
48 |
|
|
ModeSetuid // u: setuid
|
49 |
|
|
ModeSetgid // g: setgid
|
50 |
|
|
ModeCharDevice // c: Unix character device, when ModeDevice is set
|
51 |
|
|
ModeSticky // t: sticky
|
52 |
|
|
|
53 |
|
|
// Mask for the type bits. For regular files, none will be set.
|
54 |
|
|
ModeType = ModeDir | ModeSymlink | ModeNamedPipe | ModeSocket | ModeDevice
|
55 |
|
|
|
56 |
|
|
ModePerm FileMode = 0777 // permission bits
|
57 |
|
|
)
|
58 |
|
|
|
59 |
|
|
func (m FileMode) String() string {
|
60 |
|
|
const str = "dalTLDpSugct"
|
61 |
|
|
var buf [20]byte
|
62 |
|
|
w := 0
|
63 |
|
|
for i, c := range str {
|
64 |
|
|
if m&(1<
|
65 |
|
|
buf[w] = byte(c)
|
66 |
|
|
w++
|
67 |
|
|
}
|
68 |
|
|
}
|
69 |
|
|
if w == 0 {
|
70 |
|
|
buf[w] = '-'
|
71 |
|
|
w++
|
72 |
|
|
}
|
73 |
|
|
const rwx = "rwxrwxrwx"
|
74 |
|
|
for i, c := range rwx {
|
75 |
|
|
if m&(1<
|
76 |
|
|
buf[w] = byte(c)
|
77 |
|
|
} else {
|
78 |
|
|
buf[w] = '-'
|
79 |
|
|
}
|
80 |
|
|
w++
|
81 |
|
|
}
|
82 |
|
|
return string(buf[:w])
|
83 |
|
|
}
|
84 |
|
|
|
85 |
|
|
// IsDir reports whether m describes a directory.
|
86 |
|
|
// That is, it tests for the ModeDir bit being set in m.
|
87 |
|
|
func (m FileMode) IsDir() bool {
|
88 |
|
|
return m&ModeDir != 0
|
89 |
|
|
}
|
90 |
|
|
|
91 |
|
|
// Perm returns the Unix permission bits in m.
|
92 |
|
|
func (m FileMode) Perm() FileMode {
|
93 |
|
|
return m & ModePerm
|
94 |
|
|
}
|
95 |
|
|
|
96 |
|
|
// A fileStat is the implementation of FileInfo returned by Stat and Lstat.
|
97 |
|
|
type fileStat struct {
|
98 |
|
|
name string
|
99 |
|
|
size int64
|
100 |
|
|
mode FileMode
|
101 |
|
|
modTime time.Time
|
102 |
|
|
sys interface{}
|
103 |
|
|
}
|
104 |
|
|
|
105 |
|
|
func (fs *fileStat) Name() string { return fs.name }
|
106 |
|
|
func (fs *fileStat) Size() int64 { return fs.size }
|
107 |
|
|
func (fs *fileStat) Mode() FileMode { return fs.mode }
|
108 |
|
|
func (fs *fileStat) ModTime() time.Time { return fs.modTime }
|
109 |
|
|
func (fs *fileStat) IsDir() bool { return fs.mode.IsDir() }
|
110 |
|
|
func (fs *fileStat) Sys() interface{} { return fs.sys }
|
111 |
|
|
|
112 |
|
|
// SameFile reports whether fi1 and fi2 describe the same file.
|
113 |
|
|
// For example, on Unix this means that the device and inode fields
|
114 |
|
|
// of the two underlying structures are identical; on other systems
|
115 |
|
|
// the decision may be based on the path names.
|
116 |
|
|
// SameFile only applies to results returned by this package's Stat.
|
117 |
|
|
// It returns false in other cases.
|
118 |
|
|
func SameFile(fi1, fi2 FileInfo) bool {
|
119 |
|
|
fs1, ok1 := fi1.(*fileStat)
|
120 |
|
|
fs2, ok2 := fi2.(*fileStat)
|
121 |
|
|
if !ok1 || !ok2 {
|
122 |
|
|
return false
|
123 |
|
|
}
|
124 |
|
|
return sameFile(fs1.sys, fs2.sys)
|
125 |
|
|
}
|