mirror of
https://github.com/1Panel-dev/1Panel.git
synced 2026-11-20 00:01:06 +00:00
522 lines
14 KiB
Go
522 lines
14 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"syscall"
|
|
|
|
"golang.org/x/sys/unix"
|
|
)
|
|
|
|
const decompressKeepDirFlags = unix.O_RDONLY | unix.O_DIRECTORY | unix.O_NOFOLLOW | unix.O_CLOEXEC
|
|
|
|
type decompressKeepIdentity struct{ dev, ino uint64 }
|
|
type decompressKeepFilesystem struct{ dev, mount uint64 }
|
|
type decompressKeepLink struct {
|
|
stage *decompressKeepStage
|
|
name string
|
|
}
|
|
type decompressKeepStage struct {
|
|
fd, parent int
|
|
name string
|
|
identity decompressKeepIdentity
|
|
entries map[string]bool
|
|
}
|
|
type decompressKeepState struct {
|
|
stages map[decompressKeepFilesystem]*decompressKeepStage
|
|
localStages map[int]*decompressKeepStage
|
|
hardlinks map[decompressFileIdentity][]decompressKeepLink
|
|
}
|
|
|
|
func newDecompressKeepState() *decompressKeepState {
|
|
return &decompressKeepState{
|
|
stages: make(map[decompressKeepFilesystem]*decompressKeepStage),
|
|
localStages: make(map[int]*decompressKeepStage),
|
|
hardlinks: make(map[decompressFileIdentity][]decompressKeepLink),
|
|
}
|
|
}
|
|
|
|
func copyDecompressTreeKeep(ctx context.Context, src, dst string) (retErr error) {
|
|
if err := ctx.Err(); err != nil {
|
|
return err
|
|
}
|
|
parent, name, err := openDecompressKeepParent(ctx, dst)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer unix.Close(parent)
|
|
state := newDecompressKeepState()
|
|
defer func() { retErr = errors.Join(retErr, state.close()) }()
|
|
fd, created, err := state.directory(parent, name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if fd < 0 {
|
|
return fmt.Errorf("decompression destination is not a directory: %s", dst)
|
|
}
|
|
defer func() {
|
|
// A canceled task retains its new directories. Restore their public
|
|
// permissions now; a retry correctly treats them as existing entries.
|
|
if created {
|
|
retErr = errors.Join(retErr, unix.Fchmod(fd, 0755))
|
|
}
|
|
retErr = errors.Join(retErr, unix.Close(fd))
|
|
}()
|
|
return state.children(ctx, src, fd)
|
|
}
|
|
|
|
func copyDecompressEntryKeep(ctx context.Context, src, dst string) (retErr error) {
|
|
if err := ctx.Err(); err != nil {
|
|
return err
|
|
}
|
|
parent, name, err := openDecompressKeepParent(ctx, dst)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer unix.Close(parent)
|
|
state := newDecompressKeepState()
|
|
defer func() { retErr = errors.Join(retErr, state.close()) }()
|
|
if err := state.entry(ctx, src, parent, name); err != nil {
|
|
return err
|
|
}
|
|
return ctx.Err()
|
|
}
|
|
|
|
func openDecompressKeepParent(ctx context.Context, dst string) (int, string, error) {
|
|
abs, err := filepath.Abs(dst)
|
|
if err != nil {
|
|
return -1, "", err
|
|
}
|
|
parent, name := filepath.Dir(abs), filepath.Base(abs)
|
|
var missing []string
|
|
for {
|
|
if err := ctx.Err(); err != nil {
|
|
return -1, "", err
|
|
}
|
|
resolved, resolveErr := filepath.EvalSymlinks(parent)
|
|
if resolveErr == nil {
|
|
parent = resolved
|
|
break
|
|
}
|
|
if !os.IsNotExist(resolveErr) || parent == filepath.Dir(parent) {
|
|
return -1, "", resolveErr
|
|
}
|
|
missing = append(missing, filepath.Base(parent))
|
|
parent = filepath.Dir(parent)
|
|
}
|
|
for i := len(missing) - 1; i >= 0; i-- {
|
|
parent = filepath.Join(parent, missing[i])
|
|
}
|
|
fd, err := unix.Open(string(filepath.Separator), decompressKeepDirFlags, 0)
|
|
if err != nil {
|
|
return -1, "", err
|
|
}
|
|
for _, component := range strings.Split(strings.Trim(parent, string(filepath.Separator)), string(filepath.Separator)) {
|
|
if err := ctx.Err(); err != nil {
|
|
_ = unix.Close(fd)
|
|
return -1, "", err
|
|
}
|
|
if component == "" {
|
|
continue
|
|
}
|
|
next, openErr := unix.Openat(fd, component, decompressKeepDirFlags, 0)
|
|
if openErr == unix.ENOENT {
|
|
if mkdirErr := unix.Mkdirat(fd, component, 0755); mkdirErr != nil && mkdirErr != unix.EEXIST {
|
|
_ = unix.Close(fd)
|
|
return -1, "", mkdirErr
|
|
}
|
|
next, openErr = unix.Openat(fd, component, decompressKeepDirFlags, 0)
|
|
}
|
|
_ = unix.Close(fd)
|
|
if openErr != nil {
|
|
return -1, "", openErr
|
|
}
|
|
fd = next
|
|
}
|
|
return fd, name, nil
|
|
}
|
|
|
|
func decompressKeepRandomName() (string, error) {
|
|
var random [16]byte
|
|
if _, err := rand.Read(random[:]); err != nil {
|
|
return "", err
|
|
}
|
|
return ".decompress-keep-" + hex.EncodeToString(random[:]), nil
|
|
}
|
|
|
|
func decompressKeepFDIdentity(fd int) (decompressKeepIdentity, error) {
|
|
var info unix.Stat_t
|
|
if err := unix.Fstat(fd, &info); err != nil {
|
|
return decompressKeepIdentity{}, err
|
|
}
|
|
return decompressKeepIdentity{uint64(info.Dev), uint64(info.Ino)}, nil
|
|
}
|
|
|
|
func (s *decompressKeepState) staging(parent int) (*decompressKeepStage, error) {
|
|
identity, err := decompressKeepFDIdentity(parent)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
mount, err := decompressKeepMountID(parent)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filesystem := decompressKeepFilesystem{dev: identity.dev, mount: mount}
|
|
if stage := s.stages[filesystem]; stage != nil {
|
|
return stage, nil
|
|
}
|
|
stage, err := newDecompressKeepStage(parent)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
s.stages[filesystem] = stage
|
|
return stage, nil
|
|
}
|
|
|
|
func (s *decompressKeepState) localStaging(parent int) (*decompressKeepStage, error) {
|
|
if stage := s.localStages[parent]; stage != nil {
|
|
return stage, nil
|
|
}
|
|
if _, err := s.staging(parent); err != nil {
|
|
return nil, err
|
|
}
|
|
stage, err := newDecompressKeepStage(parent)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
s.localStages[parent] = stage
|
|
return stage, nil
|
|
}
|
|
|
|
func newDecompressKeepStage(parent int) (*decompressKeepStage, error) {
|
|
name, err := decompressKeepRandomName()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := unix.Mkdirat(parent, name, 0700); err != nil {
|
|
return nil, err
|
|
}
|
|
var created unix.Stat_t
|
|
if err := unix.Fstatat(parent, name, &created, unix.AT_SYMLINK_NOFOLLOW); err != nil {
|
|
return nil, err
|
|
}
|
|
if created.Mode&unix.S_IFMT != unix.S_IFDIR || created.Uid != uint32(os.Geteuid()) || created.Mode&0777 != 0700 {
|
|
return nil, fmt.Errorf("decompression staging directory changed")
|
|
}
|
|
createdIdentity := decompressKeepIdentity{uint64(created.Dev), uint64(created.Ino)}
|
|
registered := false
|
|
defer func() {
|
|
if !registered {
|
|
removeDecompressKeepStageDirectory(parent, name, createdIdentity)
|
|
}
|
|
}()
|
|
fd, err := unix.Openat(parent, name, decompressKeepDirFlags, 0)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var stat unix.Stat_t
|
|
if err = unix.Fstat(fd, &stat); err != nil || stat.Uid != uint32(os.Geteuid()) || stat.Mode&0777 != 0700 ||
|
|
(decompressKeepIdentity{uint64(stat.Dev), uint64(stat.Ino)}) != createdIdentity {
|
|
_ = unix.Close(fd)
|
|
if err == nil {
|
|
err = fmt.Errorf("decompression staging directory changed")
|
|
}
|
|
return nil, err
|
|
}
|
|
parentCopy, err := unix.Dup(parent)
|
|
if err != nil {
|
|
_ = unix.Close(fd)
|
|
return nil, err
|
|
}
|
|
unix.CloseOnExec(parentCopy)
|
|
stage := &decompressKeepStage{fd: fd, parent: parentCopy, name: name,
|
|
identity: decompressKeepIdentity{uint64(stat.Dev), uint64(stat.Ino)}, entries: make(map[string]bool)}
|
|
registered = true
|
|
return stage, nil
|
|
}
|
|
|
|
func removeDecompressKeepStageDirectory(parent int, name string, identity decompressKeepIdentity) error {
|
|
var current unix.Stat_t
|
|
if err := unix.Fstatat(parent, name, ¤t, unix.AT_SYMLINK_NOFOLLOW); err != nil {
|
|
if errors.Is(err, unix.ENOENT) {
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
if (decompressKeepIdentity{uint64(current.Dev), uint64(current.Ino)}) != identity {
|
|
return nil
|
|
}
|
|
return unix.Unlinkat(parent, name, unix.AT_REMOVEDIR)
|
|
}
|
|
|
|
func (stage *decompressKeepStage) close() (retErr error) {
|
|
for name, directory := range stage.entries {
|
|
flags := 0
|
|
if directory {
|
|
flags = unix.AT_REMOVEDIR
|
|
}
|
|
if err := unix.Unlinkat(stage.fd, name, flags); err != unix.ENOENT {
|
|
retErr = errors.Join(retErr, err)
|
|
}
|
|
}
|
|
retErr = errors.Join(retErr, removeDecompressKeepStageDirectory(stage.parent, stage.name, stage.identity))
|
|
return errors.Join(retErr, unix.Close(stage.fd), unix.Close(stage.parent))
|
|
}
|
|
|
|
func (s *decompressKeepState) closeLocal(parent int) error {
|
|
if stage := s.localStages[parent]; stage != nil {
|
|
delete(s.localStages, parent)
|
|
return stage.close()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *decompressKeepState) close() (retErr error) {
|
|
for parent := range s.localStages {
|
|
retErr = errors.Join(retErr, s.closeLocal(parent))
|
|
}
|
|
for _, stage := range s.stages {
|
|
retErr = errors.Join(retErr, stage.close())
|
|
}
|
|
clear(s.stages)
|
|
return retErr
|
|
}
|
|
|
|
func (s *decompressKeepState) directory(parent int, name string) (int, bool, error) {
|
|
var existing unix.Stat_t
|
|
err := unix.Fstatat(parent, name, &existing, unix.AT_SYMLINK_NOFOLLOW)
|
|
if err == nil {
|
|
if existing.Mode&unix.S_IFMT != unix.S_IFDIR {
|
|
return -1, false, nil
|
|
}
|
|
fd, err := unix.Openat(parent, name, decompressKeepDirFlags, 0)
|
|
if errors.Is(err, unix.ENOTDIR) || errors.Is(err, unix.ELOOP) {
|
|
return -1, false, nil
|
|
}
|
|
return fd, false, err
|
|
}
|
|
if !errors.Is(err, unix.ENOENT) {
|
|
return -1, false, err
|
|
}
|
|
stage, err := s.localStaging(parent)
|
|
if err != nil {
|
|
return -1, false, err
|
|
}
|
|
privateName, err := decompressKeepRandomName()
|
|
if err != nil {
|
|
return -1, false, err
|
|
}
|
|
if err := unix.Mkdirat(stage.fd, privateName, 0700); err != nil {
|
|
return -1, false, err
|
|
}
|
|
stage.entries[privateName] = true
|
|
fd, err := unix.Openat(stage.fd, privateName, decompressKeepDirFlags, 0)
|
|
if err != nil {
|
|
return -1, false, err
|
|
}
|
|
if err = renameDecompressKeepDirectory(stage.fd, privateName, parent, name); err != nil {
|
|
_ = unix.Close(fd)
|
|
if err == unix.EEXIST || err == unix.ENOTEMPTY {
|
|
if err := unix.Fstatat(parent, name, &existing, unix.AT_SYMLINK_NOFOLLOW); err != nil {
|
|
return -1, false, err
|
|
}
|
|
if existing.Mode&unix.S_IFMT != unix.S_IFDIR {
|
|
return -1, false, nil
|
|
}
|
|
fd, err := unix.Openat(parent, name, decompressKeepDirFlags, 0)
|
|
if err == unix.ENOTDIR || err == unix.ELOOP {
|
|
return -1, false, nil
|
|
}
|
|
return fd, false, err
|
|
}
|
|
return -1, false, err
|
|
}
|
|
delete(stage.entries, privateName)
|
|
return fd, true, nil
|
|
}
|
|
|
|
func (s *decompressKeepState) children(ctx context.Context, src string, dst int) (retErr error) {
|
|
defer func() { retErr = errors.Join(retErr, s.closeLocal(dst)) }()
|
|
if err := ctx.Err(); err != nil {
|
|
return err
|
|
}
|
|
entries, err := os.ReadDir(src)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, entry := range entries {
|
|
if err := s.entry(ctx, filepath.Join(src, entry.Name()), dst, entry.Name()); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return ctx.Err()
|
|
}
|
|
|
|
func (s *decompressKeepState) entry(ctx context.Context, src string, parent int, name string) (retErr error) {
|
|
if err := ctx.Err(); err != nil {
|
|
return err
|
|
}
|
|
info, err := os.Lstat(src)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if info.IsDir() {
|
|
fd, created, err := s.directory(parent, name)
|
|
if err != nil || fd < 0 {
|
|
return err
|
|
}
|
|
defer func() {
|
|
if created {
|
|
stamp := unix.NsecToTimespec(info.ModTime().UnixNano())
|
|
retErr = errors.Join(retErr, decompressKeepFDMetadata(fd, info),
|
|
unix.UtimesNanoAt(fd, ".", []unix.Timespec{stamp, stamp}, 0))
|
|
}
|
|
retErr = errors.Join(retErr, unix.Close(fd))
|
|
}()
|
|
return s.children(ctx, src, fd)
|
|
}
|
|
var existing unix.Stat_t
|
|
if err := unix.Fstatat(parent, name, &existing, unix.AT_SYMLINK_NOFOLLOW); err == nil {
|
|
return nil
|
|
} else if !errors.Is(err, unix.ENOENT) {
|
|
return err
|
|
}
|
|
if !info.Mode().IsRegular() && info.Mode()&os.ModeSymlink == 0 {
|
|
return fmt.Errorf("unsupported archive entry type: %s", src)
|
|
}
|
|
identity, hardlink := decompressHardlinkIdentity(info)
|
|
if hardlink && info.Mode().IsRegular() {
|
|
for _, link := range s.hardlinks[identity] {
|
|
err := unix.Linkat(link.stage.fd, link.name, parent, name, 0)
|
|
if err == nil || errors.Is(err, unix.EEXIST) {
|
|
return nil
|
|
}
|
|
if !errors.Is(err, unix.EXDEV) {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
stage, err := s.localStaging(parent)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
privateName, err := decompressKeepRandomName()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if info.Mode()&os.ModeSymlink != 0 {
|
|
target, err := os.Readlink(src)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := unix.Symlinkat(target, stage.fd, privateName); err != nil {
|
|
return err
|
|
}
|
|
stage.entries[privateName] = false
|
|
if stat, ok := info.Sys().(*syscall.Stat_t); ok {
|
|
if err := unix.Fchownat(stage.fd, privateName, int(stat.Uid), int(stat.Gid), unix.AT_SYMLINK_NOFOLLOW); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
} else {
|
|
fd, err := unix.Openat(stage.fd, privateName, unix.O_CREAT|unix.O_EXCL|unix.O_WRONLY|unix.O_NOFOLLOW|unix.O_CLOEXEC, 0600)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
stage.entries[privateName] = false
|
|
if err := copyDecompressKeepFile(ctx, src, fd, info); err != nil {
|
|
return err
|
|
}
|
|
stamp := unix.NsecToTimespec(info.ModTime().UnixNano())
|
|
if err := unix.UtimesNanoAt(stage.fd, privateName, []unix.Timespec{stamp, stamp}, 0); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if err := ctx.Err(); err != nil {
|
|
return err
|
|
}
|
|
if err := unix.Linkat(stage.fd, privateName, parent, name, 0); err != nil {
|
|
if errors.Is(err, unix.EEXIST) {
|
|
_ = unix.Unlinkat(stage.fd, privateName, 0)
|
|
delete(stage.entries, privateName)
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
if hardlink && info.Mode().IsRegular() {
|
|
anchors, err := s.staging(parent)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
anchorName, err := decompressKeepRandomName()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := unix.Linkat(stage.fd, privateName, anchors.fd, anchorName, 0); err != nil {
|
|
return err
|
|
}
|
|
anchors.entries[anchorName] = false
|
|
s.hardlinks[identity] = append(s.hardlinks[identity], decompressKeepLink{anchors, anchorName})
|
|
}
|
|
if err := unix.Unlinkat(stage.fd, privateName, 0); err != nil {
|
|
return err
|
|
}
|
|
delete(stage.entries, privateName)
|
|
return nil
|
|
}
|
|
|
|
func decompressKeepFDMetadata(fd int, info os.FileInfo) error {
|
|
var ownerErr error
|
|
if stat, ok := info.Sys().(*syscall.Stat_t); ok {
|
|
ownerErr = unix.Fchown(fd, int(stat.Uid), int(stat.Gid))
|
|
}
|
|
return errors.Join(ownerErr, unix.Fchmod(fd, uint32(info.Mode().Perm())))
|
|
}
|
|
|
|
func copyDecompressKeepFile(ctx context.Context, src string, fd int, info os.FileInfo) (retErr error) {
|
|
dst := os.NewFile(uintptr(fd), "decompression staging file")
|
|
defer func() {
|
|
if err := dst.Close(); retErr == nil {
|
|
retErr = err
|
|
}
|
|
}()
|
|
input, err := os.Open(src)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer input.Close()
|
|
buffer := make([]byte, 64*1024)
|
|
for {
|
|
if err := ctx.Err(); err != nil {
|
|
return err
|
|
}
|
|
n, readErr := input.Read(buffer)
|
|
if err := ctx.Err(); err != nil {
|
|
return err
|
|
}
|
|
if n > 0 {
|
|
written, err := dst.Write(buffer[:n])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if written != n {
|
|
return io.ErrShortWrite
|
|
}
|
|
}
|
|
if readErr == io.EOF {
|
|
break
|
|
}
|
|
if readErr != nil {
|
|
return readErr
|
|
}
|
|
}
|
|
return decompressKeepFDMetadata(fd, info)
|
|
}
|