podman

1
package afero
2

3
import (
4
	"fmt"
5
	"os"
6
	"path/filepath"
7
	"syscall"
8
	"time"
9
)
10

11
var _ Lstater = (*CopyOnWriteFs)(nil)
12

13
// The CopyOnWriteFs is a union filesystem: a read only base file system with
14
// a possibly writeable layer on top. Changes to the file system will only
15
// be made in the overlay: Changing an existing file in the base layer which
16
// is not present in the overlay will copy the file to the overlay ("changing"
17
// includes also calls to e.g. Chtimes(), Chmod() and Chown()).
18
//
19
// Reading directories is currently only supported via Open(), not OpenFile().
20
type CopyOnWriteFs struct {
21
	base  Fs
22
	layer Fs
23
}
24

25
func NewCopyOnWriteFs(base Fs, layer Fs) Fs {
26
	return &CopyOnWriteFs{base: base, layer: layer}
27
}
28

29
// Returns true if the file is not in the overlay
30
func (u *CopyOnWriteFs) isBaseFile(name string) (bool, error) {
31
	if _, err := u.layer.Stat(name); err == nil {
32
		return false, nil
33
	}
34
	_, err := u.base.Stat(name)
35
	if err != nil {
36
		if oerr, ok := err.(*os.PathError); ok {
37
			if oerr.Err == os.ErrNotExist || oerr.Err == syscall.ENOENT || oerr.Err == syscall.ENOTDIR {
38
				return false, nil
39
			}
40
		}
41
		if err == syscall.ENOENT {
42
			return false, nil
43
		}
44
	}
45
	return true, err
46
}
47

48
func (u *CopyOnWriteFs) copyToLayer(name string) error {
49
	return copyToLayer(u.base, u.layer, name)
50
}
51

52
func (u *CopyOnWriteFs) Chtimes(name string, atime, mtime time.Time) error {
53
	b, err := u.isBaseFile(name)
54
	if err != nil {
55
		return err
56
	}
57
	if b {
58
		if err := u.copyToLayer(name); err != nil {
59
			return err
60
		}
61
	}
62
	return u.layer.Chtimes(name, atime, mtime)
63
}
64

65
func (u *CopyOnWriteFs) Chmod(name string, mode os.FileMode) error {
66
	b, err := u.isBaseFile(name)
67
	if err != nil {
68
		return err
69
	}
70
	if b {
71
		if err := u.copyToLayer(name); err != nil {
72
			return err
73
		}
74
	}
75
	return u.layer.Chmod(name, mode)
76
}
77

78
func (u *CopyOnWriteFs) Chown(name string, uid, gid int) error {
79
	b, err := u.isBaseFile(name)
80
	if err != nil {
81
		return err
82
	}
83
	if b {
84
		if err := u.copyToLayer(name); err != nil {
85
			return err
86
		}
87
	}
88
	return u.layer.Chown(name, uid, gid)
89
}
90

91
func (u *CopyOnWriteFs) Stat(name string) (os.FileInfo, error) {
92
	fi, err := u.layer.Stat(name)
93
	if err != nil {
94
		isNotExist := u.isNotExist(err)
95
		if isNotExist {
96
			return u.base.Stat(name)
97
		}
98
		return nil, err
99
	}
100
	return fi, nil
101
}
102

103
func (u *CopyOnWriteFs) LstatIfPossible(name string) (os.FileInfo, bool, error) {
104
	llayer, ok1 := u.layer.(Lstater)
105
	lbase, ok2 := u.base.(Lstater)
106

107
	if ok1 {
108
		fi, b, err := llayer.LstatIfPossible(name)
109
		if err == nil {
110
			return fi, b, nil
111
		}
112

113
		if !u.isNotExist(err) {
114
			return nil, b, err
115
		}
116
	}
117

118
	if ok2 {
119
		fi, b, err := lbase.LstatIfPossible(name)
120
		if err == nil {
121
			return fi, b, nil
122
		}
123
		if !u.isNotExist(err) {
124
			return nil, b, err
125
		}
126
	}
127

128
	fi, err := u.Stat(name)
129

130
	return fi, false, err
131
}
132

133
func (u *CopyOnWriteFs) SymlinkIfPossible(oldname, newname string) error {
134
	if slayer, ok := u.layer.(Linker); ok {
135
		return slayer.SymlinkIfPossible(oldname, newname)
136
	}
137

138
	return &os.LinkError{Op: "symlink", Old: oldname, New: newname, Err: ErrNoSymlink}
139
}
140

141
func (u *CopyOnWriteFs) ReadlinkIfPossible(name string) (string, error) {
142
	if rlayer, ok := u.layer.(LinkReader); ok {
143
		return rlayer.ReadlinkIfPossible(name)
144
	}
145

146
	if rbase, ok := u.base.(LinkReader); ok {
147
		return rbase.ReadlinkIfPossible(name)
148
	}
149

150
	return "", &os.PathError{Op: "readlink", Path: name, Err: ErrNoReadlink}
151
}
152

153
func (u *CopyOnWriteFs) isNotExist(err error) bool {
154
	if e, ok := err.(*os.PathError); ok {
155
		err = e.Err
156
	}
157
	if err == os.ErrNotExist || err == syscall.ENOENT || err == syscall.ENOTDIR {
158
		return true
159
	}
160
	return false
161
}
162

163
// Renaming files present only in the base layer is not permitted
164
func (u *CopyOnWriteFs) Rename(oldname, newname string) error {
165
	b, err := u.isBaseFile(oldname)
166
	if err != nil {
167
		return err
168
	}
169
	if b {
170
		return syscall.EPERM
171
	}
172
	return u.layer.Rename(oldname, newname)
173
}
174

175
// Removing files present only in the base layer is not permitted. If
176
// a file is present in the base layer and the overlay, only the overlay
177
// will be removed.
178
func (u *CopyOnWriteFs) Remove(name string) error {
179
	err := u.layer.Remove(name)
180
	switch err {
181
	case syscall.ENOENT:
182
		_, err = u.base.Stat(name)
183
		if err == nil {
184
			return syscall.EPERM
185
		}
186
		return syscall.ENOENT
187
	default:
188
		return err
189
	}
190
}
191

192
func (u *CopyOnWriteFs) RemoveAll(name string) error {
193
	err := u.layer.RemoveAll(name)
194
	switch err {
195
	case syscall.ENOENT:
196
		_, err = u.base.Stat(name)
197
		if err == nil {
198
			return syscall.EPERM
199
		}
200
		return syscall.ENOENT
201
	default:
202
		return err
203
	}
204
}
205

206
func (u *CopyOnWriteFs) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
207
	b, err := u.isBaseFile(name)
208
	if err != nil {
209
		return nil, err
210
	}
211

212
	if flag&(os.O_WRONLY|os.O_RDWR|os.O_APPEND|os.O_CREATE|os.O_TRUNC) != 0 {
213
		if b {
214
			if err = u.copyToLayer(name); err != nil {
215
				return nil, err
216
			}
217
			return u.layer.OpenFile(name, flag, perm)
218
		}
219

220
		dir := filepath.Dir(name)
221
		isaDir, err := IsDir(u.base, dir)
222
		if err != nil && !os.IsNotExist(err) {
223
			return nil, err
224
		}
225
		if isaDir {
226
			if err = u.layer.MkdirAll(dir, 0o777); err != nil {
227
				return nil, err
228
			}
229
			return u.layer.OpenFile(name, flag, perm)
230
		}
231

232
		isaDir, err = IsDir(u.layer, dir)
233
		if err != nil {
234
			return nil, err
235
		}
236
		if isaDir {
237
			return u.layer.OpenFile(name, flag, perm)
238
		}
239

240
		return nil, &os.PathError{Op: "open", Path: name, Err: syscall.ENOTDIR} // ...or os.ErrNotExist?
241
	}
242
	if b {
243
		return u.base.OpenFile(name, flag, perm)
244
	}
245
	return u.layer.OpenFile(name, flag, perm)
246
}
247

248
// This function handles the 9 different possibilities caused
249
// by the union which are the intersection of the following...
250
//
251
//	layer: doesn't exist, exists as a file, and exists as a directory
252
//	base:  doesn't exist, exists as a file, and exists as a directory
253
func (u *CopyOnWriteFs) Open(name string) (File, error) {
254
	// Since the overlay overrides the base we check that first
255
	b, err := u.isBaseFile(name)
256
	if err != nil {
257
		return nil, err
258
	}
259

260
	// If overlay doesn't exist, return the base (base state irrelevant)
261
	if b {
262
		return u.base.Open(name)
263
	}
264

265
	// If overlay is a file, return it (base state irrelevant)
266
	dir, err := IsDir(u.layer, name)
267
	if err != nil {
268
		return nil, err
269
	}
270
	if !dir {
271
		return u.layer.Open(name)
272
	}
273

274
	// Overlay is a directory, base state now matters.
275
	// Base state has 3 states to check but 2 outcomes:
276
	// A. It's a file or non-readable in the base (return just the overlay)
277
	// B. It's an accessible directory in the base (return a UnionFile)
278

279
	// If base is file or nonreadable, return overlay
280
	dir, err = IsDir(u.base, name)
281
	if !dir || err != nil {
282
		return u.layer.Open(name)
283
	}
284

285
	// Both base & layer are directories
286
	// Return union file (if opens are without error)
287
	bfile, bErr := u.base.Open(name)
288
	lfile, lErr := u.layer.Open(name)
289

290
	// If either have errors at this point something is very wrong. Return nil and the errors
291
	if bErr != nil || lErr != nil {
292
		return nil, fmt.Errorf("BaseErr: %v\nOverlayErr: %v", bErr, lErr)
293
	}
294

295
	return &UnionFile{Base: bfile, Layer: lfile}, nil
296
}
297

298
func (u *CopyOnWriteFs) Mkdir(name string, perm os.FileMode) error {
299
	dir, err := IsDir(u.base, name)
300
	if err != nil {
301
		return u.layer.MkdirAll(name, perm)
302
	}
303
	if dir {
304
		return ErrFileExists
305
	}
306
	return u.layer.MkdirAll(name, perm)
307
}
308

309
func (u *CopyOnWriteFs) Name() string {
310
	return "CopyOnWriteFs"
311
}
312

313
func (u *CopyOnWriteFs) MkdirAll(name string, perm os.FileMode) error {
314
	dir, err := IsDir(u.base, name)
315
	if err != nil {
316
		return u.layer.MkdirAll(name, perm)
317
	}
318
	if dir {
319
		// This is in line with how os.MkdirAll behaves.
320
		return nil
321
	}
322
	return u.layer.MkdirAll(name, perm)
323
}
324

325
func (u *CopyOnWriteFs) Create(name string) (File, error) {
326
	return u.OpenFile(name, os.O_CREATE|os.O_TRUNC|os.O_RDWR, 0o666)
327
}
328