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) Name() string {
87	return "BasePathFs"
88}
89
90func (b *BasePathFs) Stat(name string) (fi os.FileInfo, err error) {
91	if name, err = b.RealPath(name); err != nil {
92		return nil, &os.PathError{Op: "stat", Path: name, Err: err}
93	}
94	return b.source.Stat(name)
95}
96
97func (b *BasePathFs) Rename(oldname, newname string) (err error) {
98	if oldname, err = b.RealPath(oldname); err != nil {
99		return &os.PathError{Op: "rename", Path: oldname, Err: err}
100	}
101	if newname, err = b.RealPath(newname); err != nil {
102		return &os.PathError{Op: "rename", Path: newname, Err: err}
103	}
104	return b.source.Rename(oldname, newname)
105}
106
107func (b *BasePathFs) RemoveAll(name string) (err error) {
108	if name, err = b.RealPath(name); err != nil {
109		return &os.PathError{Op: "remove_all", Path: name, Err: err}
110	}
111	return b.source.RemoveAll(name)
112}
113
114func (b *BasePathFs) Remove(name string) (err error) {
115	if name, err = b.RealPath(name); err != nil {
116		return &os.PathError{Op: "remove", Path: name, Err: err}
117	}
118	return b.source.Remove(name)
119}
120
121func (b *BasePathFs) OpenFile(name string, flag int, mode os.FileMode) (f File, err error) {
122	if name, err = b.RealPath(name); err != nil {
123		return nil, &os.PathError{Op: "openfile", Path: name, Err: err}
124	}
125	sourcef, err := b.source.OpenFile(name, flag, mode)
126	if err != nil {
127		return nil, err
128	}
129	return &BasePathFile{sourcef, b.path}, nil
130}
131
132func (b *BasePathFs) Open(name string) (f File, err error) {
133	if name, err = b.RealPath(name); err != nil {
134		return nil, &os.PathError{Op: "open", Path: name, Err: err}
135	}
136	sourcef, err := b.source.Open(name)
137	if err != nil {
138		return nil, err
139	}
140	return &BasePathFile{File: sourcef, path: b.path}, nil
141}
142
143func (b *BasePathFs) Mkdir(name string, mode os.FileMode) (err error) {
144	if name, err = b.RealPath(name); err != nil {
145		return &os.PathError{Op: "mkdir", Path: name, Err: err}
146	}
147	return b.source.Mkdir(name, mode)
148}
149
150func (b *BasePathFs) MkdirAll(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.MkdirAll(name, mode)
155}
156
157func (b *BasePathFs) Create(name string) (f File, err error) {
158	if name, err = b.RealPath(name); err != nil {
159		return nil, &os.PathError{Op: "create", Path: name, Err: err}
160	}
161	sourcef, err := b.source.Create(name)
162	if err != nil {
163		return nil, err
164	}
165	return &BasePathFile{File: sourcef, path: b.path}, nil
166}
167
168func (b *BasePathFs) LstatIfPossible(name string) (os.FileInfo, bool, error) {
169	name, err := b.RealPath(name)
170	if err != nil {
171		return nil, false, &os.PathError{Op: "lstat", Path: name, Err: err}
172	}
173	if lstater, ok := b.source.(Lstater); ok {
174		return lstater.LstatIfPossible(name)
175	}
176	fi, err := b.source.Stat(name)
177	return fi, false, err
178}
179
180// vim: ts=4 sw=4 noexpandtab nolist syn=go
181