Fixed issues with fragments

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
-			var curRead uint16
+			toRead := squash.s.FragCount
+			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_fs.go

@@ -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 {
@@ -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 {
@@ -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 {

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,9 +60,13 @@ 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))
-			if err != nil {
-				return nil, err
+			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,9 +76,13 @@ 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))
-		if err != nil {
-			return nil, nil, err
+		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) {
@@ -142,4 +144,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")
 }