Clean path before checking if valid.

v0.6.0 fixes

internal/inode/file.go

@@ -9,7 +9,7 @@ import (
 type fileInit struct {
 	BlockStart uint32
 	FragInd    uint32
-	Offset     uint32
+	FragOffset uint32
 	Size       uint32
 }
 
@@ -24,7 +24,7 @@ type eFileInit struct {
 	Sparse     uint64
 	LinkCount  uint32
 	FragInd    uint32
-	Offset     uint32
+	FragOffset uint32
 	XattrInd   uint32
 }
 

reader.go

@@ -96,20 +96,20 @@ func NewReader(r io.ReaderAt) (*Reader, error) {
 				return nil, err
 			}
 		} else {
-			toRead := squash.s.IdCount
+			toRead := squash.s.FragCount
-			var curRead uint16
+			var curRead uint32
 			var tmp []fragEntry
 			var rdr *metadata.Reader
 			var offset int
 			for i := range fragOffsets {
-				curRead = uint16(math.Min(512, float64(toRead)))
+				curRead = uint32(math.Min(512, float64(toRead)))
 				tmp = make([]fragEntry, curRead)
 				rdr = metadata.NewReader(toreader.NewReader(r, int64(fragOffsets[i])), squash.d)
 				err = binary.Read(rdr, binary.LittleEndian, &tmp)
 				if err != nil {
 					return nil, err
 				}
-				offset = int(squash.s.IdCount - toRead)
+				offset = int(squash.s.FragCount - toRead)
 				for i := range tmp {
 					squash.fragEntries[offset+i] = tmp[i]
 				}

reader_file.go

@@ -14,7 +14,7 @@ import (
 	"github.com/CalebQ42/squashfs/internal/inode"
 )
 
-//File represents a file inside a squashfs archive.
+// File represents a file inside a squashfs archive.
 type File struct {
 	i        inode.Inode
 	rdr      io.Reader
@@ -52,12 +52,12 @@ func (r Reader) newFile(en directory.Entry, parent *FS) (*File, error) {
 	}, nil
 }
 
-//Stat returns the File's fs.FileInfo
+// Stat returns the File's fs.FileInfo
 func (f File) Stat() (fs.FileInfo, error) {
 	return newFileInfo(f.e, f.i), nil
 }
 
-//Read reads the data from the file. Only works if file is a normal file.
+// Read reads the data from the file. Only works if file is a normal file.
 func (f File) Read(p []byte) (int, error) {
 	if f.i.Type != inode.Fil && f.i.Type != inode.EFil {
 		return 0, ErrReadNotFile
@@ -68,20 +68,20 @@ func (f File) Read(p []byte) (int, error) {
 	return f.rdr.Read(p)
 }
 
-//WriteTo writes all data from the file to the writer. This is multi-threaded.
+// WriteTo writes all data from the file to the writer. This is multi-threaded.
-//The underlying reader is seperate from the one used with Read and can be reused.
+// The underlying reader is seperate from the one used with Read and can be reused.
 func (f File) WriteTo(w io.Writer) (int64, error) {
 	return f.fullRdr.WriteTo(w)
 }
 
-//Close simply nils the underlying reader. Here mostly to satisfy fs.File
+// Close simply nils the underlying reader. Here mostly to satisfy fs.File
 func (f *File) Close() error {
 	f.rdr = nil
 	return nil
 }
 
-//ReadDir returns n fs.DirEntry's that's contained in the File (if it's a directory).
+// ReadDir returns n fs.DirEntry's that's contained in the File (if it's a directory).
-//If n <= 0 all fs.DirEntry's are returned.
+// If n <= 0 all fs.DirEntry's are returned.
 func (f *File) ReadDir(n int) (out []fs.DirEntry, err error) {
 	if !f.IsDir() {
 		return nil, errors.New("File is not a directory")
@@ -111,7 +111,7 @@ func (f *File) ReadDir(n int) (out []fs.DirEntry, err error) {
 	return
 }
 
-//FS returns the File as a FS.
+// FS returns the File as a FS.
 func (f *File) FS() (*FS, error) {
 	if !f.IsDir() {
 		return nil, errors.New("File is not a directory")
@@ -126,22 +126,22 @@ func (f *File) FS() (*FS, error) {
 	}, nil
 }
 
-//IsDir Yep.
+// IsDir Yep.
 func (f File) IsDir() bool {
 	return f.i.Type == inode.Dir || f.i.Type == inode.EDir
 }
 
-//IsRegular yep.
+// IsRegular yep.
 func (f File) IsRegular() bool {
 	return f.i.Type == inode.Fil || f.i.Type == inode.EFil
 }
 
-//IsSymlink yep.
+// IsSymlink yep.
 func (f File) IsSymlink() bool {
 	return f.i.Type == inode.Sym || f.i.Type == inode.ESym
 }
 
-//SymlinkPath returns the symlink's target path. Is the File isn't a symlink, returns an empty string.
+// SymlinkPath returns the symlink's target path. Is the File isn't a symlink, returns an empty string.
 func (f File) SymlinkPath() string {
 	switch f.i.Type {
 	case inode.Sym:
@@ -159,8 +159,8 @@ func (f File) path() string {
 	return f.parent.path() + "/" + f.e.Name
 }
 
-//GetSymlinkFile returns the File the symlink is pointing to.
+// GetSymlinkFile returns the File the symlink is pointing to.
-//If not a symlink, or the target is unobtainable (such as it being outside the archive or it's absolute) returns nil
+// If not a symlink, or the target is unobtainable (such as it being outside the archive or it's absolute) returns nil
 func (f File) GetSymlinkFile() *File {
 	if !f.IsSymlink() {
 		return nil
@@ -175,7 +175,7 @@ func (f File) GetSymlinkFile() *File {
 	return sym.(*File)
 }
 
-//ExtractionOptions are available options on how to extract.
+// ExtractionOptions are available options on how to extract.
 type ExtractionOptions struct {
 	LogOutput          io.Writer   //Where error log should write. If nil, uses os.Stdout. Has no effect if verbose is false.
 	DereferenceSymlink bool        //Replace symlinks with the target file
@@ -184,21 +184,21 @@ type ExtractionOptions struct {
 	FolderPerm         fs.FileMode //The permissions used when creating the extraction folder
 }
 
-//DefaultOptions is the default ExtractionOptions.
+// DefaultOptions is the default ExtractionOptions.
 func DefaultOptions() ExtractionOptions {
 	return ExtractionOptions{
 		FolderPerm: 0755,
 	}
 }
 
-//ExtractTo extracts the File to the given folder with the default options.
+// ExtractTo extracts the File to the given folder with the default options.
-//If the File is a directory, it instead extracts the directory's contents to the folder.
+// If the File is a directory, it instead extracts the directory's contents to the folder.
 func (f File) ExtractTo(folder string) error {
 	return f.ExtractWithOptions(folder, DefaultOptions())
 }
 
-//ExtractSymlink extracts the File to the folder with the DereferenceSymlink option.
+// ExtractSymlink extracts the File to the folder with the DereferenceSymlink option.
-//If the File is a directory, it instead extracts the directory's contents to the folder.
+// If the File is a directory, it instead extracts the directory's contents to the folder.
 func (f File) ExtractSymlink(folder string) error {
 	return f.ExtractWithOptions(folder, ExtractionOptions{
 		DereferenceSymlink: true,
@@ -206,8 +206,8 @@ func (f File) ExtractSymlink(folder string) error {
 	})
 }
 
-//ExtractWithOptions extracts the File to the given folder with the given ExtrationOptions.
+// ExtractWithOptions extracts the File to the given folder with the given ExtrationOptions.
-//If the File is a directory, it instead extracts the directory's contents to the folder.
+// If the File is a directory, it instead extracts the directory's contents to the folder.
 func (f File) ExtractWithOptions(folder string, op ExtractionOptions) error {
 	if op.Verbose {
 		if op.LogOutput == nil {
@@ -220,13 +220,13 @@ func (f File) ExtractWithOptions(folder string, op ExtractionOptions) error {
 
 func (f File) realExtract(folder string, op ExtractionOptions) error {
 	err := os.MkdirAll(folder, op.FolderPerm)
+	folder = filepath.Clean(folder)
 	if err != nil && !os.IsExist(err) {
 		if op.Verbose {
 			log.Println("Error while creating extraction folder")
 		}
 		return err
 	}
-	folder = filepath.Clean(folder)
 	if f.IsDir() {
 		filFS, _ := f.FS()
 		var ents []directory.Entry

reader_fs.go

@@ -12,8 +12,8 @@ import (
 	"github.com/CalebQ42/squashfs/internal/inode"
 )
 
-//FS is a fs.FS representation of a squashfs directory.
+// FS is a fs.FS representation of a squashfs directory.
-//Implements fs.GlobFS, fs.ReadDirFS, fs.ReadFileFS, fs.StatFS, and fs.SubFS
+// Implements fs.GlobFS, fs.ReadDirFS, fs.ReadFileFS, fs.StatFS, and fs.SubFS
 type FS struct {
 	*File
 	e []directory.Entry
@@ -39,8 +39,9 @@ func (r Reader) newFS(e directory.Entry, parent *FS) (*FS, error) {
 	}, nil
 }
 
-//Open opens the file at name. Returns a squashfs.File.
+// Open opens the file at name. Returns a squashfs.File.
 func (f FS) Open(name string) (fs.File, error) {
+	name = filepath.Clean(name)
 	if !fs.ValidPath(name) {
 		return nil, &fs.PathError{
 			Op:   "open",
@@ -48,7 +49,6 @@ func (f FS) Open(name string) (fs.File, error) {
 			Err:  fs.ErrInvalid,
 		}
 	}
-	name = filepath.Clean(name)
 	if name == "." || name == "" {
 		return f.File, nil
 	}
@@ -96,10 +96,11 @@ func (f FS) Open(name string) (fs.File, error) {
 	}
 }
 
-//Glob returns the name of the files at the given pattern.
+// Glob returns the name of the files at the given pattern.
-//All paths are relative to the FS.
+// All paths are relative to the FS.
-//Uses filepath.Match to compare names.
+// Uses filepath.Match to compare names.
 func (f FS) Glob(pattern string) (out []string, err error) {
+	pattern = filepath.Clean(pattern)
 	if !fs.ValidPath(pattern) {
 		return nil, &fs.PathError{
 			Op:   "glob",
@@ -107,7 +108,6 @@ func (f FS) Glob(pattern string) (out []string, err error) {
 			Err:  fs.ErrInvalid,
 		}
 	}
-	pattern = filepath.Clean(pattern)
 	split := strings.Split(pattern, "/")
 	for i := 0; i < len(f.e); i++ {
 		if match, _ := path.Match(split[0], f.e[i].Name); match {
@@ -131,7 +131,7 @@ func (f FS) Glob(pattern string) (out []string, err error) {
 					Err:  err,
 				}
 			}
-			subGlob, err := sub.(FS).Glob(strings.Join(split[1:], "/"))
+			subGlob, err := sub.(fs.GlobFS).Glob(strings.Join(split[1:], "/"))
 			if err != nil {
 				if pathErr, ok := err.(*fs.PathError); ok {
 					if pathErr.Err == fs.ErrNotExist {
@@ -156,9 +156,10 @@ func (f FS) Glob(pattern string) (out []string, err error) {
 	return
 }
 
-//ReadDir returns all the DirEntry returns all DirEntry's for the directory at name.
+// ReadDir returns all the DirEntry returns all DirEntry's for the directory at name.
-//If name is not a directory, returns an error.
+// If name is not a directory, returns an error.
 func (f FS) ReadDir(name string) ([]fs.DirEntry, error) {
+	name = filepath.Clean(name)
 	if !fs.ValidPath(name) {
 		return nil, &fs.PathError{
 			Op:   "readdir",
@@ -166,7 +167,6 @@ func (f FS) ReadDir(name string) ([]fs.DirEntry, error) {
 			Err:  fs.ErrInvalid,
 		}
 	}
-	name = filepath.Clean(name)
 	if name == "." || name == "" {
 		return f.File.ReadDir(-1)
 	}
@@ -208,7 +208,7 @@ func (f FS) ReadDir(name string) ([]fs.DirEntry, error) {
 					Err:  err,
 				}
 			}
-			redDir, err := sub.(FS).ReadDir(strings.Join(split[1:], "/"))
+			redDir, err := sub.(fs.ReadDirFS).ReadDir(strings.Join(split[1:], "/"))
 			if err != nil {
 				if pathErr, ok := err.(*fs.PathError); ok {
 					if pathErr.Err == fs.ErrNotExist {
@@ -234,7 +234,7 @@ func (f FS) ReadDir(name string) ([]fs.DirEntry, error) {
 	}
 }
 
-//ReadFile returns the data (in []byte) for the file at name.
+// ReadFile returns the data (in []byte) for the file at name.
 func (f FS) ReadFile(name string) ([]byte, error) {
 	fil, err := f.Open(name)
 	if err != nil {
@@ -256,8 +256,9 @@ func (f FS) ReadFile(name string) ([]byte, error) {
 	return buf.Bytes(), nil
 }
 
-//Stat returns the fs.FileInfo for the file at name.
+// Stat returns the fs.FileInfo for the file at name.
 func (f FS) Stat(name string) (fs.FileInfo, error) {
+	name = filepath.Clean(strings.TrimPrefix(name, "/"))
 	if !fs.ValidPath(name) {
 		return nil, &fs.PathError{
 			Op:   "stat",
@@ -265,7 +266,6 @@ func (f FS) Stat(name string) (fs.FileInfo, error) {
 			Err:  fs.ErrInvalid,
 		}
 	}
-	name = filepath.Clean(strings.TrimPrefix(name, "/"))
 	if name == "." || name == "" {
 		return f.File.Stat()
 	}
@@ -299,7 +299,7 @@ func (f FS) Stat(name string) (fs.FileInfo, error) {
 					Err:  err,
 				}
 			}
-			stat, err := sub.(FS).Stat(strings.Join(split[1:], "/"))
+			stat, err := sub.(fs.StatFS).Stat(strings.Join(split[1:], "/"))
 			if err != nil {
 				if pathErr, ok := err.(*fs.PathError); ok {
 					if pathErr.Err == fs.ErrNotExist {
@@ -325,8 +325,9 @@ func (f FS) Stat(name string) (fs.FileInfo, error) {
 	}
 }
 
-//Sub returns the FS at dir
+// Sub returns the FS at dir
 func (f FS) Sub(dir string) (fs.FS, error) {
+	dir = filepath.Clean(dir)
 	if !fs.ValidPath(dir) {
 		return nil, &fs.PathError{
 			Op:   "sub",
@@ -334,7 +335,6 @@ func (f FS) Sub(dir string) (fs.FS, error) {
 			Err:  fs.ErrInvalid,
 		}
 	}
-	dir = filepath.Clean(dir)
 	if dir == "." || dir == "" {
 		return f, nil
 	}

reader_inode.go

@@ -37,13 +37,13 @@ func (r Reader) getReaders(i inode.Inode) (full *data.FullReader, rdr *data.Read
 	var fragInd uint32
 	var fragSize uint32
 	if i.Type == inode.Fil {
-		fragOffset = uint64(i.Data.(inode.File).Offset)
+		fragOffset = uint64(i.Data.(inode.File).FragOffset)
 		blockOffset = uint64(i.Data.(inode.File).BlockStart)
 		blockSizes = i.Data.(inode.File).BlockSizes
 		fragInd = i.Data.(inode.File).FragInd
 		fragSize = i.Data.(inode.File).Size % r.s.BlockSize
 	} else if i.Type == inode.EFil {
-		fragOffset = uint64(i.Data.(inode.EFile).Offset)
+		fragOffset = uint64(i.Data.(inode.EFile).FragOffset)
 		blockOffset = i.Data.(inode.EFile).BlockStart
 		blockSizes = i.Data.(inode.EFile).BlockSizes
 		fragInd = i.Data.(inode.EFile).FragInd
@@ -60,10 +60,14 @@ func (r Reader) getReaders(i inode.Inode) (full *data.FullReader, rdr *data.Read
 			if err != nil {
 				return nil, err
 			}
-			_, err = fragRdr.Read(make([]byte, fragOffset))
+			var n, tmpN int
+			for n != int(fragOffset) {
+				tmpN, err = fragRdr.Read(make([]byte, int(fragOffset)-n))
 				if err != nil {
 					return nil, err
 				}
+				n += tmpN
+			}
 			fragRdr = io.LimitReader(fragRdr, int64(fragSize))
 			return fragRdr, nil
 		})
@@ -72,10 +76,14 @@ func (r Reader) getReaders(i inode.Inode) (full *data.FullReader, rdr *data.Read
 		if err != nil {
 			return nil, nil, err
 		}
-		_, err = fragRdr.Read(make([]byte, fragOffset))
+		var n, tmpN int
+		for n != int(fragOffset) {
+			tmpN, err = fragRdr.Read(make([]byte, int(fragOffset)-n))
 			if err != nil {
 				return nil, nil, err
 			}
+			n += tmpN
+		}
 		fragRdr = io.LimitReader(fragRdr, int64(fragSize))
 		rdr.AddFragment(fragRdr)
 	}

squashfs_test.go

@@ -20,6 +20,8 @@ import (
 const (
 	squashfsURL  = "https://darkstorm.tech/LinuxPATest.sfs"
 	squashfsName = "LinuxPATest.sfs"
+
+	filePath = "PortableApps/Notepad++Portable/App/DefaultData/Config/contextMenu.xml"
 )
 
 func preTest(dir string) (fil *os.File, err error) {
@@ -55,6 +57,21 @@ func preTest(dir string) (fil *os.File, err error) {
 	return
 }
 
+func TestMisc(t *testing.T) {
+	tmpDir := "testing"
+	fil, err := preTest(tmpDir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	rdr, err := squashfs.NewReader(fil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_ = rdr
+	// Put testing here
+	t.Fatal("UM")
+}
+
 func BenchmarkRace(b *testing.B) {
 	// tmpDir := b.TempDir()
 	tmpDir := "testing"
@@ -142,4 +159,29 @@ func TestExtractQuick(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	t.Fatal("end")
+}
+
+func TestSingleFile(t *testing.T) {
+	tmpDir := "testing"
+	fil, err := preTest(tmpDir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	os.Remove(filepath.Base(filePath))
+	rdr, err := squashfs.NewReader(fil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	f, err := rdr.Open(filePath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	op := squashfs.DefaultOptions()
+	op.Verbose = true
+	err = f.(*squashfs.File).ExtractWithOptions("testing", op)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Fatal("HI")
 }