forked from forgejo/forgejo
Dump: add output format tar and output to stdout (#10376)
* Dump: Use mholt/archive/v3 to support tar including many compressions Signed-off-by: Philipp Homann <homann.philipp@googlemail.com> * Dump: Allow dump output to stdout Signed-off-by: Philipp Homann <homann.philipp@googlemail.com> * Dump: Fixed bug present since #6677 where SessionConfig.Provider is never "file" Signed-off-by: Philipp Homann <homann.philipp@googlemail.com> * Dump: never pack RepoRootPath, LFS.ContentPath and LogRootPath when they are below AppDataPath Signed-off-by: Philipp Homann <homann.philipp@googlemail.com> * Dump: also dump LFS (fixes #10058) Signed-off-by: Philipp Homann <homann.philipp@googlemail.com> * Dump: never dump CustomPath if CustomPath is a subdir of or equal to AppDataPath (fixes #10365) Signed-off-by: Philipp Homann <homann.philipp@googlemail.com> * Use log.Info instead of fmt.Fprintf Signed-off-by: Philipp Homann <homann.philipp@googlemail.com> * import ordering * make fmt Co-authored-by: zeripath <art27@cantab.net> Co-authored-by: techknowlogick <techknowlogick@gitea.io> Co-authored-by: Matti R <matti@mdranta.net>
This commit is contained in:
PhilippHomann
GitHub
parent
209b17c4e2
commit
684b7a999f
303 changed files with 301317 additions and 1183 deletions
409
vendor/github.com/mholt/archiver/v3/rar.go
generated
vendored
Normal file
409
vendor/github.com/mholt/archiver/v3/rar.go
generated
vendored
Normal file
|
|
@ -0,0 +1,409 @@
|
|||
package archiver
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"os"
|
||||
"path"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/nwaples/rardecode"
|
||||
)
|
||||
|
||||
// Rar provides facilities for reading RAR archives.
|
||||
// See https://www.rarlab.com/technote.htm.
|
||||
type Rar struct {
|
||||
// Whether to overwrite existing files; if false,
|
||||
// an error is returned if the file exists.
|
||||
OverwriteExisting bool
|
||||
|
||||
// Whether to make all the directories necessary
|
||||
// to create a rar archive in the desired path.
|
||||
MkdirAll bool
|
||||
|
||||
// A single top-level folder can be implicitly
|
||||
// created by the Unarchive method if the files
|
||||
// to be extracted from the archive do not all
|
||||
// have a common root. This roughly mimics the
|
||||
// behavior of archival tools integrated into OS
|
||||
// file browsers which create a subfolder to
|
||||
// avoid unexpectedly littering the destination
|
||||
// folder with potentially many files, causing a
|
||||
// problematic cleanup/organization situation.
|
||||
// This feature is available for both creation
|
||||
// and extraction of archives, but may be slightly
|
||||
// inefficient with lots and lots of files,
|
||||
// especially on extraction.
|
||||
ImplicitTopLevelFolder bool
|
||||
|
||||
// If true, errors encountered during reading
|
||||
// or writing a single file will be logged and
|
||||
// the operation will continue on remaining files.
|
||||
ContinueOnError bool
|
||||
|
||||
// The password to open archives (optional).
|
||||
Password string
|
||||
|
||||
rr *rardecode.Reader // underlying stream reader
|
||||
rc *rardecode.ReadCloser // supports multi-volume archives (files only)
|
||||
}
|
||||
|
||||
// CheckExt ensures the file extension matches the format.
|
||||
func (*Rar) CheckExt(filename string) error {
|
||||
if !strings.HasSuffix(filename, ".rar") {
|
||||
return fmt.Errorf("filename must have a .rar extension")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Unarchive unpacks the .rar file at source to destination.
|
||||
// Destination will be treated as a folder name. It supports
|
||||
// multi-volume archives.
|
||||
func (r *Rar) Unarchive(source, destination string) error {
|
||||
if !fileExists(destination) && r.MkdirAll {
|
||||
err := mkdir(destination, 0755)
|
||||
if err != nil {
|
||||
return fmt.Errorf("preparing destination: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// if the files in the archive do not all share a common
|
||||
// root, then make sure we extract to a single subfolder
|
||||
// rather than potentially littering the destination...
|
||||
if r.ImplicitTopLevelFolder {
|
||||
var err error
|
||||
destination, err = r.addTopLevelFolder(source, destination)
|
||||
if err != nil {
|
||||
return fmt.Errorf("scanning source archive: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
err := r.OpenFile(source)
|
||||
if err != nil {
|
||||
return fmt.Errorf("opening rar archive for reading: %v", err)
|
||||
}
|
||||
defer r.Close()
|
||||
|
||||
for {
|
||||
err := r.unrarNext(destination)
|
||||
if err == io.EOF {
|
||||
break
|
||||
}
|
||||
if err != nil {
|
||||
if r.ContinueOnError {
|
||||
log.Printf("[ERROR] Reading file in rar archive: %v", err)
|
||||
continue
|
||||
}
|
||||
return fmt.Errorf("reading file in rar archive: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// addTopLevelFolder scans the files contained inside
|
||||
// the tarball named sourceArchive and returns a modified
|
||||
// destination if all the files do not share the same
|
||||
// top-level folder.
|
||||
func (r *Rar) addTopLevelFolder(sourceArchive, destination string) (string, error) {
|
||||
file, err := os.Open(sourceArchive)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("opening source archive: %v", err)
|
||||
}
|
||||
defer file.Close()
|
||||
|
||||
rc, err := rardecode.NewReader(file, r.Password)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("creating archive reader: %v", err)
|
||||
}
|
||||
|
||||
var files []string
|
||||
for {
|
||||
hdr, err := rc.Next()
|
||||
if err == io.EOF {
|
||||
break
|
||||
}
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("scanning tarball's file listing: %v", err)
|
||||
}
|
||||
files = append(files, hdr.Name)
|
||||
}
|
||||
|
||||
if multipleTopLevels(files) {
|
||||
destination = filepath.Join(destination, folderNameFromFileName(sourceArchive))
|
||||
}
|
||||
|
||||
return destination, nil
|
||||
}
|
||||
|
||||
func (r *Rar) unrarNext(to string) error {
|
||||
f, err := r.Read()
|
||||
if err != nil {
|
||||
return err // don't wrap error; calling loop must break on io.EOF
|
||||
}
|
||||
header, ok := f.Header.(*rardecode.FileHeader)
|
||||
if !ok {
|
||||
return fmt.Errorf("expected header to be *rardecode.FileHeader but was %T", f.Header)
|
||||
}
|
||||
return r.unrarFile(f, filepath.Join(to, header.Name))
|
||||
}
|
||||
|
||||
func (r *Rar) unrarFile(f File, to string) error {
|
||||
// do not overwrite existing files, if configured
|
||||
if !f.IsDir() && !r.OverwriteExisting && fileExists(to) {
|
||||
return fmt.Errorf("file already exists: %s", to)
|
||||
}
|
||||
|
||||
hdr, ok := f.Header.(*rardecode.FileHeader)
|
||||
if !ok {
|
||||
return fmt.Errorf("expected header to be *rardecode.FileHeader but was %T", f.Header)
|
||||
}
|
||||
|
||||
if f.IsDir() {
|
||||
if fileExists("testdata") {
|
||||
err := os.Chmod(to, hdr.Mode())
|
||||
if err != nil {
|
||||
return fmt.Errorf("changing dir mode: %v", err)
|
||||
}
|
||||
} else {
|
||||
err := mkdir(to, hdr.Mode())
|
||||
if err != nil {
|
||||
return fmt.Errorf("making directories: %v", err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// if files come before their containing folders, then we must
|
||||
// create their folders before writing the file
|
||||
err := mkdir(filepath.Dir(to), 0755)
|
||||
if err != nil {
|
||||
return fmt.Errorf("making parent directories: %v", err)
|
||||
}
|
||||
|
||||
if (hdr.Mode() & os.ModeSymlink) != 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
return writeNewFile(to, r.rr, hdr.Mode())
|
||||
}
|
||||
|
||||
// OpenFile opens filename for reading. This method supports
|
||||
// multi-volume archives, whereas Open does not (but Open
|
||||
// supports any stream, not just files).
|
||||
func (r *Rar) OpenFile(filename string) error {
|
||||
if r.rr != nil {
|
||||
return fmt.Errorf("rar archive is already open for reading")
|
||||
}
|
||||
var err error
|
||||
r.rc, err = rardecode.OpenReader(filename, r.Password)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
r.rr = &r.rc.Reader
|
||||
return nil
|
||||
}
|
||||
|
||||
// Open opens t for reading an archive from
|
||||
// in. The size parameter is not used.
|
||||
func (r *Rar) Open(in io.Reader, size int64) error {
|
||||
if r.rr != nil {
|
||||
return fmt.Errorf("rar archive is already open for reading")
|
||||
}
|
||||
var err error
|
||||
r.rr, err = rardecode.NewReader(in, r.Password)
|
||||
return err
|
||||
}
|
||||
|
||||
// Read reads the next file from t, which must have
|
||||
// already been opened for reading. If there are no
|
||||
// more files, the error is io.EOF. The File must
|
||||
// be closed when finished reading from it.
|
||||
func (r *Rar) Read() (File, error) {
|
||||
if r.rr == nil {
|
||||
return File{}, fmt.Errorf("rar archive is not open")
|
||||
}
|
||||
|
||||
hdr, err := r.rr.Next()
|
||||
if err != nil {
|
||||
return File{}, err // don't wrap error; preserve io.EOF
|
||||
}
|
||||
|
||||
file := File{
|
||||
FileInfo: rarFileInfo{hdr},
|
||||
Header: hdr,
|
||||
ReadCloser: ReadFakeCloser{r.rr},
|
||||
}
|
||||
|
||||
return file, nil
|
||||
}
|
||||
|
||||
// Close closes the rar archive(s) opened by Create and Open.
|
||||
func (r *Rar) Close() error {
|
||||
var err error
|
||||
if r.rc != nil {
|
||||
rc := r.rc
|
||||
r.rc = nil
|
||||
err = rc.Close()
|
||||
}
|
||||
if r.rr != nil {
|
||||
r.rr = nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
// Walk calls walkFn for each visited item in archive.
|
||||
func (r *Rar) Walk(archive string, walkFn WalkFunc) error {
|
||||
file, err := os.Open(archive)
|
||||
if err != nil {
|
||||
return fmt.Errorf("opening archive file: %v", err)
|
||||
}
|
||||
defer file.Close()
|
||||
|
||||
err = r.Open(file, 0)
|
||||
if err != nil {
|
||||
return fmt.Errorf("opening archive: %v", err)
|
||||
}
|
||||
defer r.Close()
|
||||
|
||||
for {
|
||||
f, err := r.Read()
|
||||
if err == io.EOF {
|
||||
break
|
||||
}
|
||||
if err != nil {
|
||||
if r.ContinueOnError {
|
||||
log.Printf("[ERROR] Opening next file: %v", err)
|
||||
continue
|
||||
}
|
||||
return fmt.Errorf("opening next file: %v", err)
|
||||
}
|
||||
err = walkFn(f)
|
||||
if err != nil {
|
||||
if err == ErrStopWalk {
|
||||
break
|
||||
}
|
||||
if r.ContinueOnError {
|
||||
log.Printf("[ERROR] Walking %s: %v", f.Name(), err)
|
||||
continue
|
||||
}
|
||||
return fmt.Errorf("walking %s: %v", f.Name(), err)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Extract extracts a single file from the rar archive.
|
||||
// If the target is a directory, the entire folder will
|
||||
// be extracted into destination.
|
||||
func (r *Rar) Extract(source, target, destination string) error {
|
||||
// target refers to a path inside the archive, which should be clean also
|
||||
target = path.Clean(target)
|
||||
|
||||
// if the target ends up being a directory, then
|
||||
// we will continue walking and extracting files
|
||||
// until we are no longer within that directory
|
||||
var targetDirPath string
|
||||
|
||||
return r.Walk(source, func(f File) error {
|
||||
th, ok := f.Header.(*rardecode.FileHeader)
|
||||
if !ok {
|
||||
return fmt.Errorf("expected header to be *rardecode.FileHeader but was %T", f.Header)
|
||||
}
|
||||
|
||||
// importantly, cleaning the path strips tailing slash,
|
||||
// which must be appended to folders within the archive
|
||||
name := path.Clean(th.Name)
|
||||
if f.IsDir() && target == name {
|
||||
targetDirPath = path.Dir(name)
|
||||
}
|
||||
|
||||
if within(target, th.Name) {
|
||||
// either this is the exact file we want, or is
|
||||
// in the directory we want to extract
|
||||
|
||||
// build the filename we will extract to
|
||||
end, err := filepath.Rel(targetDirPath, th.Name)
|
||||
if err != nil {
|
||||
return fmt.Errorf("relativizing paths: %v", err)
|
||||
}
|
||||
joined := filepath.Join(destination, end)
|
||||
|
||||
err = r.unrarFile(f, joined)
|
||||
if err != nil {
|
||||
return fmt.Errorf("extracting file %s: %v", th.Name, err)
|
||||
}
|
||||
|
||||
// if our target was not a directory, stop walk
|
||||
if targetDirPath == "" {
|
||||
return ErrStopWalk
|
||||
}
|
||||
} else if targetDirPath != "" {
|
||||
// finished walking the entire directory
|
||||
return ErrStopWalk
|
||||
}
|
||||
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
// Match returns true if the format of file matches this
|
||||
// type's format. It should not affect reader position.
|
||||
func (*Rar) Match(file io.ReadSeeker) (bool, error) {
|
||||
currentPos, err := file.Seek(0, io.SeekCurrent)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
_, err = file.Seek(0, 0)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
defer file.Seek(currentPos, io.SeekStart)
|
||||
|
||||
buf := make([]byte, 8)
|
||||
if n, err := file.Read(buf); err != nil || n < 8 {
|
||||
return false, nil
|
||||
}
|
||||
hasTarHeader := bytes.Equal(buf[:7], []byte("Rar!\x1a\x07\x00")) || // ver 1.5
|
||||
bytes.Equal(buf, []byte("Rar!\x1a\x07\x01\x00")) // ver 5.0
|
||||
return hasTarHeader, nil
|
||||
}
|
||||
|
||||
func (r *Rar) String() string { return "rar" }
|
||||
|
||||
// NewRar returns a new, default instance ready to be customized and used.
|
||||
func NewRar() *Rar {
|
||||
return &Rar{
|
||||
MkdirAll: true,
|
||||
}
|
||||
}
|
||||
|
||||
type rarFileInfo struct {
|
||||
fh *rardecode.FileHeader
|
||||
}
|
||||
|
||||
func (rfi rarFileInfo) Name() string { return rfi.fh.Name }
|
||||
func (rfi rarFileInfo) Size() int64 { return rfi.fh.UnPackedSize }
|
||||
func (rfi rarFileInfo) Mode() os.FileMode { return rfi.fh.Mode() }
|
||||
func (rfi rarFileInfo) ModTime() time.Time { return rfi.fh.ModificationTime }
|
||||
func (rfi rarFileInfo) IsDir() bool { return rfi.fh.IsDir }
|
||||
func (rfi rarFileInfo) Sys() interface{} { return nil }
|
||||
|
||||
// Compile-time checks to ensure type implements desired interfaces.
|
||||
var (
|
||||
_ = Reader(new(Rar))
|
||||
_ = Unarchiver(new(Rar))
|
||||
_ = Walker(new(Rar))
|
||||
_ = Extractor(new(Rar))
|
||||
_ = Matcher(new(Rar))
|
||||
_ = ExtensionChecker(new(Rar))
|
||||
_ = os.FileInfo(rarFileInfo{})
|
||||
)
|
||||
|
||||
// DefaultRar is a default instance that is conveniently ready to use.
|
||||
var DefaultRar = NewRar()
|
||||
Loading…
Add table
Add a link
Reference in a new issue