Privatae
75 lines
2.6 KiB
Go
75 lines
2.6 KiB
Go
package main
|
|
|
|
// Fuzz targets for how the op sandbox places an effect on a mount (Linux only,
|
|
// where the sandbox runs): the mount a path lives on, and the fixed part of an
|
|
// effect the mount is looked up by.
|
|
|
|
import (
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// opMountOf names the mount a path lives on, which decides whether the sandbox
|
|
// can carry an effect there. The answer must be a mount that holds the path on
|
|
// a whole-segment boundary ("/srv" does not hold "/srvx"), and no longer mount
|
|
// in the table may also hold it.
|
|
func FuzzOpMountOfIsTheLongestMountHoldingThePath(f *testing.F) {
|
|
for _, s := range [][2]string{
|
|
{"/,/srv,/srv/share,/home", "/srv/share/x"}, {"/,/srv", "/srvx/y"}, {"/srv,/srv/a", "/srv/a"},
|
|
{"/,/srv/a/b", "/srv/a"}, {"/", "/"}, {"/a,/a/b,/a/b/c", "/a/b/c/d"}, {"", "/x"},
|
|
} {
|
|
f.Add(s[0], s[1])
|
|
}
|
|
f.Fuzz(func(t *testing.T, table, p string) {
|
|
if !strings.HasPrefix(p, "/") || filepath.Clean(p) != p {
|
|
return
|
|
}
|
|
var mounts []opHostMount
|
|
for _, pt := range strings.Split(table, ",") {
|
|
if strings.HasPrefix(pt, "/") && filepath.Clean(pt) == pt {
|
|
mounts = append(mounts, opHostMount{Point: pt, FSType: "ext4"})
|
|
}
|
|
}
|
|
holds := func(point string) bool {
|
|
return point == "/" || p == point || strings.HasPrefix(p, point+"/")
|
|
}
|
|
got := opMountOf(mounts, p)
|
|
if !holds(got.Point) {
|
|
t.Fatalf("opMountOf(%v, %q) = %q, which does not hold the path", mounts, p, got.Point)
|
|
}
|
|
for _, m := range mounts {
|
|
if holds(m.Point) && len(m.Point) > len(got.Point) {
|
|
t.Fatalf("opMountOf(%v, %q) = %q, but %q is longer and holds it", mounts, p, got.Point, m.Point)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
// The sandbox looks an effect's mount up by its fixed part (opEffectPrefix).
|
|
// For that to name the right mount, every path the effect covers must sit at
|
|
// or under that fixed part.
|
|
func FuzzOpEffectPrefixHoldsEveryPathTheEffectCovers(f *testing.F) {
|
|
for _, s := range [][2]string{
|
|
{"/srv/app/", "/srv/app/x/y"}, {"/srv/a*/x", "/srv/ab/x"}, {"/srv/*", "/srv/q"}, {"/*/x", "/srv/x"},
|
|
{"/srv/app/a.conf", "/srv/app/a.conf"}, {"/srv/[ab]pp/*", "/srv/app/c"}, {"/srv/ap?/", "/srv/ap?/z"},
|
|
{"/srv/app", "/srv/app"},
|
|
} {
|
|
f.Add(s[0], s[1])
|
|
}
|
|
opsFuzzBox(f)
|
|
f.Fuzz(func(t *testing.T, effect, changed string) {
|
|
if effectOK(effect) != nil {
|
|
return
|
|
}
|
|
c := filepath.Clean(changed)
|
|
if !strings.HasPrefix(c, "/") || !effectCovers([]string{effect}, c) {
|
|
return
|
|
}
|
|
pre := opEffectPrefix(effect)
|
|
if pre != "/" && c != pre && !strings.HasPrefix(c, pre+"/") {
|
|
t.Fatalf("effect %q covers %q, which is not under its fixed part %q", effect, c, pre)
|
|
}
|
|
})
|
|
}
|