containers
/
storage
mirror of https://github.com/containers/storage.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Format sources with gofumpt 

gofumpt is a superset of gofmt, enabling some more code formatting
rules.

This commit is brought to you by

	gofumpt -w .

Signed-off-by: Kir Kolyshkin <kolyshkin@gmail.com>
This commit is contained in:
Kir Kolyshkin 2023-05-26 16:17:31 -07:00
parent 3a452d12bb
commit a4d8f720a2
123 changed files with 642 additions and 688 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cmd/containers-storage/container.go
View File

@ -9,9 +9,7 @@ import (
"github.com/containers/storage/pkg/mflag" "github.com/containers/storage/pkg/mflag"
) )
var ( var paramContainerDataFile = ""
paramContainerDataFile = ""
)
func container(flags *mflag.FlagSet, action string, m storage.Store, args []string) (int, error) { func container(flags *mflag.FlagSet, action string, m storage.Store, args []string) (int, error) {
images, err := m.Images() images, err := m.Images()

4
cmd/containers-storage/copy.go
View File

@ -13,9 +13,7 @@ import (
"github.com/containers/storage/pkg/mflag" "github.com/containers/storage/pkg/mflag"
) )
var ( var chownOptions = ""
chownOptions = ""
)
func copyContent(flags *mflag.FlagSet, action string, m storage.Store, args []string) (int, error) { func copyContent(flags *mflag.FlagSet, action string, m storage.Store, args []string) (int, error) {
var untarIDMappings *idtools.IDMappings var untarIDMappings *idtools.IDMappings

4
cmd/containers-storage/image.go
View File

@ -10,9 +10,7 @@ import (
digest "github.com/opencontainers/go-digest" digest "github.com/opencontainers/go-digest"
) )
var ( var paramImageDataFile = ""
paramImageDataFile = ""
)
func image(flags *mflag.FlagSet, action string, m storage.Store, args []string) (int, error) { func image(flags *mflag.FlagSet, action string, m storage.Store, args []string) (int, error) {
matched := []*storage.Image{} matched := []*storage.Image{}

4
cmd/containers-storage/images.go
View File

@ -8,9 +8,7 @@ import (
digest "github.com/opencontainers/go-digest" digest "github.com/opencontainers/go-digest"
) )
var ( var imagesQuiet = false
imagesQuiet = false
)
func images(flags *mflag.FlagSet, action string, m storage.Store, args []string) (int, error) { func images(flags *mflag.FlagSet, action string, m storage.Store, args []string) (int, error) {
images, err := m.Images() images, err := m.Images()

4
cmd/containers-storage/layer.go
View File

@ -9,9 +9,7 @@ import (
"github.com/containers/storage/pkg/mflag" "github.com/containers/storage/pkg/mflag"
) )
var ( var paramLayerDataFile = ""
paramLayerDataFile = ""
)
func listLayerBigData(flags *mflag.FlagSet, action string, m storage.Store, args []string) (int, error) { func listLayerBigData(flags *mflag.FlagSet, action string, m storage.Store, args []string) (int, error) {
layer, err := m.Layer(args[0]) layer, err := m.Layer(args[0])

4
cmd/containers-storage/shutdown.go
View File

@ -7,9 +7,7 @@ import (
"github.com/containers/storage/pkg/mflag" "github.com/containers/storage/pkg/mflag"
) )
var ( var forceShutdown = false
forceShutdown = false
)
func shutdown(flags *mflag.FlagSet, action string, m storage.Store, args []string) (int, error) { func shutdown(flags *mflag.FlagSet, action string, m storage.Store, args []string) (int, error) {
_, err := m.Shutdown(forceShutdown) _, err := m.Shutdown(forceShutdown)

14
cmd/containers-storage/tree.go
View File

@ -5,12 +5,14 @@ import (
"strings" "strings"
) )
const treeIndentStep = 2 const (
const treeStemWidth = treeIndentStep - 1 treeIndentStep = 2
const treeVertical = '\u2502' treeStemWidth = treeIndentStep - 1
const treeThisAndMore = "\u251c" treeVertical = '\u2502'
const treeJustThis = "\u2514" treeThisAndMore = "\u251c"
const treeStem = "\u2500" treeJustThis = "\u2514"
treeStem = "\u2500"
)
type treeNode struct { type treeNode struct {
left, right string left, right string

12
containers.go
View File

@ -536,7 +536,7 @@ func (r *containerStore) save(saveLocations containerLocations) error {
continue continue
} }
rpath := r.jsonPath[locationIndex] rpath := r.jsonPath[locationIndex]
if err := os.MkdirAll(filepath.Dir(rpath), 0700); err != nil { if err := os.MkdirAll(filepath.Dir(rpath), 0o700); err != nil {
return err return err
} }
subsetContainers := make([]*Container, 0, len(r.containers)) subsetContainers := make([]*Container, 0, len(r.containers))
@ -556,7 +556,7 @@ func (r *containerStore) save(saveLocations containerLocations) error {
NoSync: true, NoSync: true,
} }
} }
if err := ioutils.AtomicWriteFileWithOpts(rpath, jdata, 0600, opts); err != nil { if err := ioutils.AtomicWriteFileWithOpts(rpath, jdata, 0o600, opts); err != nil {
return err return err
} }
} }
@ -571,12 +571,12 @@ func (r *containerStore) saveFor(modifiedContainer *Container) error {
} }
func newContainerStore(dir string, runDir string, transient bool) (rwContainerStore, error) { func newContainerStore(dir string, runDir string, transient bool) (rwContainerStore, error) {
if err := os.MkdirAll(dir, 0700); err != nil { if err := os.MkdirAll(dir, 0o700); err != nil {
return nil, err return nil, err
} }
volatileDir := dir volatileDir := dir
if transient { if transient {
if err := os.MkdirAll(runDir, 0700); err != nil { if err := os.MkdirAll(runDir, 0o700); err != nil {
return nil, err return nil, err
} }
volatileDir = runDir volatileDir = runDir
@ -928,10 +928,10 @@ func (r *containerStore) SetBigData(id, key string, data []byte) error {
if !ok { if !ok {
return ErrContainerUnknown return ErrContainerUnknown
} }
if err := os.MkdirAll(r.datadir(c.ID), 0700); err != nil { if err := os.MkdirAll(r.datadir(c.ID), 0o700); err != nil {
return err return err
} }
err := ioutils.AtomicWriteFile(r.datapath(c.ID, key), data, 0600) err := ioutils.AtomicWriteFile(r.datapath(c.ID, key), data, 0o600)
if err == nil { if err == nil {
save := false save := false
if c.BigDataSizes == nil { if c.BigDataSizes == nil {

9
drivers/aufs/aufs.go
View File

@ -64,7 +64,7 @@ var (
enableDirperm bool enableDirperm bool
) )
const defaultPerms = os.FileMode(0555) const defaultPerms = os.FileMode(0o555)
func init() { func init() {
graphdriver.MustRegister("aufs", Init) graphdriver.MustRegister("aufs", Init)
@ -87,11 +87,9 @@ type Driver struct {
// Init returns a new AUFS driver. // Init returns a new AUFS driver.
// An error is returned if AUFS is not supported. // An error is returned if AUFS is not supported.
func Init(home string, options graphdriver.Options) (graphdriver.Driver, error) { func Init(home string, options graphdriver.Options) (graphdriver.Driver, error) {
// Try to load the aufs kernel module // Try to load the aufs kernel module
if err := supportsAufs(); err != nil { if err := supportsAufs(); err != nil {
return nil, fmt.Errorf("kernel does not support aufs: %w", graphdriver.ErrNotSupported) return nil, fmt.Errorf("kernel does not support aufs: %w", graphdriver.ErrNotSupported)
} }
fsMagic, err := graphdriver.GetFSMagic(home) fsMagic, err := graphdriver.GetFSMagic(home)
@ -145,7 +143,7 @@ func Init(home string, options graphdriver.Options) (graphdriver.Driver, error)
// Create the root aufs driver dir and return // Create the root aufs driver dir and return
// if it already exists // if it already exists
// If not populate the dir structure // If not populate the dir structure
if err := idtools.MkdirAllAs(home, 0700, rootUID, rootGID); err != nil { if err := idtools.MkdirAllAs(home, 0o700, rootUID, rootGID); err != nil {
if os.IsExist(err) { if os.IsExist(err) {
return a, nil return a, nil
} }
@ -158,7 +156,7 @@ func Init(home string, options graphdriver.Options) (graphdriver.Driver, error)
// Populate the dir structure // Populate the dir structure
for _, p := range paths { for _, p := range paths {
if err := idtools.MkdirAllAs(path.Join(home, p), 0700, rootUID, rootGID); err != nil { if err := idtools.MkdirAllAs(path.Join(home, p), 0o700, rootUID, rootGID); err != nil {
return nil, err return nil, err
} }
} }
@ -290,7 +288,6 @@ func (a *Driver) CreateReadWrite(id, parent string, opts *graphdriver.CreateOpts
// Create three folders for each id // Create three folders for each id
// mnt, layers, and diff // mnt, layers, and diff
func (a *Driver) Create(id, parent string, opts *graphdriver.CreateOpts) error { func (a *Driver) Create(id, parent string, opts *graphdriver.CreateOpts) error {
if opts != nil && len(opts.StorageOpt) != 0 { if opts != nil && len(opts.StorageOpt) != 0 {
return fmt.Errorf("--storage-opt is not supported for aufs") return fmt.Errorf("--storage-opt is not supported for aufs")
} }

12
drivers/aufs/aufs_test.go
View File

@ -52,7 +52,7 @@ func driverGet(d *Driver, id string, mntLabel string) (string, error) {
} }
func newDriver(t testing.TB) *Driver { func newDriver(t testing.TB) *Driver {
if err := os.MkdirAll(tmp, 0755); err != nil { if err := os.MkdirAll(tmp, 0o755); err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -61,7 +61,7 @@ func newDriver(t testing.TB) *Driver {
} }
func TestNewDriver(t *testing.T) { func TestNewDriver(t *testing.T) {
if err := os.MkdirAll(tmp, 0755); err != nil { if err := os.MkdirAll(tmp, 0o755); err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -100,7 +100,7 @@ func TestCreateDirStructure(t *testing.T) {
// We should be able to create two drivers with the same dir structure // We should be able to create two drivers with the same dir structure
func TestNewDriverFromExistingDir(t *testing.T) { func TestNewDriverFromExistingDir(t *testing.T) {
if err := os.MkdirAll(tmp, 0755); err != nil { if err := os.MkdirAll(tmp, 0o755); err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -646,7 +646,7 @@ func hash(c string) string {
} }
func testMountMoreThan42Layers(t *testing.T, mountPath string) { func testMountMoreThan42Layers(t *testing.T, mountPath string) {
if err := os.MkdirAll(mountPath, 0755); err != nil { if err := os.MkdirAll(mountPath, 0o755); err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -786,13 +786,13 @@ func BenchmarkConcurrentAccess(b *testing.B) {
} }
func TestInitStaleCleanup(t *testing.T) { func TestInitStaleCleanup(t *testing.T) {
if err := os.MkdirAll(tmp, 0755); err != nil { if err := os.MkdirAll(tmp, 0o755); err != nil {
t.Fatal(err) t.Fatal(err)
} }
defer os.RemoveAll(tmp) defer os.RemoveAll(tmp)
for _, d := range []string{"diff", "mnt"} { for _, d := range []string{"diff", "mnt"} {
if err := os.MkdirAll(filepath.Join(tmp, d, "123-removing"), 0755); err != nil { if err := os.MkdirAll(filepath.Join(tmp, d, "123-removing"), 0o755); err != nil {
t.Fatal(err) t.Fatal(err)
} }
} }

15
drivers/btrfs/btrfs.go
View File

@ -42,7 +42,7 @@ import (
"golang.org/x/sys/unix" "golang.org/x/sys/unix"
) )
const defaultPerms = os.FileMode(0555) const defaultPerms = os.FileMode(0o555)
func init() { func init() {
graphdriver.MustRegister("btrfs", Init) graphdriver.MustRegister("btrfs", Init)
@ -56,7 +56,6 @@ type btrfsOptions struct {
// Init returns a new BTRFS driver. // Init returns a new BTRFS driver.
// An error is returned if BTRFS is not supported. // An error is returned if BTRFS is not supported.
func Init(home string, options graphdriver.Options) (graphdriver.Driver, error) { func Init(home string, options graphdriver.Options) (graphdriver.Driver, error) {
fsMagic, err := graphdriver.GetFSMagic(home) fsMagic, err := graphdriver.GetFSMagic(home)
if err != nil { if err != nil {
return nil, err return nil, err
@ -70,7 +69,7 @@ func Init(home string, options graphdriver.Options) (graphdriver.Driver, error)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if err := idtools.MkdirAllAs(filepath.Join(home, "subvolumes"), 0700, rootUID, rootGID); err != nil { if err := idtools.MkdirAllAs(filepath.Join(home, "subvolumes"), 0o700, rootUID, rootGID); err != nil {
return nil, err return nil, err
} }
@ -127,7 +126,7 @@ func parseOptions(opt []string) (btrfsOptions, bool, error) {
// Driver contains information about the filesystem mounted. // Driver contains information about the filesystem mounted.
type Driver struct { type Driver struct {
//root of the file system // root of the file system
home string home string
uidMaps []idtools.IDMap uidMaps []idtools.IDMap
gidMaps []idtools.IDMap gidMaps []idtools.IDMap
@ -226,7 +225,7 @@ func subvolSnapshot(src, dest, name string) error {
var args C.struct_btrfs_ioctl_vol_args_v2 var args C.struct_btrfs_ioctl_vol_args_v2
args.fd = C.__s64(getDirFd(srcDir)) args.fd = C.__s64(getDirFd(srcDir))
var cs = C.CString(name) cs := C.CString(name)
C.set_name_btrfs_ioctl_vol_args_v2(&args, cs) C.set_name_btrfs_ioctl_vol_args_v2(&args, cs)
C.free(unsafe.Pointer(cs)) C.free(unsafe.Pointer(cs))
@ -485,7 +484,7 @@ func (d *Driver) Create(id, parent string, opts *graphdriver.CreateOpts) error {
if err != nil { if err != nil {
return err return err
} }
if err := idtools.MkdirAllAs(subvolumes, 0700, rootUID, rootGID); err != nil { if err := idtools.MkdirAllAs(subvolumes, 0o700, rootUID, rootGID); err != nil {
return err return err
} }
if parent == "" { if parent == "" {
@ -523,10 +522,10 @@ func (d *Driver) Create(id, parent string, opts *graphdriver.CreateOpts) error {
if err := d.setStorageSize(path.Join(subvolumes, id), driver); err != nil { if err := d.setStorageSize(path.Join(subvolumes, id), driver); err != nil {
return err return err
} }
if err := idtools.MkdirAllAs(quotas, 0700, rootUID, rootGID); err != nil { if err := idtools.MkdirAllAs(quotas, 0o700, rootUID, rootGID); err != nil {
return err return err
} }
if err := os.WriteFile(path.Join(quotas, id), []byte(fmt.Sprint(driver.options.size)), 0644); err != nil { if err := os.WriteFile(path.Join(quotas, id), []byte(fmt.Sprint(driver.options.size)), 0o644); err != nil {
return err return err
} }
} }

3
drivers/chown_windows.go
View File

@ -10,8 +10,7 @@ import (
"github.com/containers/storage/pkg/idtools" "github.com/containers/storage/pkg/idtools"
) )
type platformChowner struct { type platformChowner struct{}
}
func newLChowner() *platformChowner { func newLChowner() *platformChowner {
return &platformChowner{} return &platformChowner{}

1
drivers/copy/copy_linux.go
View File

@ -11,6 +11,7 @@ package copy
#endif #endif
*/ */
import "C" import "C"
import ( import (
"container/list" "container/list"
"errors" "errors"

8
drivers/copy/copy_test.go
View File

@ -92,7 +92,7 @@ func populateSrcDir(t *testing.T, srcDir string, remainingDepth int) {
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
dirName := filepath.Join(srcDir, fmt.Sprintf("srcdir-%d", i)) dirName := filepath.Join(srcDir, fmt.Sprintf("srcdir-%d", i))
// Owner all bits set // Owner all bits set
assert.NilError(t, os.Mkdir(dirName, randomMode(0700))) assert.NilError(t, os.Mkdir(dirName, randomMode(0o700)))
populateSrcDir(t, dirName, remainingDepth-1) populateSrcDir(t, dirName, remainingDepth-1)
assert.NilError(t, system.Chtimes(dirName, aTime, mTime)) assert.NilError(t, system.Chtimes(dirName, aTime, mTime))
} }
@ -100,7 +100,7 @@ func populateSrcDir(t *testing.T, srcDir string, remainingDepth int) {
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
fileName := filepath.Join(srcDir, fmt.Sprintf("srcfile-%d", i)) fileName := filepath.Join(srcDir, fmt.Sprintf("srcfile-%d", i))
// Owner read bit set // Owner read bit set
assert.NilError(t, os.WriteFile(fileName, []byte{}, randomMode(0400))) assert.NilError(t, os.WriteFile(fileName, []byte{}, randomMode(0o400)))
assert.NilError(t, system.Chtimes(fileName, aTime, mTime)) assert.NilError(t, system.Chtimes(fileName, aTime, mTime))
} }
} }
@ -114,7 +114,7 @@ func doCopyTest(t *testing.T, copyWithFileRange, copyWithFileClone *bool) {
buf := make([]byte, 1024) buf := make([]byte, 1024)
_, err := r.Read(buf) _, err := r.Read(buf)
assert.NilError(t, err) assert.NilError(t, err)
assert.NilError(t, os.WriteFile(srcFilename, buf, 0777)) assert.NilError(t, os.WriteFile(srcFilename, buf, 0o777))
fileinfo, err := os.Stat(srcFilename) fileinfo, err := os.Stat(srcFilename)
assert.NilError(t, err) assert.NilError(t, err)
@ -134,7 +134,7 @@ func TestCopyHardlink(t *testing.T) {
srcFile2 := filepath.Join(srcDir, "file2") srcFile2 := filepath.Join(srcDir, "file2")
dstFile1 := filepath.Join(dstDir, "file1") dstFile1 := filepath.Join(dstDir, "file1")
dstFile2 := filepath.Join(dstDir, "file2") dstFile2 := filepath.Join(dstDir, "file2")
assert.NilError(t, os.WriteFile(srcFile1, []byte{}, 0777)) assert.NilError(t, os.WriteFile(srcFile1, []byte{}, 0o777))
assert.NilError(t, os.Link(srcFile1, srcFile2)) assert.NilError(t, os.Link(srcFile1, srcFile2))
assert.Check(t, DirCopy(srcDir, dstDir, Content, false)) assert.Check(t, DirCopy(srcDir, dstDir, Content, false))

2
drivers/counter.go
View File

@ -53,7 +53,7 @@ func (c *RefCounter) incdec(path string, infoOp func(minfo *minfo)) int {
} }
} else if !c.checker.IsMounted(path) { } else if !c.checker.IsMounted(path) {
// if the unmount was performed outside of this process (e.g. conmon cleanup) // if the unmount was performed outside of this process (e.g. conmon cleanup)
//the ref counter would lose track of it. Check if it is still mounted. // the ref counter would lose track of it. Check if it is still mounted.
m.count = 0 m.count = 0
} }
infoOp(m) infoOp(m)

6
drivers/devmapper/device_setup.go
View File

@ -177,7 +177,7 @@ func writeLVMConfig(root string, cfg directLVMConfig) error {
if err != nil { if err != nil {
return fmt.Errorf("marshalling direct lvm config: %w", err) return fmt.Errorf("marshalling direct lvm config: %w", err)
} }
if err := os.WriteFile(p, b, 0600); err != nil { if err := os.WriteFile(p, b, 0o600); err != nil {
return fmt.Errorf("writing direct lvm config to file: %w", err) return fmt.Errorf("writing direct lvm config to file: %w", err)
} }
return nil return nil
@ -193,7 +193,7 @@ func setupDirectLVM(cfg directLVMConfig) error {
} }
} }
err := os.MkdirAll(lvmProfileDir, 0755) err := os.MkdirAll(lvmProfileDir, 0o755)
if err != nil { if err != nil {
return fmt.Errorf("creating lvm profile directory: %w", err) return fmt.Errorf("creating lvm profile directory: %w", err)
} }
@ -241,7 +241,7 @@ func setupDirectLVM(cfg directLVMConfig) error {
} }
profile := fmt.Sprintf("activation{\nthin_pool_autoextend_threshold=%d\nthin_pool_autoextend_percent=%d\n}", cfg.AutoExtendThreshold, cfg.AutoExtendPercent) profile := fmt.Sprintf("activation{\nthin_pool_autoextend_threshold=%d\nthin_pool_autoextend_percent=%d\n}", cfg.AutoExtendThreshold, cfg.AutoExtendPercent)
err = os.WriteFile(lvmProfileDir+"/storage-thinpool.profile", []byte(profile), 0600) err = os.WriteFile(lvmProfileDir+"/storage-thinpool.profile", []byte(profile), 0o600)
if err != nil { if err != nil {
return fmt.Errorf("writing storage thinp autoextend profile: %w", err) return fmt.Errorf("writing storage thinp autoextend profile: %w", err)
} }

31
drivers/devmapper/deviceset.go
View File

@ -124,7 +124,7 @@ type DeviceSet struct {
deletionWorkerTicker *time.Ticker deletionWorkerTicker *time.Ticker
uidMaps []idtools.IDMap uidMaps []idtools.IDMap
gidMaps []idtools.IDMap gidMaps []idtools.IDMap
minFreeSpacePercent uint32 //min free space percentage in thinpool minFreeSpacePercent uint32 // min free space percentage in thinpool
xfsNospaceRetries string // max retries when xfs receives ENOSPC xfsNospaceRetries string // max retries when xfs receives ENOSPC
lvmSetupConfig directLVMConfig lvmSetupConfig directLVMConfig
} }
@ -273,7 +273,7 @@ func (devices *DeviceSet) ensureImage(name string, size int64) (string, error) {
if err != nil { if err != nil {
return "", err return "", err
} }
if err := idtools.MkdirAllAs(dirname, 0700, uid, gid); err != nil { if err := idtools.MkdirAllAs(dirname, 0o700, uid, gid); err != nil {
return "", err return "", err
} }
@ -282,7 +282,7 @@ func (devices *DeviceSet) ensureImage(name string, size int64) (string, error) {
return "", err return "", err
} }
logrus.Debugf("devmapper: Creating loopback file %s for device-manage use", filename) logrus.Debugf("devmapper: Creating loopback file %s for device-manage use", filename)
file, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, 0600) file, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, 0o600)
if err != nil { if err != nil {
return "", err return "", err
} }
@ -293,7 +293,7 @@ func (devices *DeviceSet) ensureImage(name string, size int64) (string, error) {
} }
} else { } else {
if fi.Size() < size { if fi.Size() < size {
file, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, 0600) file, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, 0o600)
if err != nil { if err != nil {
return "", err return "", err
} }
@ -421,7 +421,6 @@ func (devices *DeviceSet) constructDeviceIDMap() {
} }
func (devices *DeviceSet) deviceFileWalkFunction(path string, name string) error { func (devices *DeviceSet) deviceFileWalkFunction(path string, name string) error {
// Skip some of the meta files which are not device files. // Skip some of the meta files which are not device files.
if strings.HasSuffix(name, ".migrated") { if strings.HasSuffix(name, ".migrated") {
logrus.Debugf("devmapper: Skipping file %s", path) logrus.Debugf("devmapper: Skipping file %s", path)
@ -458,7 +457,7 @@ func (devices *DeviceSet) loadDeviceFilesOnStart() error {
logrus.Debug("devmapper: loadDeviceFilesOnStart()") logrus.Debug("devmapper: loadDeviceFilesOnStart()")
defer logrus.Debug("devmapper: loadDeviceFilesOnStart() END") defer logrus.Debug("devmapper: loadDeviceFilesOnStart() END")
var scan = func(path string, d fs.DirEntry, err error) error { scan := func(path string, d fs.DirEntry, err error) error {
if err != nil { if err != nil {
logrus.Debugf("devmapper: Can't walk the file %s: %v", path, err) logrus.Debugf("devmapper: Can't walk the file %s: %v", path, err)
return nil return nil
@ -1156,7 +1155,6 @@ func (devices *DeviceSet) setupVerifyBaseImageUUIDFS(baseInfo *devInfo) error {
} }
func (devices *DeviceSet) checkGrowBaseDeviceFS(info *devInfo) error { func (devices *DeviceSet) checkGrowBaseDeviceFS(info *devInfo) error {
if !userBaseSize { if !userBaseSize {
return nil return nil
} }
@ -1195,7 +1193,7 @@ func (devices *DeviceSet) growFS(info *devInfo) error {
fsMountPoint := "/run/containers/storage/mnt" fsMountPoint := "/run/containers/storage/mnt"
if _, err := os.Stat(fsMountPoint); os.IsNotExist(err) { if _, err := os.Stat(fsMountPoint); os.IsNotExist(err) {
if err := os.MkdirAll(fsMountPoint, 0700); err != nil { if err := os.MkdirAll(fsMountPoint, 0o700); err != nil {
return err return err
} }
defer os.RemoveAll(fsMountPoint) defer os.RemoveAll(fsMountPoint)
@ -1661,7 +1659,6 @@ func (devices *DeviceSet) loadThinPoolLoopBackInfo() error {
} }
func (devices *DeviceSet) enableDeferredRemovalDeletion() error { func (devices *DeviceSet) enableDeferredRemovalDeletion() error {
// If user asked for deferred removal then check both libdm library // If user asked for deferred removal then check both libdm library
// and kernel driver support deferred removal otherwise error out. // and kernel driver support deferred removal otherwise error out.
if enableDeferredRemoval { if enableDeferredRemoval {
@ -1699,19 +1696,19 @@ func (devices *DeviceSet) initDevmapper(doInit bool) (retErr error) {
} }
} }
//create the root dir of the devmapper driver ownership to match this // create the root dir of the devmapper driver ownership to match this
//daemon's remapped root uid/gid so containers can start properly // daemon's remapped root uid/gid so containers can start properly
uid, gid, err := idtools.GetRootUIDGID(devices.uidMaps, devices.gidMaps) uid, gid, err := idtools.GetRootUIDGID(devices.uidMaps, devices.gidMaps)
if err != nil { if err != nil {
return err return err
} }
if err := idtools.MkdirAs(devices.root, 0700, uid, gid); err != nil { if err := idtools.MkdirAs(devices.root, 0o700, uid, gid); err != nil {
return err return err
} }
if err := os.MkdirAll(devices.metadataDir(), 0700); err != nil { if err := os.MkdirAll(devices.metadataDir(), 0o700); err != nil {
return err return err
} }
if err := idtools.MkdirAs(filepath.Join(devices.root, "mnt"), 0700, uid, gid); err != nil && !errors.Is(err, os.ErrExist) { if err := idtools.MkdirAs(filepath.Join(devices.root, "mnt"), 0o700, uid, gid); err != nil && !errors.Is(err, os.ErrExist) {
return err return err
} }
@ -1818,7 +1815,7 @@ func (devices *DeviceSet) initDevmapper(doInit bool) (retErr error) {
devices.dataLoopFile = data devices.dataLoopFile = data
devices.dataDevice = dataFile.Name() devices.dataDevice = dataFile.Name()
} else { } else {
dataFile, err = os.OpenFile(devices.dataDevice, os.O_RDWR, 0600) dataFile, err = os.OpenFile(devices.dataDevice, os.O_RDWR, 0o600)
if err != nil { if err != nil {
return err return err
} }
@ -1851,7 +1848,7 @@ func (devices *DeviceSet) initDevmapper(doInit bool) (retErr error) {
devices.metadataLoopFile = metadata devices.metadataLoopFile = metadata
devices.metadataDevice = metadataFile.Name() devices.metadataDevice = metadataFile.Name()
} else { } else {
metadataFile, err = os.OpenFile(devices.metadataDevice, os.O_RDWR, 0600) metadataFile, err = os.OpenFile(devices.metadataDevice, os.O_RDWR, 0o600)
if err != nil { if err != nil {
return err return err
} }
@ -1973,7 +1970,6 @@ func (devices *DeviceSet) AddDevice(hash, baseHash string, storageOpt map[string
} }
func (devices *DeviceSet) parseStorageOpt(storageOpt map[string]string) (uint64, error) { func (devices *DeviceSet) parseStorageOpt(storageOpt map[string]string) (uint64, error) {
// Read size to change the block device size per container. // Read size to change the block device size per container.
for key, val := range storageOpt { for key, val := range storageOpt {
key := strings.ToLower(key) key := strings.ToLower(key)
@ -2547,7 +2543,6 @@ func (devices *DeviceSet) GetDeviceStatus(hash string) (*DevStatus, error) {
} }
sizeInSectors, mappedSectors, highestMappedSector, err := devices.deviceStatus(info.DevName()) sizeInSectors, mappedSectors, highestMappedSector, err := devices.deviceStatus(info.DevName())
if err != nil { if err != nil {
return nil, err return nil, err
} }

4
drivers/devmapper/devmapper_test.go
View File

@ -61,7 +61,7 @@ func getBaseLoopStats() (*syscall.Stat_t, error) {
return &syscall.Stat_t{ return &syscall.Stat_t{
Uid: 0, Uid: 0,
Gid: 0, Gid: 0,
Mode: 0660, Mode: 0o660,
}, nil }, nil
} }
return nil, err return nil, err
@ -123,7 +123,7 @@ func testChangeLoopBackSize(t *testing.T, delta, expectDataSize, expectMetaDataS
if err := driver.Cleanup(); err != nil { if err := driver.Cleanup(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
//Reload // Reload
d, err := Init(driver.home, graphdriver.Options{DriverOptions: []string{ d, err := Init(driver.home, graphdriver.Options{DriverOptions: []string{
fmt.Sprintf("dm.loopdatasize=%d", defaultDataLoopbackSize+delta), fmt.Sprintf("dm.loopdatasize=%d", defaultDataLoopbackSize+delta),
fmt.Sprintf("dm.loopmetadatasize=%d", defaultMetaDataLoopbackSize+delta), fmt.Sprintf("dm.loopmetadatasize=%d", defaultMetaDataLoopbackSize+delta),

9
drivers/devmapper/driver.go
View File

@ -20,7 +20,7 @@ import (
"golang.org/x/sys/unix" "golang.org/x/sys/unix"
) )
const defaultPerms = os.FileMode(0555) const defaultPerms = os.FileMode(0o555)
func init() { func init() {
graphdriver.MustRegister("devicemapper", Init) graphdriver.MustRegister("devicemapper", Init)
@ -102,7 +102,6 @@ func (d *Driver) Status() [][2]string {
// Metadata returns a map of information about the device. // Metadata returns a map of information about the device.
func (d *Driver) Metadata(id string) (map[string]string, error) { func (d *Driver) Metadata(id string) (map[string]string, error) {
m, err := d.DeviceSet.exportDeviceMetadata(id) m, err := d.DeviceSet.exportDeviceMetadata(id)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -201,11 +200,11 @@ func (d *Driver) Get(id string, options graphdriver.MountOpts) (string, error) {
} }
// Create the target directories if they don't exist // Create the target directories if they don't exist
if err := idtools.MkdirAllAs(path.Join(d.home, "mnt"), 0755, uid, gid); err != nil { if err := idtools.MkdirAllAs(path.Join(d.home, "mnt"), 0o755, uid, gid); err != nil {
d.ctr.Decrement(mp) d.ctr.Decrement(mp)
return "", err return "", err
} }
if err := idtools.MkdirAs(mp, 0755, uid, gid); err != nil && !os.IsExist(err) { if err := idtools.MkdirAs(mp, 0o755, uid, gid); err != nil && !os.IsExist(err) {
d.ctr.Decrement(mp) d.ctr.Decrement(mp)
return "", err return "", err
} }
@ -226,7 +225,7 @@ func (d *Driver) Get(id string, options graphdriver.MountOpts) (string, error) {
if _, err := os.Stat(idFile); err != nil && os.IsNotExist(err) { if _, err := os.Stat(idFile); err != nil && os.IsNotExist(err) {
// Create an "id" file with the container/image id in it to help reconstruct this in case // Create an "id" file with the container/image id in it to help reconstruct this in case
// of later problems // of later problems
if err := os.WriteFile(idFile, []byte(id), 0600); err != nil { if err := os.WriteFile(idFile, []byte(id), 0o600); err != nil {
d.ctr.Decrement(mp) d.ctr.Decrement(mp)
d.DeviceSet.UnmountDevice(id, mp) d.DeviceSet.UnmountDevice(id, mp)
return "", err return "", err

10
drivers/driver_darwin.go
View File

@ -1,11 +1,9 @@
package graphdriver package graphdriver
var ( // Slice of drivers that should be used in order
// Slice of drivers that should be used in order var Priority = []string{
Priority = []string{ "vfs",
"vfs", }
}
)
// GetFSMagic returns the filesystem id given the path. // GetFSMagic returns the filesystem id given the path.
func GetFSMagic(rootpath string) (FsMagic, error) { func GetFSMagic(rootpath string) (FsMagic, error) {

3
drivers/driver_freebsd.go
View File

@ -31,8 +31,7 @@ func NewDefaultChecker() Checker {
return &defaultChecker{} return &defaultChecker{}
} }
type defaultChecker struct { type defaultChecker struct{}
}
func (c *defaultChecker) IsMounted(path string) bool { func (c *defaultChecker) IsMounted(path string) bool {
m, _ := mount.Mounted(path) m, _ := mount.Mounted(path)

3
drivers/driver_linux.go
View File

@ -161,8 +161,7 @@ func NewDefaultChecker() Checker {
return &defaultChecker{} return &defaultChecker{}
} }
type defaultChecker struct { type defaultChecker struct{}
}
func (c *defaultChecker) IsMounted(path string) bool { func (c *defaultChecker) IsMounted(path string) bool {
m, _ := mount.Mounted(path) m, _ := mount.Mounted(path)

5
drivers/driver_solaris.go
View File

@ -16,6 +16,7 @@ static inline struct statvfs *getstatfs(char *s) {
} }
*/ */
import "C" import "C"
import ( import (
"path/filepath" "path/filepath"
"unsafe" "unsafe"
@ -69,8 +70,7 @@ func NewDefaultChecker() Checker {
return &defaultChecker{} return &defaultChecker{}
} }
type defaultChecker struct { type defaultChecker struct{}
}
func (c *defaultChecker) IsMounted(path string) bool { func (c *defaultChecker) IsMounted(path string) bool {
m, _ := mount.Mounted(path) m, _ := mount.Mounted(path)
@ -80,7 +80,6 @@ func (c *defaultChecker) IsMounted(path string) bool {
// Mounted checks if the given path is mounted as the fs type // Mounted checks if the given path is mounted as the fs type
// Solaris supports only ZFS for now // Solaris supports only ZFS for now
func Mounted(fsType FsMagic, mountPath string) (bool, error) { func Mounted(fsType FsMagic, mountPath string) (bool, error) {
cs := C.CString(filepath.Dir(mountPath)) cs := C.CString(filepath.Dir(mountPath))
defer C.free(unsafe.Pointer(cs)) defer C.free(unsafe.Pointer(cs))
buf := C.getstatfs(cs) buf := C.getstatfs(cs)

10
drivers/driver_unsupported.go
View File

@ -3,12 +3,10 @@
package graphdriver package graphdriver
var ( // Slice of drivers that should be used in an order
// Slice of drivers that should be used in an order var Priority = []string{
Priority = []string{ "unsupported",
"unsupported", }
}
)
// GetFSMagic returns the filesystem id given the path. // GetFSMagic returns the filesystem id given the path.
func GetFSMagic(rootpath string) (FsMagic, error) { func GetFSMagic(rootpath string) (FsMagic, error) {

10
drivers/driver_windows.go
View File

@ -1,11 +1,9 @@
package graphdriver package graphdriver
var ( // Slice of drivers that should be used in order
// Slice of drivers that should be used in order var Priority = []string{
Priority = []string{ "windowsfilter",
"windowsfilter", }
}
)
// GetFSMagic returns the filesystem id given the path. // GetFSMagic returns the filesystem id given the path.
func GetFSMagic(rootpath string) (FsMagic, error) { func GetFSMagic(rootpath string) (FsMagic, error) {

10
drivers/fsdiff.go
View File

@ -14,11 +14,9 @@ import (
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
) )
var ( // ApplyUncompressedLayer defines the unpack method used by the graph
// ApplyUncompressedLayer defines the unpack method used by the graph // driver.
// driver. var ApplyUncompressedLayer = chrootarchive.ApplyUncompressedLayer
ApplyUncompressedLayer = chrootarchive.ApplyUncompressedLayer
)
// NaiveDiffDriver takes a ProtoDriver and adds the // NaiveDiffDriver takes a ProtoDriver and adds the
// capability of the Diffing methods which it may or may not // capability of the Diffing methods which it may or may not
@ -173,7 +171,7 @@ func (gdw *NaiveDiffDriver) ApplyDiff(id, parent string, options ApplyDiffOpts)
} }
defer driverPut(driver, id, &err) defer driverPut(driver, id, &err)
defaultForceMask := os.FileMode(0700) defaultForceMask := os.FileMode(0o700)
var forceMask *os.FileMode // = nil var forceMask *os.FileMode // = nil
if runtime.GOOS == "darwin" { if runtime.GOOS == "darwin" {
forceMask = &defaultForceMask forceMask = &defaultForceMask

2
drivers/graphtest/graphbench_unix.go
View File

@ -176,7 +176,7 @@ func DriverBenchDiffApplyN(b *testing.B, fileCount int, drivername string, drive
if applyDiffSize != diffSize { if applyDiffSize != diffSize {
// TODO: enforce this // TODO: enforce this
//b.Fatalf("Apply diff size different, got %d, expected %s", applyDiffSize, diffSize) // b.Fatalf("Apply diff size different, got %d, expected %s", applyDiffSize, diffSize)
} }
if err := checkManyFiles(driver, diff, fileCount, 6); err != nil { if err := checkManyFiles(driver, diff, fileCount, 6); err != nil {
b.Fatal(err) b.Fatal(err)

16
drivers/graphtest/graphtest_unix.go
View File

@ -23,9 +23,7 @@ import (
"golang.org/x/sys/unix" "golang.org/x/sys/unix"
) )
var ( var drv *Driver
drv *Driver
)
const ( const (
defaultPerms = os.FileMode(0o555) defaultPerms = os.FileMode(0o555)
@ -52,7 +50,7 @@ func newDriver(t testing.TB, name string, options []string) *Driver {
runroot, err := os.MkdirTemp("", "storage-graphtest-") runroot, err := os.MkdirTemp("", "storage-graphtest-")
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, os.MkdirAll(root, 0755)) require.NoError(t, os.MkdirAll(root, 0o755))
d, err := graphdriver.GetDriver(name, graphdriver.Options{DriverOptions: options, Root: root, RunRoot: runroot}) d, err := graphdriver.GetDriver(name, graphdriver.Options{DriverOptions: options, Root: root, RunRoot: runroot})
if err != nil { if err != nil {
t.Logf("graphdriver: %v\n", err) t.Logf("graphdriver: %v\n", err)
@ -416,7 +414,7 @@ func writeRandomFile(path string, size uint64) error {
return err return err
} }
return os.WriteFile(path, data, 0700) return os.WriteFile(path, data, 0o700)
} }
// DriverTestSetQuota Create a driver and test setting quota. // DriverTestSetQuota Create a driver and test setting quota.
@ -482,14 +480,14 @@ func DriverTestEcho(t testing.TB, drivername string, driverOptions ...string) {
for i := 0; i < components-1; i++ { for i := 0; i < components-1; i++ {
path = filepath.Join(path, fmt.Sprintf("subdir%d", i+1)) path = filepath.Join(path, fmt.Sprintf("subdir%d", i+1))
paths = append(paths, path) paths = append(paths, path)
if err = os.Mkdir(filepath.Join(root, path), 0700); err != nil { if err = os.Mkdir(filepath.Join(root, path), 0o700); err != nil {
t.Fatal(err) t.Fatal(err)
} }
expectedChanges = append(expectedChanges, archive.Change{Kind: archive.ChangeAdd, Path: path}) expectedChanges = append(expectedChanges, archive.Change{Kind: archive.ChangeAdd, Path: path})
} }
path = filepath.Join(path, "file") path = filepath.Join(path, "file")
paths = append(paths, path) paths = append(paths, path)
if err = os.WriteFile(filepath.Join(root, path), randomContent(128, int64(depth)), 0600); err != nil { if err = os.WriteFile(filepath.Join(root, path), randomContent(128, int64(depth)), 0o600); err != nil {
t.Fatal(err) t.Fatal(err)
} }
expectedChanges = append(expectedChanges, archive.Change{Kind: archive.ChangeAdd, Path: path}) expectedChanges = append(expectedChanges, archive.Change{Kind: archive.ChangeAdd, Path: path})
@ -544,12 +542,12 @@ func DriverTestEcho(t testing.TB, drivername string, driverOptions ...string) {
expectedChanges = append(expectedChanges, archive.Change{Kind: archive.ChangeModify, Path: paths[i]}) expectedChanges = append(expectedChanges, archive.Change{Kind: archive.ChangeModify, Path: paths[i]})
} }
for i := depth; i < components-1; i++ { for i := depth; i < components-1; i++ {
if err = os.Mkdir(filepath.Join(root, paths[i]), 0700); err != nil { if err = os.Mkdir(filepath.Join(root, paths[i]), 0o700); err != nil {
t.Fatal(err) t.Fatal(err)
} }
expectedChanges = append(expectedChanges, archive.Change{Kind: archive.ChangeAdd, Path: paths[i]}) expectedChanges = append(expectedChanges, archive.Change{Kind: archive.ChangeAdd, Path: paths[i]})
} }
if err = os.WriteFile(filepath.Join(root, paths[len(paths)-1]), randomContent(128, int64(depth)), 0600); err != nil { if err = os.WriteFile(filepath.Join(root, paths[len(paths)-1]), randomContent(128, int64(depth)), 0o600); err != nil {
t.Fatal(err) t.Fatal(err)
} }
expectedChanges = append(expectedChanges, archive.Change{Kind: archive.ChangeAdd, Path: paths[len(paths)-1]}) expectedChanges = append(expectedChanges, archive.Change{Kind: archive.ChangeAdd, Path: paths[len(paths)-1]})

30
drivers/graphtest/testutil.go
View File

@ -40,17 +40,17 @@ func addFiles(drv graphdriver.Driver, layer string, seed int64) error {
} }
defer drv.Put(layer) defer drv.Put(layer)
if err := os.WriteFile(path.Join(root, "file-a"), randomContent(64, seed), 0755); err != nil { if err := os.WriteFile(path.Join(root, "file-a"), randomContent(64, seed), 0o755); err != nil {
return err return err
} }
if err := os.MkdirAll(path.Join(root, "dir-b"), 0755); err != nil { if err := os.MkdirAll(path.Join(root, "dir-b"), 0o755); err != nil {
return err return err
} }
if err := os.WriteFile(path.Join(root, "dir-b", "file-b"), randomContent(128, seed+1), 0755); err != nil { if err := os.WriteFile(path.Join(root, "dir-b", "file-b"), randomContent(128, seed+1), 0o755); err != nil {
return err return err
} }
return os.WriteFile(path.Join(root, "file-c"), randomContent(128*128, seed+2), 0755) return os.WriteFile(path.Join(root, "file-c"), randomContent(128*128, seed+2), 0o755)
} }
func checkFile(drv graphdriver.Driver, layer, filename string, content []byte) error { func checkFile(drv graphdriver.Driver, layer, filename string, content []byte) error {
@ -79,7 +79,7 @@ func addFile(drv graphdriver.Driver, layer, filename string, content []byte) err
} }
defer drv.Put(layer) defer drv.Put(layer)
return os.WriteFile(path.Join(root, filename), content, 0755) return os.WriteFile(path.Join(root, filename), content, 0o755)
} }
func addDirectory(drv graphdriver.Driver, layer, dir string) error { func addDirectory(drv graphdriver.Driver, layer, dir string) error {
@ -89,7 +89,7 @@ func addDirectory(drv graphdriver.Driver, layer, dir string) error {
} }
defer drv.Put(layer) defer drv.Put(layer)
return os.MkdirAll(path.Join(root, dir), 0755) return os.MkdirAll(path.Join(root, dir), 0o755)
} }
func removeAll(drv graphdriver.Driver, layer string, names ...string) error { func removeAll(drv graphdriver.Driver, layer string, names ...string) error {
@ -132,12 +132,12 @@ func addManyFiles(drv graphdriver.Driver, layer string, count int, seed int64) e
for i := 0; i < count; i += 100 { for i := 0; i < count; i += 100 {
dir := path.Join(root, fmt.Sprintf("directory-%d", i)) dir := path.Join(root, fmt.Sprintf("directory-%d", i))
if err := os.MkdirAll(dir, 0755); err != nil { if err := os.MkdirAll(dir, 0o755); err != nil {
return err return err
} }
for j := 0; i+j < count && j < 100; j++ { for j := 0; i+j < count && j < 100; j++ {
file := path.Join(dir, fmt.Sprintf("file-%d", i+j)) file := path.Join(dir, fmt.Sprintf("file-%d", i+j))
if err := os.WriteFile(file, randomContent(64, seed+int64(i+j)), 0755); err != nil { if err := os.WriteFile(file, randomContent(64, seed+int64(i+j)), 0o755); err != nil {
return err return err
} }
} }
@ -156,7 +156,7 @@ func changeManyFiles(drv graphdriver.Driver, layer string, count int, seed int64
changes := []archive.Change{} changes := []archive.Change{}
for i := 0; i < count; i += 100 { for i := 0; i < count; i += 100 {
archiveRoot := fmt.Sprintf("/directory-%d", i) archiveRoot := fmt.Sprintf("/directory-%d", i)
if err := os.MkdirAll(path.Join(root, archiveRoot), 0755); err != nil { if err := os.MkdirAll(path.Join(root, archiveRoot), 0o755); err != nil {
return nil, err return nil, err
} }
for j := 0; i+j < count && j < 100; j++ { for j := 0; i+j < count && j < 100; j++ {
@ -177,7 +177,7 @@ func changeManyFiles(drv graphdriver.Driver, layer string, count int, seed int64
return nil, err return nil, err
} }
for updatedFileInfo == nil || updatedFileInfo.ModTime().Equal(originalFileInfo.ModTime()) { for updatedFileInfo == nil || updatedFileInfo.ModTime().Equal(originalFileInfo.ModTime()) {
if err := os.WriteFile(path.Join(root, change.Path), randomContent(64, seed+int64(i+j)), 0755); err != nil { if err := os.WriteFile(path.Join(root, change.Path), randomContent(64, seed+int64(i+j)), 0o755); err != nil {
return nil, err return nil, err
} }
if updatedFileInfo, err = os.Stat(path.Join(root, change.Path)); err != nil { if updatedFileInfo, err = os.Stat(path.Join(root, change.Path)); err != nil {
@ -188,7 +188,7 @@ func changeManyFiles(drv graphdriver.Driver, layer string, count int, seed int64
case 1: case 1:
change.Path = path.Join(archiveRoot, fmt.Sprintf("file-%d-%d", seed, i+j)) change.Path = path.Join(archiveRoot, fmt.Sprintf("file-%d-%d", seed, i+j))
change.Kind = archive.ChangeAdd change.Kind = archive.ChangeAdd
if err := os.WriteFile(path.Join(root, change.Path), randomContent(64, seed+int64(i+j)), 0755); err != nil { if err := os.WriteFile(path.Join(root, change.Path), randomContent(64, seed+int64(i+j)), 0o755); err != nil {
return nil, err return nil, err
} }
// Remove file // Remove file
@ -267,17 +267,17 @@ func addLayerFiles(drv graphdriver.Driver, layer, parent string, i int) error {
} }
defer drv.Put(layer) defer drv.Put(layer)
if err := os.WriteFile(path.Join(root, "top-id"), []byte(layer), 0755); err != nil { if err := os.WriteFile(path.Join(root, "top-id"), []byte(layer), 0o755); err != nil {
return err return err
} }
layerDir := path.Join(root, fmt.Sprintf("layer-%d", i)) layerDir := path.Join(root, fmt.Sprintf("layer-%d", i))
if err := os.MkdirAll(layerDir, 0755); err != nil { if err := os.MkdirAll(layerDir, 0o755); err != nil {
return err return err
} }
if err := os.WriteFile(path.Join(layerDir, "layer-id"), []byte(layer), 0755); err != nil { if err := os.WriteFile(path.Join(layerDir, "layer-id"), []byte(layer), 0o755); err != nil {
return err return err
} }
if err := os.WriteFile(path.Join(layerDir, "parent-id"), []byte(parent), 0755); err != nil { if err := os.WriteFile(path.Join(layerDir, "parent-id"), []byte(parent), 0o755); err != nil {
return err return err
} }

44
drivers/overlay/check.go
View File

@ -38,22 +38,22 @@ func doesSupportNativeDiff(d, mountOpts string) error {
}() }()
// Make directories l1/d, l1/d1, l2/d, l3, work, merged // Make directories l1/d, l1/d1, l2/d, l3, work, merged
if err := os.MkdirAll(filepath.Join(td, "l1", "d"), 0755); err != nil { if err := os.MkdirAll(filepath.Join(td, "l1", "d"), 0o755); err != nil {
return err return err
} }
if err := os.MkdirAll(filepath.Join(td, "l1", "d1"), 0755); err != nil { if err := os.MkdirAll(filepath.Join(td, "l1", "d1"), 0o755); err != nil {
return err return err
} }
if err := os.MkdirAll(filepath.Join(td, "l2", "d"), 0755); err != nil { if err := os.MkdirAll(filepath.Join(td, "l2", "d"), 0o755); err != nil {
return err return err
} }
if err := os.Mkdir(filepath.Join(td, "l3"), 0755); err != nil { if err := os.Mkdir(filepath.Join(td, "l3"), 0o755); err != nil {
return err return err
} }
if err := os.Mkdir(filepath.Join(td, "work"), 0755); err != nil { if err := os.Mkdir(filepath.Join(td, "work"), 0o755); err != nil {
return err return err
} }
if err := os.Mkdir(filepath.Join(td, "merged"), 0755); err != nil { if err := os.Mkdir(filepath.Join(td, "merged"), 0o755); err != nil {
return err return err
} }
@ -82,7 +82,7 @@ func doesSupportNativeDiff(d, mountOpts string) error {
}() }()
// Touch file in d to force copy up of opaque directory "d" from "l2" to "l3" // Touch file in d to force copy up of opaque directory "d" from "l2" to "l3"
if err := os.WriteFile(filepath.Join(td, "merged", "d", "f"), []byte{}, 0644); err != nil { if err := os.WriteFile(filepath.Join(td, "merged", "d", "f"), []byte{}, 0o644); err != nil {
return fmt.Errorf("failed to write to merged directory: %w", err) return fmt.Errorf("failed to write to merged directory: %w", err)
} }
@ -132,19 +132,19 @@ func doesMetacopy(d, mountOpts string) (bool, error) {
}() }()
// Make directories l1, l2, work, merged // Make directories l1, l2, work, merged
if err := os.MkdirAll(filepath.Join(td, "l1"), 0755); err != nil { if err := os.MkdirAll(filepath.Join(td, "l1"), 0o755); err != nil {
return false, err return false, err
} }
if err := ioutils.AtomicWriteFile(filepath.Join(td, "l1", "f"), []byte{0xff}, 0700); err != nil { if err := ioutils.AtomicWriteFile(filepath.Join(td, "l1", "f"), []byte{0xff}, 0o700); err != nil {
return false, err return false, err
} }
if err := os.MkdirAll(filepath.Join(td, "l2"), 0755); err != nil { if err := os.MkdirAll(filepath.Join(td, "l2"), 0o755); err != nil {
return false, err return false, err
} }
if err := os.Mkdir(filepath.Join(td, "work"), 0755); err != nil { if err := os.Mkdir(filepath.Join(td, "work"), 0o755); err != nil {
return false, err return false, err
} }
if err := os.Mkdir(filepath.Join(td, "merged"), 0755); err != nil { if err := os.Mkdir(filepath.Join(td, "merged"), 0o755); err != nil {
return false, err return false, err
} }
// Mount using the mandatory options and configured options // Mount using the mandatory options and configured options
@ -170,7 +170,7 @@ func doesMetacopy(d, mountOpts string) (bool, error) {
}() }()
// Make a change that only impacts the inode, and check if the pulled-up copy is marked // Make a change that only impacts the inode, and check if the pulled-up copy is marked
// as a metadata-only copy // as a metadata-only copy
if err := os.Chmod(filepath.Join(td, "merged", "f"), 0600); err != nil { if err := os.Chmod(filepath.Join(td, "merged", "f"), 0o600); err != nil {
return false, fmt.Errorf("changing permissions on file for metacopy check: %w", err) return false, fmt.Errorf("changing permissions on file for metacopy check: %w", err)
} }
metacopy, err := system.Lgetxattr(filepath.Join(td, "l2", "f"), archive.GetOverlayXattrName("metacopy")) metacopy, err := system.Lgetxattr(filepath.Join(td, "l2", "f"), archive.GetOverlayXattrName("metacopy"))
@ -196,16 +196,16 @@ func doesVolatile(d string) (bool, error) {
} }
}() }()
if err := os.MkdirAll(filepath.Join(td, "lower"), 0755); err != nil { if err := os.MkdirAll(filepath.Join(td, "lower"), 0o755); err != nil {
return false, err return false, err
} }
if err := os.MkdirAll(filepath.Join(td, "upper"), 0755); err != nil { if err := os.MkdirAll(filepath.Join(td, "upper"), 0o755); err != nil {
return false, err return false, err
} }
if err := os.Mkdir(filepath.Join(td, "work"), 0755); err != nil { if err := os.Mkdir(filepath.Join(td, "work"), 0o755); err != nil {
return false, err return false, err
} }
if err := os.Mkdir(filepath.Join(td, "merged"), 0755); err != nil { if err := os.Mkdir(filepath.Join(td, "merged"), 0o755); err != nil {
return false, err return false, err
} }
// Mount using the mandatory options and configured options // Mount using the mandatory options and configured options
@ -241,11 +241,11 @@ func supportsIdmappedLowerLayers(home string) (bool, error) {
upperDir := filepath.Join(layerDir, "upper") upperDir := filepath.Join(layerDir, "upper")
workDir := filepath.Join(layerDir, "work") workDir := filepath.Join(layerDir, "work")
_ = idtools.MkdirAs(mergedDir, 0700, 0, 0) _ = idtools.MkdirAs(mergedDir, 0o700, 0, 0)
_ = idtools.MkdirAs(lowerDir, 0700, 0, 0) _ = idtools.MkdirAs(lowerDir, 0o700, 0, 0)
_ = idtools.MkdirAs(lowerMappedDir, 0700, 0, 0) _ = idtools.MkdirAs(lowerMappedDir, 0o700, 0, 0)
_ = idtools.MkdirAs(upperDir, 0700, 0, 0) _ = idtools.MkdirAs(upperDir, 0o700, 0, 0)
_ = idtools.MkdirAs(workDir, 0700, 0, 0) _ = idtools.MkdirAs(workDir, 0o700, 0, 0)
mapping := []idtools.IDMap{ mapping := []idtools.IDMap{
{ {

2
drivers/overlay/mount.go
View File

@ -55,7 +55,7 @@ func mountOverlayFrom(dir, device, target, mType string, flags uintptr, label st
w.Close() w.Close()
return fmt.Errorf("mountfrom error on re-exec cmd: %w", err) return fmt.Errorf("mountfrom error on re-exec cmd: %w", err)
} }
//write the options to the pipe for the untar exec to read // write the options to the pipe for the untar exec to read
if err := json.NewEncoder(w).Encode(options); err != nil { if err := json.NewEncoder(w).Encode(options); err != nil {
w.Close() w.Close()
return fmt.Errorf("mountfrom json encode to pipe failed: %w", err) return fmt.Errorf("mountfrom json encode to pipe failed: %w", err)

73
drivers/overlay/overlay.go
View File

@ -40,13 +40,11 @@ import (
"golang.org/x/sys/unix" "golang.org/x/sys/unix"
) )
var ( // untar defines the untar method
// untar defines the untar method var untar = chrootarchive.UntarUncompressed
untar = chrootarchive.UntarUncompressed
)
const ( const (
defaultPerms = os.FileMode(0555) defaultPerms = os.FileMode(0o555)
selinuxLabelTest = "system_u:object_r:container_file_t:s0" selinuxLabelTest = "system_u:object_r:container_file_t:s0"
mountProgramFlagFile = ".has-mount-program" mountProgramFlagFile = ".has-mount-program"
) )
@ -339,17 +337,17 @@ func Init(home string, options graphdriver.Options) (graphdriver.Driver, error)
} }
// Create the driver home dir // Create the driver home dir
if err := idtools.MkdirAllAs(path.Join(home, linkDir), 0755, 0, 0); err != nil { if err := idtools.MkdirAllAs(path.Join(home, linkDir), 0o755, 0, 0); err != nil {
return nil, err return nil, err
} }
if options.ImageStore != "" { if options.ImageStore != "" {
if err := idtools.MkdirAllAs(path.Join(options.ImageStore, linkDir), 0755, 0, 0); err != nil { if err := idtools.MkdirAllAs(path.Join(options.ImageStore, linkDir), 0o755, 0, 0); err != nil {
return nil, err return nil, err
} }
} }
if err := idtools.MkdirAllAs(runhome, 0700, rootUID, rootGID); err != nil { if err := idtools.MkdirAllAs(runhome, 0o700, rootUID, rootGID); err != nil {
return nil, err return nil, err
} }
@ -365,12 +363,12 @@ func Init(home string, options graphdriver.Options) (graphdriver.Driver, error)
if opts.mountProgram != "" { if opts.mountProgram != "" {
if unshare.IsRootless() && isNetworkFileSystem(fsMagic) && opts.forceMask == nil { if unshare.IsRootless() && isNetworkFileSystem(fsMagic) && opts.forceMask == nil {
m := os.FileMode(0700) m := os.FileMode(0o700)
opts.forceMask = &m opts.forceMask = &m
logrus.Warnf("Network file system detected as backing store. Enforcing overlay option `force_mask=\"%o\"`. Add it to storage.conf to silence this warning", m) logrus.Warnf("Network file system detected as backing store. Enforcing overlay option `force_mask=\"%o\"`. Add it to storage.conf to silence this warning", m)
} }
if err := os.WriteFile(getMountProgramFlagFile(home), []byte("true"), 0600); err != nil { if err := os.WriteFile(getMountProgramFlagFile(home), []byte("true"), 0o600); err != nil {
return nil, err return nil, err
} }
} else { } else {
@ -581,9 +579,9 @@ func parseOptions(options []string) (*overlayOptions, error) {
var mask int64 var mask int64
switch val { switch val {
case "shared": case "shared":
mask = 0755 mask = 0o755
case "private": case "private":
mask = 0700 mask = 0o700
default: default:
mask, err = strconv.ParseInt(val, 8, 32) mask, err = strconv.ParseInt(val, 8, 32)
if err != nil { if err != nil {
@ -648,7 +646,7 @@ func SupportsNativeOverlay(home, runhome string) (bool, error) {
if err != nil && !os.IsNotExist(err) { if err != nil && !os.IsNotExist(err) {
return false, err return false, err
} }
if err := os.WriteFile(getMountProgramFlagFile(home), []byte(fmt.Sprintf("%t", needsMountProgram)), 0600); err != nil && !os.IsNotExist(err) { if err := os.WriteFile(getMountProgramFlagFile(home), []byte(fmt.Sprintf("%t", needsMountProgram)), 0o600); err != nil && !os.IsNotExist(err) {
return false, err return false, err
} }
if needsMountProgram { if needsMountProgram {
@ -661,7 +659,7 @@ func SupportsNativeOverlay(home, runhome string) (bool, error) {
for _, dir := range []string{home, runhome} { for _, dir := range []string{home, runhome} {
if _, err := os.Stat(dir); err != nil { if _, err := os.Stat(dir); err != nil {
_ = idtools.MkdirAllAs(dir, 0700, 0, 0) _ = idtools.MkdirAllAs(dir, 0o700, 0, 0)
} }
} }
@ -721,12 +719,12 @@ func supportsOverlay(home string, homeMagic graphdriver.FsMagic, rootUID, rootGI
_ = os.RemoveAll(layerDir) _ = os.RemoveAll(layerDir)
_ = os.Remove(home) _ = os.Remove(home)
}() }()
_ = idtools.MkdirAs(mergedDir, 0700, rootUID, rootGID) _ = idtools.MkdirAs(mergedDir, 0o700, rootUID, rootGID)
_ = idtools.MkdirAs(lower1Dir, 0700, rootUID, rootGID) _ = idtools.MkdirAs(lower1Dir, 0o700, rootUID, rootGID)
_ = idtools.MkdirAs(lower2Dir, 0700, rootUID, rootGID) _ = idtools.MkdirAs(lower2Dir, 0o700, rootUID, rootGID)
_ = idtools.MkdirAs(lower2Subdir, 0700, rootUID, rootGID) _ = idtools.MkdirAs(lower2Subdir, 0o700, rootUID, rootGID)
_ = idtools.MkdirAs(upperDir, 0700, rootUID, rootGID) _ = idtools.MkdirAs(upperDir, 0o700, rootUID, rootGID)
_ = idtools.MkdirAs(workDir, 0700, rootUID, rootGID) _ = idtools.MkdirAs(workDir, 0o700, rootUID, rootGID)
f, err := os.Create(lower2SubdirFile) f, err := os.Create(lower2SubdirFile)
if err != nil { if err != nil {
logrus.Debugf("Unable to create test file: %v", err) logrus.Debugf("Unable to create test file: %v", err)
@ -744,7 +742,7 @@ func supportsOverlay(home string, homeMagic graphdriver.FsMagic, rootUID, rootGI
if unshare.IsRootless() { if unshare.IsRootless() {
flags = fmt.Sprintf("%s,userxattr", flags) flags = fmt.Sprintf("%s,userxattr", flags)
} }
if err := syscall.Mknod(filepath.Join(upperDir, "whiteout"), syscall.S_IFCHR|0600, int(unix.Mkdev(0, 0))); err != nil { if err := syscall.Mknod(filepath.Join(upperDir, "whiteout"), syscall.S_IFCHR|0o600, int(unix.Mkdev(0, 0))); err != nil {
logrus.Debugf("Unable to create kernel-style whiteout: %v", err) logrus.Debugf("Unable to create kernel-style whiteout: %v", err)
return supportsDType, fmt.Errorf("unable to create kernel-style whiteout: %w", err) return supportsDType, fmt.Errorf("unable to create kernel-style whiteout: %w", err)
} }
@ -968,7 +966,7 @@ func (d *Driver) create(id, parent string, opts *graphdriver.CreateOpts, disable
} }
// Make the link directory if it does not exist // Make the link directory if it does not exist
if err := idtools.MkdirAllAs(path.Join(d.home, linkDir), 0755, 0, 0); err != nil { if err := idtools.MkdirAllAs(path.Join(d.home, linkDir), 0o755, 0, 0); err != nil {
return err return err
} }
@ -982,13 +980,13 @@ func (d *Driver) create(id, parent string, opts *graphdriver.CreateOpts, disable
GID: rootGID, GID: rootGID,
} }
if err := idtools.MkdirAllAndChownNew(path.Dir(dir), 0755, idPair); err != nil { if err := idtools.MkdirAllAndChownNew(path.Dir(dir), 0o755, idPair); err != nil {
return err return err
} }
workDirBase := dir workDirBase := dir
if imageStore != "" { if imageStore != "" {
workDirBase = imageStore workDirBase = imageStore
if err := idtools.MkdirAllAndChownNew(path.Dir(imageStore), 0755, idPair); err != nil { if err := idtools.MkdirAllAndChownNew(path.Dir(imageStore), 0o755, idPair); err != nil {
return err return err
} }
} }
@ -1014,11 +1012,11 @@ func (d *Driver) create(id, parent string, opts *graphdriver.CreateOpts, disable
} }
} }
if err := idtools.MkdirAllAndChownNew(dir, 0700, idPair); err != nil { if err := idtools.MkdirAllAndChownNew(dir, 0o700, idPair); err != nil {
return err return err
} }
if imageStore != "" { if imageStore != "" {
if err := idtools.MkdirAllAndChownNew(imageStore, 0700, idPair); err != nil { if err := idtools.MkdirAllAndChownNew(imageStore, 0o700, idPair); err != nil {
return err return err
} }
} }
@ -1096,20 +1094,20 @@ func (d *Driver) create(id, parent string, opts *graphdriver.CreateOpts, disable
} }
// Write link id to link file // Write link id to link file
if err := os.WriteFile(path.Join(dir, "link"), []byte(lid), 0644); err != nil { if err := os.WriteFile(path.Join(dir, "link"), []byte(lid), 0o644); err != nil {
return err return err
} }
if err := idtools.MkdirAs(path.Join(workDirBase, "work"), 0700, rootUID, rootGID); err != nil { if err := idtools.MkdirAs(path.Join(workDirBase, "work"), 0o700, rootUID, rootGID); err != nil {
return err return err
} }
if err := idtools.MkdirAs(path.Join(dir, "merged"), 0700, rootUID, rootGID); err != nil { if err := idtools.MkdirAs(path.Join(dir, "merged"), 0o700, rootUID, rootGID); err != nil {
return err return err
} }
// if no parent directory, create a dummy lower directory and skip writing a "lowers" file // if no parent directory, create a dummy lower directory and skip writing a "lowers" file
if parent == "" { if parent == "" {
return idtools.MkdirAs(path.Join(dir, "empty"), 0700, rootUID, rootGID) return idtools.MkdirAs(path.Join(dir, "empty"), 0o700, rootUID, rootGID)
} }
lower, err := d.getLower(parent) lower, err := d.getLower(parent)
@ -1117,7 +1115,7 @@ func (d *Driver) create(id, parent string, opts *graphdriver.CreateOpts, disable
return err return err
} }
if lower != "" { if lower != "" {
if err := os.WriteFile(path.Join(dir, lowerFile), []byte(lower), 0666); err != nil { if err := os.WriteFile(path.Join(dir, lowerFile), []byte(lower), 0o666); err != nil {
return err return err
} }
} }
@ -1312,7 +1310,7 @@ func (d *Driver) recreateSymlinks() error {
return fmt.Errorf("reading driver home directory %q: %w", d.home, err) return fmt.Errorf("reading driver home directory %q: %w", d.home, err)
} }
// This makes the link directory if it doesn't exist // This makes the link directory if it doesn't exist
if err := idtools.MkdirAllAs(path.Join(d.home, linkDir), 0755, 0, 0); err != nil { if err := idtools.MkdirAllAs(path.Join(d.home, linkDir), 0o755, 0, 0); err != nil {
return err return err
} }
// Keep looping as long as we take some corrective action in each iteration // Keep looping as long as we take some corrective action in each iteration
@ -1389,7 +1387,7 @@ func (d *Driver) recreateSymlinks() error {
if err != nil || string(data) != link.Name() { if err != nil || string(data) != link.Name() {
// NOTE: If two or more links point to the same target, we will update linkFile // NOTE: If two or more links point to the same target, we will update linkFile
// with every value of link.Name(), and set madeProgress = true every time. // with every value of link.Name(), and set madeProgress = true every time.
if err := os.WriteFile(linkFile, []byte(link.Name()), 0644); err != nil { if err := os.WriteFile(linkFile, []byte(link.Name()), 0o644); err != nil {
errs = multierror.Append(errs, fmt.Errorf("correcting link for layer %s: %w", targetID, err)) errs = multierror.Append(errs, fmt.Errorf("correcting link for layer %s: %w", targetID, err))
continue continue
} }
@ -1565,7 +1563,7 @@ func (d *Driver) get(id string, disableShifting bool, options graphdriver.MountO
mergedDir := path.Join(dir, "merged") mergedDir := path.Join(dir, "merged")
// Create the driver merged dir // Create the driver merged dir
if err := idtools.MkdirAs(mergedDir, 0700, rootUID, rootGID); err != nil && !os.IsExist(err) { if err := idtools.MkdirAs(mergedDir, 0o700, rootUID, rootGID); err != nil && !os.IsExist(err) {
return "", err return "", err
} }
if count := d.ctr.Increment(mergedDir); count > 1 { if count := d.ctr.Increment(mergedDir); count > 1 {
@ -1601,7 +1599,7 @@ func (d *Driver) get(id string, disableShifting bool, options graphdriver.MountO
if !disableShifting && len(options.UidMaps) > 0 && len(options.GidMaps) > 0 && d.options.mountProgram == "" { if !disableShifting && len(options.UidMaps) > 0 && len(options.GidMaps) > 0 && d.options.mountProgram == "" {
var newAbsDir []string var newAbsDir []string
mappedRoot := filepath.Join(d.home, id, "mapped") mappedRoot := filepath.Join(d.home, id, "mapped")
if err := os.MkdirAll(mappedRoot, 0700); err != nil { if err := os.MkdirAll(mappedRoot, 0o700); err != nil {
return "", err return "", err
} }
@ -1911,7 +1909,7 @@ func (d *Driver) ApplyDiffWithDiffer(id, parent string, options *graphdriver.App
var applyDir string var applyDir string
if id == "" { if id == "" {
err := os.MkdirAll(d.getStagingDir(), 0700) err := os.MkdirAll(d.getStagingDir(), 0o700)
if err != nil && !os.IsExist(err) { if err != nil && !os.IsExist(err) {
return graphdriver.DriverWithDifferOutput{}, err return graphdriver.DriverWithDifferOutput{}, err
} }
@ -1964,7 +1962,6 @@ func (d *Driver) DifferTarget(id string) (string, error) {
// ApplyDiff applies the new layer into a root // ApplyDiff applies the new layer into a root
func (d *Driver) ApplyDiff(id, parent string, options graphdriver.ApplyDiffOpts) (size int64, err error) { func (d *Driver) ApplyDiff(id, parent string, options graphdriver.ApplyDiffOpts) (size int64, err error) {
if !d.isParent(id, parent) { if !d.isParent(id, parent) {
if d.options.ignoreChownErrors { if d.options.ignoreChownErrors {
options.IgnoreChownErrors = d.options.ignoreChownErrors options.IgnoreChownErrors = d.options.ignoreChownErrors
@ -2284,7 +2281,7 @@ func (al *additionalLayer) CreateAs(id, parent string) error {
} }
// tell the additional layer store that we use this layer. // tell the additional layer store that we use this layer.
// mark this layer as "additional layer" // mark this layer as "additional layer"
if err := os.WriteFile(path.Join(dir, "additionallayer"), []byte(al.path), 0644); err != nil { if err := os.WriteFile(path.Join(dir, "additionallayer"), []byte(al.path), 0o644); err != nil {
return err return err
} }
notifyUseAdditionalLayer(al.path) notifyUseAdditionalLayer(al.path)

9
drivers/quota/projectquota.go
View File

@ -50,6 +50,7 @@ struct fsxattr {
#endif #endif
*/ */
import "C" import "C"
import ( import (
"errors" "errors"
"fmt" "fmt"
@ -98,7 +99,6 @@ func generateUniqueProjectID(path string) (uint32, error) {
stat, ok := fileinfo.Sys().(*syscall.Stat_t) stat, ok := fileinfo.Sys().(*syscall.Stat_t)
if !ok { if !ok {
return 0, fmt.Errorf("not a syscall.Stat_t %s", path) return 0, fmt.Errorf("not a syscall.Stat_t %s", path)
} }
projectID := projectIDsAllocatedPerQuotaHome + (stat.Ino*projectIDsAllocatedPerQuotaHome)%(math.MaxUint32-projectIDsAllocatedPerQuotaHome) projectID := projectIDsAllocatedPerQuotaHome + (stat.Ino*projectIDsAllocatedPerQuotaHome)%(math.MaxUint32-projectIDsAllocatedPerQuotaHome)
return uint32(projectID), nil return uint32(projectID), nil
@ -191,7 +191,6 @@ func NewControl(basePath string) (*Control, error) {
// SetQuota - assign a unique project id to directory and set the quota limits // SetQuota - assign a unique project id to directory and set the quota limits
// for that project id // for that project id
func (q *Control) SetQuota(targetPath string, quota Quota) error { func (q *Control) SetQuota(targetPath string, quota Quota) error {
projectID, ok := q.quotas[targetPath] projectID, ok := q.quotas[targetPath]
if !ok { if !ok {
projectID = q.nextProjectID projectID = q.nextProjectID
@ -239,7 +238,7 @@ func (q *Control) setProjectQuota(projectID uint32, quota Quota) error {
d.d_ino_softlimit = d.d_ino_hardlimit d.d_ino_softlimit = d.d_ino_hardlimit
} }
var cs = C.CString(q.backingFsBlockDev) cs := C.CString(q.backingFsBlockDev)
defer C.free(unsafe.Pointer(cs)) defer C.free(unsafe.Pointer(cs))
runQuotactl := func() syscall.Errno { runQuotactl := func() syscall.Errno {
@ -307,7 +306,7 @@ func (q *Control) fsDiskQuotaFromPath(targetPath string) (C.fs_disk_quota_t, err
// //
// get the quota limit for the container's project id // get the quota limit for the container's project id
// //
var cs = C.CString(q.backingFsBlockDev) cs := C.CString(q.backingFsBlockDev)
defer C.free(unsafe.Pointer(cs)) defer C.free(unsafe.Pointer(cs))
_, _, errno := unix.Syscall6(unix.SYS_QUOTACTL, C.Q_XGETPQUOTA, _, _, errno := unix.Syscall6(unix.SYS_QUOTACTL, C.Q_XGETPQUOTA,
@ -428,7 +427,7 @@ func makeBackingFsDev(home string) (string, error) {
backingFsBlockDev := path.Join(home, BackingFsBlockDeviceLink) backingFsBlockDev := path.Join(home, BackingFsBlockDeviceLink)
backingFsBlockDevTmp := backingFsBlockDev + ".tmp" backingFsBlockDevTmp := backingFsBlockDev + ".tmp"
// Re-create just in case someone copied the home directory over to a new device // Re-create just in case someone copied the home directory over to a new device
if err := unix.Mknod(backingFsBlockDevTmp, unix.S_IFBLK|0600, int(stat.Dev)); err != nil { if err := unix.Mknod(backingFsBlockDevTmp, unix.S_IFBLK|0o600, int(stat.Dev)); err != nil {
return "", fmt.Errorf("failed to mknod %s: %w", backingFsBlockDevTmp, err) return "", fmt.Errorf("failed to mknod %s: %w", backingFsBlockDevTmp, err)
} }
if err := unix.Rename(backingFsBlockDevTmp, backingFsBlockDev); err != nil { if err := unix.Rename(backingFsBlockDevTmp, backingFsBlockDev); err != nil {

3
drivers/quota/projectquota_unsupported.go
View File

@ -15,8 +15,7 @@ type Quota struct {
// Control - Context to be used by storage driver (e.g. overlay) // Control - Context to be used by storage driver (e.g. overlay)
// who wants to apply project quotas to container dirs // who wants to apply project quotas to container dirs
type Control struct { type Control struct{}
}
func NewControl(basePath string) (*Control, error) { func NewControl(basePath string) (*Control, error) {
return nil, errors.New("filesystem does not support, or has not enabled quotas") return nil, errors.New("filesystem does not support, or has not enabled quotas")

10
drivers/vfs/driver.go
View File

@ -20,7 +20,7 @@ import (
"github.com/vbatts/tar-split/tar/storage" "github.com/vbatts/tar-split/tar/storage"
) )
const defaultPerms = os.FileMode(0555) const defaultPerms = os.FileMode(0o555)
func init() { func init() {
graphdriver.MustRegister("vfs", Init) graphdriver.MustRegister("vfs", Init)
@ -36,7 +36,7 @@ func Init(home string, options graphdriver.Options) (graphdriver.Driver, error)
} }
rootIDs := d.idMappings.RootPair() rootIDs := d.idMappings.RootPair()
if err := idtools.MkdirAllAndChown(filepath.Join(home, "dir"), 0700, rootIDs); err != nil { if err := idtools.MkdirAllAndChown(filepath.Join(home, "dir"), 0o700, rootIDs); err != nil {
return nil, err return nil, err
} }
for _, option := range options.DriverOptions { for _, option := range options.DriverOptions {
@ -160,7 +160,7 @@ func (d *Driver) create(id, parent string, opts *graphdriver.CreateOpts, ro bool
dir := d.dir(id) dir := d.dir(id)
rootIDs := idMappings.RootPair() rootIDs := idMappings.RootPair()
if err := idtools.MkdirAllAndChown(filepath.Dir(dir), 0700, rootIDs); err != nil { if err := idtools.MkdirAllAndChown(filepath.Dir(dir), 0o700, rootIDs); err != nil {
return err return err
} }
@ -172,7 +172,7 @@ func (d *Driver) create(id, parent string, opts *graphdriver.CreateOpts, ro bool
rootPerms := defaultPerms rootPerms := defaultPerms
if runtime.GOOS == "darwin" { if runtime.GOOS == "darwin" {
rootPerms = os.FileMode(0700) rootPerms = os.FileMode(0o700)
} }
if parent != "" { if parent != "" {
@ -202,7 +202,6 @@ func (d *Driver) create(id, parent string, opts *graphdriver.CreateOpts, ro bool
} }
return nil return nil
} }
func (d *Driver) dir(id string) string { func (d *Driver) dir(id string) string {
@ -312,7 +311,6 @@ func (d *Driver) UpdateLayerIDMap(id string, toContainer, toHost *idtools.IDMapp
return err return err
} }
return os.Chown(dir, rootIDs.UID, rootIDs.GID) return os.Chown(dir, rootIDs.UID, rootIDs.GID)
} }
// Changes produces a list of changes between the specified layer // Changes produces a list of changes between the specified layer

9
drivers/windows/windows.go
View File

@ -64,8 +64,7 @@ func init() {
} }
} }
type checker struct { type checker struct{}
}
func (c *checker) IsMounted(path string) bool { func (c *checker) IsMounted(path string) bool {
return false return false
@ -102,7 +101,7 @@ func InitFilter(home string, options graphdriver.Options) (graphdriver.Driver, e
return nil, fmt.Errorf("%s is on an ReFS volume - ReFS volumes are not supported", home) return nil, fmt.Errorf("%s is on an ReFS volume - ReFS volumes are not supported", home)
} }
if err := idtools.MkdirAllAs(home, 0700, 0, 0); err != nil { if err := idtools.MkdirAllAs(home, 0o700, 0, 0); err != nil {
return nil, fmt.Errorf("windowsfilter failed to create '%s': %w", home, err) return nil, fmt.Errorf("windowsfilter failed to create '%s': %w", home, err)
} }
@ -885,7 +884,7 @@ func (d *Driver) resolveID(id string) (string, error) {
// setID stores the layerId in disk. // setID stores the layerId in disk.
func (d *Driver) setID(id, altID string) error { func (d *Driver) setID(id, altID string) error {
return os.WriteFile(filepath.Join(d.dir(id), "layerId"), []byte(altID), 0600) return os.WriteFile(filepath.Join(d.dir(id), "layerId"), []byte(altID), 0o600)
} }
// getLayerChain returns the layer chain information. // getLayerChain returns the layer chain information.
@ -915,7 +914,7 @@ func (d *Driver) setLayerChain(id string, chain []string) error {
} }
jPath := filepath.Join(d.dir(id), "layerchain.json") jPath := filepath.Join(d.dir(id), "layerchain.json")
err = os.WriteFile(jPath, content, 0600) err = os.WriteFile(jPath, content, 0o600)
if err != nil { if err != nil {
return fmt.Errorf("unable to write layerchain file - %s", err) return fmt.Errorf("unable to write layerchain file - %s", err)
} }

8
drivers/zfs/zfs.go
View File

@ -30,7 +30,7 @@ type zfsOptions struct {
mountOptions string mountOptions string
} }
const defaultPerms = os.FileMode(0555) const defaultPerms = os.FileMode(0o555)
func init() { func init() {
graphdriver.MustRegister("zfs", Init) graphdriver.MustRegister("zfs", Init)
@ -57,7 +57,7 @@ func Init(base string, opt graphdriver.Options) (graphdriver.Driver, error) {
return nil, fmt.Errorf("the 'zfs' command is not available: %w", graphdriver.ErrPrerequisites) return nil, fmt.Errorf("the 'zfs' command is not available: %w", graphdriver.ErrPrerequisites)
} }
file, err := unix.Open("/dev/zfs", unix.O_RDWR, 0600) file, err := unix.Open("/dev/zfs", unix.O_RDWR, 0o600)
if err != nil { if err != nil {
logger.Debugf("cannot open /dev/zfs: %v", err) logger.Debugf("cannot open /dev/zfs: %v", err)
return nil, fmt.Errorf("could not open /dev/zfs: %v: %w", err, graphdriver.ErrPrerequisites) return nil, fmt.Errorf("could not open /dev/zfs: %v: %w", err, graphdriver.ErrPrerequisites)
@ -110,7 +110,7 @@ func Init(base string, opt graphdriver.Options) (graphdriver.Driver, error) {
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to get root uid/gid: %w", err) return nil, fmt.Errorf("failed to get root uid/gid: %w", err)
} }
if err := idtools.MkdirAllAs(base, 0700, rootUID, rootGID); err != nil { if err := idtools.MkdirAllAs(base, 0o700, rootUID, rootGID); err != nil {
return nil, fmt.Errorf("failed to create '%s': %w", base, err) return nil, fmt.Errorf("failed to create '%s': %w", base, err)
} }
@ -453,7 +453,7 @@ func (d *Driver) Get(id string, options graphdriver.MountOpts) (_ string, retErr
return "", err return "", err
} }
// Create the target directories if they don't exist // Create the target directories if they don't exist
if err := idtools.MkdirAllAs(mountpoint, 0755, rootUID, rootGID); err != nil { if err := idtools.MkdirAllAs(mountpoint, 0o755, rootUID, rootGID); err != nil {
return "", err return "", err
} }

3
idset_test.go
View File

@ -566,7 +566,8 @@ func TestIDSetFindAvailable(t *testing.T) {
nil, nil,
true, true,
}, },
{"OneIntervalFindZero", {
"OneIntervalFindZero",
newIDSet([]interval{{1, 5}}), newIDSet([]interval{{1, 5}}),
0, 0,
&idSet{set: intervalset.NewImmutableSet(nil)}, &idSet{set: intervalset.NewImmutableSet(nil)},

10
images.go
View File

@ -568,7 +568,7 @@ func (r *imageStore) Save() error {
} }
r.lockfile.AssertLockedForWriting() r.lockfile.AssertLockedForWriting()
rpath := r.imagespath() rpath := r.imagespath()
if err := os.MkdirAll(filepath.Dir(rpath), 0700); err != nil { if err := os.MkdirAll(filepath.Dir(rpath), 0o700); err != nil {
return err return err
} }
jdata, err := json.Marshal(&r.images) jdata, err := json.Marshal(&r.images)
@ -582,14 +582,14 @@ func (r *imageStore) Save() error {
return err return err
} }
r.lastWrite = lw r.lastWrite = lw
if err := ioutils.AtomicWriteFile(rpath, jdata, 0600); err != nil { if err := ioutils.AtomicWriteFile(rpath, jdata, 0o600); err != nil {
return err return err
} }
return nil return nil
} }
func newImageStore(dir string) (rwImageStore, error) { func newImageStore(dir string) (rwImageStore, error) {
if err := os.MkdirAll(dir, 0700); err != nil { if err := os.MkdirAll(dir, 0o700); err != nil {
return nil, err return nil, err
} }
lockfile, err := lockfile.GetLockFile(filepath.Join(dir, "images.lock")) lockfile, err := lockfile.GetLockFile(filepath.Join(dir, "images.lock"))
@ -1017,11 +1017,11 @@ func (r *imageStore) setBigData(image *Image, key string, data []byte, newDigest
if key == "" { if key == "" {
return fmt.Errorf("can't set empty name for image big data item: %w", ErrInvalidBigDataName) return fmt.Errorf("can't set empty name for image big data item: %w", ErrInvalidBigDataName)
} }
err := os.MkdirAll(r.datadir(image.ID), 0700) err := os.MkdirAll(r.datadir(image.ID), 0o700)
if err != nil { if err != nil {
return err return err
} }
err = ioutils.AtomicWriteFile(r.datapath(image.ID, key), data, 0600) err = ioutils.AtomicWriteFile(r.datapath(image.ID, key), data, 0o600)
if err == nil { if err == nil {
save := false save := false
if image.BigDataSizes == nil { if image.BigDataSizes == nil {

2
internal/opts/opts.go
View File

@ -209,7 +209,7 @@ type ValidatorFctListType func(val string) ([]string, error)
// ValidateIPAddress validates an Ip address. // ValidateIPAddress validates an Ip address.
func ValidateIPAddress(val string) (string, error) { func ValidateIPAddress(val string) (string, error) {
var ip = net.ParseIP(strings.TrimSpace(val)) ip := net.ParseIP(strings.TrimSpace(val))
if ip != nil { if ip != nil {
return ip.String(), nil return ip.String(), nil
} }

2
internal/opts/opts_test.go
View File

@ -30,7 +30,6 @@ func TestValidateIPAddress(t *testing.T) {
if ret, err := opts.ValidateIPAddress(`random invalid string`); err == nil || ret != "" { if ret, err := opts.ValidateIPAddress(`random invalid string`); err == nil || ret != "" {
t.Fatalf("ValidateIPAddress(`random invalid string`) got %s %s", ret, err) t.Fatalf("ValidateIPAddress(`random invalid string`) got %s %s", ret, err)
} }
} }
func TestMapOpts(t *testing.T) { func TestMapOpts(t *testing.T) {
@ -95,7 +94,6 @@ func TestListOptsWithoutValidator(t *testing.T) {
if len(mapListOpts) != 1 { if len(mapListOpts) != 1 {
t.Errorf("Expected [map[bar:{}]], got [%v]", mapListOpts) t.Errorf("Expected [map[bar:{}]], got [%v]", mapListOpts)
} }
} }
func TestListOptsWithValidator(t *testing.T) { func TestListOptsWithValidator(t *testing.T) {

6
internal/opts/parse.go
View File

@ -131,7 +131,7 @@ func (args Args) Len() int {
func (args Args) MatchKVList(key string, sources map[string]string) bool { func (args Args) MatchKVList(key string, sources map[string]string) bool {
fieldValues := args.fields[key] fieldValues := args.fields[key]
//do not filter if there is no filter set or cannot determine filter // do not filter if there is no filter set or cannot determine filter
if len(fieldValues) == 0 { if len(fieldValues) == 0 {
return true return true
} }
@ -177,7 +177,7 @@ func (args Args) Match(field, source string) bool {
// ExactMatch returns true if the source matches exactly one of the values. // ExactMatch returns true if the source matches exactly one of the values.
func (args Args) ExactMatch(key, source string) bool { func (args Args) ExactMatch(key, source string) bool {
fieldValues, ok := args.fields[key] fieldValues, ok := args.fields[key]
//do not filter if there is no filter set or cannot determine filter // do not filter if there is no filter set or cannot determine filter
if !ok || len(fieldValues) == 0 { if !ok || len(fieldValues) == 0 {
return true return true
} }
@ -190,7 +190,7 @@ func (args Args) ExactMatch(key, source string) bool {
// matches exactly the value. // matches exactly the value.
func (args Args) UniqueExactMatch(key, source string) bool { func (args Args) UniqueExactMatch(key, source string) bool {
fieldValues := args.fields[key] fieldValues := args.fields[key]
//do not filter if there is no filter set or cannot determine filter // do not filter if there is no filter set or cannot determine filter
if len(fieldValues) == 0 { if len(fieldValues) == 0 {
return true return true
} }

25
layers.go
View File

@ -657,7 +657,6 @@ func (r *layerStore) Layers() ([]Layer, error) {
// Requires startWriting. // Requires startWriting.
func (r *layerStore) GarbageCollect() error { func (r *layerStore) GarbageCollect() error {
layers, err := r.driver.ListLayers() layers, err := r.driver.ListLayers()
if err != nil { if err != nil {
if errors.Is(err, drivers.ErrNotSupported) { if errors.Is(err, drivers.ErrNotSupported) {
return nil return nil
@ -936,7 +935,7 @@ func (r *layerStore) saveLayers(saveLocations layerLocations) error {
continue continue
} }
rpath := r.jsonPath[locationIndex] rpath := r.jsonPath[locationIndex]
if err := os.MkdirAll(filepath.Dir(rpath), 0700); err != nil { if err := os.MkdirAll(filepath.Dir(rpath), 0o700); err != nil {
return err return err
} }
subsetLayers := make([]*Layer, 0, len(r.layers)) subsetLayers := make([]*Layer, 0, len(r.layers))
@ -954,7 +953,7 @@ func (r *layerStore) saveLayers(saveLocations layerLocations) error {
if location == volatileLayerLocation { if location == volatileLayerLocation {
opts.NoSync = true opts.NoSync = true
} }
if err := ioutils.AtomicWriteFileWithOpts(rpath, jldata, 0600, &opts); err != nil { if err := ioutils.AtomicWriteFileWithOpts(rpath, jldata, 0o600, &opts); err != nil {
return err return err
} }
r.layerspathsModified[locationIndex] = opts.ModTime r.layerspathsModified[locationIndex] = opts.ModTime
@ -970,7 +969,7 @@ func (r *layerStore) saveMounts() error {
} }
r.mountsLockfile.AssertLockedForWriting() r.mountsLockfile.AssertLockedForWriting()
mpath := r.mountspath() mpath := r.mountspath()
if err := os.MkdirAll(filepath.Dir(mpath), 0700); err != nil { if err := os.MkdirAll(filepath.Dir(mpath), 0o700); err != nil {
return err return err
} }
mounts := make([]layerMountPoint, 0, len(r.layers)) mounts := make([]layerMountPoint, 0, len(r.layers))
@ -996,17 +995,17 @@ func (r *layerStore) saveMounts() error {
} }
r.mountsLastWrite = lw r.mountsLastWrite = lw
if err = ioutils.AtomicWriteFile(mpath, jmdata, 0600); err != nil { if err = ioutils.AtomicWriteFile(mpath, jmdata, 0o600); err != nil {
return err return err
} }
return r.loadMounts() return r.loadMounts()
} }
func (s *store) newLayerStore(rundir string, layerdir string, driver drivers.Driver, transient bool) (rwLayerStore, error) { func (s *store) newLayerStore(rundir string, layerdir string, driver drivers.Driver, transient bool) (rwLayerStore, error) {
if err := os.MkdirAll(rundir, 0700); err != nil { if err := os.MkdirAll(rundir, 0o700); err != nil {
return nil, err return nil, err
} }
if err := os.MkdirAll(layerdir, 0700); err != nil { if err := os.MkdirAll(layerdir, 0o700); err != nil {
return nil, err return nil, err
} }
// Note: While the containers.lock file is in rundir for transient stores // Note: While the containers.lock file is in rundir for transient stores
@ -1222,10 +1221,10 @@ func (r *layerStore) create(id string, parentLayer *Layer, names []string, mount
if !r.lockfile.IsReadWrite() { if !r.lockfile.IsReadWrite() {
return nil, -1, fmt.Errorf("not allowed to create new layers at %q: %w", r.layerdir, ErrStoreIsReadOnly) return nil, -1, fmt.Errorf("not allowed to create new layers at %q: %w", r.layerdir, ErrStoreIsReadOnly)
} }
if err := os.MkdirAll(r.rundir, 0700); err != nil { if err := os.MkdirAll(r.rundir, 0o700); err != nil {
return nil, -1, err return nil, -1, err
} }
if err := os.MkdirAll(r.layerdir, 0700); err != nil { if err := os.MkdirAll(r.layerdir, 0o700); err != nil {
return nil, -1, err return nil, -1, err
} }
if id == "" { if id == "" {
@ -1699,7 +1698,7 @@ func (r *layerStore) setBigData(layer *Layer, key string, data io.Reader) error
if key == "" { if key == "" {
return fmt.Errorf("can't set empty name for layer big data item: %w", ErrInvalidBigDataName) return fmt.Errorf("can't set empty name for layer big data item: %w", ErrInvalidBigDataName)
} }
err := os.MkdirAll(r.datadir(layer.ID), 0700) err := os.MkdirAll(r.datadir(layer.ID), 0o700)
if err != nil { if err != nil {
return err return err
} }
@ -1707,7 +1706,7 @@ func (r *layerStore) setBigData(layer *Layer, key string, data io.Reader) error
// NewAtomicFileWriter doesn't overwrite/truncate the existing inode. // NewAtomicFileWriter doesn't overwrite/truncate the existing inode.
// BigData() relies on this behaviour when opening the file for read // BigData() relies on this behaviour when opening the file for read
// so that it is either accessing the old data or the new one. // so that it is either accessing the old data or the new one.
writer, err := ioutils.NewAtomicFileWriter(r.datapath(layer.ID, key), 0600) writer, err := ioutils.NewAtomicFileWriter(r.datapath(layer.ID, key), 0o600)
if err != nil { if err != nil {
return fmt.Errorf("opening bigdata file: %w", err) return fmt.Errorf("opening bigdata file: %w", err)
} }
@ -2291,10 +2290,10 @@ func (r *layerStore) applyDiffWithOptions(to string, layerOptions *LayerOptions,
return -1, err return -1, err
} }
compressor.Close() compressor.Close()
if err := os.MkdirAll(filepath.Dir(r.tspath(layer.ID)), 0700); err != nil { if err := os.MkdirAll(filepath.Dir(r.tspath(layer.ID)), 0o700); err != nil {
return -1, err return -1, err
} }
if err := ioutils.AtomicWriteFile(r.tspath(layer.ID), tsdata.Bytes(), 0600); err != nil { if err := ioutils.AtomicWriteFile(r.tspath(layer.ID), tsdata.Bytes(), 0o600); err != nil {
return -1, err return -1, err
} }
if compressedDigester != nil { if compressedDigester != nil {

30
pkg/archive/archive.go
View File

@ -132,13 +132,13 @@ const (
) )
const ( const (
modeISDIR = 040000 // Directory modeISDIR = 0o40000 // Directory
modeISFIFO = 010000 // FIFO modeISFIFO = 0o10000 // FIFO
modeISREG = 0100000 // Regular file modeISREG = 0o100000 // Regular file
modeISLNK = 0120000 // Symbolic link modeISLNK = 0o120000 // Symbolic link
modeISBLK = 060000 // Block special file modeISBLK = 0o60000 // Block special file
modeISCHR = 020000 // Character special file modeISCHR = 0o20000 // Character special file
modeISSOCK = 0140000 // Socket modeISSOCK = 0o140000 // Socket
) )
// IsArchivePath checks if the (possibly compressed) file at the given path // IsArchivePath checks if the (possibly compressed) file at the given path
@ -328,7 +328,6 @@ func ReplaceFileTarWrapper(inputTarStream io.ReadCloser, mods map[string]TarModi
} }
pipeWriter.Close() pipeWriter.Close()
}() }()
return pipeReader return pipeReader
} }
@ -552,9 +551,9 @@ func (ta *tarAppender) addTarFile(path, name string) error {
} }
} }
//handle re-mapping container ID mappings back to host ID mappings before // handle re-mapping container ID mappings back to host ID mappings before
//writing tar headers/files. We skip whiteout files because they were written // writing tar headers/files. We skip whiteout files because they were written
//by the kernel and already have proper ownership relative to the host // by the kernel and already have proper ownership relative to the host
if !strings.HasPrefix(filepath.Base(hdr.Name), WhiteoutPrefix) && !ta.IDMappings.Empty() { if !strings.HasPrefix(filepath.Base(hdr.Name), WhiteoutPrefix) && !ta.IDMappings.Empty() {
fileIDPair, err := getFileUIDGID(fi.Sys()) fileIDPair, err := getFileUIDGID(fi.Sys())
if err != nil { if err != nil {
@ -702,7 +701,7 @@ func createTarFile(path, extractDir string, hdr *tar.Header, reader io.Reader, L
} }
if forceMask != nil && (hdr.Typeflag != tar.TypeSymlink || runtime.GOOS == "darwin") { if forceMask != nil && (hdr.Typeflag != tar.TypeSymlink || runtime.GOOS == "darwin") {
value := fmt.Sprintf("%d:%d:0%o", hdr.Uid, hdr.Gid, hdrInfo.Mode()&07777) value := fmt.Sprintf("%d:%d:0%o", hdr.Uid, hdr.Gid, hdrInfo.Mode()&0o7777)
if err := system.Lsetxattr(path, idtools.ContainersOverrideXattr, []byte(value), 0); err != nil { if err := system.Lsetxattr(path, idtools.ContainersOverrideXattr, []byte(value), 0); err != nil {
return err return err
} }
@ -800,7 +799,6 @@ func Tar(path string, compression Compression) (io.ReadCloser, error) {
// TarWithOptions creates an archive from the directory at `path`, only including files whose relative // TarWithOptions creates an archive from the directory at `path`, only including files whose relative
// paths are included in `options.IncludeFiles` (if non-nil) or not in `options.ExcludePatterns`. // paths are included in `options.IncludeFiles` (if non-nil) or not in `options.ExcludePatterns`.
func TarWithOptions(srcPath string, options *TarOptions) (io.ReadCloser, error) { func TarWithOptions(srcPath string, options *TarOptions) (io.ReadCloser, error) {
// Fix the source path to work with long path names. This is a no-op // Fix the source path to work with long path names. This is a no-op
// on platforms other than Windows. // on platforms other than Windows.
srcPath = fixVolumePathPrefix(srcPath) srcPath = fixVolumePathPrefix(srcPath)
@ -1032,7 +1030,7 @@ loop:
parent := filepath.Dir(hdr.Name) parent := filepath.Dir(hdr.Name)
parentPath := filepath.Join(dest, parent) parentPath := filepath.Join(dest, parent)
if _, err := os.Lstat(parentPath); err != nil && os.IsNotExist(err) { if _, err := os.Lstat(parentPath); err != nil && os.IsNotExist(err) {
err = idtools.MkdirAllAndChownNew(parentPath, 0777, rootIDs) err = idtools.MkdirAllAndChownNew(parentPath, 0o777, rootIDs)
if err != nil { if err != nil {
return err return err
} }
@ -1239,7 +1237,7 @@ func (archiver *Archiver) CopyWithTar(src, dst string) error {
} }
// Create dst, copy src's content into it // Create dst, copy src's content into it
logrus.Debugf("Creating dest directory: %s", dst) logrus.Debugf("Creating dest directory: %s", dst)
if err := idtools.MkdirAllAndChownNew(dst, 0755, rootIDs); err != nil { if err := idtools.MkdirAllAndChownNew(dst, 0o755, rootIDs); err != nil {
return err return err
} }
logrus.Debugf("Calling TarUntar(%s, %s)", src, dst) logrus.Debugf("Calling TarUntar(%s, %s)", src, dst)
@ -1266,7 +1264,7 @@ func (archiver *Archiver) CopyFileWithTar(src, dst string) (err error) {
dst = filepath.Join(dst, filepath.Base(src)) dst = filepath.Join(dst, filepath.Base(src))
} }
// Create the holding directory if necessary // Create the holding directory if necessary
if err := os.MkdirAll(filepath.Dir(dst), 0700); err != nil { if err := os.MkdirAll(filepath.Dir(dst), 0o700); err != nil {
return err return err
} }

5
pkg/archive/archive_linux.go
View File

@ -153,8 +153,7 @@ func (overlayWhiteoutConverter) ConvertReadWithHandler(hdr *tar.Header, path str
return true, nil return true, nil
} }
type directHandler struct { type directHandler struct{}
}
func (d directHandler) Setxattr(path, name string, value []byte) error { func (d directHandler) Setxattr(path, name string, value []byte) error {
return unix.Setxattr(path, name, value, 0) return unix.Setxattr(path, name, value, 0)
@ -185,7 +184,7 @@ func GetFileOwner(path string) (uint32, uint32, uint32, error) {
} }
s, ok := f.Sys().(*syscall.Stat_t) s, ok := f.Sys().(*syscall.Stat_t)
if ok { if ok {
return s.Uid, s.Gid, s.Mode & 07777, nil return s.Uid, s.Gid, s.Mode & 0o7777, nil
} }
return 0, 0, uint32(f.Mode()), nil return 0, 0, uint32(f.Mode()), nil
} }

37
pkg/archive/archive_linux_test.go
View File

@ -25,27 +25,27 @@ import (
// └── f1 # whiteout, 0000 // └── f1 # whiteout, 0000
func setupOverlayTestDir(t *testing.T, src string) { func setupOverlayTestDir(t *testing.T, src string) {
// Create opaque directory containing single file and permission 0700 // 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)
require.NoError(t, err) require.NoError(t, err)
err = system.Lsetxattr(filepath.Join(src, "d1"), getOverlayOpaqueXattrName(), []byte("y"), 0) err = system.Lsetxattr(filepath.Join(src, "d1"), getOverlayOpaqueXattrName(), []byte("y"), 0)
require.NoError(t, err) require.NoError(t, err)
err = os.WriteFile(filepath.Join(src, "d1", "f1"), []byte{}, 0600) err = os.WriteFile(filepath.Join(src, "d1", "f1"), []byte{}, 0o600)
require.NoError(t, err) require.NoError(t, err)
// Create another opaque directory containing single file but with permission 0750 // 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)
require.NoError(t, err) require.NoError(t, err)
err = system.Lsetxattr(filepath.Join(src, "d2"), getOverlayOpaqueXattrName(), []byte("y"), 0) err = system.Lsetxattr(filepath.Join(src, "d2"), getOverlayOpaqueXattrName(), []byte("y"), 0)
require.NoError(t, err) require.NoError(t, err)
err = os.WriteFile(filepath.Join(src, "d2", "f1"), []byte{}, 0660) err = os.WriteFile(filepath.Join(src, "d2", "f1"), []byte{}, 0o660)
require.NoError(t, err) require.NoError(t, err)
// Create regular directory with deleted file // Create regular directory with deleted file
err = os.Mkdir(filepath.Join(src, "d3"), 0700) err = os.Mkdir(filepath.Join(src, "d3"), 0o700)
require.NoError(t, err) require.NoError(t, err)
err = system.Mknod(filepath.Join(src, "d3", "f1"), unix.S_IFCHR, 0) err = system.Mknod(filepath.Join(src, "d3", "f1"), unix.S_IFCHR, 0)
@ -54,10 +54,10 @@ func setupOverlayTestDir(t *testing.T, src string) {
func setupOverlayLowerDir(t *testing.T, lower string) { func setupOverlayLowerDir(t *testing.T, lower string) {
// Create a subdirectory to use as the "lower layer"'s copy of a deleted directory // Create a subdirectory to use as the "lower layer"'s copy of a deleted directory
err := os.Mkdir(filepath.Join(lower, "d1"), 0700) err := os.Mkdir(filepath.Join(lower, "d1"), 0o700)
require.NoError(t, err) require.NoError(t, err)
err = os.WriteFile(filepath.Join(lower, "d1", "f1"), []byte{}, 0600) err = os.WriteFile(filepath.Join(lower, "d1", "f1"), []byte{}, 0o600)
require.NoError(t, err) require.NoError(t, err)
} }
@ -68,7 +68,6 @@ func checkOpaqueness(t *testing.T, path string, opaque string) {
if string(xattrOpaque) != opaque { if string(xattrOpaque) != opaque {
t.Fatalf("Unexpected opaque value: %q, expected %q", string(xattrOpaque), opaque) t.Fatalf("Unexpected opaque value: %q, expected %q", string(xattrOpaque), opaque)
} }
} }
func checkOverlayWhiteout(t *testing.T, path string) { func checkOverlayWhiteout(t *testing.T, path string) {
@ -118,11 +117,11 @@ func TestOverlayTarUntar(t *testing.T) {
err = Untar(archive, dst, options) err = Untar(archive, dst, options)
require.NoError(t, err) require.NoError(t, err)
checkFileMode(t, filepath.Join(dst, "d1"), 0700|os.ModeDir) checkFileMode(t, filepath.Join(dst, "d1"), 0o700|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d2"), 0750|os.ModeDir) checkFileMode(t, filepath.Join(dst, "d2"), 0o750|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d3"), 0700|os.ModeDir) checkFileMode(t, filepath.Join(dst, "d3"), 0o700|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d1", "f1"), 0600) checkFileMode(t, filepath.Join(dst, "d1", "f1"), 0o600)
checkFileMode(t, filepath.Join(dst, "d2", "f1"), 0660) checkFileMode(t, filepath.Join(dst, "d2", "f1"), 0o660)
checkFileMode(t, filepath.Join(dst, "d3", "f1"), os.ModeCharDevice|os.ModeDevice) checkFileMode(t, filepath.Join(dst, "d3", "f1"), os.ModeCharDevice|os.ModeDevice)
checkOpaqueness(t, filepath.Join(dst, "d1"), "y") checkOpaqueness(t, filepath.Join(dst, "d1"), "y")
@ -158,12 +157,12 @@ func TestOverlayTarAUFSUntar(t *testing.T) {
}) })
require.NoError(t, err) require.NoError(t, err)
checkFileMode(t, filepath.Join(dst, "d1"), 0700|os.ModeDir) checkFileMode(t, filepath.Join(dst, "d1"), 0o700|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d1", WhiteoutOpaqueDir), 0700) checkFileMode(t, filepath.Join(dst, "d1", WhiteoutOpaqueDir), 0o700)
checkFileMode(t, filepath.Join(dst, "d2"), 0750|os.ModeDir) checkFileMode(t, filepath.Join(dst, "d2"), 0o750|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d3"), 0700|os.ModeDir) checkFileMode(t, filepath.Join(dst, "d3"), 0o700|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d1", "f1"), 0600) checkFileMode(t, filepath.Join(dst, "d1", "f1"), 0o600)
checkFileMode(t, filepath.Join(dst, "d2", "f1"), 0660) checkFileMode(t, filepath.Join(dst, "d2", "f1"), 0o660)
checkFileMode(t, filepath.Join(dst, "d3", WhiteoutPrefix+"f1"), 0) checkFileMode(t, filepath.Join(dst, "d3", WhiteoutPrefix+"f1"), 0)
} }

118
pkg/archive/archive_test.go
View File

@ -186,6 +186,7 @@ func TestExtensionUncompressed(t *testing.T) {
t.Fatalf("The extension of an uncompressed archive should be 'tar'.") t.Fatalf("The extension of an uncompressed archive should be 'tar'.")
} }
} }
func TestExtensionBzip2(t *testing.T) { func TestExtensionBzip2(t *testing.T) {
compression := Bzip2 compression := Bzip2
output := compression.Extension() output := compression.Extension()
@ -193,6 +194,7 @@ func TestExtensionBzip2(t *testing.T) {
t.Fatalf("The extension of a bzip2 archive should be 'tar.bz2'") t.Fatalf("The extension of a bzip2 archive should be 'tar.bz2'")
} }
} }
func TestExtensionGzip(t *testing.T) { func TestExtensionGzip(t *testing.T) {
compression := Gzip compression := Gzip
output := compression.Extension() output := compression.Extension()
@ -200,6 +202,7 @@ func TestExtensionGzip(t *testing.T) {
t.Fatalf("The extension of a bzip2 archive should be 'tar.gz'") t.Fatalf("The extension of a bzip2 archive should be 'tar.gz'")
} }
} }
func TestExtensionXz(t *testing.T) { func TestExtensionXz(t *testing.T) {
compression := Xz compression := Xz
output := compression.Extension() output := compression.Extension()
@ -258,7 +261,7 @@ func TestUntarPath(t *testing.T) {
createEmptyFile(t, filepath.Join(tmpFolder, "src")) createEmptyFile(t, filepath.Join(tmpFolder, "src"))
destFolder := filepath.Join(tmpFolder, "dest") destFolder := filepath.Join(tmpFolder, "dest")
err := os.MkdirAll(destFolder, 0740) err := os.MkdirAll(destFolder, 0o740)
if err != nil { if err != nil {
t.Fatalf("Fail to create the destination file") t.Fatalf("Fail to create the destination file")
} }
@ -335,13 +338,13 @@ func TestUntarPathWithDestinationSrcFileAsFolder(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
destFolder := filepath.Join(tmpFolder, "dest") destFolder := filepath.Join(tmpFolder, "dest")
err = os.MkdirAll(destFolder, 0740) err = os.MkdirAll(destFolder, 0o740)
if err != nil { if err != nil {
t.Fatalf("Fail to create the destination folder") 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) // Let's create a folder that will has the same path as the extracted file (from tar)
destSrcFileAsFolder := filepath.Join(destFolder, srcFileU) destSrcFileAsFolder := filepath.Join(destFolder, srcFileU)
err = os.MkdirAll(destSrcFileAsFolder, 0740) err = os.MkdirAll(destSrcFileAsFolder, 0o740)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -355,7 +358,7 @@ func TestCopyWithTarInvalidSrc(t *testing.T) {
tempFolder := t.TempDir() tempFolder := t.TempDir()
destFolder := filepath.Join(tempFolder, "dest") destFolder := filepath.Join(tempFolder, "dest")
invalidSrc := filepath.Join(tempFolder, "doesnotexists") invalidSrc := filepath.Join(tempFolder, "doesnotexists")
err := os.MkdirAll(destFolder, 0740) err := os.MkdirAll(destFolder, 0o740)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -369,7 +372,7 @@ func TestCopyWithTarInexistentDestWillCreateIt(t *testing.T) {
tempFolder := t.TempDir() tempFolder := t.TempDir()
srcFolder := filepath.Join(tempFolder, "src") srcFolder := filepath.Join(tempFolder, "src")
inexistentDestFolder := filepath.Join(tempFolder, "doesnotexists") inexistentDestFolder := filepath.Join(tempFolder, "doesnotexists")
err := os.MkdirAll(srcFolder, 0740) err := os.MkdirAll(srcFolder, 0o740)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -389,15 +392,15 @@ func TestCopyWithTarSrcFile(t *testing.T) {
dest := filepath.Join(folder, "dest") dest := filepath.Join(folder, "dest")
srcFolder := filepath.Join(folder, "src") srcFolder := filepath.Join(folder, "src")
src := filepath.Join(folder, filepath.Join("src", "src")) src := filepath.Join(folder, filepath.Join("src", "src"))
err := os.MkdirAll(srcFolder, 0740) err := os.MkdirAll(srcFolder, 0o740)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
err = os.MkdirAll(dest, 0740) err = os.MkdirAll(dest, 0o740)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
err = os.WriteFile(src, []byte("content"), 0777) err = os.WriteFile(src, []byte("content"), 0o777)
if err != nil { if err != nil {
t.Fatalf("archiver.CopyWithTar couldn't write content, %s.", err) t.Fatalf("archiver.CopyWithTar couldn't write content, %s.", err)
} }
@ -415,7 +418,7 @@ func TestCopyWithTarSrcFile(t *testing.T) {
if err != nil { if err != nil {
t.Fatalf("archiver.CopyWithTar shouldn't have thrown an error, %s.", err) t.Fatalf("archiver.CopyWithTar shouldn't have thrown an error, %s.", err)
} }
err = os.WriteFile(dest, []byte("modified content"), 0751) err = os.WriteFile(dest, []byte("modified content"), 0o751)
if err != nil { if err != nil {
t.Fatalf("archiver.CopyWithTar couldn't write modified content, %s.", err) t.Fatalf("archiver.CopyWithTar couldn't write modified content, %s.", err)
} }
@ -450,15 +453,15 @@ func TestCopyWithTarSrcFolder(t *testing.T) {
folder := t.TempDir() folder := t.TempDir()
dest := filepath.Join(folder, "dest") dest := filepath.Join(folder, "dest")
src := filepath.Join(folder, filepath.Join("src", "folder")) src := filepath.Join(folder, filepath.Join("src", "folder"))
err := os.MkdirAll(src, 0740) err := os.MkdirAll(src, 0o740)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
err = os.MkdirAll(dest, 0740) err = os.MkdirAll(dest, 0o740)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
err = os.WriteFile(filepath.Join(src, "file"), []byte("content"), 0777) err = os.WriteFile(filepath.Join(src, "file"), []byte("content"), 0o777)
require.NoError(t, err) require.NoError(t, err)
err = defaultCopyWithTar(src, dest) err = defaultCopyWithTar(src, dest)
if err != nil { if err != nil {
@ -474,7 +477,7 @@ func TestCopyWithTarSrcFolder(t *testing.T) {
func TestCopyFileWithTarInvalidSrc(t *testing.T) { func TestCopyFileWithTarInvalidSrc(t *testing.T) {
tempFolder := t.TempDir() tempFolder := t.TempDir()
destFolder := filepath.Join(tempFolder, "dest") destFolder := filepath.Join(tempFolder, "dest")
err := os.MkdirAll(destFolder, 0740) err := os.MkdirAll(destFolder, 0o740)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -505,11 +508,11 @@ func TestCopyFileWithTarSrcFolder(t *testing.T) {
folder := t.TempDir() folder := t.TempDir()
dest := filepath.Join(folder, "dest") dest := filepath.Join(folder, "dest")
src := filepath.Join(folder, "srcfolder") src := filepath.Join(folder, "srcfolder")
err := os.MkdirAll(src, 0740) err := os.MkdirAll(src, 0o740)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
err = os.MkdirAll(dest, 0740) err = os.MkdirAll(dest, 0o740)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -524,15 +527,15 @@ func TestCopyFileWithTarSrcFile(t *testing.T) {
dest := filepath.Join(folder, "dest") dest := filepath.Join(folder, "dest")
srcFolder := filepath.Join(folder, "src") srcFolder := filepath.Join(folder, "src")
src := filepath.Join(folder, filepath.Join("src", "src")) src := filepath.Join(folder, filepath.Join("src", "src"))
err := os.MkdirAll(srcFolder, 0740) err := os.MkdirAll(srcFolder, 0o740)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
err = os.MkdirAll(dest, 0740) err = os.MkdirAll(dest, 0o740)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
err = os.WriteFile(src, []byte("content"), 0777) err = os.WriteFile(src, []byte("content"), 0o777)
require.NoError(t, err) require.NoError(t, err)
err = defaultCopyWithTar(src, dest+"/") err = defaultCopyWithTar(src, dest+"/")
if err != nil { if err != nil {
@ -548,7 +551,7 @@ func TestCopySocket(t *testing.T) {
folder := t.TempDir() folder := t.TempDir()
dest := filepath.Join(folder, "dest") dest := filepath.Join(folder, "dest")
src := filepath.Join(folder, "src") src := filepath.Join(folder, "src")
err := os.MkdirAll(src, 0740) err := os.MkdirAll(src, 0o740)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -558,7 +561,7 @@ func TestCopySocket(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
err = os.MkdirAll(dest, 0740) err = os.MkdirAll(dest, 0o740)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -647,13 +650,13 @@ func TestTarUntar(t *testing.T) {
t.Skip("Failing on Windows") t.Skip("Failing on Windows")
} }
origin := t.TempDir() origin := t.TempDir()
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) 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) 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) t.Fatal(err)
} }
@ -665,7 +668,6 @@ func TestTarUntar(t *testing.T) {
Compression: c, Compression: c,
ExcludePatterns: []string{"3"}, ExcludePatterns: []string{"3"},
}) })
if err != nil { if err != nil {
t.Fatalf("Error tar/untar for compression %s: %s", c.Extension(), err) t.Fatalf("Error tar/untar for compression %s: %s", c.Extension(), err)
} }
@ -679,7 +681,7 @@ func TestTarUntar(t *testing.T) {
func TestTarWithOptionsChownOptsAlwaysOverridesIdPair(t *testing.T) { func TestTarWithOptionsChownOptsAlwaysOverridesIdPair(t *testing.T) {
origin := t.TempDir() origin := t.TempDir()
filePath := filepath.Join(origin, "1") filePath := filepath.Join(origin, "1")
err := os.WriteFile(filePath, []byte("hello world"), 0700) err := os.WriteFile(filePath, []byte("hello world"), 0o700)
require.NoError(t, err) require.NoError(t, err)
idMaps := []idtools.IDMap{ idMaps := []idtools.IDMap{
@ -733,10 +735,10 @@ func TestTarWithOptions(t *testing.T) {
if _, err := os.MkdirTemp(origin, "folder"); err != nil { if _, err := os.MkdirTemp(origin, "folder"); err != nil {
t.Fatal(err) t.Fatal(err)
} }
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) 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) t.Fatal(err)
} }
@ -810,7 +812,7 @@ func prepareUntarSourceDirectory(numberOfFiles int, targetPath string, makeLinks
fileData := []byte("fooo") fileData := []byte("fooo")
for n := 0; n < numberOfFiles; n++ { for n := 0; n < numberOfFiles; n++ {
fileName := fmt.Sprintf("file-%d", 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 return 0, err
} }
if makeLinks { if makeLinks {
@ -872,7 +874,7 @@ func TestUntarSelinuxLabel(t *testing.T) {
{ {
Name: "foo", Name: "foo",
Typeflag: tar.TypeReg, Typeflag: tar.TypeReg,
Mode: 0644, Mode: 0o644,
PAXRecords: xattrs, PAXRecords: xattrs,
}, },
}, },
@ -893,7 +895,7 @@ func TestUntarInvalidFilenames(t *testing.T) {
{ {
Name: "../victim/dotdot", Name: "../victim/dotdot",
Typeflag: tar.TypeReg, Typeflag: tar.TypeReg,
Mode: 0644, Mode: 0o644,
}, },
}, },
{ {
@ -901,7 +903,7 @@ func TestUntarInvalidFilenames(t *testing.T) {
// Note the leading slash // Note the leading slash
Name: "/../victim/slash-dotdot", Name: "/../victim/slash-dotdot",
Typeflag: tar.TypeReg, Typeflag: tar.TypeReg,
Mode: 0644, Mode: 0o644,
}, },
}, },
} { } {
@ -922,18 +924,18 @@ func TestUntarHardlinkToSymlink(t *testing.T) {
Name: "symlink1", Name: "symlink1",
Typeflag: tar.TypeSymlink, Typeflag: tar.TypeSymlink,
Linkname: "regfile", Linkname: "regfile",
Mode: 0644, Mode: 0o644,
}, },
{ {
Name: "symlink2", Name: "symlink2",
Typeflag: tar.TypeLink, Typeflag: tar.TypeLink,
Linkname: "symlink1", Linkname: "symlink1",
Mode: 0644, Mode: 0o644,
}, },
{ {
Name: "regfile", Name: "regfile",
Typeflag: tar.TypeReg, Typeflag: tar.TypeReg,
Mode: 0644, Mode: 0o644,
}, },
}, },
} { } {
@ -954,7 +956,7 @@ func TestUntarInvalidHardlink(t *testing.T) {
Name: "dotdot", Name: "dotdot",
Typeflag: tar.TypeLink, Typeflag: tar.TypeLink,
Linkname: "../victim/hello", Linkname: "../victim/hello",
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // try reading victim/hello (/../) { // try reading victim/hello (/../)
@ -963,7 +965,7 @@ func TestUntarInvalidHardlink(t *testing.T) {
Typeflag: tar.TypeLink, Typeflag: tar.TypeLink,
// Note the leading slash // Note the leading slash
Linkname: "/../victim/hello", Linkname: "/../victim/hello",
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // try writing victim/file { // try writing victim/file
@ -971,12 +973,12 @@ func TestUntarInvalidHardlink(t *testing.T) {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeLink, Typeflag: tar.TypeLink,
Linkname: "../victim", Linkname: "../victim",
Mode: 0755, Mode: 0o755,
}, },
{ {
Name: "loophole-victim/file", Name: "loophole-victim/file",
Typeflag: tar.TypeReg, Typeflag: tar.TypeReg,
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // try reading victim/hello (hardlink, symlink) { // try reading victim/hello (hardlink, symlink)
@ -984,13 +986,13 @@ func TestUntarInvalidHardlink(t *testing.T) {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeLink, Typeflag: tar.TypeLink,
Linkname: "../victim", Linkname: "../victim",
Mode: 0755, Mode: 0o755,
}, },
{ {
Name: "symlink", Name: "symlink",
Typeflag: tar.TypeSymlink, Typeflag: tar.TypeSymlink,
Linkname: "loophole-victim/hello", Linkname: "loophole-victim/hello",
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // Try reading victim/hello (hardlink, hardlink) { // Try reading victim/hello (hardlink, hardlink)
@ -998,13 +1000,13 @@ func TestUntarInvalidHardlink(t *testing.T) {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeLink, Typeflag: tar.TypeLink,
Linkname: "../victim", Linkname: "../victim",
Mode: 0755, Mode: 0o755,
}, },
{ {
Name: "hardlink", Name: "hardlink",
Typeflag: tar.TypeLink, Typeflag: tar.TypeLink,
Linkname: "loophole-victim/hello", Linkname: "loophole-victim/hello",
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // Try removing victim directory (hardlink) { // Try removing victim directory (hardlink)
@ -1012,12 +1014,12 @@ func TestUntarInvalidHardlink(t *testing.T) {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeLink, Typeflag: tar.TypeLink,
Linkname: "../victim", Linkname: "../victim",
Mode: 0755, Mode: 0o755,
}, },
{ {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeReg, Typeflag: tar.TypeReg,
Mode: 0644, Mode: 0o644,
}, },
}, },
} { } {
@ -1038,7 +1040,7 @@ func TestUntarInvalidSymlink(t *testing.T) {
Name: "dotdot", Name: "dotdot",
Typeflag: tar.TypeSymlink, Typeflag: tar.TypeSymlink,
Linkname: "../victim/hello", Linkname: "../victim/hello",
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // try reading victim/hello (/../) { // try reading victim/hello (/../)
@ -1047,7 +1049,7 @@ func TestUntarInvalidSymlink(t *testing.T) {
Typeflag: tar.TypeSymlink, Typeflag: tar.TypeSymlink,
// Note the leading slash // Note the leading slash
Linkname: "/../victim/hello", Linkname: "/../victim/hello",
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // try writing victim/file { // try writing victim/file
@ -1055,12 +1057,12 @@ func TestUntarInvalidSymlink(t *testing.T) {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeSymlink, Typeflag: tar.TypeSymlink,
Linkname: "../victim", Linkname: "../victim",
Mode: 0755, Mode: 0o755,
}, },
{ {
Name: "loophole-victim/file", Name: "loophole-victim/file",
Typeflag: tar.TypeReg, Typeflag: tar.TypeReg,
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // try reading victim/hello (symlink, symlink) { // try reading victim/hello (symlink, symlink)
@ -1068,13 +1070,13 @@ func TestUntarInvalidSymlink(t *testing.T) {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeSymlink, Typeflag: tar.TypeSymlink,
Linkname: "../victim", Linkname: "../victim",
Mode: 0755, Mode: 0o755,
}, },
{ {
Name: "symlink", Name: "symlink",
Typeflag: tar.TypeSymlink, Typeflag: tar.TypeSymlink,
Linkname: "loophole-victim/hello", Linkname: "loophole-victim/hello",
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // try reading victim/hello (symlink, hardlink) { // try reading victim/hello (symlink, hardlink)
@ -1082,13 +1084,13 @@ func TestUntarInvalidSymlink(t *testing.T) {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeSymlink, Typeflag: tar.TypeSymlink,
Linkname: "../victim", Linkname: "../victim",
Mode: 0755, Mode: 0o755,
}, },
{ {
Name: "hardlink", Name: "hardlink",
Typeflag: tar.TypeLink, Typeflag: tar.TypeLink,
Linkname: "loophole-victim/hello", Linkname: "loophole-victim/hello",
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // try removing victim directory (symlink) { // try removing victim directory (symlink)
@ -1096,12 +1098,12 @@ func TestUntarInvalidSymlink(t *testing.T) {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeSymlink, Typeflag: tar.TypeSymlink,
Linkname: "../victim", Linkname: "../victim",
Mode: 0755, Mode: 0o755,
}, },
{ {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeReg, Typeflag: tar.TypeReg,
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // try writing to victim/newdir/newfile with a symlink in the path { // try writing to victim/newdir/newfile with a symlink in the path
@ -1110,12 +1112,12 @@ func TestUntarInvalidSymlink(t *testing.T) {
Name: "dir/loophole", Name: "dir/loophole",
Typeflag: tar.TypeSymlink, Typeflag: tar.TypeSymlink,
Linkname: "../../victim", Linkname: "../../victim",
Mode: 0755, Mode: 0o755,
}, },
{ {
Name: "dir/loophole/newdir/newfile", Name: "dir/loophole/newdir/newfile",
Typeflag: tar.TypeReg, Typeflag: tar.TypeReg,
Mode: 0644, Mode: 0o644,
}, },
}, },
} { } {
@ -1209,7 +1211,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) { func createOrReplaceModifier(path string, header *tar.Header, content io.Reader) (*tar.Header, []byte, error) {
return &tar.Header{ return &tar.Header{
Mode: 0600, Mode: 0o600,
Typeflag: tar.TypeReg, Typeflag: tar.TypeReg,
}, []byte("the new content"), nil }, []byte("the new content"), nil
} }
@ -1229,7 +1231,7 @@ func appendModifier(path string, header *tar.Header, content io.Reader) (*tar.He
} }
} }
buffer.WriteString("\nnext line") 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 { func readFileFromArchive(t *testing.T, archive io.ReadCloser, name string, expectedCount int, doc string) string {

2
pkg/archive/archive_unix.go
View File

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

25
pkg/archive/archive_unix_test.go
View File

@ -59,11 +59,11 @@ func TestChmodTarEntry(t *testing.T) {
cases := []struct { cases := []struct {
in, expected os.FileMode in, expected os.FileMode
}{ }{
{0000, 0000}, {0o000, 0o000},
{0777, 0777}, {0o777, 0o777},
{0644, 0644}, {0o644, 0o644},
{0755, 0755}, {0o755, 0o755},
{0444, 0444}, {0o444, 0o444},
} }
for _, v := range cases { for _, v := range cases {
if out := chmodTarEntry(v.in); out != v.expected { if out := chmodTarEntry(v.in); out != v.expected {
@ -75,7 +75,7 @@ func TestChmodTarEntry(t *testing.T) {
func TestTarWithHardLink(t *testing.T) { func TestTarWithHardLink(t *testing.T) {
origin := t.TempDir() origin := t.TempDir()
err := os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0700) err := os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0o700)
require.NoError(t, err) require.NoError(t, err)
err = os.Link(filepath.Join(origin, "1"), filepath.Join(origin, "2")) err = os.Link(filepath.Join(origin, "1"), filepath.Join(origin, "2"))
@ -117,10 +117,10 @@ func TestTarWithHardLinkAndRebase(t *testing.T) {
tmpDir := t.TempDir() tmpDir := t.TempDir()
origin := filepath.Join(tmpDir, "origin") origin := filepath.Join(tmpDir, "origin")
err := os.Mkdir(origin, 0700) err := os.Mkdir(origin, 0o700)
require.NoError(t, err) require.NoError(t, err)
err = os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0700) err = os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0o700)
require.NoError(t, err) require.NoError(t, err)
err = os.Link(filepath.Join(origin, "1"), filepath.Join(origin, "2")) err = os.Link(filepath.Join(origin, "1"), filepath.Join(origin, "2"))
@ -181,7 +181,7 @@ func getInode(path string) (uint64, error) {
func TestTarWithBlockCharFifo(t *testing.T) { func TestTarWithBlockCharFifo(t *testing.T) {
origin := t.TempDir() origin := t.TempDir()
err := os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0700) err := os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0o700)
require.NoError(t, err) require.NoError(t, err)
err = system.Mknod(filepath.Join(origin, "2"), unix.S_IFBLK, system.Mkdev(int64(12), int64(5))) err = system.Mknod(filepath.Join(origin, "2"), unix.S_IFBLK, system.Mkdev(int64(12), int64(5)))
@ -222,12 +222,12 @@ func TestTarUntarWithXattr(t *testing.T) {
t.Skip() t.Skip()
} }
origin := t.TempDir() origin := t.TempDir()
err := os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0700) err := os.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0o700)
require.NoError(t, err) require.NoError(t, err)
err = os.WriteFile(filepath.Join(origin, "2"), []byte("welcome!"), 0700) err = os.WriteFile(filepath.Join(origin, "2"), []byte("welcome!"), 0o700)
require.NoError(t, err) require.NoError(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)
require.NoError(t, err) require.NoError(t, err)
encoded := [20]byte{0, 0, 0, 2} encoded := [20]byte{0, 0, 0, 2}
err = system.Lsetxattr(filepath.Join(origin, "2"), "security.capability", encoded[:], 0) err = system.Lsetxattr(filepath.Join(origin, "2"), "security.capability", encoded[:], 0)
@ -241,7 +241,6 @@ func TestTarUntarWithXattr(t *testing.T) {
Compression: c, Compression: c,
ExcludePatterns: []string{"3"}, ExcludePatterns: []string{"3"},
}) })
if err != nil { if err != nil {
t.Fatalf("Error tar/untar for compression %s: %s", c.Extension(), err) t.Fatalf("Error tar/untar for compression %s: %s", c.Extension(), err)
} }

7
pkg/archive/archive_windows.go
View File

@ -38,18 +38,17 @@ func CanonicalTarNameForPath(p string) (string, error) {
return "", fmt.Errorf("windows path contains forward slash: %s", p) return "", fmt.Errorf("windows path contains forward slash: %s", p)
} }
return strings.Replace(p, string(os.PathSeparator), "/", -1), nil return strings.Replace(p, string(os.PathSeparator), "/", -1), nil
} }
// chmodTarEntry is used to adjust the file permissions used in tar header based // chmodTarEntry is used to adjust the file permissions used in tar header based
// on the platform the archival is done. // on the platform the archival is done.
func chmodTarEntry(perm os.FileMode) os.FileMode { func chmodTarEntry(perm os.FileMode) os.FileMode {
//perm &= 0755 // this 0-ed out tar flags (like link, regular file, directory marker etc.) // perm &= 0755 // this 0-ed out tar flags (like link, regular file, directory marker etc.)
permPart := perm & os.ModePerm permPart := perm & os.ModePerm
noPermPart := perm &^ os.ModePerm noPermPart := perm &^ os.ModePerm
// Add the x bit: make everything +x from windows // Add the x bit: make everything +x from windows
permPart |= 0111 permPart |= 0o111
permPart &= 0755 permPart &= 0o755
return noPermPart | permPart return noPermPart | permPart
} }

18
pkg/archive/archive_windows_test.go
View File

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

14
pkg/archive/changes.go
View File

@ -131,9 +131,11 @@ func isENOTDIR(err error) bool {
return false return false
} }
type skipChange func(string) (bool, error) type (
type deleteChange func(string, string, os.FileInfo) (string, error) skipChange func(string) (bool, error)
type whiteoutChange func(string, string) (bool, error) deleteChange func(string, string, os.FileInfo) (string, error)
whiteoutChange func(string, string) (bool, error)
)
func changes(layers []string, rw string, dc deleteChange, sc skipChange, wc whiteoutChange) ([]Change, error) { func changes(layers []string, rw string, dc deleteChange, sc skipChange, wc whiteoutChange) ([]Change, error) {
var ( var (
@ -299,7 +301,6 @@ func (info *FileInfo) path() string {
} }
func (info *FileInfo) addChanges(oldInfo *FileInfo, changes *[]Change) { func (info *FileInfo) addChanges(oldInfo *FileInfo, changes *[]Change) {
sizeAtEntry := len(*changes) sizeAtEntry := len(*changes)
if oldInfo == nil { if oldInfo == nil {
@ -373,7 +374,6 @@ func (info *FileInfo) addChanges(oldInfo *FileInfo, changes *[]Change) {
copy((*changes)[sizeAtEntry+1:], (*changes)[sizeAtEntry:]) copy((*changes)[sizeAtEntry+1:], (*changes)[sizeAtEntry:])
(*changes)[sizeAtEntry] = change (*changes)[sizeAtEntry] = change
} }
} }
// Changes add changes to file information. // Changes add changes to file information.
@ -398,9 +398,7 @@ func newRootFileInfo(idMappings *idtools.IDMappings) *FileInfo {
// ChangesDirs compares two directories and generates an array of Change objects describing the changes. // 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. // If oldDir is "", then all files in newDir will be Add-Changes.
func ChangesDirs(newDir string, newMappings *idtools.IDMappings, oldDir string, oldMappings *idtools.IDMappings) ([]Change, error) { func ChangesDirs(newDir string, newMappings *idtools.IDMappings, oldDir string, oldMappings *idtools.IDMappings) ([]Change, error) {
var ( var oldRoot, newRoot *FileInfo
oldRoot, newRoot *FileInfo
)
if oldDir == "" { if oldDir == "" {
emptyDir, err := os.MkdirTemp("", "empty") emptyDir, err := os.MkdirTemp("", "empty")
if err != nil { if err != nil {

4
pkg/archive/changes_bsd_test.go
View File

@ -62,7 +62,7 @@ func TestApplyToImmutable(t *testing.T) {
createSampleDir(t, src) createSampleDir(t, src)
file1 := path.Join(src, "dir1/file1-1") file1 := path.Join(src, "dir1/file1-1")
file2 := path.Join(src, "dir1/file1-2") file2 := path.Join(src, "dir1/file1-2")
require.NoError(t, os.Chmod(file1, 0777)) require.NoError(t, os.Chmod(file1, 0o777))
require.NoError(t, system.Lchflags(file1, system.SF_IMMUTABLE)) require.NoError(t, system.Lchflags(file1, system.SF_IMMUTABLE))
require.NoError(t, system.Lchflags(file2, system.SF_IMMUTABLE)) require.NoError(t, system.Lchflags(file2, system.SF_IMMUTABLE))
@ -73,7 +73,7 @@ func TestApplyToImmutable(t *testing.T) {
file1 = path.Join(dst, "dir1/file1-1") file1 = path.Join(dst, "dir1/file1-1")
file2 = path.Join(dst, "dir1/file1-2") file2 = path.Join(dst, "dir1/file1-2")
require.NoError(t, system.Lchflags(file1, 0)) require.NoError(t, system.Lchflags(file1, 0))
require.NoError(t, os.Chmod(file1, 0666)) require.NoError(t, os.Chmod(file1, 0o666))
require.NoError(t, system.Lchflags(file2, 0)) require.NoError(t, system.Lchflags(file2, 0))
require.NoError(t, os.RemoveAll(file2)) require.NoError(t, os.RemoveAll(file2))

1
pkg/archive/changes_linux.go
View File

@ -397,5 +397,4 @@ func overlayDeletedFile(layers []string, root, path string, fi os.FileInfo) (str
// We didn't find the same path in any older layers, so it was new in this one. // We didn't find the same path in any older layers, so it was new in this one.
return "", nil return "", nil
} }

3
pkg/archive/changes_posix_test.go
View File

@ -14,7 +14,7 @@ import (
) )
func TestHardLinkOrder(t *testing.T) { func TestHardLinkOrder(t *testing.T) {
//TODO Should run for Solaris // TODO Should run for Solaris
if runtime.GOOS == "solaris" { if runtime.GOOS == "solaris" {
t.Skip("gcp failures on Solaris") t.Skip("gcp failures on Solaris")
} }
@ -99,7 +99,6 @@ func TestHardLinkOrder(t *testing.T) {
t.Errorf("headers - %q expected linkname %q; but got %q", hdrs[i].Name, hdrs[i].Linkname, hdrsRev[i].Linkname) t.Errorf("headers - %q expected linkname %q; but got %q", hdrs[i].Name, hdrs[i].Linkname, hdrsRev[i].Linkname)
} }
} }
} }
type tarHeaders []tar.Header type tarHeaders []tar.Header

84
pkg/archive/changes_test.go
View File

@ -50,30 +50,30 @@ type FileData struct {
func createSampleDir(t *testing.T, root string) { func createSampleDir(t *testing.T, root string) {
files := []FileData{ files := []FileData{
{Regular, "file1", "file1\n", 0600}, {Regular, "file1", "file1\n", 0o600},
{Regular, "file2", "file2\n", 0666}, {Regular, "file2", "file2\n", 0o666},
{Regular, "file3", "file3\n", 0404}, {Regular, "file3", "file3\n", 0o404},
{Regular, "file4", "file4\n", 0600}, {Regular, "file4", "file4\n", 0o600},
{Regular, "file5", "file5\n", 0600}, {Regular, "file5", "file5\n", 0o600},
{Regular, "file6", "file6\n", 0600}, {Regular, "file6", "file6\n", 0o600},
{Regular, "file7", "file7\n", 0600}, {Regular, "file7", "file7\n", 0o600},
{Dir, "dir1", "", 0740}, {Dir, "dir1", "", 0o740},
{Regular, "dir1/file1-1", "file1-1\n", 01444}, {Regular, "dir1/file1-1", "file1-1\n", 0o1444},
{Regular, "dir1/file1-2", "file1-2\n", 0666}, {Regular, "dir1/file1-2", "file1-2\n", 0o666},
{Dir, "dir2", "", 0700}, {Dir, "dir2", "", 0o700},
{Regular, "dir2/file2-1", "file2-1\n", 0666}, {Regular, "dir2/file2-1", "file2-1\n", 0o666},
{Regular, "dir2/file2-2", "file2-2\n", 0666}, {Regular, "dir2/file2-2", "file2-2\n", 0o666},
{Dir, "dir3", "", 0700}, {Dir, "dir3", "", 0o700},
{Regular, "dir3/file3-1", "file3-1\n", 0666}, {Regular, "dir3/file3-1", "file3-1\n", 0o666},
{Regular, "dir3/file3-2", "file3-2\n", 0666}, {Regular, "dir3/file3-2", "file3-2\n", 0o666},
{Dir, "dir4", "", 0700}, {Dir, "dir4", "", 0o700},
{Regular, "dir4/file3-1", "file4-1\n", 0666}, {Regular, "dir4/file3-1", "file4-1\n", 0o666},
{Regular, "dir4/file3-2", "file4-2\n", 0666}, {Regular, "dir4/file3-2", "file4-2\n", 0o666},
{Symlink, "symlink1", "target1", 0666}, {Symlink, "symlink1", "target1", 0o666},
{Symlink, "symlink2", "target2", 0666}, {Symlink, "symlink2", "target2", 0o666},
{Symlink, "symlink3", root + "/file1", 0666}, {Symlink, "symlink3", root + "/file1", 0o666},
{Symlink, "symlink4", root + "/symlink3", 0666}, {Symlink, "symlink4", root + "/symlink3", 0o666},
{Symlink, "dirSymlink", root + "/dir1", 0740}, {Symlink, "dirSymlink", root + "/dir1", 0o740},
} }
now := time.Now() now := time.Now()
@ -141,7 +141,7 @@ func TestChangesWithChanges(t *testing.T) {
// Mock the readonly layer // Mock the readonly layer
layer := t.TempDir() layer := t.TempDir()
createSampleDir(t, layer) createSampleDir(t, layer)
err := os.MkdirAll(path.Join(layer, "dir1/subfolder"), 0740) err := os.MkdirAll(path.Join(layer, "dir1/subfolder"), 0o740)
require.NoError(t, err) require.NoError(t, err)
// Mock the RW layer // Mock the RW layer
@ -149,20 +149,20 @@ func TestChangesWithChanges(t *testing.T) {
// Create a folder in RW layer // Create a folder in RW layer
dir1 := path.Join(rwLayer, "dir1") dir1 := path.Join(rwLayer, "dir1")
err = os.MkdirAll(dir1, 0740) err = os.MkdirAll(dir1, 0o740)
require.NoError(t, err) require.NoError(t, err)
deletedFile := path.Join(dir1, ".wh.file1-2") deletedFile := path.Join(dir1, ".wh.file1-2")
err = os.WriteFile(deletedFile, []byte{}, 0600) err = os.WriteFile(deletedFile, []byte{}, 0o600)
require.NoError(t, err) require.NoError(t, err)
modifiedFile := path.Join(dir1, "file1-1") modifiedFile := path.Join(dir1, "file1-1")
err = os.WriteFile(modifiedFile, []byte{0x00}, 01444) err = os.WriteFile(modifiedFile, []byte{0x00}, 0o1444)
require.NoError(t, err) require.NoError(t, err)
// Let's add a subfolder for a newFile // Let's add a subfolder for a newFile
subfolder := path.Join(dir1, "subfolder") subfolder := path.Join(dir1, "subfolder")
err = os.MkdirAll(subfolder, 0740) err = os.MkdirAll(subfolder, 0o740)
require.NoError(t, err) require.NoError(t, err)
newFile := path.Join(subfolder, "newFile") newFile := path.Join(subfolder, "newFile")
err = os.WriteFile(newFile, []byte{}, 0740) err = os.WriteFile(newFile, []byte{}, 0o740)
require.NoError(t, err) require.NoError(t, err)
changes, err := Changes([]string{layer}, rwLayer) changes, err := Changes([]string{layer}, rwLayer)
@ -188,11 +188,11 @@ func TestChangesWithChangesGH13590(t *testing.T) {
baseLayer := t.TempDir() baseLayer := t.TempDir()
dir3 := path.Join(baseLayer, "dir1/dir2/dir3") dir3 := path.Join(baseLayer, "dir1/dir2/dir3")
err := os.MkdirAll(dir3, 07400) err := os.MkdirAll(dir3, 0o7400)
require.NoError(t, err) require.NoError(t, err)
file := path.Join(dir3, "file.txt") file := path.Join(dir3, "file.txt")
err = os.WriteFile(file, []byte("hello"), 0666) err = os.WriteFile(file, []byte("hello"), 0o666)
require.NoError(t, err) require.NoError(t, err)
layer := t.TempDir() layer := t.TempDir()
@ -204,7 +204,7 @@ func TestChangesWithChangesGH13590(t *testing.T) {
os.Remove(path.Join(layer, "dir1/dir2/dir3/file.txt")) os.Remove(path.Join(layer, "dir1/dir2/dir3/file.txt"))
file = path.Join(layer, "dir1/dir2/dir3/file1.txt") file = path.Join(layer, "dir1/dir2/dir3/file1.txt")
err = os.WriteFile(file, []byte("bye"), 0666) err = os.WriteFile(file, []byte("bye"), 0o666)
require.NoError(t, err) require.NoError(t, err)
changes, err := Changes([]string{baseLayer}, layer) changes, err := Changes([]string{baseLayer}, layer)
@ -226,7 +226,7 @@ func TestChangesWithChangesGH13590(t *testing.T) {
} }
file = path.Join(layer, "dir1/dir2/dir3/file.txt") file = path.Join(layer, "dir1/dir2/dir3/file.txt")
err = os.WriteFile(file, []byte("bye"), 0666) err = os.WriteFile(file, []byte("bye"), 0o666)
require.NoError(t, err) require.NoError(t, err)
changes, err = Changes([]string{baseLayer}, layer) changes, err = Changes([]string{baseLayer}, layer)
@ -273,13 +273,13 @@ func mutateSampleDir(t *testing.T, root string) {
require.NoError(t, err) require.NoError(t, err)
// Rewrite a file // 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)
require.NoError(t, err) require.NoError(t, err)
// Replace a file // Replace a file
err = os.RemoveAll(path.Join(root, "file3")) err = os.RemoveAll(path.Join(root, "file3"))
require.NoError(t, err) require.NoError(t, err)
err = os.WriteFile(path.Join(root, "file3"), []byte("fileMM\n"), 0404) err = os.WriteFile(path.Join(root, "file3"), []byte("fileMM\n"), 0o404)
require.NoError(t, err) require.NoError(t, err)
// Touch file // Touch file
@ -289,15 +289,15 @@ func mutateSampleDir(t *testing.T, root string) {
// Replace file with dir // Replace file with dir
err = os.RemoveAll(path.Join(root, "file5")) err = os.RemoveAll(path.Join(root, "file5"))
require.NoError(t, err) require.NoError(t, err)
err = os.MkdirAll(path.Join(root, "file5"), 0666) err = os.MkdirAll(path.Join(root, "file5"), 0o666)
require.NoError(t, err) require.NoError(t, err)
// Create new file // 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)
require.NoError(t, err) require.NoError(t, err)
// Create new dir // Create new dir
err = os.MkdirAll(path.Join(root, "dirnew"), 0766) err = os.MkdirAll(path.Join(root, "dirnew"), 0o766)
require.NoError(t, err) require.NoError(t, err)
// Create a new symlink // Create a new symlink
@ -314,7 +314,7 @@ func mutateSampleDir(t *testing.T, root string) {
// Replace dir with file // Replace dir with file
err = os.RemoveAll(path.Join(root, "dir2")) err = os.RemoveAll(path.Join(root, "dir2"))
require.NoError(t, err) require.NoError(t, err)
err = os.WriteFile(path.Join(root, "dir2"), []byte("dir2\n"), 0777) err = os.WriteFile(path.Join(root, "dir2"), []byte("dir2\n"), 0o777)
require.NoError(t, err) require.NoError(t, err)
// Touch dir // Touch dir
@ -451,10 +451,10 @@ func TestChangesSizeWithOnlyDeleteChanges(t *testing.T) {
func TestChangesSize(t *testing.T) { func TestChangesSize(t *testing.T) {
parentPath := t.TempDir() parentPath := t.TempDir()
addition := path.Join(parentPath, "addition") addition := path.Join(parentPath, "addition")
err := os.WriteFile(addition, []byte{0x01, 0x01, 0x01}, 0744) err := os.WriteFile(addition, []byte{0x01, 0x01, 0x01}, 0o744)
require.NoError(t, err) require.NoError(t, err)
modification := path.Join(parentPath, "modification") modification := path.Join(parentPath, "modification")
err = os.WriteFile(modification, []byte{0x01, 0x01, 0x01}, 0744) err = os.WriteFile(modification, []byte{0x01, 0x01, 0x01}, 0o744)
require.NoError(t, err) require.NoError(t, err)
changes := []Change{ changes := []Change{

1
pkg/archive/changes_windows.go
View File

@ -7,7 +7,6 @@ import (
) )
func statDifferent(oldStat *system.StatT, oldInfo *FileInfo, newStat *system.StatT, newInfo *FileInfo) bool { func statDifferent(oldStat *system.StatT, oldInfo *FileInfo, newStat *system.StatT, newInfo *FileInfo) bool {
// Don't look at size for dirs, its not a good measure of change // Don't look at size for dirs, its not a good measure of change
if oldStat.Mtim() != newStat.Mtim() || if oldStat.Mtim() != newStat.Mtim() ||
oldStat.Mode() != newStat.Mode() || oldStat.Mode() != newStat.Mode() ||

1
pkg/archive/copy.go
View File

@ -297,7 +297,6 @@ func PrepareArchiveCopy(srcContent io.Reader, srcInfo, dstInfo CopyInfo) (dstDir
} }
return dstDir, RebaseArchiveEntries(srcContent, srcBase, dstBase), nil return dstDir, RebaseArchiveEntries(srcContent, srcBase, dstBase), nil
} }
} }
// RebaseArchiveEntries rewrites the given srcContent archive replacing // RebaseArchiveEntries rewrites the given srcContent archive replacing

17
pkg/archive/copy_unix_test.go
View File

@ -328,7 +328,6 @@ func TestCopyCaseB(t *testing.T) {
if err != ErrDirNotExists { if err != ErrDirNotExists {
t.Fatalf("expected ErrDirNotExists error, but got %T: %s", err, err) t.Fatalf("expected ErrDirNotExists error, but got %T: %s", err, err)
} }
} }
// C. SRC specifies a file and DST exists as a file. This should overwrite // C. SRC specifies a file and DST exists as a file. This should overwrite
@ -431,7 +430,7 @@ func TestCopyCaseD(t *testing.T) {
t.Fatalf("unable to remove dstDir: %s", err) 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) t.Fatalf("unable to make dstDir: %s", err)
} }
@ -482,7 +481,7 @@ func TestCopyCaseDFSym(t *testing.T) {
t.Fatalf("unable to remove dstDir: %s", err) 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) t.Fatalf("unable to make dstDir: %s", err)
} }
@ -648,7 +647,7 @@ func TestCopyCaseG(t *testing.T) {
t.Fatalf("unable to remove dstDir: %s", err) 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) t.Fatalf("unable to make dstDir: %s", err)
} }
@ -694,7 +693,7 @@ func TestCopyCaseGFSym(t *testing.T) {
t.Fatalf("unable to remove dstDir: %s", err) 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) t.Fatalf("unable to make dstDir: %s", err)
} }
@ -857,7 +856,7 @@ func TestCopyCaseJ(t *testing.T) {
var err error var err error
// first to create an empty dir // 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) t.Fatalf("unable to make dstDir: %s", err)
} }
@ -874,7 +873,7 @@ func TestCopyCaseJ(t *testing.T) {
t.Fatalf("unable to remove dstDir: %s", err) 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) t.Fatalf("unable to make dstDir: %s", err)
} }
@ -908,7 +907,7 @@ func TestCopyCaseJFSym(t *testing.T) {
var err error var err error
// first to create an empty dir // 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) t.Fatalf("unable to make dstDir: %s", err)
} }
@ -925,7 +924,7 @@ func TestCopyCaseJFSym(t *testing.T) {
t.Fatalf("unable to remove dstDir: %s", err) 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) t.Fatalf("unable to make dstDir: %s", err)
} }

2
pkg/archive/diff.go
View File

@ -85,7 +85,7 @@ func UnpackLayer(dest string, layer io.Reader, options *TarOptions) (size int64,
parentPath := filepath.Join(dest, parent) parentPath := filepath.Join(dest, parent)
if _, err := os.Lstat(parentPath); err != nil && os.IsNotExist(err) { if _, err := os.Lstat(parentPath); err != nil && os.IsNotExist(err) {
err = os.MkdirAll(parentPath, 0755) err = os.MkdirAll(parentPath, 0o755)
if err != nil { if err != nil {
return 0, err return 0, err
} }

49
pkg/archive/diff_test.go
View File

@ -23,7 +23,7 @@ func TestApplyLayerInvalidFilenames(t *testing.T) {
{ {
Name: "../victim/dotdot", Name: "../victim/dotdot",
Typeflag: tar.TypeReg, Typeflag: tar.TypeReg,
Mode: 0644, Mode: 0o644,
}, },
}, },
{ {
@ -31,7 +31,7 @@ func TestApplyLayerInvalidFilenames(t *testing.T) {
// Note the leading slash // Note the leading slash
Name: "/../victim/slash-dotdot", Name: "/../victim/slash-dotdot",
Typeflag: tar.TypeReg, Typeflag: tar.TypeReg,
Mode: 0644, Mode: 0o644,
}, },
}, },
} { } {
@ -51,7 +51,7 @@ func TestApplyLayerInvalidHardlink(t *testing.T) {
Name: "dotdot", Name: "dotdot",
Typeflag: tar.TypeLink, Typeflag: tar.TypeLink,
Linkname: "../victim/hello", Linkname: "../victim/hello",
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // try reading victim/hello (/../) { // try reading victim/hello (/../)
@ -60,7 +60,7 @@ func TestApplyLayerInvalidHardlink(t *testing.T) {
Typeflag: tar.TypeLink, Typeflag: tar.TypeLink,
// Note the leading slash // Note the leading slash
Linkname: "/../victim/hello", Linkname: "/../victim/hello",
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // try writing victim/file { // try writing victim/file
@ -68,12 +68,12 @@ func TestApplyLayerInvalidHardlink(t *testing.T) {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeLink, Typeflag: tar.TypeLink,
Linkname: "../victim", Linkname: "../victim",
Mode: 0755, Mode: 0o755,
}, },
{ {
Name: "loophole-victim/file", Name: "loophole-victim/file",
Typeflag: tar.TypeReg, Typeflag: tar.TypeReg,
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // try reading victim/hello (hardlink, symlink) { // try reading victim/hello (hardlink, symlink)
@ -81,13 +81,13 @@ func TestApplyLayerInvalidHardlink(t *testing.T) {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeLink, Typeflag: tar.TypeLink,
Linkname: "../victim", Linkname: "../victim",
Mode: 0755, Mode: 0o755,
}, },
{ {
Name: "symlink", Name: "symlink",
Typeflag: tar.TypeSymlink, Typeflag: tar.TypeSymlink,
Linkname: "loophole-victim/hello", Linkname: "loophole-victim/hello",
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // Try reading victim/hello (hardlink, hardlink) { // Try reading victim/hello (hardlink, hardlink)
@ -95,13 +95,13 @@ func TestApplyLayerInvalidHardlink(t *testing.T) {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeLink, Typeflag: tar.TypeLink,
Linkname: "../victim", Linkname: "../victim",
Mode: 0755, Mode: 0o755,
}, },
{ {
Name: "hardlink", Name: "hardlink",
Typeflag: tar.TypeLink, Typeflag: tar.TypeLink,
Linkname: "loophole-victim/hello", Linkname: "loophole-victim/hello",
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // Try removing victim directory (hardlink) { // Try removing victim directory (hardlink)
@ -109,12 +109,12 @@ func TestApplyLayerInvalidHardlink(t *testing.T) {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeLink, Typeflag: tar.TypeLink,
Linkname: "../victim", Linkname: "../victim",
Mode: 0755, Mode: 0o755,
}, },
{ {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeReg, Typeflag: tar.TypeReg,
Mode: 0644, Mode: 0o644,
}, },
}, },
} { } {
@ -134,7 +134,7 @@ func TestApplyLayerInvalidSymlink(t *testing.T) {
Name: "dotdot", Name: "dotdot",
Typeflag: tar.TypeSymlink, Typeflag: tar.TypeSymlink,
Linkname: "../victim/hello", Linkname: "../victim/hello",
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // try reading victim/hello (/../) { // try reading victim/hello (/../)
@ -143,7 +143,7 @@ func TestApplyLayerInvalidSymlink(t *testing.T) {
Typeflag: tar.TypeSymlink, Typeflag: tar.TypeSymlink,
// Note the leading slash // Note the leading slash
Linkname: "/../victim/hello", Linkname: "/../victim/hello",
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // try writing victim/file { // try writing victim/file
@ -151,12 +151,12 @@ func TestApplyLayerInvalidSymlink(t *testing.T) {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeSymlink, Typeflag: tar.TypeSymlink,
Linkname: "../victim", Linkname: "../victim",
Mode: 0755, Mode: 0o755,
}, },
{ {
Name: "loophole-victim/file", Name: "loophole-victim/file",
Typeflag: tar.TypeReg, Typeflag: tar.TypeReg,
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // try reading victim/hello (symlink, symlink) { // try reading victim/hello (symlink, symlink)
@ -164,13 +164,13 @@ func TestApplyLayerInvalidSymlink(t *testing.T) {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeSymlink, Typeflag: tar.TypeSymlink,
Linkname: "../victim", Linkname: "../victim",
Mode: 0755, Mode: 0o755,
}, },
{ {
Name: "symlink", Name: "symlink",
Typeflag: tar.TypeSymlink, Typeflag: tar.TypeSymlink,
Linkname: "loophole-victim/hello", Linkname: "loophole-victim/hello",
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // try reading victim/hello (symlink, hardlink) { // try reading victim/hello (symlink, hardlink)
@ -178,13 +178,13 @@ func TestApplyLayerInvalidSymlink(t *testing.T) {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeSymlink, Typeflag: tar.TypeSymlink,
Linkname: "../victim", Linkname: "../victim",
Mode: 0755, Mode: 0o755,
}, },
{ {
Name: "hardlink", Name: "hardlink",
Typeflag: tar.TypeLink, Typeflag: tar.TypeLink,
Linkname: "loophole-victim/hello", Linkname: "loophole-victim/hello",
Mode: 0644, Mode: 0o644,
}, },
}, },
{ // try removing victim directory (symlink) { // try removing victim directory (symlink)
@ -192,12 +192,12 @@ func TestApplyLayerInvalidSymlink(t *testing.T) {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeSymlink, Typeflag: tar.TypeSymlink,
Linkname: "../victim", Linkname: "../victim",
Mode: 0755, Mode: 0o755,
}, },
{ {
Name: "loophole-victim", Name: "loophole-victim",
Typeflag: tar.TypeReg, Typeflag: tar.TypeReg,
Mode: 0644, Mode: 0o644,
}, },
}, },
} { } {
@ -321,18 +321,17 @@ func TestApplyLayerWhiteouts(t *testing.T) {
t.Fatalf("invalid files for layer %d: expected %q, got %q", i, tc.expected, paths) t.Fatalf("invalid files for layer %d: expected %q, got %q", i, tc.expected, paths)
} }
} }
} }
func makeTestLayer(t *testing.T, paths []string) (rc io.ReadCloser, err error) { func makeTestLayer(t *testing.T, paths []string) (rc io.ReadCloser, err error) {
tmpDir := t.TempDir() tmpDir := t.TempDir()
for _, p := range paths { for _, p := range paths {
if p[len(p)-1] == filepath.Separator { if p[len(p)-1] == filepath.Separator {
if err = os.MkdirAll(filepath.Join(tmpDir, p), 0700); err != nil { if err = os.MkdirAll(filepath.Join(tmpDir, p), 0o700); err != nil {
return return
} }
} else { } 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 return
} }
} }

2
pkg/archive/example_changes.go
View File

@ -83,7 +83,7 @@ func prepareUntarSourceDirectory(numberOfFiles int, targetPath string, makeLinks
fileData := []byte("fooo") fileData := []byte("fooo")
for n := 0; n < numberOfFiles; n++ { for n := 0; n < numberOfFiles; n++ {
fileName := fmt.Sprintf("file-%d", 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 return 0, err
} }
if makeLinks { if makeLinks {

2
pkg/archive/fflags_bsd.go
View File

@ -98,7 +98,7 @@ func parseFileFlags(fflags string) (uint32, uint32, error) {
} }
func formatFileFlags(fflags uint32) (string, error) { func formatFileFlags(fflags uint32) (string, error) {
var res = []string{} res := []string{}
for fflags != 0 { for fflags != 0 {
// Extract lowest set bit // Extract lowest set bit
fflag := uint32(1) << bits.TrailingZeros32(fflags) fflag := uint32(1) << bits.TrailingZeros32(fflags)

6
pkg/archive/utils_test.go
View File

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

2
pkg/chrootarchive/archive.go
View File

@ -77,7 +77,7 @@ func untarHandler(tarArchive io.Reader, dest string, options *archive.TarOptions
dest = filepath.Clean(dest) dest = filepath.Clean(dest)
if _, err := os.Stat(dest); os.IsNotExist(err) { if _, err := os.Stat(dest); os.IsNotExist(err) {
if err := idtools.MkdirAllAndChownNew(dest, 0755, rootIDs); err != nil { if err := idtools.MkdirAllAndChownNew(dest, 0o755, rootIDs); err != nil {
return err return err
} }
} }

3
pkg/chrootarchive/archive_darwin.go
View File

@ -8,7 +8,8 @@ import (
func invokeUnpack(decompressedArchive io.Reader, func invokeUnpack(decompressedArchive io.Reader,
dest string, dest string,
options *archive.TarOptions, root string) error { options *archive.TarOptions, root string,
) error {
return archive.Unpack(decompressedArchive, dest, options) return archive.Unpack(decompressedArchive, dest, options)
} }

49
pkg/chrootarchive/archive_test.go
View File

@ -49,13 +49,13 @@ func CopyWithTar(src, dst string) error {
func TestChrootTarUntar(t *testing.T) { func TestChrootTarUntar(t *testing.T) {
tmpdir := t.TempDir() tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "src") src := filepath.Join(tmpdir, "src")
if err := os.MkdirAll(src, 0700); err != nil { if err := os.MkdirAll(src, 0o700); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := os.WriteFile(filepath.Join(src, "toto"), []byte("hello toto"), 0644); err != nil { if err := os.WriteFile(filepath.Join(src, "toto"), []byte("hello toto"), 0o644); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := os.WriteFile(filepath.Join(src, "lolo"), []byte("hello lolo"), 0644); err != nil { if err := os.WriteFile(filepath.Join(src, "lolo"), []byte("hello lolo"), 0o644); err != nil {
t.Fatal(err) t.Fatal(err)
} }
stream, err := archive.Tar(src, archive.Uncompressed) stream, err := archive.Tar(src, archive.Uncompressed)
@ -63,7 +63,7 @@ func TestChrootTarUntar(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
dest := filepath.Join(tmpdir, "src") dest := filepath.Join(tmpdir, "src")
if err := os.MkdirAll(dest, 0700); err != nil { if err := os.MkdirAll(dest, 0o700); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := Untar(stream, dest, &archive.TarOptions{ExcludePatterns: []string{"lolo"}}); err != nil { if err := Untar(stream, dest, &archive.TarOptions{ExcludePatterns: []string{"lolo"}}); err != nil {
@ -76,10 +76,10 @@ func TestChrootTarUntar(t *testing.T) {
func TestChrootUntarWithHugeExcludesList(t *testing.T) { func TestChrootUntarWithHugeExcludesList(t *testing.T) {
tmpdir := t.TempDir() tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "src") src := filepath.Join(tmpdir, "src")
if err := os.MkdirAll(src, 0700); err != nil { if err := os.MkdirAll(src, 0o700); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := os.WriteFile(filepath.Join(src, "toto"), []byte("hello toto"), 0644); err != nil { if err := os.WriteFile(filepath.Join(src, "toto"), []byte("hello toto"), 0o644); err != nil {
t.Fatal(err) t.Fatal(err)
} }
stream, err := archive.Tar(src, archive.Uncompressed) stream, err := archive.Tar(src, archive.Uncompressed)
@ -87,12 +87,12 @@ func TestChrootUntarWithHugeExcludesList(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
dest := filepath.Join(tmpdir, "dest") dest := filepath.Join(tmpdir, "dest")
if err := os.MkdirAll(dest, 0700); err != nil { if err := os.MkdirAll(dest, 0o700); err != nil {
t.Fatal(err) t.Fatal(err)
} }
options := &archive.TarOptions{} options := &archive.TarOptions{}
//65534 entries of 64-byte strings ~= 4MB of environment space which should overflow // 65534 entries of 64-byte strings ~= 4MB of environment space which should overflow
//on most systems when passed via environment or command line arguments // on most systems when passed via environment or command line arguments
excludes := make([]string, 65534) excludes := make([]string, 65534)
for i := 0; i < 65534; i++ { for i := 0; i < 65534; i++ {
excludes[i] = strings.Repeat(fmt.Sprintf("%d", i), 64) excludes[i] = strings.Repeat(fmt.Sprintf("%d", i), 64)
@ -114,7 +114,7 @@ func prepareSourceDirectory(numberOfFiles int, targetPath string, makeSymLinks b
fileData := []byte("fooo") fileData := []byte("fooo")
for n := 0; n < numberOfFiles; n++ { for n := 0; n < numberOfFiles; n++ {
fileName := fmt.Sprintf("file-%d", 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 return 0, err
} }
if makeSymLinks { if makeSymLinks {
@ -190,7 +190,6 @@ func compareFilesChown(src string, dest string, uid, gid int) error {
} }
} }
return err return err
} }
func TestChrootTarUntarWithSymlink(t *testing.T) { func TestChrootTarUntarWithSymlink(t *testing.T) {
@ -200,7 +199,7 @@ func TestChrootTarUntarWithSymlink(t *testing.T) {
} }
tmpdir := t.TempDir() tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "src") src := filepath.Join(tmpdir, "src")
if err := os.MkdirAll(src, 0700); err != nil { if err := os.MkdirAll(src, 0o700); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if _, err := prepareSourceDirectory(10, src, false); err != nil { if _, err := prepareSourceDirectory(10, src, false); err != nil {
@ -222,7 +221,7 @@ func TestChrootCopyWithTar(t *testing.T) {
} }
tmpdir := t.TempDir() tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "src") src := filepath.Join(tmpdir, "src")
if err := os.MkdirAll(src, 0700); err != nil { if err := os.MkdirAll(src, 0o700); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if _, err := prepareSourceDirectory(10, src, true); err != nil { if _, err := prepareSourceDirectory(10, src, true); err != nil {
@ -268,7 +267,7 @@ func TestChrootCopyWithTarAndChown(t *testing.T) {
} }
tmpdir := t.TempDir() tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "src") src := filepath.Join(tmpdir, "src")
if err := os.MkdirAll(src, 0700); err != nil { if err := os.MkdirAll(src, 0o700); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if _, err := prepareSourceDirectory(10, src, true); err != nil { if _, err := prepareSourceDirectory(10, src, true); err != nil {
@ -316,7 +315,7 @@ func TestChrootCopyWithTarAndChown(t *testing.T) {
func TestChrootCopyFileWithTar(t *testing.T) { func TestChrootCopyFileWithTar(t *testing.T) {
tmpdir := t.TempDir() tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "src") src := filepath.Join(tmpdir, "src")
if err := os.MkdirAll(src, 0700); err != nil { if err := os.MkdirAll(src, 0o700); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if _, err := prepareSourceDirectory(10, src, true); err != nil { if _, err := prepareSourceDirectory(10, src, true); err != nil {
@ -355,7 +354,7 @@ func TestChrootCopyFileWithTar(t *testing.T) {
func TestChrootCopyFileWithTarAndChown(t *testing.T) { func TestChrootCopyFileWithTarAndChown(t *testing.T) {
tmpdir := t.TempDir() tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "src") src := filepath.Join(tmpdir, "src")
if err := os.MkdirAll(src, 0700); err != nil { if err := os.MkdirAll(src, 0o700); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if _, err := prepareSourceDirectory(10, src, true); err != nil { if _, err := prepareSourceDirectory(10, src, true); err != nil {
@ -405,7 +404,7 @@ func TestChrootUntarPath(t *testing.T) {
} }
tmpdir := t.TempDir() tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "src") src := filepath.Join(tmpdir, "src")
if err := os.MkdirAll(src, 0700); err != nil { if err := os.MkdirAll(src, 0o700); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if _, err := prepareSourceDirectory(10, src, false); err != nil { if _, err := prepareSourceDirectory(10, src, false); err != nil {
@ -427,7 +426,7 @@ func TestChrootUntarPath(t *testing.T) {
_, err = buf.ReadFrom(stream) _, err = buf.ReadFrom(stream)
require.NoError(t, err) require.NoError(t, err)
tarfile := filepath.Join(tmpdir, "src.tar") tarfile := filepath.Join(tmpdir, "src.tar")
if err := os.WriteFile(tarfile, buf.Bytes(), 0644); err != nil { if err := os.WriteFile(tarfile, buf.Bytes(), 0o644); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := UntarPath(tarfile, dest); err != nil { if err := UntarPath(tarfile, dest); err != nil {
@ -445,7 +444,7 @@ func TestChrootUntarPathAndChown(t *testing.T) {
} }
tmpdir := t.TempDir() tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "src") src := filepath.Join(tmpdir, "src")
if err := os.MkdirAll(src, 0700); err != nil { if err := os.MkdirAll(src, 0o700); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if _, err := prepareSourceDirectory(10, src, false); err != nil { if _, err := prepareSourceDirectory(10, src, false); err != nil {
@ -477,7 +476,7 @@ func TestChrootUntarPathAndChown(t *testing.T) {
_, err = buf.ReadFrom(stream) _, err = buf.ReadFrom(stream)
require.NoError(t, err) require.NoError(t, err)
tarfile := filepath.Join(tmpdir, "src.tar") tarfile := filepath.Join(tmpdir, "src.tar")
if err := os.WriteFile(tarfile, buf.Bytes(), 0644); err != nil { if err := os.WriteFile(tarfile, buf.Bytes(), 0o644); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := untarFunc(tarfile, dest); err != nil { if err := untarFunc(tarfile, dest); err != nil {
@ -514,7 +513,7 @@ func (s *slowEmptyTarReader) Read(p []byte) (int, error) {
func TestChrootUntarEmptyArchiveFromSlowReader(t *testing.T) { func TestChrootUntarEmptyArchiveFromSlowReader(t *testing.T) {
tmpdir := t.TempDir() tmpdir := t.TempDir()
dest := filepath.Join(tmpdir, "dest") dest := filepath.Join(tmpdir, "dest")
if err := os.MkdirAll(dest, 0700); err != nil { if err := os.MkdirAll(dest, 0o700); err != nil {
t.Fatal(err) t.Fatal(err)
} }
stream := &slowEmptyTarReader{size: 10240, chunkSize: 1024} stream := &slowEmptyTarReader{size: 10240, chunkSize: 1024}
@ -526,7 +525,7 @@ func TestChrootUntarEmptyArchiveFromSlowReader(t *testing.T) {
func TestChrootApplyEmptyArchiveFromSlowReader(t *testing.T) { func TestChrootApplyEmptyArchiveFromSlowReader(t *testing.T) {
tmpdir := t.TempDir() tmpdir := t.TempDir()
dest := filepath.Join(tmpdir, "dest") dest := filepath.Join(tmpdir, "dest")
if err := os.MkdirAll(dest, 0700); err != nil { if err := os.MkdirAll(dest, 0o700); err != nil {
t.Fatal(err) t.Fatal(err)
} }
stream := &slowEmptyTarReader{size: 10240, chunkSize: 1024} stream := &slowEmptyTarReader{size: 10240, chunkSize: 1024}
@ -538,10 +537,10 @@ func TestChrootApplyEmptyArchiveFromSlowReader(t *testing.T) {
func TestChrootApplyDotDotFile(t *testing.T) { func TestChrootApplyDotDotFile(t *testing.T) {
tmpdir := t.TempDir() tmpdir := t.TempDir()
src := filepath.Join(tmpdir, "src") src := filepath.Join(tmpdir, "src")
if err := os.MkdirAll(src, 0700); err != nil { if err := os.MkdirAll(src, 0o700); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := os.WriteFile(filepath.Join(src, "..gitme"), []byte(""), 0644); err != nil { if err := os.WriteFile(filepath.Join(src, "..gitme"), []byte(""), 0o644); err != nil {
t.Fatal(err) t.Fatal(err)
} }
stream, err := archive.Tar(src, archive.Uncompressed) stream, err := archive.Tar(src, archive.Uncompressed)
@ -549,7 +548,7 @@ func TestChrootApplyDotDotFile(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
dest := filepath.Join(tmpdir, "dest") dest := filepath.Join(tmpdir, "dest")
if err := os.MkdirAll(dest, 0700); err != nil { if err := os.MkdirAll(dest, 0o700); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if _, err := ApplyLayer(dest, stream); err != nil { if _, err := ApplyLayer(dest, stream); err != nil {

4
pkg/chrootarchive/archive_unix.go
View File

@ -27,7 +27,7 @@ func untar() {
var options archive.TarOptions var options archive.TarOptions
//read the options from the pipe "ExtraFiles" // read the options from the pipe "ExtraFiles"
if err := json.NewDecoder(os.NewFile(3, "options")).Decode(&options); err != nil { if err := json.NewDecoder(os.NewFile(3, "options")).Decode(&options); err != nil {
fatal(err) fatal(err)
} }
@ -99,7 +99,7 @@ func invokeUnpack(decompressedArchive io.Reader, dest string, options *archive.T
return fmt.Errorf("untar error on re-exec cmd: %w", err) return fmt.Errorf("untar error on re-exec cmd: %w", err)
} }
//write the options to the pipe for the untar exec to read // write the options to the pipe for the untar exec to read
if err := json.NewEncoder(w).Encode(options); err != nil { if err := json.NewEncoder(w).Encode(options); err != nil {
w.Close() w.Close()
return fmt.Errorf("untar json encode to pipe failed: %w", err) return fmt.Errorf("untar json encode to pipe failed: %w", err)

14
pkg/chrootarchive/archive_unix_test.go
View File

@ -26,12 +26,12 @@ func TestUntarWithMaliciousSymlinks(t *testing.T) {
dir := t.TempDir() dir := t.TempDir()
root := filepath.Join(dir, "root") root := filepath.Join(dir, "root")
err := os.MkdirAll(root, 0755) err := os.MkdirAll(root, 0o755)
assert.NilError(t, err) assert.NilError(t, err)
// Add a file into a directory above root // Add a file into a directory above root
// Ensure that we can't access this file while tarring. // Ensure that we can't access this file while tarring.
err = os.WriteFile(filepath.Join(dir, "host-file"), []byte("I am a host file"), 0644) err = os.WriteFile(filepath.Join(dir, "host-file"), []byte("I am a host file"), 0o644)
assert.NilError(t, err) assert.NilError(t, err)
// Create some data which will be copied into the "container" root into // Create some data which will be copied into the "container" root into
@ -39,9 +39,9 @@ func TestUntarWithMaliciousSymlinks(t *testing.T) {
// Before this change, the copy would overwrite the "host" content. // Before this change, the copy would overwrite the "host" content.
// With this change it should not. // With this change it should not.
data := filepath.Join(dir, "data") data := filepath.Join(dir, "data")
err = os.MkdirAll(data, 0755) err = os.MkdirAll(data, 0o755)
assert.NilError(t, err) assert.NilError(t, err)
err = os.WriteFile(filepath.Join(data, "local-file"), []byte("pwn3d"), 0644) err = os.WriteFile(filepath.Join(data, "local-file"), []byte("pwn3d"), 0o644)
assert.NilError(t, err) assert.NilError(t, err)
safe := filepath.Join(root, "safe") safe := filepath.Join(root, "safe")
@ -86,14 +86,14 @@ func TestTarWithMaliciousSymlinks(t *testing.T) {
root := filepath.Join(dir, "root") root := filepath.Join(dir, "root")
err := os.MkdirAll(root, 0755) err := os.MkdirAll(root, 0o755)
assert.NilError(t, err) assert.NilError(t, err)
hostFileData := []byte("I am a host file") hostFileData := []byte("I am a host file")
// Add a file into a directory above root // Add a file into a directory above root
// Ensure that we can't access this file while tarring. // Ensure that we can't access this file while tarring.
err = os.WriteFile(filepath.Join(dir, "host-file"), hostFileData, 0644) err = os.WriteFile(filepath.Join(dir, "host-file"), hostFileData, 0o644)
assert.NilError(t, err) assert.NilError(t, err)
safe := filepath.Join(root, "safe") safe := filepath.Join(root, "safe")
@ -101,7 +101,7 @@ func TestTarWithMaliciousSymlinks(t *testing.T) {
assert.NilError(t, err) assert.NilError(t, err)
data := filepath.Join(dir, "data") data := filepath.Join(dir, "data")
err = os.MkdirAll(data, 0755) err = os.MkdirAll(data, 0o755)
assert.NilError(t, err) assert.NilError(t, err)
type testCase struct { type testCase struct {

3
pkg/chrootarchive/archive_windows.go
View File

@ -14,7 +14,8 @@ func chroot(path string) error {
func invokeUnpack(decompressedArchive io.Reader, func invokeUnpack(decompressedArchive io.Reader,
dest string, dest string,
options *archive.TarOptions, root string) error { options *archive.TarOptions, root string,
) error {
// Windows is different to Linux here because Windows does not support // Windows is different to Linux here because Windows does not support
// chroot. Hence there is no point sandboxing a chrooted process to // chroot. Hence there is no point sandboxing a chrooted process to
// do the unpack. We call inline instead within the daemon process. // do the unpack. We call inline instead within the daemon process.

1
pkg/chrootarchive/diff_unix.go
View File

@ -26,7 +26,6 @@ type applyLayerResponse struct {
// used on Windows as it does not support chroot, hence no point sandboxing // used on Windows as it does not support chroot, hence no point sandboxing
// through chroot and rexec. // through chroot and rexec.
func applyLayer() { func applyLayer() {
var ( var (
tmpDir string tmpDir string
err error err error

6
pkg/chunked/cache_linux.go
View File

@ -48,8 +48,10 @@ type layersCache struct {
created time.Time created time.Time
} }
var cacheMutex sync.Mutex var (
var cache *layersCache cacheMutex sync.Mutex
cache *layersCache
)
func (c *layersCache) release() { func (c *layersCache) release() {
cacheMutex.Lock() cacheMutex.Lock()

6
pkg/chunked/compressor/compressor.go
View File

@ -15,8 +15,10 @@ import (
"github.com/vbatts/tar-split/archive/tar" "github.com/vbatts/tar-split/archive/tar"
) )
const RollsumBits = 16 const (
const holesThreshold = int64(1 << 10) RollsumBits = 16
holesThreshold = int64(1 << 10)
)
type holesFinder struct { type holesFinder struct {
reader *bufio.Reader reader *bufio.Reader

12
pkg/chunked/compressor/rollsum.go
View File

@ -25,11 +25,15 @@ import (
"math/bits" "math/bits"
) )
const windowSize = 64 // Roll assumes windowSize is a power of 2 const (
const charOffset = 31 windowSize = 64 // Roll assumes windowSize is a power of 2
charOffset = 31
)
const blobBits = 13 const (
const blobSize = 1 << blobBits // 8k blobBits = 13
blobSize = 1 << blobBits // 8k
)
type RollSum struct { type RollSum struct {
s1, s2 uint32 s1, s2 uint32

2
pkg/chunked/internal/compression.go
View File

@ -134,7 +134,7 @@ func WriteZstdChunkedManifest(dest io.Writer, outMetadata map[string]string, off
Entries: metadata, Entries: metadata,
} }
var json = jsoniter.ConfigCompatibleWithStandardLibrary json := jsoniter.ConfigCompatibleWithStandardLibrary
// Generate the manifest // Generate the manifest
manifest, err := json.Marshal(toc) manifest, err := json.Marshal(toc)
if err != nil { if err != nil {

6
pkg/chunked/storage_linux.go
View File

@ -558,7 +558,7 @@ func openFileUnderRootFallback(dirfd int, name string, flags uint64, mode os.Fil
func openFileUnderRootOpenat2(dirfd int, name string, flags uint64, mode os.FileMode) (int, error) { func openFileUnderRootOpenat2(dirfd int, name string, flags uint64, mode os.FileMode) (int, error) {
how := unix.OpenHow{ how := unix.OpenHow{
Flags: flags, Flags: flags,
Mode: uint64(mode & 07777), Mode: uint64(mode & 0o7777),
Resolve: unix.RESOLVE_IN_ROOT, Resolve: unix.RESOLVE_IN_ROOT,
} }
return unix.Openat2(dirfd, name, &how) return unix.Openat2(dirfd, name, &how)
@ -636,7 +636,7 @@ func openOrCreateDirUnderRoot(name string, dirfd int, mode os.FileMode) (*os.Fil
baseName := filepath.Base(name) baseName := filepath.Base(name)
if err2 := unix.Mkdirat(int(pDir.Fd()), baseName, 0755); err2 != nil { if err2 := unix.Mkdirat(int(pDir.Fd()), baseName, 0o755); err2 != nil {
return nil, err return nil, err
} }
@ -1384,7 +1384,7 @@ func (c *chunkedDiffer) ApplyDiff(dest string, options *archive.TarOptions) (gra
filesToWaitFor := 0 filesToWaitFor := 0
for i, r := range mergedEntries { for i, r := range mergedEntries {
if options.ForceMask != nil { if options.ForceMask != nil {
value := fmt.Sprintf("%d:%d:0%o", r.UID, r.GID, r.Mode&07777) value := fmt.Sprintf("%d:%d:0%o", r.UID, r.GID, r.Mode&0o7777)
r.Xattrs[containersOverrideXattr] = base64.StdEncoding.EncodeToString([]byte(value)) r.Xattrs[containersOverrideXattr] = base64.StdEncoding.EncodeToString([]byte(value))
r.Mode = int64(*options.ForceMask) r.Mode = int64(*options.ForceMask)
} }

6
pkg/chunked/zstdchunked_test.go
View File

@ -61,13 +61,13 @@ var someFiles = []internal.FileMetadata{
{ {
Type: "dir", Type: "dir",
Name: "/foo", Name: "/foo",
Mode: 0755, Mode: 0o755,
Size: 0, Size: 0,
}, },
{ {
Type: "reg", Type: "reg",
Name: "/foo/bar", Name: "/foo/bar",
Mode: 0755, Mode: 0o755,
Size: 10, Size: 10,
Digest: "sha256:5891b5b522d5df086d0ff0b110fbd9d21bb4fc7163af34d08286a2e846f6be03", Digest: "sha256:5891b5b522d5df086d0ff0b110fbd9d21bb4fc7163af34d08286a2e846f6be03",
Offset: 100, Offset: 100,
@ -79,7 +79,7 @@ var someFiles = []internal.FileMetadata{
{ {
Type: "reg", Type: "reg",
Name: "/foo/baz", Name: "/foo/baz",
Mode: 0755, Mode: 0o755,
Size: 12, Size: 12,
Digest: "sha256:6f0378f21a495f5c13247317d158e9d51da45a5bf68fc2f366e450deafdc8302", Digest: "sha256:6f0378f21a495f5c13247317d158e9d51da45a5bf68fc2f366e450deafdc8302",
Offset: 200, Offset: 200,

3
pkg/config/config_test.go
View File

@ -123,7 +123,6 @@ func TestDeviceMapperOptions(t *testing.T) {
if !searchOptions(doptions, s100) { if !searchOptions(doptions, s100) {
t.Fatalf("Expected to find size %q, got %v", s100, doptions) t.Fatalf("Expected to find size %q, got %v", s100, doptions)
} }
} }
func TestBtrfsOptions(t *testing.T) { func TestBtrfsOptions(t *testing.T) {
@ -164,7 +163,6 @@ func TestBtrfsOptions(t *testing.T) {
if !searchOptions(doptions, s100) { if !searchOptions(doptions, s100) {
t.Fatalf("Expected to find size %q, got %v", s100, doptions) t.Fatalf("Expected to find size %q, got %v", s100, doptions)
} }
} }
func TestOverlayOptions(t *testing.T) { func TestOverlayOptions(t *testing.T) {
@ -281,7 +279,6 @@ func TestOverlayOptions(t *testing.T) {
if !searchOptions(doptions, s100) { if !searchOptions(doptions, s100) {
t.Fatalf("Expected to find size %q, got %v", s100, doptions) t.Fatalf("Expected to find size %q, got %v", s100, doptions)
} }
} }
func TestVfsOptions(t *testing.T) { func TestVfsOptions(t *testing.T) {

4
pkg/devicemapper/devmapper.go
View File

@ -239,8 +239,8 @@ func (t *Task) getDriverVersion() (string, error) {
} }
func (t *Task) getNextTarget(next unsafe.Pointer) (nextPtr unsafe.Pointer, start uint64, func (t *Task) getNextTarget(next unsafe.Pointer) (nextPtr unsafe.Pointer, start uint64,
length uint64, targetType string, params string) { length uint64, targetType string, params string,
) {
return DmGetNextTarget(t.unmanaged, next, &start, &length, return DmGetNextTarget(t.unmanaged, next, &start, &length,
&targetType, &params), &targetType, &params),
start, length, targetType, params start, length, targetType, params

4
pkg/devicemapper/devmapper_wrapper.go
View File

@ -138,8 +138,8 @@ func dmTaskSetRoFct(task *cdmTask) int {
} }
func dmTaskAddTargetFct(task *cdmTask, func dmTaskAddTargetFct(task *cdmTask,
start, size uint64, ttype, params string) int { start, size uint64, ttype, params string,
) int {
Cttype := C.CString(ttype) Cttype := C.CString(ttype)
defer free(Cttype) defer free(Cttype)

7
pkg/fileutils/fileutils.go
View File

@ -183,7 +183,6 @@ func (p *Pattern) Exclusion() bool {
} }
func (p *Pattern) match(path string) (bool, error) { func (p *Pattern) match(path string) (bool, error) {
if p.regexp == nil { if p.regexp == nil {
if err := p.compile(); err != nil { if err := p.compile(); err != nil {
return false, filepath.ErrBadPattern return false, filepath.ErrBadPattern
@ -356,12 +355,12 @@ func CreateIfNotExists(path string, isDir bool) error {
if _, err := os.Stat(path); err != nil { if _, err := os.Stat(path); err != nil {
if os.IsNotExist(err) { if os.IsNotExist(err) {
if isDir { if isDir {
return os.MkdirAll(path, 0755) return os.MkdirAll(path, 0o755)
} }
if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil { if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
return err return err
} }
f, err := os.OpenFile(path, os.O_CREATE, 0755) f, err := os.OpenFile(path, os.O_CREATE, 0o755)
if err != nil { if err != nil {
return err return err
} }

16
pkg/fileutils/fileutils_test.go
View File

@ -25,14 +25,13 @@ func TestCopyFileWithInvalidSrc(t *testing.T) {
if bytes != 0 { if bytes != 0 {
t.Fatal("Should have written 0 bytes") t.Fatal("Should have written 0 bytes")
} }
} }
// CopyFile with invalid dest // CopyFile with invalid dest
func TestCopyFileWithInvalidDest(t *testing.T) { func TestCopyFileWithInvalidDest(t *testing.T) {
tempFolder := t.TempDir() tempFolder := t.TempDir()
src := path.Join(tempFolder, "file") src := path.Join(tempFolder, "file")
err := os.WriteFile(src, []byte("content"), 0740) err := os.WriteFile(src, []byte("content"), 0o740)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -43,14 +42,13 @@ func TestCopyFileWithInvalidDest(t *testing.T) {
if bytes != 0 { if bytes != 0 {
t.Fatal("Should have written 0 bytes") t.Fatal("Should have written 0 bytes")
} }
} }
// CopyFile with same src and dest // CopyFile with same src and dest
func TestCopyFileWithSameSrcAndDest(t *testing.T) { func TestCopyFileWithSameSrcAndDest(t *testing.T) {
tempFolder := t.TempDir() tempFolder := t.TempDir()
file := path.Join(tempFolder, "file") file := path.Join(tempFolder, "file")
err := os.WriteFile(file, []byte("content"), 0740) err := os.WriteFile(file, []byte("content"), 0o740)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -67,13 +65,13 @@ func TestCopyFileWithSameSrcAndDest(t *testing.T) {
func TestCopyFileWithSameSrcAndDestWithPathNameDifferent(t *testing.T) { func TestCopyFileWithSameSrcAndDestWithPathNameDifferent(t *testing.T) {
tempFolder := t.TempDir() tempFolder := t.TempDir()
testFolder := path.Join(tempFolder, "test") testFolder := path.Join(tempFolder, "test")
err := os.MkdirAll(testFolder, 0740) err := os.MkdirAll(testFolder, 0o740)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
file := path.Join(testFolder, "file") file := path.Join(testFolder, "file")
sameFile := testFolder + "/../test/file" sameFile := testFolder + "/../test/file"
err = os.WriteFile(file, []byte("content"), 0740) err = os.WriteFile(file, []byte("content"), 0o740)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -90,10 +88,10 @@ func TestCopyFile(t *testing.T) {
tempFolder := t.TempDir() tempFolder := t.TempDir()
src := path.Join(tempFolder, "src") src := path.Join(tempFolder, "src")
dest := path.Join(tempFolder, "dest") dest := path.Join(tempFolder, "dest")
err := os.WriteFile(src, []byte("content"), 0777) err := os.WriteFile(src, []byte("content"), 0o777)
require.NoError(t, err) require.NoError(t, err)
err = os.WriteFile(dest, []byte("destContent"), 0777) err = os.WriteFile(dest, []byte("destContent"), 0o777)
require.NoError(t, err) require.NoError(t, err)
bytes, err := CopyFile(src, dest) bytes, err := CopyFile(src, dest)
if err != nil { if err != nil {
@ -118,7 +116,7 @@ func TestReadSymlinkedDirectoryExistingDirectory(t *testing.T) {
t.Skip("Needs porting to Windows") t.Skip("Needs porting to Windows")
} }
var err error var err error
if err = os.Mkdir("/tmp/testReadSymlinkToExistingDirectory", 0777); err != nil { if err = os.Mkdir("/tmp/testReadSymlinkToExistingDirectory", 0o777); err != nil {
t.Errorf("failed to create directory: %s", err) t.Errorf("failed to create directory: %s", err)
} }

4
pkg/idmap/idmapped_utils.go
View File

@ -104,7 +104,7 @@ func CreateIDMappedMount(source, target string, pid int) error {
&attr, uint(unsafe.Sizeof(attr))); err != nil { &attr, uint(unsafe.Sizeof(attr))); err != nil {
return err return err
} }
if err := os.Mkdir(target, 0700); err != nil && !os.IsExist(err) { if err := os.Mkdir(target, 0o700); err != nil && !os.IsExist(err) {
return err return err
} }
return moveMount(targetDirFd, target) return moveMount(targetDirFd, target)
@ -140,7 +140,7 @@ func CreateUsernsProcess(uidMaps []idtools.IDMap, gidMaps []idtools.IDMap) (int,
for _, m := range idmap { for _, m := range idmap {
mappings = mappings + fmt.Sprintf("%d %d %d\n", m.ContainerID, m.HostID, m.Size) mappings = mappings + fmt.Sprintf("%d %d %d\n", m.ContainerID, m.HostID, m.Size)
} }
return os.WriteFile(fmt.Sprintf("/proc/%d/%s", pid, fname), []byte(mappings), 0600) return os.WriteFile(fmt.Sprintf("/proc/%d/%s", pid, fname), []byte(mappings), 0o600)
} }
if err := writeMappings("uid_map", uidMaps); err != nil { if err := writeMappings("uid_map", uidMaps); err != nil {
cleanupFunc() cleanupFunc()

6
pkg/idtools/idtools_unix.go
View File

@ -91,13 +91,13 @@ func CanAccess(path string, pair IDPair) bool {
} }
func accessible(isOwner, isGroup bool, perms os.FileMode) bool { func accessible(isOwner, isGroup bool, perms os.FileMode) bool {
if isOwner && (perms&0100 == 0100) { if isOwner && (perms&0o100 == 0o100) {
return true return true
} }
if isGroup && (perms&0010 == 0010) { if isGroup && (perms&0o010 == 0o010) {
return true return true
} }
if perms&0001 == 0001 { if perms&0o001 == 0o001 {
return true return true
} }
return false return false

25
pkg/idtools/idtools_unix_test.go
View File

@ -34,7 +34,7 @@ func TestMkdirAllAs(t *testing.T) {
} }
// test adding a directory to a pre-existing dir; only the new dir is owned by the uid/gid // test adding a directory to a pre-existing dir; only the new dir is owned by the uid/gid
if err := MkdirAllAs(filepath.Join(dirName, "usr", "share"), 0755, 99, 99); err != nil { if err := MkdirAllAs(filepath.Join(dirName, "usr", "share"), 0o755, 99, 99); err != nil {
t.Fatal(err) t.Fatal(err)
} }
testTree["usr/share"] = node{99, 99} testTree["usr/share"] = node{99, 99}
@ -47,7 +47,7 @@ func TestMkdirAllAs(t *testing.T) {
} }
// test 2-deep new directories--both should be owned by the uid/gid pair // test 2-deep new directories--both should be owned by the uid/gid pair
if err := MkdirAllAs(filepath.Join(dirName, "lib", "some", "other"), 0755, 101, 101); err != nil { if err := MkdirAllAs(filepath.Join(dirName, "lib", "some", "other"), 0o755, 101, 101); err != nil {
t.Fatal(err) t.Fatal(err)
} }
testTree["lib/some"] = node{101, 101} testTree["lib/some"] = node{101, 101}
@ -61,7 +61,7 @@ func TestMkdirAllAs(t *testing.T) {
} }
// test a directory that already exists; should be chowned, but nothing else // test a directory that already exists; should be chowned, but nothing else
if err := MkdirAllAs(filepath.Join(dirName, "usr"), 0755, 102, 102); err != nil { if err := MkdirAllAs(filepath.Join(dirName, "usr"), 0o755, 102, 102); err != nil {
t.Fatal(err) t.Fatal(err)
} }
testTree["usr"] = node{102, 102} testTree["usr"] = node{102, 102}
@ -74,7 +74,7 @@ func TestMkdirAllAs(t *testing.T) {
} }
// relative path will return an error // relative path will return an error
if err := MkdirAllAs("test", 0755, 102, 102); err == nil || err.Error() != "path: test should be absolute" { if err := MkdirAllAs("test", 0o755, 102, 102); err == nil || err.Error() != "path: test should be absolute" {
t.Fatalf("Expect path error, but got:%v", err) t.Fatalf("Expect path error, but got:%v", err)
} }
} }
@ -92,7 +92,7 @@ func TestMkdirAllAndChownNew(t *testing.T) {
require.NoError(t, buildTree(dirName, testTree)) require.NoError(t, buildTree(dirName, testTree))
// test adding a directory to a pre-existing dir; only the new dir is owned by the uid/gid // test adding a directory to a pre-existing dir; only the new dir is owned by the uid/gid
err := MkdirAllAndChownNew(filepath.Join(dirName, "usr", "share"), 0755, IDPair{99, 99}) err := MkdirAllAndChownNew(filepath.Join(dirName, "usr", "share"), 0o755, IDPair{99, 99})
require.NoError(t, err) require.NoError(t, err)
testTree["usr/share"] = node{99, 99} testTree["usr/share"] = node{99, 99}
@ -101,7 +101,7 @@ func TestMkdirAllAndChownNew(t *testing.T) {
require.NoError(t, compareTrees(testTree, verifyTree)) require.NoError(t, compareTrees(testTree, verifyTree))
// test 2-deep new directories--both should be owned by the uid/gid pair // test 2-deep new directories--both should be owned by the uid/gid pair
err = MkdirAllAndChownNew(filepath.Join(dirName, "lib", "some", "other"), 0755, IDPair{101, 101}) err = MkdirAllAndChownNew(filepath.Join(dirName, "lib", "some", "other"), 0o755, IDPair{101, 101})
require.NoError(t, err) require.NoError(t, err)
testTree["lib/some"] = node{101, 101} testTree["lib/some"] = node{101, 101}
testTree["lib/some/other"] = node{101, 101} testTree["lib/some/other"] = node{101, 101}
@ -110,7 +110,7 @@ func TestMkdirAllAndChownNew(t *testing.T) {
require.NoError(t, compareTrees(testTree, verifyTree)) require.NoError(t, compareTrees(testTree, verifyTree))
// test a directory that already exists; should NOT be chowned // test a directory that already exists; should NOT be chowned
err = MkdirAllAndChownNew(filepath.Join(dirName, "usr"), 0755, IDPair{102, 102}) err = MkdirAllAndChownNew(filepath.Join(dirName, "usr"), 0o755, IDPair{102, 102})
require.NoError(t, err) require.NoError(t, err)
verifyTree, err = readTree(dirName, "") verifyTree, err = readTree(dirName, "")
require.NoError(t, err) require.NoError(t, err)
@ -118,7 +118,6 @@ func TestMkdirAllAndChownNew(t *testing.T) {
} }
func TestMkdirAs(t *testing.T) { func TestMkdirAs(t *testing.T) {
dirName := t.TempDir() dirName := t.TempDir()
testTree := map[string]node{ testTree := map[string]node{
@ -129,7 +128,7 @@ func TestMkdirAs(t *testing.T) {
} }
// test a directory that already exists; should just chown to the requested uid/gid // test a directory that already exists; should just chown to the requested uid/gid
if err := MkdirAs(filepath.Join(dirName, "usr"), 0755, 99, 99); err != nil { if err := MkdirAs(filepath.Join(dirName, "usr"), 0o755, 99, 99); err != nil {
t.Fatal(err) t.Fatal(err)
} }
testTree["usr"] = node{99, 99} testTree["usr"] = node{99, 99}
@ -142,12 +141,12 @@ func TestMkdirAs(t *testing.T) {
} }
// create a subdir under a dir which doesn't exist--should fail // create a subdir under a dir which doesn't exist--should fail
if err := MkdirAs(filepath.Join(dirName, "usr", "bin", "subdir"), 0755, 102, 102); err == nil { if err := MkdirAs(filepath.Join(dirName, "usr", "bin", "subdir"), 0o755, 102, 102); err == nil {
t.Fatalf("Trying to create a directory with Mkdir where the parent doesn't exist should have failed") t.Fatalf("Trying to create a directory with Mkdir where the parent doesn't exist should have failed")
} }
// create a subdir under an existing dir; should only change the ownership of the new subdir // create a subdir under an existing dir; should only change the ownership of the new subdir
if err := MkdirAs(filepath.Join(dirName, "usr", "bin"), 0755, 102, 102); err != nil { if err := MkdirAs(filepath.Join(dirName, "usr", "bin"), 0o755, 102, 102); err != nil {
t.Fatal(err) t.Fatal(err)
} }
testTree["usr/bin"] = node{102, 102} testTree["usr/bin"] = node{102, 102}
@ -163,7 +162,7 @@ func TestMkdirAs(t *testing.T) {
func buildTree(base string, tree map[string]node) error { func buildTree(base string, tree map[string]node) error {
for path, node := range tree { for path, node := range tree {
fullPath := filepath.Join(base, path) fullPath := filepath.Join(base, path)
if err := os.MkdirAll(fullPath, 0755); err != nil { if err := os.MkdirAll(fullPath, 0o755); err != nil {
return fmt.Errorf("couldn't create path: %s; error: %w", fullPath, err) return fmt.Errorf("couldn't create path: %s; error: %w", fullPath, err)
} }
if err := os.Chown(fullPath, node.uid, node.gid); err != nil { if err := os.Chown(fullPath, node.uid, node.gid); err != nil {
@ -227,7 +226,7 @@ func TestParseSubidFileWithNewlinesAndComments(t *testing.T) {
# empty default subuid/subgid file # empty default subuid/subgid file
dockremap:231072:65536` dockremap:231072:65536`
if err := os.WriteFile(fnamePath, []byte(fcontent), 0644); err != nil { if err := os.WriteFile(fnamePath, []byte(fcontent), 0o644); err != nil {
t.Fatal(err) t.Fatal(err)
} }
ranges, err := parseSubidFile(fnamePath, "dockremap") ranges, err := parseSubidFile(fnamePath, "dockremap")

1
pkg/idtools/usergroupadd_linux.go
View File

@ -89,7 +89,6 @@ func addUser(userName string) error {
} }
func createSubordinateRanges(name string) error { func createSubordinateRanges(name string) error {
// first, we should verify that ranges weren't automatically created // first, we should verify that ranges weren't automatically created
// by the distro tooling // by the distro tooling
ranges, err := readSubuid(name) ranges, err := readSubuid(name)

4
pkg/idtools/utils_unix.go
View File

@ -19,8 +19,8 @@ func resolveBinary(binname string) (string, error) {
if err != nil { if err != nil {
return "", err return "", err
} }
//only return no error if the final resolved binary basename // only return no error if the final resolved binary basename
//matches what was searched for // matches what was searched for
if filepath.Base(resolvedPath) == binname { if filepath.Base(resolvedPath) == binname {
return resolvedPath, nil return resolvedPath, nil
} }

16
pkg/ioutils/fswriters_test.go
View File

@ -8,14 +8,12 @@ import (
"testing" "testing"
) )
var ( var testMode os.FileMode = 0o640
testMode os.FileMode = 0640
)
func init() { func init() {
// Windows does not support full Linux file mode // Windows does not support full Linux file mode
if runtime.GOOS == "windows" { if runtime.GOOS == "windows" {
testMode = 0666 testMode = 0o666
} }
} }
@ -53,13 +51,12 @@ func TestAtomicCommitAndRollbackFile(t *testing.T) {
newData := "newdata" newData := "newdata"
check := func(n int, initData string, writeData string, expected string, explicit bool, commit bool) { check := func(n int, initData string, writeData string, expected string, explicit bool, commit bool) {
if err := os.WriteFile(path, []byte(initData), 0644); err != nil { if err := os.WriteFile(path, []byte(initData), 0o644); err != nil {
t.Fatalf("Failed creating initial file: %v", err) t.Fatalf("Failed creating initial file: %v", err)
} }
opts := &AtomicFileWriterOptions{ExplicitCommit: explicit} opts := &AtomicFileWriterOptions{ExplicitCommit: explicit}
w, err := NewAtomicFileWriterWithOpts(filepath.Join(tmpDir, "foo"), 0644, opts) w, err := NewAtomicFileWriterWithOpts(filepath.Join(tmpDir, "foo"), 0o644, opts)
if err != nil { if err != nil {
t.Fatalf("(%d) Failed creating writer: %v", n, err) t.Fatalf("(%d) Failed creating writer: %v", n, err)
} }
@ -98,7 +95,7 @@ func TestAtomicCommitAndRollbackFile(t *testing.T) {
func TestAtomicWriteSetCommit(t *testing.T) { func TestAtomicWriteSetCommit(t *testing.T) {
tmpDir := t.TempDir() tmpDir := t.TempDir()
if err := os.Mkdir(filepath.Join(tmpDir, "tmp"), 0700); err != nil { if err := os.Mkdir(filepath.Join(tmpDir, "tmp"), 0o700); err != nil {
t.Fatalf("Error creating tmp directory: %s", err) t.Fatalf("Error creating tmp directory: %s", err)
} }
@ -137,13 +134,12 @@ func TestAtomicWriteSetCommit(t *testing.T) {
if expected := os.FileMode(testMode); st.Mode() != expected { if expected := os.FileMode(testMode); st.Mode() != expected {
t.Fatalf("Mode mismatched, expected %o, got %o", expected, st.Mode()) t.Fatalf("Mode mismatched, expected %o, got %o", expected, st.Mode())
} }
} }
func TestAtomicWriteSetCancel(t *testing.T) { func TestAtomicWriteSetCancel(t *testing.T) {
tmpDir := t.TempDir() tmpDir := t.TempDir()
if err := os.Mkdir(filepath.Join(tmpDir, "tmp"), 0700); err != nil { if err := os.Mkdir(filepath.Join(tmpDir, "tmp"), 0o700); err != nil {
t.Fatalf("Error creating tmp directory: %s", err) t.Fatalf("Error creating tmp directory: %s", err)
} }

1
pkg/ioutils/writers_test.go
View File

@ -29,7 +29,6 @@ func TestNopWriteCloser(t *testing.T) {
if err := wrapper.Close(); err != nil { if err := wrapper.Close(); err != nil {
t.Fatal("NopWriteCloser always return nil on Close.") t.Fatal("NopWriteCloser always return nil on Close.")
} }
} }
func TestNopWriter(t *testing.T) { func TestNopWriter(t *testing.T) {

2
pkg/lockfile/lockfile_unix.go
View File

@ -135,7 +135,7 @@ func openLock(path string, ro bool) (fd int, err error) {
// the directory of the lockfile seems to be removed, try to create it // the directory of the lockfile seems to be removed, try to create it
if os.IsNotExist(err) { if os.IsNotExist(err) {
if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil { if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
return fd, fmt.Errorf("creating lock file directory: %w", err) return fd, fmt.Errorf("creating lock file directory: %w", err)
} }

1
pkg/lockfile/lockfile_windows.go
View File

@ -138,6 +138,7 @@ func (l *LockFile) Modified() (bool, error) {
func (l *LockFile) Touch() error { func (l *LockFile) Touch() error {
return nil return nil
} }
func (l *LockFile) IsReadWrite() bool { func (l *LockFile) IsReadWrite() bool {
return false return false
} }

7
pkg/loopback/attach_loopback.go
View File

@ -26,7 +26,7 @@ func stringToLoopName(src string) [LoNameSize]uint8 {
} }
func getNextFreeLoopbackIndex() (int, error) { func getNextFreeLoopbackIndex() (int, error) {
f, err := os.OpenFile("/dev/loop-control", os.O_RDONLY, 0644) f, err := os.OpenFile("/dev/loop-control", os.O_RDONLY, 0o644)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@ -67,7 +67,7 @@ func openNextAvailableLoopback(index int, sparseName string, sparseFile *os.File
} }
// OpenFile adds O_CLOEXEC // OpenFile adds O_CLOEXEC
loopFile, err = os.OpenFile(target, os.O_RDWR, 0644) loopFile, err = os.OpenFile(target, os.O_RDWR, 0o644)
if err != nil { if err != nil {
logrus.Errorf("Opening loopback device: %s", err) logrus.Errorf("Opening loopback device: %s", err)
return nil, ErrAttachLoopbackDevice return nil, ErrAttachLoopbackDevice
@ -114,7 +114,6 @@ func openNextAvailableLoopback(index int, sparseName string, sparseFile *os.File
// AttachLoopDevice attaches the given sparse file to the next // AttachLoopDevice attaches the given sparse file to the next
// available loopback device. It returns an opened *os.File. // available loopback device. It returns an opened *os.File.
func AttachLoopDevice(sparseName string) (loop *os.File, err error) { func AttachLoopDevice(sparseName string) (loop *os.File, err error) {
// Try to retrieve the next available loopback device via syscall. // Try to retrieve the next available loopback device via syscall.
// If it fails, we discard error and start looping for a // If it fails, we discard error and start looping for a
// loopback from index 0. // loopback from index 0.
@ -124,7 +123,7 @@ func AttachLoopDevice(sparseName string) (loop *os.File, err error) {
} }
// OpenFile adds O_CLOEXEC // OpenFile adds O_CLOEXEC
sparseFile, err := os.OpenFile(sparseName, os.O_RDWR, 0644) sparseFile, err := os.OpenFile(sparseName, os.O_RDWR, 0o644)
if err != nil { if err != nil {
logrus.Errorf("Opening sparse file: %v", err) logrus.Errorf("Opening sparse file: %v", err)
return nil, ErrAttachLoopbackDevice return nil, ErrAttachLoopbackDevice

1
pkg/mflag/example/example.go
View File

@ -23,6 +23,7 @@ func init() {
flag.StringVar(&str, []string{"mode"}, "mode1", "set the mode\nmode1: use the mode1\nmode2: use the mode2\nmode3: use the mode3") flag.StringVar(&str, []string{"mode"}, "mode1", "set the mode\nmode1: use the mode1\nmode2: use the mode2\nmode3: use the mode3")
flag.Parse() flag.Parse()
} }
func main() { func main() {
if h { if h {
flag.PrintDefaults() flag.PrintDefaults()

3
pkg/mflag/flag_test.go
View File

@ -24,6 +24,7 @@ func ResetForTesting(usage func()) {
CommandLine = NewFlagSet(os.Args[0], ContinueOnError) CommandLine = NewFlagSet(os.Args[0], ContinueOnError)
Usage = usage Usage = usage
} }
func boolString(s string) string { func boolString(s string) string {
if s == "0" { if s == "0" {
return "false" return "false"
@ -405,7 +406,7 @@ func TestChangingArgs(t *testing.T) {
// Test that -help invokes the usage message and returns ErrHelp. // Test that -help invokes the usage message and returns ErrHelp.
func TestHelp(t *testing.T) { func TestHelp(t *testing.T) {
var helpCalled = false helpCalled := false
fs := NewFlagSet("help test", ContinueOnError) fs := NewFlagSet("help test", ContinueOnError)
fs.Usage = func() { helpCalled = true } fs.Usage = func() { helpCalled = true }
var flag bool var flag bool

14
pkg/mount/mount_unix_test.go
View File

@ -31,7 +31,7 @@ func TestMounted(t *testing.T) {
} }
tmp := path.Join(os.TempDir(), "mount-tests") tmp := path.Join(os.TempDir(), "mount-tests")
if err := os.MkdirAll(tmp, 0777); err != nil { if err := os.MkdirAll(tmp, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
defer os.RemoveAll(tmp) defer os.RemoveAll(tmp)
@ -43,11 +43,11 @@ func TestMounted(t *testing.T) {
targetPath = path.Join(targetDir, "file.txt") targetPath = path.Join(targetDir, "file.txt")
) )
if err := os.Mkdir(sourceDir, 0777); err != nil { if err := os.Mkdir(sourceDir, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := os.Mkdir(targetDir, 0777); err != nil { if err := os.Mkdir(targetDir, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -94,7 +94,7 @@ func TestMountReadonly(t *testing.T) {
} }
tmp := path.Join(os.TempDir(), "mount-tests") tmp := path.Join(os.TempDir(), "mount-tests")
if err := os.MkdirAll(tmp, 0777); err != nil { if err := os.MkdirAll(tmp, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
defer os.RemoveAll(tmp) defer os.RemoveAll(tmp)
@ -106,10 +106,10 @@ func TestMountReadonly(t *testing.T) {
targetPath = path.Join(targetDir, "file.txt") targetPath = path.Join(targetDir, "file.txt")
) )
if err := os.Mkdir(sourceDir, 0777); err != nil { if err := os.Mkdir(sourceDir, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := os.Mkdir(targetDir, 0777); err != nil { if err := os.Mkdir(targetDir, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -138,7 +138,7 @@ func TestMountReadonly(t *testing.T) {
} }
}() }()
f, err = os.OpenFile(targetPath, os.O_RDWR, 0777) f, err = os.OpenFile(targetPath, os.O_RDWR, 0o777)
if err == nil { if err == nil {
f.Close() f.Close()
t.Fatal("Should not be able to open a ro file as rw") t.Fatal("Should not be able to open a ro file as rw")

38
pkg/mount/sharedsubtree_linux_test.go
View File

@ -16,7 +16,7 @@ func TestSubtreePrivate(t *testing.T) {
} }
tmp := path.Join(os.TempDir(), "mount-tests") tmp := path.Join(os.TempDir(), "mount-tests")
if err := os.MkdirAll(tmp, 0777); err != nil { if err := os.MkdirAll(tmp, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
defer os.RemoveAll(tmp) defer os.RemoveAll(tmp)
@ -32,19 +32,19 @@ func TestSubtreePrivate(t *testing.T) {
outside1CheckPath = path.Join(targetDir, "a", "file.txt") outside1CheckPath = path.Join(targetDir, "a", "file.txt")
outside2CheckPath = path.Join(sourceDir, "b", "file.txt") outside2CheckPath = path.Join(sourceDir, "b", "file.txt")
) )
if err := os.MkdirAll(path.Join(sourceDir, "a"), 0777); err != nil { if err := os.MkdirAll(path.Join(sourceDir, "a"), 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := os.MkdirAll(path.Join(sourceDir, "b"), 0777); err != nil { if err := os.MkdirAll(path.Join(sourceDir, "b"), 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := os.Mkdir(targetDir, 0777); err != nil { if err := os.Mkdir(targetDir, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := os.Mkdir(outside1Dir, 0777); err != nil { if err := os.Mkdir(outside1Dir, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := os.Mkdir(outside2Dir, 0777); err != nil { if err := os.Mkdir(outside2Dir, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -118,7 +118,7 @@ func TestSubtreeShared(t *testing.T) {
} }
tmp := path.Join(os.TempDir(), "mount-tests") tmp := path.Join(os.TempDir(), "mount-tests")
if err := os.MkdirAll(tmp, 0777); err != nil { if err := os.MkdirAll(tmp, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
defer os.RemoveAll(tmp) defer os.RemoveAll(tmp)
@ -132,13 +132,13 @@ func TestSubtreeShared(t *testing.T) {
sourceCheckPath = path.Join(sourceDir, "a", "file.txt") sourceCheckPath = path.Join(sourceDir, "a", "file.txt")
) )
if err := os.MkdirAll(path.Join(sourceDir, "a"), 0777); err != nil { if err := os.MkdirAll(path.Join(sourceDir, "a"), 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := os.Mkdir(targetDir, 0777); err != nil { if err := os.Mkdir(targetDir, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := os.Mkdir(outsideDir, 0777); err != nil { if err := os.Mkdir(outsideDir, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -190,7 +190,7 @@ func TestSubtreeSharedSlave(t *testing.T) {
} }
tmp := path.Join(os.TempDir(), "mount-tests") tmp := path.Join(os.TempDir(), "mount-tests")
if err := os.MkdirAll(tmp, 0777); err != nil { if err := os.MkdirAll(tmp, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
defer os.RemoveAll(tmp) defer os.RemoveAll(tmp)
@ -206,19 +206,19 @@ func TestSubtreeSharedSlave(t *testing.T) {
outside1CheckPath = path.Join(targetDir, "a", "file.txt") outside1CheckPath = path.Join(targetDir, "a", "file.txt")
outside2CheckPath = path.Join(sourceDir, "b", "file.txt") outside2CheckPath = path.Join(sourceDir, "b", "file.txt")
) )
if err := os.MkdirAll(path.Join(sourceDir, "a"), 0777); err != nil { if err := os.MkdirAll(path.Join(sourceDir, "a"), 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := os.MkdirAll(path.Join(sourceDir, "b"), 0777); err != nil { if err := os.MkdirAll(path.Join(sourceDir, "b"), 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := os.Mkdir(targetDir, 0777); err != nil { if err := os.Mkdir(targetDir, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := os.Mkdir(outside1Dir, 0777); err != nil { if err := os.Mkdir(outside1Dir, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := os.Mkdir(outside2Dir, 0777); err != nil { if err := os.Mkdir(outside2Dir, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -298,7 +298,7 @@ func TestSubtreeUnbindable(t *testing.T) {
} }
tmp := path.Join(os.TempDir(), "mount-tests") tmp := path.Join(os.TempDir(), "mount-tests")
if err := os.MkdirAll(tmp, 0777); err != nil { if err := os.MkdirAll(tmp, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
defer os.RemoveAll(tmp) defer os.RemoveAll(tmp)
@ -307,10 +307,10 @@ func TestSubtreeUnbindable(t *testing.T) {
sourceDir = path.Join(tmp, "source") sourceDir = path.Join(tmp, "source")
targetDir = path.Join(tmp, "target") targetDir = path.Join(tmp, "target")
) )
if err := os.MkdirAll(sourceDir, 0777); err != nil { if err := os.MkdirAll(sourceDir, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := os.MkdirAll(targetDir, 0777); err != nil { if err := os.MkdirAll(targetDir, 0o777); err != nil {
t.Fatal(err) t.Fatal(err)
} }

4
pkg/parsers/kernel/kernel_unix_test.go
View File

@ -10,9 +10,7 @@ import (
func assertParseRelease(t *testing.T, release string, b *VersionInfo, result int) { func assertParseRelease(t *testing.T, release string, b *VersionInfo, result int) {
t.Helper() t.Helper()
var ( var a *VersionInfo
a *VersionInfo
)
a, _ = ParseRelease(release) a, _ = ParseRelease(release)
if r := CompareKernelVersion(*a, *b); r != result { if r := CompareKernelVersion(*a, *b); r != result {

1
pkg/parsers/kernel/kernel_windows.go
View File

@ -24,7 +24,6 @@ func (k *VersionInfo) String() string {
// GetKernelVersion gets the current kernel version. // GetKernelVersion gets the current kernel version.
func GetKernelVersion() (*VersionInfo, error) { func GetKernelVersion() (*VersionInfo, error) {
var ( var (
h windows.Handle h windows.Handle
dwVersion uint32 dwVersion uint32

18
pkg/parsers/operatingsystem/operatingsystem_unix_test.go
View File

@ -10,7 +10,7 @@ import (
) )
func TestGetOperatingSystem(t *testing.T) { func TestGetOperatingSystem(t *testing.T) {
var backup = etcOsRelease backup := etcOsRelease
invalids := []struct { invalids := []struct {
content string content string
@ -117,7 +117,7 @@ PRETTY_NAME="Source Mage"`,
}() }()
for _, elt := range invalids { for _, elt := range invalids {
if err := os.WriteFile(etcOsRelease, []byte(elt.content), 0600); err != nil { if err := os.WriteFile(etcOsRelease, []byte(elt.content), 0o600); err != nil {
t.Fatalf("failed to write to %s: %v", etcOsRelease, err) t.Fatalf("failed to write to %s: %v", etcOsRelease, err)
} }
s, err := GetOperatingSystem() s, err := GetOperatingSystem()
@ -127,7 +127,7 @@ PRETTY_NAME="Source Mage"`,
} }
for _, elt := range valids { for _, elt := range valids {
if err := os.WriteFile(etcOsRelease, []byte(elt.content), 0600); err != nil { if err := os.WriteFile(etcOsRelease, []byte(elt.content), 0o600); err != nil {
t.Fatalf("failed to write to %s: %v", etcOsRelease, err) t.Fatalf("failed to write to %s: %v", etcOsRelease, err)
} }
s, err := GetOperatingSystem() s, err := GetOperatingSystem()
@ -183,7 +183,7 @@ func TestIsContainerized(t *testing.T) {
proc1Cgroup = backup proc1Cgroup = backup
}() }()
if err := os.WriteFile(proc1Cgroup, nonContainerizedProc1Cgroup, 0600); err != nil { if err := os.WriteFile(proc1Cgroup, nonContainerizedProc1Cgroup, 0o600); err != nil {
t.Fatalf("failed to write to %s: %v", proc1Cgroup, err) t.Fatalf("failed to write to %s: %v", proc1Cgroup, err)
} }
inContainer, err := IsContainerized() inContainer, err := IsContainerized()
@ -194,7 +194,7 @@ func TestIsContainerized(t *testing.T) {
t.Fatal("Wrongly assuming containerized") t.Fatal("Wrongly assuming containerized")
} }
if err := os.WriteFile(proc1Cgroup, nonContainerizedProc1Cgroupsystemd226, 0600); err != nil { if err := os.WriteFile(proc1Cgroup, nonContainerizedProc1Cgroupsystemd226, 0o600); err != nil {
t.Fatalf("failed to write to %s: %v", proc1Cgroup, err) t.Fatalf("failed to write to %s: %v", proc1Cgroup, err)
} }
inContainer, err = IsContainerized() inContainer, err = IsContainerized()
@ -205,7 +205,7 @@ func TestIsContainerized(t *testing.T) {
t.Fatal("Wrongly assuming containerized for systemd /init.scope cgroup layout") t.Fatal("Wrongly assuming containerized for systemd /init.scope cgroup layout")
} }
if err := os.WriteFile(proc1Cgroup, containerizedProc1Cgroup, 0600); err != nil { if err := os.WriteFile(proc1Cgroup, containerizedProc1Cgroup, 0o600); err != nil {
t.Fatalf("failed to write to %s: %v", proc1Cgroup, err) t.Fatalf("failed to write to %s: %v", proc1Cgroup, err)
} }
inContainer, err = IsContainerized() inContainer, err = IsContainerized()
@ -218,8 +218,8 @@ func TestIsContainerized(t *testing.T) {
} }
func TestOsReleaseFallback(t *testing.T) { func TestOsReleaseFallback(t *testing.T) {
var backup = etcOsRelease backup := etcOsRelease
var altBackup = altOsRelease altBackup := altOsRelease
dir := os.TempDir() dir := os.TempDir()
etcOsRelease = filepath.Join(dir, "etcOsRelease") etcOsRelease = filepath.Join(dir, "etcOsRelease")
altOsRelease = filepath.Join(dir, "altOsRelease") altOsRelease = filepath.Join(dir, "altOsRelease")
@ -237,7 +237,7 @@ HOME_URL="http://www.gentoo.org/"
SUPPORT_URL="http://www.gentoo.org/main/en/support.xml" SUPPORT_URL="http://www.gentoo.org/main/en/support.xml"
BUG_REPORT_URL="https://bugs.gentoo.org/" BUG_REPORT_URL="https://bugs.gentoo.org/"
` `
if err := os.WriteFile(altOsRelease, []byte(content), 0600); err != nil { if err := os.WriteFile(altOsRelease, []byte(content), 0o600); err != nil {
t.Fatalf("failed to write to %s: %v", etcOsRelease, err) t.Fatalf("failed to write to %s: %v", etcOsRelease, err)
} }
s, err := GetOperatingSystem() s, err := GetOperatingSystem()

1
pkg/parsers/operatingsystem/operatingsystem_windows.go
View File

@ -11,7 +11,6 @@ import (
// GetOperatingSystem gets the name of the current operating system. // GetOperatingSystem gets the name of the current operating system.
func GetOperatingSystem() (string, error) { func GetOperatingSystem() (string, error) {
var h windows.Handle var h windows.Handle
// Default return value // Default return value

Some files were not shown because too many files have changed in this diff Show More