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