0ct0pu5/moby
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

pkg/archive: format code with gofumpt

Browse source 
Formatting the code with https://github.com/mvdan/gofumpt

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
This commit is contained in:
Sebastiaan van Stijn 2022-01-20 13:44:47 +01:00
parent 225e2562c9
commit f7552f1de4
No known key found for this signature in database
GPG key ID: 76698F39D527CE8C
14 changed files with 200 additions and 199 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
pkg/archive/archive.go
View file

@ -43,7 +43,7 @@ import (
// This value is currently implementation-defined, and not captured in any cross-runtime specification. Thus, it is
// subject to change in Moby at any time -- image authors who require consistent or known directory permissions
// should explicitly control them by ensuring that header entries exist for any applicable path.
const ImpliedDirectoryMode = 0755
const ImpliedDirectoryMode = 0o755
type (
// Compression is the state represents if compressed or not.
@ -1312,7 +1312,7 @@ func (archiver *Archiver) CopyWithTar(src, dst string) error {
// as owner
rootIDs := archiver.IDMapping.RootPair()
// Create dst, copy src's content into it
if err := idtools.MkdirAllAndChownNew(dst, 0755, rootIDs); err != nil {
if err := idtools.MkdirAllAndChownNew(dst, 0o755, rootIDs); err != nil {
return err
}
return archiver.TarUntar(src, dst)
@ -1337,7 +1337,7 @@ func (archiver *Archiver) CopyFileWithTar(src, dst string) (err error) {
dst = filepath.Join(dst, filepath.Base(src))
}
// Create the holding directory if necessary
if err := system.MkdirAll(filepath.Dir(dst), 0700); err != nil {
if err := system.MkdirAll(filepath.Dir(dst), 0o700); err != nil {
return err
}

5
pkg/archive/archive_linux.go
View file

@ -21,8 +21,7 @@ func getWhiteoutConverter(format WhiteoutFormat, inUserNS bool) (tarWhiteoutConv
return nil, nil
}
type overlayWhiteoutConverter struct {
}
type overlayWhiteoutConverter struct{}
func (overlayWhiteoutConverter) ConvertWrite(hdr *tar.Header, path string, fi os.FileInfo) (wo *tar.Header, err error) {
// convert whiteouts to AUFS format
@ -30,7 +29,7 @@ func (overlayWhiteoutConverter) ConvertWrite(hdr *tar.Header, path string, fi os
// we just rename the file and make it normal
dir, filename := filepath.Split(hdr.Name)
hdr.Name = filepath.Join(dir, WhiteoutPrefix+filename)
hdr.Mode = 0600
hdr.Mode = 0o600
hdr.Typeflag = tar.TypeReg
hdr.Size = 0
}

36
pkg/archive/archive_linux_test.go
View file

@ -27,27 +27,27 @@ func setupOverlayTestDir(t *testing.T, src string) {
skip.If(t, os.Getuid() != 0, "skipping test that requires root")
skip.If(t, userns.RunningInUserNS(), "skipping test that requires initial userns (trusted.overlay.opaque xattr cannot be set in userns, even with Ubuntu kernel)")
// Create opaque directory containing single file and permission 0700
err := os.Mkdir(filepath.Join(src, "d1"), 0700)
err := os.Mkdir(filepath.Join(src, "d1"), 0o700)
assert.NilError(t, err)
err = system.Lsetxattr(filepath.Join(src, "d1"), "trusted.overlay.opaque", []byte("y"), 0)
assert.NilError(t, err)
err = os.WriteFile(filepath.Join(src, "d1", "f1"), []byte{}, 0600)
err = os.WriteFile(filepath.Join(src, "d1", "f1"), []byte{}, 0o600)
assert.NilError(t, err)
// Create another opaque directory containing single file but with permission 0750
err = os.Mkdir(filepath.Join(src, "d2"), 0750)
err = os.Mkdir(filepath.Join(src, "d2"), 0o750)
assert.NilError(t, err)
err = system.Lsetxattr(filepath.Join(src, "d2"), "trusted.overlay.opaque", []byte("y"), 0)
assert.NilError(t, err)
err = os.WriteFile(filepath.Join(src, "d2", "f1"), []byte{}, 0660)
err = os.WriteFile(filepath.Join(src, "d2", "f1"), []byte{}, 0o660)
assert.NilError(t, err)
// Create regular directory with deleted file
err = os.Mkdir(filepath.Join(src, "d3"), 0700)
err = os.Mkdir(filepath.Join(src, "d3"), 0o700)
assert.NilError(t, err)
err = system.Mknod(filepath.Join(src, "d3", "f1"), unix.S_IFCHR, 0)
@ -110,11 +110,11 @@ func TestOverlayTarUntar(t *testing.T) {
err = Untar(archive, dst, options)
assert.NilError(t, err)
checkFileMode(t, filepath.Join(dst, "d1"), 0700|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d2"), 0750|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d3"), 0700|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d1", "f1"), 0600)
checkFileMode(t, filepath.Join(dst, "d2", "f1"), 0660)
checkFileMode(t, filepath.Join(dst, "d1"), 0o700|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d2"), 0o750|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d3"), 0o700|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d1", "f1"), 0o600)
checkFileMode(t, filepath.Join(dst, "d2", "f1"), 0o660)
checkFileMode(t, filepath.Join(dst, "d3", "f1"), os.ModeCharDevice|os.ModeDevice)
checkOpaqueness(t, filepath.Join(dst, "d1"), "y")
@ -150,12 +150,12 @@ func TestOverlayTarAUFSUntar(t *testing.T) {
})
assert.NilError(t, err)
checkFileMode(t, filepath.Join(dst, "d1"), 0700|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d1", WhiteoutOpaqueDir), 0700)
checkFileMode(t, filepath.Join(dst, "d2"), 0750|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d2", WhiteoutOpaqueDir), 0750)
checkFileMode(t, filepath.Join(dst, "d3"), 0700|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d1", "f1"), 0600)
checkFileMode(t, filepath.Join(dst, "d2", "f1"), 0660)
checkFileMode(t, filepath.Join(dst, "d3", WhiteoutPrefix+"f1"), 0600)
checkFileMode(t, filepath.Join(dst, "d1"), 0o700|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d1", WhiteoutOpaqueDir), 0o700)
checkFileMode(t, filepath.Join(dst, "d2"), 0o750|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d2", WhiteoutOpaqueDir), 0o750)
checkFileMode(t, filepath.Join(dst, "d3"), 0o700|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d1", "f1"), 0o600)
checkFileMode(t, filepath.Join(dst, "d2", "f1"), 0o660)
checkFileMode(t, filepath.Join(dst, "d3", WhiteoutPrefix+"f1"), 0o600)
}

125
pkg/archive/archive_test.go
View file

@ -197,6 +197,7 @@ func TestExtensionUncompressed(t *testing.T) {
t.Fatalf("The extension of an uncompressed archive should be 'tar'.")
}
}
func TestExtensionBzip2(t *testing.T) {
compression := Bzip2
output := compression.Extension()
@ -204,6 +205,7 @@ func TestExtensionBzip2(t *testing.T) {
t.Fatalf("The extension of a bzip2 archive should be 'tar.bz2'")
}
}
func TestExtensionGzip(t *testing.T) {
compression := Gzip
output := compression.Extension()
@ -211,6 +213,7 @@ func TestExtensionGzip(t *testing.T) {
t.Fatalf("The extension of a gzip archive should be 'tar.gz'")
}
}
func TestExtensionXz(t *testing.T) {
compression := Xz
output := compression.Extension()
@ -218,6 +221,7 @@ func TestExtensionXz(t *testing.T) {
t.Fatalf("The extension of a xz archive should be 'tar.xz'")
}
}
func TestExtensionZstd(t *testing.T) {
compression := Zstd
output := compression.Extension()
@ -330,7 +334,7 @@ func TestUntarPath(t *testing.T) {
os.Create(filepath.Join(tmpFolder, "src"))
destFolder := filepath.Join(tmpFolder, "dest")
err = os.MkdirAll(destFolder, 0740)
err = os.MkdirAll(destFolder, 0o740)
if err != nil {
t.Fatalf("Fail to create the destination file")
}
@ -418,13 +422,13 @@ func TestUntarPathWithDestinationSrcFileAsFolder(t *testing.T) {
t.Fatal(err)
}
destFolder := filepath.Join(tmpFolder, "dest")
err = os.MkdirAll(destFolder, 0740)
err = os.MkdirAll(destFolder, 0o740)
if err != nil {
t.Fatalf("Fail to create the destination folder")
}
// Let's create a folder that will has the same path as the extracted file (from tar)
destSrcFileAsFolder := filepath.Join(destFolder, srcFileU)
err = os.MkdirAll(destSrcFileAsFolder, 0740)
err = os.MkdirAll(destSrcFileAsFolder, 0o740)
if err != nil {
t.Fatal(err)
}
@ -441,7 +445,7 @@ func TestCopyWithTarInvalidSrc(t *testing.T) {
}
destFolder := filepath.Join(tempFolder, "dest")
invalidSrc := filepath.Join(tempFolder, "doesnotexists")
err = os.MkdirAll(destFolder, 0740)
err = os.MkdirAll(destFolder, 0o740)
if err != nil {
t.Fatal(err)
}
@ -459,7 +463,7 @@ func TestCopyWithTarInexistentDestWillCreateIt(t *testing.T) {
}
srcFolder := filepath.Join(tempFolder, "src")
inexistentDestFolder := filepath.Join(tempFolder, "doesnotexists")
err = os.MkdirAll(srcFolder, 0740)
err = os.MkdirAll(srcFolder, 0o740)
if err != nil {
t.Fatal(err)
}
@ -483,15 +487,15 @@ func TestCopyWithTarSrcFile(t *testing.T) {
dest := filepath.Join(folder, "dest")
srcFolder := filepath.Join(folder, "src")
src := filepath.Join(folder, filepath.Join("src", "src"))
err = os.MkdirAll(srcFolder, 0740)
err = os.MkdirAll(srcFolder, 0o740)
if err != nil {
t.Fatal(err)
}
err = os.MkdirAll(dest, 0740)
err = os.MkdirAll(dest, 0o740)
if err != nil {
t.Fatal(err)
}
os.WriteFile(src, []byte("content"), 0777)
os.WriteFile(src, []byte("content"), 0o777)
err = defaultCopyWithTar(src, dest)
if err != nil {
t.Fatalf("archiver.CopyWithTar shouldn't throw an error, %s.", err)
@ -512,15 +516,15 @@ func TestCopyWithTarSrcFolder(t *testing.T) {
defer os.RemoveAll(folder)
dest := filepath.Join(folder, "dest")
src := filepath.Join(folder, filepath.Join("src", "folder"))
err = os.MkdirAll(src, 0740)
err = os.MkdirAll(src, 0o740)
if err != nil {
t.Fatal(err)
}
err = os.MkdirAll(dest, 0740)
err = os.MkdirAll(dest, 0o740)
if err != nil {
t.Fatal(err)
}
os.WriteFile(filepath.Join(src, "file"), []byte("content"), 0777)
os.WriteFile(filepath.Join(src, "file"), []byte("content"), 0o777)
err = defaultCopyWithTar(src, dest)
if err != nil {
t.Fatalf("archiver.CopyWithTar shouldn't throw an error, %s.", err)
@ -539,7 +543,7 @@ func TestCopyFileWithTarInvalidSrc(t *testing.T) {
}
defer os.RemoveAll(tempFolder)
destFolder := filepath.Join(tempFolder, "dest")
err = os.MkdirAll(destFolder, 0740)
err = os.MkdirAll(destFolder, 0o740)
if err != nil {
t.Fatal(err)
}
@ -581,11 +585,11 @@ func TestCopyFileWithTarSrcFolder(t *testing.T) {
defer os.RemoveAll(folder)
dest := filepath.Join(folder, "dest")
src := filepath.Join(folder, "srcfolder")
err = os.MkdirAll(src, 0740)
err = os.MkdirAll(src, 0o740)
if err != nil {
t.Fatal(err)
}
err = os.MkdirAll(dest, 0740)
err = os.MkdirAll(dest, 0o740)
if err != nil {
t.Fatal(err)
}
@ -604,15 +608,15 @@ func TestCopyFileWithTarSrcFile(t *testing.T) {
dest := filepath.Join(folder, "dest")
srcFolder := filepath.Join(folder, "src")
src := filepath.Join(folder, filepath.Join("src", "src"))
err = os.MkdirAll(srcFolder, 0740)
err = os.MkdirAll(srcFolder, 0o740)
if err != nil {
t.Fatal(err)
}
err = os.MkdirAll(dest, 0740)
err = os.MkdirAll(dest, 0o740)
if err != nil {
t.Fatal(err)
}
os.WriteFile(src, []byte("content"), 0777)
os.WriteFile(src, []byte("content"), 0o777)
err = defaultCopyWithTar(src, dest+"/")
if err != nil {
t.Fatalf("archiver.CopyFileWithTar shouldn't throw an error, %s.", err)
@ -735,13 +739,13 @@ func TestTarUntar(t *testing.T) {
t.Fatal(err)
}
defer os.RemoveAll(origin)
if err := os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0700); err != nil {
if err := os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0o700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(origin, "2"), []byte("welcome!"), 0700); err != nil {
if err := os.WriteFile(filepath.Join(origin, "2"), []byte("welcome!"), 0o700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(origin, "3"), []byte("will be ignored"), 0700); err != nil {
if err := os.WriteFile(filepath.Join(origin, "3"), []byte("will be ignored"), 0o700); err != nil {
t.Fatal(err)
}
@ -753,7 +757,6 @@ func TestTarUntar(t *testing.T) {
Compression: c,
ExcludePatterns: []string{"3"},
})
if err != nil {
t.Fatalf("Error tar/untar for compression %s: %s", c.Extension(), err)
}
@ -770,7 +773,7 @@ func TestTarWithOptionsChownOptsAlwaysOverridesIdPair(t *testing.T) {
defer os.RemoveAll(origin)
filePath := filepath.Join(origin, "1")
err = os.WriteFile(filePath, []byte("hello world"), 0700)
err = os.WriteFile(filePath, []byte("hello world"), 0o700)
assert.NilError(t, err)
idMaps := []idtools.IDMap{
@ -824,10 +827,10 @@ func TestTarWithOptions(t *testing.T) {
t.Fatal(err)
}
defer os.RemoveAll(origin)
if err := os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0700); err != nil {
if err := os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0o700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(origin, "2"), []byte("welcome!"), 0700); err != nil {
if err := os.WriteFile(filepath.Join(origin, "2"), []byte("welcome!"), 0o700); err != nil {
t.Fatal(err)
}
@ -904,7 +907,7 @@ func prepareUntarSourceDirectory(numberOfFiles int, targetPath string, makeLinks
fileData := []byte("fooo")
for n := 0; n < numberOfFiles; n++ {
fileName := fmt.Sprintf("file-%d", n)
if err := os.WriteFile(filepath.Join(targetPath, fileName), fileData, 0700); err != nil {
if err := os.WriteFile(filepath.Join(targetPath, fileName), fileData, 0o700); err != nil {
return 0, err
}
if makeLinks {
@ -979,7 +982,7 @@ func TestUntarInvalidFilenames(t *testing.T) {
{
Name: "../victim/dotdot",
Typeflag: tar.TypeReg,
Mode: 0644,
Mode: 0o644,
},
},
{
@ -987,7 +990,7 @@ func TestUntarInvalidFilenames(t *testing.T) {
// Note the leading slash
Name: "/../victim/slash-dotdot",
Typeflag: tar.TypeReg,
Mode: 0644,
Mode: 0o644,
},
},
} {
@ -1005,18 +1008,18 @@ func TestUntarHardlinkToSymlink(t *testing.T) {
Name: "symlink1",
Typeflag: tar.TypeSymlink,
Linkname: "regfile",
Mode: 0644,
Mode: 0o644,
},
{
Name: "symlink2",
Typeflag: tar.TypeLink,
Linkname: "symlink1",
Mode: 0644,
Mode: 0o644,
},
{
Name: "regfile",
Typeflag: tar.TypeReg,
Mode: 0644,
Mode: 0o644,
},
},
} {
@ -1033,7 +1036,7 @@ func TestUntarInvalidHardlink(t *testing.T) {
Name: "dotdot",
Typeflag: tar.TypeLink,
Linkname: "../victim/hello",
Mode: 0644,
Mode: 0o644,
},
},
{ // try reading victim/hello (/../)
@ -1042,7 +1045,7 @@ func TestUntarInvalidHardlink(t *testing.T) {
Typeflag: tar.TypeLink,
// Note the leading slash
Linkname: "/../victim/hello",
Mode: 0644,
Mode: 0o644,
},
},
{ // try writing victim/file
@ -1050,12 +1053,12 @@ func TestUntarInvalidHardlink(t *testing.T) {
Name: "loophole-victim",
Typeflag: tar.TypeLink,
Linkname: "../victim",
Mode: 0755,
Mode: 0o755,
},
{
Name: "loophole-victim/file",
Typeflag: tar.TypeReg,
Mode: 0644,
Mode: 0o644,
},
},
{ // try reading victim/hello (hardlink, symlink)
@ -1063,13 +1066,13 @@ func TestUntarInvalidHardlink(t *testing.T) {
Name: "loophole-victim",
Typeflag: tar.TypeLink,
Linkname: "../victim",
Mode: 0755,
Mode: 0o755,
},
{
Name: "symlink",
Typeflag: tar.TypeSymlink,
Linkname: "loophole-victim/hello",
Mode: 0644,
Mode: 0o644,
},
},
{ // Try reading victim/hello (hardlink, hardlink)
@ -1077,13 +1080,13 @@ func TestUntarInvalidHardlink(t *testing.T) {
Name: "loophole-victim",
Typeflag: tar.TypeLink,
Linkname: "../victim",
Mode: 0755,
Mode: 0o755,
},
{
Name: "hardlink",
Typeflag: tar.TypeLink,
Linkname: "loophole-victim/hello",
Mode: 0644,
Mode: 0o644,
},
},
{ // Try removing victim directory (hardlink)
@ -1091,12 +1094,12 @@ func TestUntarInvalidHardlink(t *testing.T) {
Name: "loophole-victim",
Typeflag: tar.TypeLink,
Linkname: "../victim",
Mode: 0755,
Mode: 0o755,
},
{
Name: "loophole-victim",
Typeflag: tar.TypeReg,
Mode: 0644,
Mode: 0o644,
},
},
} {
@ -1113,7 +1116,7 @@ func TestUntarInvalidSymlink(t *testing.T) {
Name: "dotdot",
Typeflag: tar.TypeSymlink,
Linkname: "../victim/hello",
Mode: 0644,
Mode: 0o644,
},
},
{ // try reading victim/hello (/../)
@ -1122,7 +1125,7 @@ func TestUntarInvalidSymlink(t *testing.T) {
Typeflag: tar.TypeSymlink,
// Note the leading slash
Linkname: "/../victim/hello",
Mode: 0644,
Mode: 0o644,
},
},
{ // try writing victim/file
@ -1130,12 +1133,12 @@ func TestUntarInvalidSymlink(t *testing.T) {
Name: "loophole-victim",
Typeflag: tar.TypeSymlink,
Linkname: "../victim",
Mode: 0755,
Mode: 0o755,
},
{
Name: "loophole-victim/file",
Typeflag: tar.TypeReg,
Mode: 0644,
Mode: 0o644,
},
},
{ // try reading victim/hello (symlink, symlink)
@ -1143,13 +1146,13 @@ func TestUntarInvalidSymlink(t *testing.T) {
Name: "loophole-victim",
Typeflag: tar.TypeSymlink,
Linkname: "../victim",
Mode: 0755,
Mode: 0o755,
},
{
Name: "symlink",
Typeflag: tar.TypeSymlink,
Linkname: "loophole-victim/hello",
Mode: 0644,
Mode: 0o644,
},
},
{ // try reading victim/hello (symlink, hardlink)
@ -1157,13 +1160,13 @@ func TestUntarInvalidSymlink(t *testing.T) {
Name: "loophole-victim",
Typeflag: tar.TypeSymlink,
Linkname: "../victim",
Mode: 0755,
Mode: 0o755,
},
{
Name: "hardlink",
Typeflag: tar.TypeLink,
Linkname: "loophole-victim/hello",
Mode: 0644,
Mode: 0o644,
},
},
{ // try removing victim directory (symlink)
@ -1171,12 +1174,12 @@ func TestUntarInvalidSymlink(t *testing.T) {
Name: "loophole-victim",
Typeflag: tar.TypeSymlink,
Linkname: "../victim",
Mode: 0755,
Mode: 0o755,
},
{
Name: "loophole-victim",
Typeflag: tar.TypeReg,
Mode: 0644,
Mode: 0o644,
},
},
{ // try writing to victim/newdir/newfile with a symlink in the path
@ -1185,12 +1188,12 @@ func TestUntarInvalidSymlink(t *testing.T) {
Name: "dir/loophole",
Typeflag: tar.TypeSymlink,
Linkname: "../../victim",
Mode: 0755,
Mode: 0o755,
},
{
Name: "dir/loophole/newdir/newfile",
Typeflag: tar.TypeReg,
Mode: 0644,
Mode: 0o644,
},
},
} {
@ -1248,13 +1251,13 @@ func TestImpliedDirectoryPermissions(t *testing.T) {
Name: "deeply/nested/and/implied",
}, {
Name: "explicit/",
Mode: 0644,
Mode: 0o644,
}, {
Name: "explicit/permissions/",
Mode: 0600,
Mode: 0o600,
}, {
Name: "explicit/permissions/specified",
Mode: 0400,
Mode: 0o400,
}}
w := tar.NewWriter(buf)
@ -1279,9 +1282,9 @@ func TestImpliedDirectoryPermissions(t *testing.T) {
assertMode("deeply/nested", ImpliedDirectoryMode)
assertMode("deeply/nested/and", ImpliedDirectoryMode)
assertMode("explicit", 0644)
assertMode("explicit/permissions", 0600)
assertMode("explicit/permissions/specified", 0400)
assertMode("explicit", 0o644)
assertMode("explicit/permissions", 0o600)
assertMode("explicit/permissions/specified", 0o400)
}
func TestReplaceFileTarWrapper(t *testing.T) {
@ -1342,7 +1345,7 @@ func TestPrefixHeaderReadable(t *testing.T) {
skip.If(t, runtime.GOOS != "windows" && os.Getuid() != 0, "skipping test that requires root")
skip.If(t, userns.RunningInUserNS(), "skipping test that requires more than 010000000 UIDs, which is unlikely to be satisfied when running in userns")
// https://gist.github.com/stevvooe/e2a790ad4e97425896206c0816e1a882#file-out-go
var testFile = []byte("\x1f\x8b\x08\x08\x44\x21\x68\x59\x00\x03\x74\x2e\x74\x61\x72\x00\x4b\xcb\xcf\x67\xa0\x35\x30\x80\x00\x86\x06\x10\x47\x01\xc1\x37\x40\x00\x54\xb6\xb1\xa1\xa9\x99\x09\x48\x25\x1d\x40\x69\x71\x49\x62\x91\x02\xe5\x76\xa1\x79\x84\x21\x91\xd6\x80\x72\xaf\x8f\x82\x51\x30\x0a\x46\x36\x00\x00\xf0\x1c\x1e\x95\x00\x06\x00\x00")
testFile := []byte("\x1f\x8b\x08\x08\x44\x21\x68\x59\x00\x03\x74\x2e\x74\x61\x72\x00\x4b\xcb\xcf\x67\xa0\x35\x30\x80\x00\x86\x06\x10\x47\x01\xc1\x37\x40\x00\x54\xb6\xb1\xa1\xa9\x99\x09\x48\x25\x1d\x40\x69\x71\x49\x62\x91\x02\xe5\x76\xa1\x79\x84\x21\x91\xd6\x80\x72\xaf\x8f\x82\x51\x30\x0a\x46\x36\x00\x00\xf0\x1c\x1e\x95\x00\x06\x00\x00")
tmpDir, err := os.MkdirTemp("", "prefix-test")
assert.NilError(t, err)
@ -1374,7 +1377,7 @@ func buildSourceArchive(t *testing.T, numberOfFiles int) (io.ReadCloser, func())
func createOrReplaceModifier(path string, header *tar.Header, content io.Reader) (*tar.Header, []byte, error) {
return &tar.Header{
Mode: 0600,
Mode: 0o600,
Typeflag: tar.TypeReg,
}, []byte("the new content"), nil
}
@ -1394,7 +1397,7 @@ func appendModifier(path string, header *tar.Header, content io.Reader) (*tar.He
}
}
buffer.WriteString("\nnext line")
return &tar.Header{Mode: 0600, Typeflag: tar.TypeReg}, buffer.Bytes(), nil
return &tar.Header{Mode: 0o600, Typeflag: tar.TypeReg}, buffer.Bytes(), nil
}
func readFileFromArchive(t *testing.T, archive io.ReadCloser, name string, expectedCount int, doc string) string {

2
pkg/archive/archive_unix.go
View file

@ -82,7 +82,7 @@ func getFileUIDGID(stat interface{}) (idtools.Identity, error) {
// handleTarTypeBlockCharFifo is an OS-specific helper function used by
// createTarFile to handle the following types of header: Block; Char; Fifo
func handleTarTypeBlockCharFifo(hdr *tar.Header, path string) error {
mode := uint32(hdr.Mode & 07777)
mode := uint32(hdr.Mode & 0o7777)
switch hdr.Typeflag {
case tar.TypeBlock:
mode |= unix.S_IFBLK

41
pkg/archive/archive_unix_test.go
View file

@ -44,11 +44,11 @@ func TestChmodTarEntry(t *testing.T) {
cases := []struct {
in, expected os.FileMode
}{
{0000, 0000},
{0777, 0777},
{0644, 0644},
{0755, 0755},
{0444, 0444},
{0o000, 0o000},
{0o777, 0o777},
{0o644, 0o644},
{0o755, 0o755},
{0o444, 0o444},
}
for _, v := range cases {
if out := chmodTarEntry(v.in); out != v.expected {
@ -62,7 +62,7 @@ func TestTarWithHardLink(t *testing.T) {
assert.NilError(t, err)
defer os.RemoveAll(origin)
err = os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0700)
err = os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0o700)
assert.NilError(t, err)
err = os.Link(filepath.Join(origin, "1"), filepath.Join(origin, "2"))
@ -108,10 +108,10 @@ func TestTarWithHardLinkAndRebase(t *testing.T) {
defer os.RemoveAll(tmpDir)
origin := filepath.Join(tmpDir, "origin")
err = os.Mkdir(origin, 0700)
err = os.Mkdir(origin, 0o700)
assert.NilError(t, err)
err = os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0700)
err = os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0o700)
assert.NilError(t, err)
err = os.Link(filepath.Join(origin, "1"), filepath.Join(origin, "2"))
@ -160,7 +160,7 @@ func TestUntarParentPathPermissions(t *testing.T) {
fi, err := os.Lstat(filepath.Join(tmpDir, "foo"))
assert.NilError(t, err)
assert.Equal(t, fi.Mode(), 0755|os.ModeDir)
assert.Equal(t, fi.Mode(), 0o755|os.ModeDir)
}
func getNlink(path string) (uint64, error) {
@ -196,7 +196,7 @@ func TestTarWithBlockCharFifo(t *testing.T) {
assert.NilError(t, err)
defer os.RemoveAll(origin)
err = os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0700)
err = os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0o700)
assert.NilError(t, err)
err = system.Mknod(filepath.Join(origin, "2"), unix.S_IFBLK, int(system.Mkdev(int64(12), int64(5))))
@ -243,12 +243,12 @@ func TestTarUntarWithXattr(t *testing.T) {
origin, err := os.MkdirTemp("", "docker-test-untar-origin")
assert.NilError(t, err)
defer os.RemoveAll(origin)
err = os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0700)
err = os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0o700)
assert.NilError(t, err)
err = os.WriteFile(filepath.Join(origin, "2"), []byte("welcome!"), 0700)
err = os.WriteFile(filepath.Join(origin, "2"), []byte("welcome!"), 0o700)
assert.NilError(t, err)
err = os.WriteFile(filepath.Join(origin, "3"), []byte("will be ignored"), 0700)
err = os.WriteFile(filepath.Join(origin, "3"), []byte("will be ignored"), 0o700)
assert.NilError(t, err)
// there is no known Go implementation of setcap/getcap with support for v3 file capability
out, err := exec.Command("setcap", "cap_block_suspend+ep", filepath.Join(origin, "2")).CombinedOutput()
@ -262,7 +262,6 @@ func TestTarUntarWithXattr(t *testing.T) {
Compression: c,
ExcludePatterns: []string{"3"},
})
if err != nil {
t.Fatalf("Error tar/untar for compression %s: %s", c.Extension(), err)
}
@ -291,30 +290,30 @@ func TestCopyInfoDestinationPathSymlink(t *testing.T) {
testData := []FileTestData{
// Create a directory: /tmp/archive-copy-test*/dir1
// Test will "copy" file1 to dir1
{resource: FileData{filetype: Dir, path: "dir1", permissions: 0740}, file: "file1", expected: CopyInfo{Path: root + "dir1/file1", Exists: false, IsDir: false}},
{resource: FileData{filetype: Dir, path: "dir1", permissions: 0o740}, file: "file1", expected: CopyInfo{Path: root + "dir1/file1", Exists: false, IsDir: false}},
// Create a symlink directory to dir1: /tmp/archive-copy-test*/dirSymlink -> dir1
// Test will "copy" file2 to dirSymlink
{resource: FileData{filetype: Symlink, path: "dirSymlink", contents: root + "dir1", permissions: 0600}, file: "file2", expected: CopyInfo{Path: root + "dirSymlink/file2", Exists: false, IsDir: false}},
{resource: FileData{filetype: Symlink, path: "dirSymlink", contents: root + "dir1", permissions: 0o600}, file: "file2", expected: CopyInfo{Path: root + "dirSymlink/file2", Exists: false, IsDir: false}},
// Create a file in tmp directory: /tmp/archive-copy-test*/file1
// Test to cover when the full file path already exists.
{resource: FileData{filetype: Regular, path: "file1", permissions: 0600}, file: "", expected: CopyInfo{Path: root + "file1", Exists: true}},
{resource: FileData{filetype: Regular, path: "file1", permissions: 0o600}, file: "", expected: CopyInfo{Path: root + "file1", Exists: true}},
// Create a directory: /tmp/archive-copy*/dir2
// Test to cover when the full directory path already exists
{resource: FileData{filetype: Dir, path: "dir2", permissions: 0740}, file: "", expected: CopyInfo{Path: root + "dir2", Exists: true, IsDir: true}},
{resource: FileData{filetype: Dir, path: "dir2", permissions: 0o740}, file: "", expected: CopyInfo{Path: root + "dir2", Exists: true, IsDir: true}},
// Create a symlink to a non-existent target: /tmp/archive-copy*/symlink1 -> noSuchTarget
// Negative test to cover symlinking to a target that does not exit
{resource: FileData{filetype: Symlink, path: "symlink1", contents: "noSuchTarget", permissions: 0600}, file: "", expected: CopyInfo{Path: root + "noSuchTarget", Exists: false}},
{resource: FileData{filetype: Symlink, path: "symlink1", contents: "noSuchTarget", permissions: 0o600}, file: "", expected: CopyInfo{Path: root + "noSuchTarget", Exists: false}},
// Create a file in tmp directory for next test: /tmp/existingfile
{resource: FileData{filetype: Regular, path: "existingfile", permissions: 0600}, file: "", expected: CopyInfo{Path: root + "existingfile", Exists: true}},
{resource: FileData{filetype: Regular, path: "existingfile", permissions: 0o600}, file: "", expected: CopyInfo{Path: root + "existingfile", Exists: true}},
// Create a symlink to an existing file: /tmp/archive-copy*/symlink2 -> /tmp/existingfile
// Test to cover when the parent directory of a new file is a symlink
{resource: FileData{filetype: Symlink, path: "symlink2", contents: "existingfile", permissions: 0600}, file: "", expected: CopyInfo{Path: root + "existingfile", Exists: true}},
{resource: FileData{filetype: Symlink, path: "symlink2", contents: "existingfile", permissions: 0o600}, file: "", expected: CopyInfo{Path: root + "existingfile", Exists: true}},
}
var dirs []FileData

14
pkg/archive/archive_windows_test.go
View file

@ -21,11 +21,11 @@ func TestCopyFileWithInvalidDest(t *testing.T) {
dest := "c:dest"
srcFolder := filepath.Join(folder, "src")
src := filepath.Join(folder, "src", "src")
err = os.MkdirAll(srcFolder, 0740)
err = os.MkdirAll(srcFolder, 0o740)
if err != nil {
t.Fatal(err)
}
os.WriteFile(src, []byte("content"), 0777)
os.WriteFile(src, []byte("content"), 0o777)
err = defaultCopyWithTar(src, dest)
if err == nil {
t.Fatalf("archiver.CopyWithTar should throw an error on invalid dest.")
@ -54,11 +54,11 @@ func TestChmodTarEntry(t *testing.T) {
cases := []struct {
in, expected os.FileMode
}{
{0000, 0111},
{0777, 0755},
{0644, 0755},
{0755, 0755},
{0444, 0555},
{0o000, 0o111},
{0o777, 0o755},
{0o644, 0o755},
{0o755, 0o755},
{0o444, 0o555},
}
for _, v := range cases {
if out := chmodTarEntry(v.in); out != v.expected {

10
pkg/archive/changes.go
View file

@ -108,8 +108,10 @@ func aufsDeletedFile(root, path string, fi os.FileInfo) (string, error) {
return "", nil
}
type skipChange func(string) (bool, error)
type deleteChange func(string, string, os.FileInfo) (string, error)
type (
skipChange func(string) (bool, error)
deleteChange func(string, string, os.FileInfo) (string, error)
)
func changes(layers []string, rw string, dc deleteChange, sc skipChange) ([]Change, error) {
var (
@ -342,9 +344,7 @@ func newRootFileInfo() *FileInfo {
// ChangesDirs compares two directories and generates an array of Change objects describing the changes.
// If oldDir is "", then all files in newDir will be Add-Changes.
func ChangesDirs(newDir, oldDir string) ([]Change, error) {
var (
oldRoot, newRoot *FileInfo
)
var oldRoot, newRoot *FileInfo
if oldDir == "" {
emptyDir, err := os.MkdirTemp("", "empty")
if err != nil {

2
pkg/archive/changes_linux.go
View file

@ -267,7 +267,7 @@ func parseDirent(buf []byte, names []nameIno) (consumed int, newnames []nameIno)
continue
}
bytes := (*[10000]byte)(unsafe.Pointer(&dirent.Name[0]))
var name = string(bytes[0:clen(bytes[:])])
name := string(bytes[0:clen(bytes[:])])
if name == "." || name == ".." { // Useless names
continue
}

84
pkg/archive/changes_test.go
View file

@ -66,30 +66,30 @@ type FileData struct {
func createSampleDir(t *testing.T, root string) {
files := []FileData{
{filetype: Regular, path: "file1", contents: "file1\n", permissions: 0600},
{filetype: Regular, path: "file2", contents: "file2\n", permissions: 0666},
{filetype: Regular, path: "file3", contents: "file3\n", permissions: 0404},
{filetype: Regular, path: "file4", contents: "file4\n", permissions: 0600},
{filetype: Regular, path: "file5", contents: "file5\n", permissions: 0600},
{filetype: Regular, path: "file6", contents: "file6\n", permissions: 0600},
{filetype: Regular, path: "file7", contents: "file7\n", permissions: 0600},
{filetype: Dir, path: "dir1", contents: "", permissions: 0740},
{filetype: Regular, path: "dir1/file1-1", contents: "file1-1\n", permissions: 01444},
{filetype: Regular, path: "dir1/file1-2", contents: "file1-2\n", permissions: 0666},
{filetype: Dir, path: "dir2", contents: "", permissions: 0700},
{filetype: Regular, path: "dir2/file2-1", contents: "file2-1\n", permissions: 0666},
{filetype: Regular, path: "dir2/file2-2", contents: "file2-2\n", permissions: 0666},
{filetype: Dir, path: "dir3", contents: "", permissions: 0700},
{filetype: Regular, path: "dir3/file3-1", contents: "file3-1\n", permissions: 0666},
{filetype: Regular, path: "dir3/file3-2", contents: "file3-2\n", permissions: 0666},
{filetype: Dir, path: "dir4", contents: "", permissions: 0700},
{filetype: Regular, path: "dir4/file3-1", contents: "file4-1\n", permissions: 0666},
{filetype: Regular, path: "dir4/file3-2", contents: "file4-2\n", permissions: 0666},
{filetype: Symlink, path: "symlink1", contents: "target1", permissions: 0666},
{filetype: Symlink, path: "symlink2", contents: "target2", permissions: 0666},
{filetype: Symlink, path: "symlink3", contents: root + "/file1", permissions: 0666},
{filetype: Symlink, path: "symlink4", contents: root + "/symlink3", permissions: 0666},
{filetype: Symlink, path: "dirSymlink", contents: root + "/dir1", permissions: 0740},
{filetype: Regular, path: "file1", contents: "file1\n", permissions: 0o600},
{filetype: Regular, path: "file2", contents: "file2\n", permissions: 0o666},
{filetype: Regular, path: "file3", contents: "file3\n", permissions: 0o404},
{filetype: Regular, path: "file4", contents: "file4\n", permissions: 0o600},
{filetype: Regular, path: "file5", contents: "file5\n", permissions: 0o600},
{filetype: Regular, path: "file6", contents: "file6\n", permissions: 0o600},
{filetype: Regular, path: "file7", contents: "file7\n", permissions: 0o600},
{filetype: Dir, path: "dir1", contents: "", permissions: 0o740},
{filetype: Regular, path: "dir1/file1-1", contents: "file1-1\n", permissions: 0o1444},
{filetype: Regular, path: "dir1/file1-2", contents: "file1-2\n", permissions: 0o666},
{filetype: Dir, path: "dir2", contents: "", permissions: 0o700},
{filetype: Regular, path: "dir2/file2-1", contents: "file2-1\n", permissions: 0o666},
{filetype: Regular, path: "dir2/file2-2", contents: "file2-2\n", permissions: 0o666},
{filetype: Dir, path: "dir3", contents: "", permissions: 0o700},
{filetype: Regular, path: "dir3/file3-1", contents: "file3-1\n", permissions: 0o666},
{filetype: Regular, path: "dir3/file3-2", contents: "file3-2\n", permissions: 0o666},
{filetype: Dir, path: "dir4", contents: "", permissions: 0o700},
{filetype: Regular, path: "dir4/file3-1", contents: "file4-1\n", permissions: 0o666},
{filetype: Regular, path: "dir4/file3-2", contents: "file4-2\n", permissions: 0o666},
{filetype: Symlink, path: "symlink1", contents: "target1", permissions: 0o666},
{filetype: Symlink, path: "symlink2", contents: "target2", permissions: 0o666},
{filetype: Symlink, path: "symlink3", contents: root + "/file1", permissions: 0o666},
{filetype: Symlink, path: "symlink4", contents: root + "/symlink3", permissions: 0o666},
{filetype: Symlink, path: "dirSymlink", contents: root + "/dir1", permissions: 0o740},
}
provisionSampleDir(t, root, files)
}
@ -156,7 +156,7 @@ func TestChangesWithChanges(t *testing.T) {
assert.NilError(t, err)
defer os.RemoveAll(layer)
createSampleDir(t, layer)
os.MkdirAll(path.Join(layer, "dir1/subfolder"), 0740)
os.MkdirAll(path.Join(layer, "dir1/subfolder"), 0o740)
// Mock the RW layer
rwLayer, err := os.MkdirTemp("", "docker-changes-test")
@ -165,16 +165,16 @@ func TestChangesWithChanges(t *testing.T) {
// Create a folder in RW layer
dir1 := path.Join(rwLayer, "dir1")
os.MkdirAll(dir1, 0740)
os.MkdirAll(dir1, 0o740)
deletedFile := path.Join(dir1, ".wh.file1-2")
os.WriteFile(deletedFile, []byte{}, 0600)
os.WriteFile(deletedFile, []byte{}, 0o600)
modifiedFile := path.Join(dir1, "file1-1")
os.WriteFile(modifiedFile, []byte{0x00}, 01444)
os.WriteFile(modifiedFile, []byte{0x00}, 0o1444)
// Let's add a subfolder for a newFile
subfolder := path.Join(dir1, "subfolder")
os.MkdirAll(subfolder, 0740)
os.MkdirAll(subfolder, 0o740)
newFile := path.Join(subfolder, "newFile")
os.WriteFile(newFile, []byte{}, 0740)
os.WriteFile(newFile, []byte{}, 0o740)
changes, err := Changes([]string{layer}, rwLayer)
assert.NilError(t, err)
@ -200,10 +200,10 @@ func TestChangesWithChangesGH13590(t *testing.T) {
defer os.RemoveAll(baseLayer)
dir3 := path.Join(baseLayer, "dir1/dir2/dir3")
os.MkdirAll(dir3, 07400)
os.MkdirAll(dir3, 0o7400)
file := path.Join(dir3, "file.txt")
os.WriteFile(file, []byte("hello"), 0666)
os.WriteFile(file, []byte("hello"), 0o666)
layer, err := os.MkdirTemp("", "docker-changes-test2.")
assert.NilError(t, err)
@ -216,7 +216,7 @@ func TestChangesWithChangesGH13590(t *testing.T) {
os.Remove(path.Join(layer, "dir1/dir2/dir3/file.txt"))
file = path.Join(layer, "dir1/dir2/dir3/file1.txt")
os.WriteFile(file, []byte("bye"), 0666)
os.WriteFile(file, []byte("bye"), 0o666)
changes, err := Changes([]string{baseLayer}, layer)
assert.NilError(t, err)
@ -237,7 +237,7 @@ func TestChangesWithChangesGH13590(t *testing.T) {
}
file = path.Join(layer, "dir1/dir2/dir3/file.txt")
os.WriteFile(file, []byte("bye"), 0666)
os.WriteFile(file, []byte("bye"), 0o666)
changes, err = Changes([]string{baseLayer}, layer)
assert.NilError(t, err)
@ -294,13 +294,13 @@ func mutateSampleDir(t *testing.T, root string) {
assert.NilError(t, err)
// Rewrite a file
err = os.WriteFile(path.Join(root, "file2"), []byte("fileNN\n"), 0777)
err = os.WriteFile(path.Join(root, "file2"), []byte("fileNN\n"), 0o777)
assert.NilError(t, err)
// Replace a file
err = os.RemoveAll(path.Join(root, "file3"))
assert.NilError(t, err)
err = os.WriteFile(path.Join(root, "file3"), []byte("fileMM\n"), 0404)
err = os.WriteFile(path.Join(root, "file3"), []byte("fileMM\n"), 0o404)
assert.NilError(t, err)
// Touch file
@ -310,15 +310,15 @@ func mutateSampleDir(t *testing.T, root string) {
// Replace file with dir
err = os.RemoveAll(path.Join(root, "file5"))
assert.NilError(t, err)
err = os.MkdirAll(path.Join(root, "file5"), 0666)
err = os.MkdirAll(path.Join(root, "file5"), 0o666)
assert.NilError(t, err)
// Create new file
err = os.WriteFile(path.Join(root, "filenew"), []byte("filenew\n"), 0777)
err = os.WriteFile(path.Join(root, "filenew"), []byte("filenew\n"), 0o777)
assert.NilError(t, err)
// Create new dir
err = os.MkdirAll(path.Join(root, "dirnew"), 0766)
err = os.MkdirAll(path.Join(root, "dirnew"), 0o766)
assert.NilError(t, err)
// Create a new symlink
@ -335,7 +335,7 @@ func mutateSampleDir(t *testing.T, root string) {
// Replace dir with file
err = os.RemoveAll(path.Join(root, "dir2"))
assert.NilError(t, err)
err = os.WriteFile(path.Join(root, "dir2"), []byte("dir2\n"), 0777)
err = os.WriteFile(path.Join(root, "dir2"), []byte("dir2\n"), 0o777)
assert.NilError(t, err)
// Touch dir
@ -510,10 +510,10 @@ func TestChangesSize(t *testing.T) {
assert.NilError(t, err)
defer os.RemoveAll(parentPath)
addition := path.Join(parentPath, "addition")
err = os.WriteFile(addition, []byte{0x01, 0x01, 0x01}, 0744)
err = os.WriteFile(addition, []byte{0x01, 0x01, 0x01}, 0o744)
assert.NilError(t, err)
modification := path.Join(parentPath, "modification")
err = os.WriteFile(modification, []byte{0x01, 0x01, 0x01}, 0744)
err = os.WriteFile(modification, []byte{0x01, 0x01, 0x01}, 0o744)
assert.NilError(t, err)
changes := []Change{

16
pkg/archive/copy_unix_test.go
View file

@ -472,7 +472,7 @@ func TestCopyCaseD(t *testing.T) {
t.Fatalf("unable to remove dstDir: %s", err)
}
if err = os.MkdirAll(dstDir, os.FileMode(0755)); err != nil {
if err = os.MkdirAll(dstDir, os.FileMode(0o755)); err != nil {
t.Fatalf("unable to make dstDir: %s", err)
}
@ -523,7 +523,7 @@ func TestCopyCaseDFSym(t *testing.T) {
t.Fatalf("unable to remove dstDir: %s", err)
}
if err = os.MkdirAll(dstDir, os.FileMode(0755)); err != nil {
if err = os.MkdirAll(dstDir, os.FileMode(0o755)); err != nil {
t.Fatalf("unable to make dstDir: %s", err)
}
@ -693,7 +693,7 @@ func TestCopyCaseG(t *testing.T) {
t.Fatalf("unable to remove dstDir: %s", err)
}
if err = os.MkdirAll(dstDir, os.FileMode(0755)); err != nil {
if err = os.MkdirAll(dstDir, os.FileMode(0o755)); err != nil {
t.Fatalf("unable to make dstDir: %s", err)
}
@ -739,7 +739,7 @@ func TestCopyCaseGFSym(t *testing.T) {
t.Fatalf("unable to remove dstDir: %s", err)
}
if err = os.MkdirAll(dstDir, os.FileMode(0755)); err != nil {
if err = os.MkdirAll(dstDir, os.FileMode(0o755)); err != nil {
t.Fatalf("unable to make dstDir: %s", err)
}
@ -905,7 +905,7 @@ func TestCopyCaseJ(t *testing.T) {
var err error
// first to create an empty dir
if err = os.MkdirAll(dstDir, os.FileMode(0755)); err != nil {
if err = os.MkdirAll(dstDir, os.FileMode(0o755)); err != nil {
t.Fatalf("unable to make dstDir: %s", err)
}
@ -922,7 +922,7 @@ func TestCopyCaseJ(t *testing.T) {
t.Fatalf("unable to remove dstDir: %s", err)
}
if err = os.MkdirAll(dstDir, os.FileMode(0755)); err != nil {
if err = os.MkdirAll(dstDir, os.FileMode(0o755)); err != nil {
t.Fatalf("unable to make dstDir: %s", err)
}
@ -956,7 +956,7 @@ func TestCopyCaseJFSym(t *testing.T) {
var err error
// first to create an empty dir
if err = os.MkdirAll(dstDir, os.FileMode(0755)); err != nil {
if err = os.MkdirAll(dstDir, os.FileMode(0o755)); err != nil {
t.Fatalf("unable to make dstDir: %s", err)
}
@ -973,7 +973,7 @@ func TestCopyCaseJFSym(t *testing.T) {
t.Fatalf("unable to remove dstDir: %s", err)
}
if err = os.MkdirAll(dstDir, os.FileMode(0755)); err != nil {
if err = os.MkdirAll(dstDir, os.FileMode(0o755)); err != nil {
t.Fatalf("unable to make dstDir: %s", err)
}

48
pkg/archive/diff_test.go
View file

@ -17,7 +17,7 @@ func TestApplyLayerInvalidFilenames(t *testing.T) {
{
Name: "../victim/dotdot",
Typeflag: tar.TypeReg,
Mode: 0644,
Mode: 0o644,
},
},
{
@ -25,7 +25,7 @@ func TestApplyLayerInvalidFilenames(t *testing.T) {
// Note the leading slash
Name: "/../victim/slash-dotdot",
Typeflag: tar.TypeReg,
Mode: 0644,
Mode: 0o644,
},
},
} {
@ -42,7 +42,7 @@ func TestApplyLayerInvalidHardlink(t *testing.T) {
Name: "dotdot",
Typeflag: tar.TypeLink,
Linkname: "../victim/hello",
Mode: 0644,
Mode: 0o644,
},
},
{ // try reading victim/hello (/../)
@ -51,7 +51,7 @@ func TestApplyLayerInvalidHardlink(t *testing.T) {
Typeflag: tar.TypeLink,
// Note the leading slash
Linkname: "/../victim/hello",
Mode: 0644,
Mode: 0o644,
},
},
{ // try writing victim/file
@ -59,12 +59,12 @@ func TestApplyLayerInvalidHardlink(t *testing.T) {
Name: "loophole-victim",
Typeflag: tar.TypeLink,
Linkname: "../victim",
Mode: 0755,
Mode: 0o755,
},
{
Name: "loophole-victim/file",
Typeflag: tar.TypeReg,
Mode: 0644,
Mode: 0o644,
},
},
{ // try reading victim/hello (hardlink, symlink)
@ -72,13 +72,13 @@ func TestApplyLayerInvalidHardlink(t *testing.T) {
Name: "loophole-victim",
Typeflag: tar.TypeLink,
Linkname: "../victim",
Mode: 0755,
Mode: 0o755,
},
{
Name: "symlink",
Typeflag: tar.TypeSymlink,
Linkname: "loophole-victim/hello",
Mode: 0644,
Mode: 0o644,
},
},
{ // Try reading victim/hello (hardlink, hardlink)
@ -86,13 +86,13 @@ func TestApplyLayerInvalidHardlink(t *testing.T) {
Name: "loophole-victim",
Typeflag: tar.TypeLink,
Linkname: "../victim",
Mode: 0755,
Mode: 0o755,
},
{
Name: "hardlink",
Typeflag: tar.TypeLink,
Linkname: "loophole-victim/hello",
Mode: 0644,
Mode: 0o644,
},
},
{ // Try removing victim directory (hardlink)
@ -100,12 +100,12 @@ func TestApplyLayerInvalidHardlink(t *testing.T) {
Name: "loophole-victim",
Typeflag: tar.TypeLink,
Linkname: "../victim",
Mode: 0755,
Mode: 0o755,
},
{
Name: "loophole-victim",
Typeflag: tar.TypeReg,
Mode: 0644,
Mode: 0o644,
},
},
} {
@ -122,7 +122,7 @@ func TestApplyLayerInvalidSymlink(t *testing.T) {
Name: "dotdot",
Typeflag: tar.TypeSymlink,
Linkname: "../victim/hello",
Mode: 0644,
Mode: 0o644,
},
},
{ // try reading victim/hello (/../)
@ -131,7 +131,7 @@ func TestApplyLayerInvalidSymlink(t *testing.T) {
Typeflag: tar.TypeSymlink,
// Note the leading slash
Linkname: "/../victim/hello",
Mode: 0644,
Mode: 0o644,
},
},
{ // try writing victim/file
@ -139,12 +139,12 @@ func TestApplyLayerInvalidSymlink(t *testing.T) {
Name: "loophole-victim",
Typeflag: tar.TypeSymlink,
Linkname: "../victim",
Mode: 0755,
Mode: 0o755,
},
{
Name: "loophole-victim/file",
Typeflag: tar.TypeReg,
Mode: 0644,
Mode: 0o644,
},
},
{ // try reading victim/hello (symlink, symlink)
@ -152,13 +152,13 @@ func TestApplyLayerInvalidSymlink(t *testing.T) {
Name: "loophole-victim",
Typeflag: tar.TypeSymlink,
Linkname: "../victim",
Mode: 0755,
Mode: 0o755,
},
{
Name: "symlink",
Typeflag: tar.TypeSymlink,
Linkname: "loophole-victim/hello",
Mode: 0644,
Mode: 0o644,
},
},
{ // try reading victim/hello (symlink, hardlink)
@ -166,13 +166,13 @@ func TestApplyLayerInvalidSymlink(t *testing.T) {
Name: "loophole-victim",
Typeflag: tar.TypeSymlink,
Linkname: "../victim",
Mode: 0755,
Mode: 0o755,
},
{
Name: "hardlink",
Typeflag: tar.TypeLink,
Linkname: "loophole-victim/hello",
Mode: 0644,
Mode: 0o644,
},
},
{ // try removing victim directory (symlink)
@ -180,12 +180,12 @@ func TestApplyLayerInvalidSymlink(t *testing.T) {
Name: "loophole-victim",
Typeflag: tar.TypeSymlink,
Linkname: "../victim",
Mode: 0755,
Mode: 0o755,
},
{
Name: "loophole-victim",
Typeflag: tar.TypeReg,
Mode: 0644,
Mode: 0o644,
},
},
} {
@ -324,11 +324,11 @@ func makeTestLayer(paths []string) (rc io.ReadCloser, err error) {
// Source files are always in Unix format. But we use filepath on
// creation to be platform agnostic.
if p[len(p)-1] == '/' {
if err = os.MkdirAll(filepath.Join(tmpDir, p), 0700); err != nil {
if err = os.MkdirAll(filepath.Join(tmpDir, p), 0o700); err != nil {
return
}
} else {
if err = os.WriteFile(filepath.Join(tmpDir, p), nil, 0600); err != nil {
if err = os.WriteFile(filepath.Join(tmpDir, p), nil, 0o600); err != nil {
return
}
}

4
pkg/archive/example_changes.go
View file

@ -12,8 +12,8 @@ import (
"os"
"path"
"github.com/docker/docker/pkg/archive"
"github.com/containerd/containerd/log"
"github.com/docker/docker/pkg/archive"
)
var (
@ -82,7 +82,7 @@ func prepareUntarSourceDirectory(numberOfFiles int, targetPath string, makeLinks
fileData := []byte("fooo")
for n := 0; n < numberOfFiles; n++ {
fileName := fmt.Sprintf("file-%d", n)
if err := os.WriteFile(path.Join(targetPath, fileName), fileData, 0700); err != nil {
if err := os.WriteFile(path.Join(targetPath, fileName), fileData, 0o700); err != nil {
return 0, err
}
if makeLinks {

6
pkg/archive/utils_test.go
View file

@ -40,12 +40,12 @@ func testBreakout(untarFn string, tmpdir string, headers []*tar.Header) error {
defer os.RemoveAll(tmpdir)
dest := filepath.Join(tmpdir, "dest")
if err := os.Mkdir(dest, 0755); err != nil {
if err := os.Mkdir(dest, 0o755); err != nil {
return err
}
victim := filepath.Join(tmpdir, "victim")
if err := os.Mkdir(victim, 0755); err != nil {
if err := os.Mkdir(victim, 0o755); err != nil {
return err
}
hello := filepath.Join(victim, "hello")
@ -53,7 +53,7 @@ func testBreakout(untarFn string, tmpdir string, headers []*tar.Header) error {
if err != nil {
return err
}
if err := os.WriteFile(hello, helloData, 0644); err != nil {
if err := os.WriteFile(hello, helloData, 0o644); err != nil {
return err
}
helloStat, err := os.Stat(hello)