basepath.go raw
1 package afero
2
3 import (
4 "io/fs"
5 "os"
6 "path/filepath"
7 "runtime"
8 "strings"
9 "time"
10 )
11
12 var (
13 _ Lstater = (*BasePathFs)(nil)
14 _ fs.ReadDirFile = (*BasePathFile)(nil)
15 )
16
17 // The BasePathFs restricts all operations to a given path within an Fs.
18 // The given file name to the operations on this Fs will be prepended with
19 // the base path before calling the base Fs.
20 // Any file name (after filepath.Clean()) outside this base path will be
21 // treated as non existing file.
22 //
23 // Note that it does not clean the error messages on return, so you may
24 // reveal the real path on errors.
25 type BasePathFs struct {
26 source Fs
27 path string
28 }
29
30 type BasePathFile struct {
31 File
32 path string
33 }
34
35 func (f *BasePathFile) Name() string {
36 sourcename := f.File.Name()
37 return strings.TrimPrefix(sourcename, filepath.Clean(f.path))
38 }
39
40 func (f *BasePathFile) ReadDir(n int) ([]fs.DirEntry, error) {
41 if rdf, ok := f.File.(fs.ReadDirFile); ok {
42 return rdf.ReadDir(n)
43 }
44 return readDirFile{f.File}.ReadDir(n)
45 }
46
47 func NewBasePathFs(source Fs, path string) Fs {
48 return &BasePathFs{source: source, path: path}
49 }
50
51 // on a file outside the base path it returns the given file name and an error,
52 // else the given file with the base path prepended
53 func (b *BasePathFs) RealPath(name string) (path string, err error) {
54 if err := validateBasePathName(name); err != nil {
55 return name, err
56 }
57
58 bpath := filepath.Clean(b.path)
59 path = filepath.Clean(filepath.Join(bpath, name))
60 if !strings.HasPrefix(path, bpath) {
61 return name, os.ErrNotExist
62 }
63
64 return path, nil
65 }
66
67 func validateBasePathName(name string) error {
68 if runtime.GOOS != "windows" {
69 // Not much to do here;
70 // the virtual file paths all look absolute on *nix.
71 return nil
72 }
73
74 // On Windows a common mistake would be to provide an absolute OS path
75 // We could strip out the base part, but that would not be very portable.
76 if filepath.IsAbs(name) {
77 return os.ErrNotExist
78 }
79
80 return nil
81 }
82
83 func (b *BasePathFs) Chtimes(name string, atime, mtime time.Time) (err error) {
84 if name, err = b.RealPath(name); err != nil {
85 return &os.PathError{Op: "chtimes", Path: name, Err: err}
86 }
87 return b.source.Chtimes(name, atime, mtime)
88 }
89
90 func (b *BasePathFs) Chmod(name string, mode os.FileMode) (err error) {
91 if name, err = b.RealPath(name); err != nil {
92 return &os.PathError{Op: "chmod", Path: name, Err: err}
93 }
94 return b.source.Chmod(name, mode)
95 }
96
97 func (b *BasePathFs) Chown(name string, uid, gid int) (err error) {
98 if name, err = b.RealPath(name); err != nil {
99 return &os.PathError{Op: "chown", Path: name, Err: err}
100 }
101 return b.source.Chown(name, uid, gid)
102 }
103
104 func (b *BasePathFs) Name() string {
105 return "BasePathFs"
106 }
107
108 func (b *BasePathFs) Stat(name string) (fi os.FileInfo, err error) {
109 if name, err = b.RealPath(name); err != nil {
110 return nil, &os.PathError{Op: "stat", Path: name, Err: err}
111 }
112 return b.source.Stat(name)
113 }
114
115 func (b *BasePathFs) Rename(oldname, newname string) (err error) {
116 if oldname, err = b.RealPath(oldname); err != nil {
117 return &os.PathError{Op: "rename", Path: oldname, Err: err}
118 }
119 if newname, err = b.RealPath(newname); err != nil {
120 return &os.PathError{Op: "rename", Path: newname, Err: err}
121 }
122 return b.source.Rename(oldname, newname)
123 }
124
125 func (b *BasePathFs) RemoveAll(name string) (err error) {
126 if name, err = b.RealPath(name); err != nil {
127 return &os.PathError{Op: "remove_all", Path: name, Err: err}
128 }
129 return b.source.RemoveAll(name)
130 }
131
132 func (b *BasePathFs) Remove(name string) (err error) {
133 if name, err = b.RealPath(name); err != nil {
134 return &os.PathError{Op: "remove", Path: name, Err: err}
135 }
136 return b.source.Remove(name)
137 }
138
139 func (b *BasePathFs) OpenFile(name string, flag int, mode os.FileMode) (f File, err error) {
140 if name, err = b.RealPath(name); err != nil {
141 return nil, &os.PathError{Op: "openfile", Path: name, Err: err}
142 }
143 sourcef, err := b.source.OpenFile(name, flag, mode)
144 if err != nil {
145 return nil, err
146 }
147 return &BasePathFile{sourcef, b.path}, nil
148 }
149
150 func (b *BasePathFs) Open(name string) (f File, err error) {
151 if name, err = b.RealPath(name); err != nil {
152 return nil, &os.PathError{Op: "open", Path: name, Err: err}
153 }
154 sourcef, err := b.source.Open(name)
155 if err != nil {
156 return nil, err
157 }
158 return &BasePathFile{File: sourcef, path: b.path}, nil
159 }
160
161 func (b *BasePathFs) Mkdir(name string, mode os.FileMode) (err error) {
162 if name, err = b.RealPath(name); err != nil {
163 return &os.PathError{Op: "mkdir", Path: name, Err: err}
164 }
165 return b.source.Mkdir(name, mode)
166 }
167
168 func (b *BasePathFs) MkdirAll(name string, mode os.FileMode) (err error) {
169 if name, err = b.RealPath(name); err != nil {
170 return &os.PathError{Op: "mkdir", Path: name, Err: err}
171 }
172 return b.source.MkdirAll(name, mode)
173 }
174
175 func (b *BasePathFs) Create(name string) (f File, err error) {
176 if name, err = b.RealPath(name); err != nil {
177 return nil, &os.PathError{Op: "create", Path: name, Err: err}
178 }
179 sourcef, err := b.source.Create(name)
180 if err != nil {
181 return nil, err
182 }
183 return &BasePathFile{File: sourcef, path: b.path}, nil
184 }
185
186 func (b *BasePathFs) LstatIfPossible(name string) (os.FileInfo, bool, error) {
187 name, err := b.RealPath(name)
188 if err != nil {
189 return nil, false, &os.PathError{Op: "lstat", Path: name, Err: err}
190 }
191 if lstater, ok := b.source.(Lstater); ok {
192 return lstater.LstatIfPossible(name)
193 }
194 fi, err := b.source.Stat(name)
195 return fi, false, err
196 }
197
198 func (b *BasePathFs) SymlinkIfPossible(oldname, newname string) error {
199 oldname, err := b.RealPath(oldname)
200 if err != nil {
201 return &os.LinkError{Op: "symlink", Old: oldname, New: newname, Err: err}
202 }
203 newname, err = b.RealPath(newname)
204 if err != nil {
205 return &os.LinkError{Op: "symlink", Old: oldname, New: newname, Err: err}
206 }
207 if linker, ok := b.source.(Linker); ok {
208 return linker.SymlinkIfPossible(oldname, newname)
209 }
210 return &os.LinkError{Op: "symlink", Old: oldname, New: newname, Err: ErrNoSymlink}
211 }
212
213 func (b *BasePathFs) ReadlinkIfPossible(name string) (string, error) {
214 name, err := b.RealPath(name)
215 if err != nil {
216 return "", &os.PathError{Op: "readlink", Path: name, Err: err}
217 }
218 if reader, ok := b.source.(LinkReader); ok {
219 return reader.ReadlinkIfPossible(name)
220 }
221 return "", &os.PathError{Op: "readlink", Path: name, Err: ErrNoReadlink}
222 }
223