Added ReaderAtOffset

Fuse SUCCESS

README.md

@@ -17,6 +17,4 @@ Thanks also to [distri's squashfs library](https://github.com/distr1/distri/tree
 
 ## Performance
 
-This library, decompressing the Firefox AppImage and using go tests, takes about twice as long as `unsquashfs` on my quad core laptop. (~1 second with the library and about half a second with `unsquashfs`).
+Testing on a zstd compressed file, my library is anywhere from 5x ~ 7x slower then `unsquashfs`
-
-**My recents tests have shown the Firefox AppImage might be an outlier and this library might be considerably slower (4x ~ 6x time slower then `unsquashfs`)**

fuse.go

@@ -0,0 +1,123 @@
+package squashfs
+
+import (
+	"bytes"
+	"context"
+	"io"
+
+	"github.com/CalebQ42/fuse"
+	"github.com/CalebQ42/fuse/fs"
+	"github.com/CalebQ42/squashfs/internal/inode"
+)
+
+// Creates a fuse mount, then mounts the archive on a seperate goroutine.
+// If waiting for the mount to end, simply do <-con.Ready.
+func (r *Reader) Mount(mountpoint string) (con *fuse.Conn, err error) {
+	con, err = fuse.Mount(mountpoint, fuse.ReadOnly())
+	if err != nil {
+		return
+	}
+	go fs.Serve(con, &squashFuse{r: r})
+	return
+}
+
+type squashFuse struct {
+	r *Reader
+}
+
+func (s *squashFuse) Root() (fs.Node, error) {
+	return &fileNode{File: s.r.FS.File}, nil
+}
+
+type fileNode struct {
+	*File
+}
+
+func (f *fileNode) Attr(ctx context.Context, attr *fuse.Attr) error {
+	attr.Blocks = f.r.s.Size / 512
+	if f.r.s.Size%512 > 0 {
+		attr.Blocks++
+	}
+	attr.Gid = f.r.ids[f.i.GidInd]
+	attr.Inode = uint64(f.i.Num)
+	attr.Mode = f.i.Mode()
+	attr.Nlink = f.i.LinkCount()
+	attr.Size = f.i.Size()
+	attr.Uid = f.r.ids[f.i.UidInd]
+	return nil
+}
+
+func (f *fileNode) Id() uint64 {
+	return uint64(f.i.Num)
+}
+
+func (f *fileNode) Readlink(ctx context.Context, req *fuse.ReadlinkRequest) (string, error) {
+	return f.SymlinkPath(), nil
+}
+
+func (f *fileNode) Lookup(ctx context.Context, name string) (fs.Node, error) {
+	asFS, err := f.FS()
+	if err != nil {
+		return nil, fuse.ENOTDIR
+	}
+	ret, err := asFS.OpenFile(name)
+	if err != nil {
+		return nil, fuse.ENOENT
+	}
+	return &fileNode{File: ret}, nil
+}
+
+func (f *fileNode) ReadAll(ctx context.Context) ([]byte, error) {
+	if f.IsRegular() {
+		var buf bytes.Buffer
+		_, err := f.WriteTo(&buf)
+		return buf.Bytes(), err
+	}
+	return nil, fuse.ENODATA
+}
+
+func (f *fileNode) Read(ctx context.Context, req *fuse.ReadRequest, resp *fuse.ReadResponse) error {
+	if f.IsRegular() {
+		buf := make([]byte, req.Size)
+		n, err := f.File.ReadAt(buf, req.Offset)
+		if err == io.EOF {
+			resp.Data = buf[:n]
+		}
+		return nil
+	}
+	return fuse.ENODATA
+}
+
+func (f *fileNode) ReadDirAll(ctx context.Context) (out []fuse.Dirent, err error) {
+	asFS, err := f.FS()
+	if err != nil {
+		return nil, fuse.ENOTDIR
+	}
+	var t fuse.DirentType
+	for i := range asFS.e {
+		switch asFS.e[i].Type {
+		case inode.Fil:
+			t = fuse.DT_File
+		case inode.Dir:
+			t = fuse.DT_Dir
+		case inode.Block:
+			t = fuse.DT_Block
+		case inode.Sym:
+			t = fuse.DT_Link
+		case inode.Char:
+			t = fuse.DT_Char
+		case inode.Fifo:
+			t = fuse.DT_FIFO
+		case inode.Sock:
+			t = fuse.DT_Socket
+		default:
+			t = fuse.DT_Unknown
+		}
+		out = append(out, fuse.Dirent{
+			Inode: uint64(asFS.e[i].Num),
+			Type:  t,
+			Name:  asFS.e[i].Name,
+		})
+	}
+	return
+}

go.mod

@@ -3,9 +3,12 @@ module github.com/CalebQ42/squashfs
 go 1.19
 
 require (
-	github.com/klauspost/compress v1.15.9
+	github.com/CalebQ42/fuse v0.1.0
-	github.com/pierrec/lz4/v4 v4.1.15
+	github.com/klauspost/compress v1.15.12
+	github.com/pierrec/lz4/v4 v4.1.17
 	github.com/rasky/go-lzo v0.0.0-20200203143853-96a758eda86e
 	github.com/therootcompany/xz v1.0.1
 	github.com/ulikunitz/xz v0.5.10
 )
+
+require golang.org/x/sys v0.2.0 // indirect

go.sum

@@ -1,10 +1,14 @@
-github.com/klauspost/compress v1.15.9 h1:wKRjX6JRtDdrE9qwa4b/Cip7ACOshUI4smpCQanqjSY=
+github.com/CalebQ42/fuse v0.1.0 h1:KLCNjun7zcd2kBNVFfH+SWJyhuwJdE0nhw5/q8K8HGQ=
-github.com/klauspost/compress v1.15.9/go.mod h1:PhcZ0MbTNciWF3rruxRgKxI5NkcHHrHUDtV4Yw2GlzU=
+github.com/CalebQ42/fuse v0.1.0/go.mod h1:pJpoKG03HJKVhsp8o0YQYqmfbFsr3Eowt90yQGQVO+4=
-github.com/pierrec/lz4/v4 v4.1.15 h1:MO0/ucJhngq7299dKLwIMtgTfbkoSPF6AoMYDd8Q4q0=
+github.com/klauspost/compress v1.15.12 h1:YClS/PImqYbn+UILDnqxQCZ3RehC9N318SU3kElDUEM=
-github.com/pierrec/lz4/v4 v4.1.15/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
+github.com/klauspost/compress v1.15.12/go.mod h1:QPwzmACJjUTFsnSHH934V6woptycfrDDJnH7hvFVbGM=
+github.com/pierrec/lz4/v4 v4.1.17 h1:kV4Ip+/hUBC+8T6+2EgburRtkE9ef4nbY3f4dFhGjMc=
+github.com/pierrec/lz4/v4 v4.1.17/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/rasky/go-lzo v0.0.0-20200203143853-96a758eda86e h1:dCWirM5F3wMY+cmRda/B1BiPsFtmzXqV9b0hLWtVBMs=
 github.com/rasky/go-lzo v0.0.0-20200203143853-96a758eda86e/go.mod h1:9leZcVcItj6m9/CfHY5Em/iBrCz7js8LcRQGTKEEv2M=
 github.com/therootcompany/xz v1.0.1 h1:CmOtsn1CbtmyYiusbfmhmkpAAETj0wBIH6kCYaX+xzw=
 github.com/therootcompany/xz v1.0.1/go.mod h1:3K3UH1yCKgBneZYhuQUvJ9HPD19UEXEI0BWbMn8qNMY=
 github.com/ulikunitz/xz v0.5.10 h1:t92gobL9l3HE202wg3rlk19F6X+JOxl9BBrCCMYEYd8=
 github.com/ulikunitz/xz v0.5.10/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
+golang.org/x/sys v0.2.0 h1:ljd4t30dBnAvMZaQCevtY0xLLD0A+bRZXbgLMLU1F/A=
+golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

internal/data/fullreader.go

@@ -2,6 +2,7 @@ package data
 
 import (
 	"io"
+	"sync"
 
 	"github.com/CalebQ42/squashfs/internal/decompress"
 	"github.com/CalebQ42/squashfs/internal/toreader"
@@ -26,9 +27,9 @@ func NewFullReader(r io.ReaderAt, start uint64, d decompress.Decompressor, block
 	}
 }
 
-func (r *FullReader) AddFragment(rdr func() (io.Reader, error)) {
+func (r *FullReader) AddFragment(rdr func() (io.Reader, error), size uint32) {
 	r.fragRdr = rdr
-	r.sizes = append(r.sizes, 0)
+	r.sizes = append(r.sizes, size)
 }
 
 type outDat struct {
@@ -37,88 +38,188 @@ type outDat struct {
 	i    int
 }
 
-func (r FullReader) process(index int, offset int64, out chan outDat) {
+func (r FullReader) process(index int, offset int64, od *outDat, out chan *outDat) {
-	var err error
+	defer func() {
-	var dat []byte
+		out <- od
-	var rdr io.ReadCloser
+	}()
+	od.i = index
 	size := realSize(r.sizes[index])
 	if size == 0 {
-		out <- outDat{
+		od.err = nil
-			i:    index,
+		od.data = make([]byte, r.blockSize)
-			err:  nil,
-			data: make([]byte, r.blockSize),
-		}
 		return
 	}
-	// rdr := io.LimitReader(toreader.NewReader(r.r, offset), int64(size))
 	if size == r.sizes[index] {
-		//Special workaround for zstd for increased performancce.
+		if dec, ok := r.d.(decompress.Decoder); ok {
-		if zstd, ok := r.d.(*decompress.Zstd); ok {
+			dat := make([]byte, size)
-			dat = make([]byte, size)
+			_, od.err = r.r.ReadAt(dat, offset)
-			_, err = r.r.ReadAt(dat, offset)
+			if od.err != nil {
-			if err == nil {
+				return
-				dat, err = zstd.Decode(dat)
 			}
+			od.data, od.err = dec.Decode(dat, int(r.blockSize))
+			return
+		}
+		var rdr io.ReadCloser
+		rdr, od.err = r.d.Reader(io.LimitReader(toreader.NewReader(r.r, offset), int64(size)))
+		if od.err != nil {
+			return
+		}
+		od.data = make([]byte, r.blockSize)
+		var read int
+		read, od.err = rdr.Read(od.data)
+		od.data = od.data[:read]
+		rdr.Close()
 	} else {
-			rdr, err = r.d.Reader(io.LimitReader(toreader.NewReader(r.r, offset), int64(size)))
+		od.data = make([]byte, size)
-			if err == nil {
+		_, od.err = r.r.ReadAt(od.data, offset)
-				dat, err = io.ReadAll(rdr)
-			}
-		}
-	} else {
-		dat = make([]byte, size)
-		_, err = r.r.ReadAt(dat, offset)
-	}
-	out <- outDat{
-		i:    index,
-		err:  err,
-		data: dat,
-	}
-	if clr, ok := rdr.(io.Closer); ok {
-		clr.Close()
 	}
 }
 
-func (r FullReader) WriteTo(w io.Writer) (n int64, err error) {
+func (r FullReader) ReadAt(p []byte, off int64) (n int, err error) {
-	out := make(chan outDat, len(r.sizes))
+	pol := &sync.Pool{
+		New: func() any {
+			return new(outDat)
+		},
+	}
+	out := make(chan *outDat, len(r.sizes))
 	offset := r.start
 	num := len(r.sizes)
+	start := off / int64(r.blockSize)
+	end := len(p) / int(r.blockSize)
+	if end%int(r.blockSize) > 0 {
+		end++
+	}
+	if end > len(r.sizes) {
+		if r.fragRdr != nil {
+			end = len(r.sizes)
+		} else {
+			end = len(r.sizes) + 1
+		}
+	}
 	for i := 0; i < num; i++ {
+		if i < int(start) || i > end {
+			offset += uint64(realSize(r.sizes[i]))
+			continue
+		}
+		od := pol.Get().(*outDat)
 		if i == num-1 && r.fragRdr != nil {
 			go func() {
+				defer func() {
+					out <- od
+				}()
 				rdr, e := r.fragRdr()
 				if err != nil {
-					out <- outDat{
+					od.i = num - 1
-						i:   num - 1,
+					od.err = e
-						err: e,
-					}
 					return
 				}
-				dat, e := io.ReadAll(rdr)
+				od.data = make([]byte, r.sizes[num-1])
-				out <- outDat{
+				_, e = rdr.Read(od.data)
-					i:    num - 1,
+				od.i = num - 1
-					err:  e,
+				od.err = e
-					data: dat,
-				}
 				if clr, ok := rdr.(io.Closer); ok {
 					clr.Close()
 				}
 			}()
 			continue
 		}
-		go r.process(i, int64(offset), out)
+		go r.process(i, int64(offset), od, out)
 		offset += uint64(realSize(r.sizes[i]))
 	}
+	cur := start
+	cache := make(map[int]outDat)
+	for dat := range out {
+		if dat.err != nil {
+			err = dat.err
+			pol.Put(dat)
+			return
+		}
+		if dat.i != int(cur) {
+			cache[dat.i] = *dat
+			pol.Put(dat)
+			continue
+		}
+		if cur == start {
+			dat.data = dat.data[off%int64(r.blockSize):]
+		}
+		for i := range dat.data {
+			p[n+i] = dat.data[i]
+		}
+		n += len(dat.data)
+		cur++
+		pol.Put(dat)
+		var ok bool
+		var curDat outDat
+		for {
+			curDat, ok = cache[int(cur)]
+			if !ok {
+				break
+			}
+			for i := range curDat.data {
+				p[n+i] = curDat.data[i]
+			}
+			n += len(curDat.data)
+			cur++
+			delete(cache, int(cur))
+		}
+	}
+	if n < len(p) {
+		err = io.EOF
+	}
+	return
+}
+
+func (r FullReader) WriteTo(w io.Writer) (n int64, err error) {
+	pol := &sync.Pool{
+		New: func() any {
+			return new(outDat)
+		},
+	}
+	out := make(chan *outDat, len(r.sizes))
+	offset := r.start
+	num := len(r.sizes)
+	for i := 0; i < num; i++ {
+		od := pol.Get().(*outDat)
+		if i == num-1 && r.fragRdr != nil {
+			go func() {
+				defer func() {
+					out <- od
+				}()
+				rdr, e := r.fragRdr()
+				if err != nil {
+					od.i = num - 1
+					od.err = e
+					return
+				}
+				buf := make([]byte, r.sizes[num-1])
+				_, e = rdr.Read(buf)
+				od.i = num - 1
+				od.err = e
+				od.data = buf
+				if clr, ok := rdr.(io.Closer); ok {
+					clr.Close()
+				}
+			}()
+			continue
+		}
+		go r.process(i, int64(offset), od, out)
+		offset += uint64(realSize(r.sizes[i]))
+	}
+	wt, ok := w.(io.WriterAt)
+	if !ok {
+		var cur int
 		cache := make(map[int]outDat)
 		var tmpN int
-	for cur := 0; cur < num; {
+		var dat *outDat
-		dat := <-out
+		for cur < len(r.sizes) {
+			dat = <-out
+			defer pol.Put(dat)
 			if dat.err != nil {
 				err = dat.err
 				return
 			}
 			if dat.i != cur {
-			cache[dat.i] = dat
+				cache[dat.i] = *dat
 				continue
 			}
 			tmpN, err = w.Write(dat.data)
@@ -128,12 +229,13 @@ func (r FullReader) WriteTo(w io.Writer) (n int64, err error) {
 			}
 			cur++
 			var ok bool
+			var curDat outDat
 			for {
-			dat, ok = cache[cur]
+				curDat, ok = cache[cur]
 				if !ok {
 					break
 				}
-			tmpN, err = w.Write(dat.data)
+				tmpN, err = w.Write(curDat.data)
 				n += int64(tmpN)
 				if err != nil {
 					return
@@ -141,5 +243,22 @@ func (r FullReader) WriteTo(w io.Writer) (n int64, err error) {
 				cur++
 			}
 		}
+	} else {
+		var done int
+		var dat *outDat
+		for done < len(r.sizes) {
+			dat = <-out
+			defer pol.Put(dat)
+			if dat.err != nil {
+				err = dat.err
+				return
+			}
+			_, err = wt.WriteAt(dat.data, int64(dat.i*int(r.blockSize)))
+			if err != nil {
+				return
+			}
+			done++
+		}
+	}
 	return
 }

internal/data/reader.go

@@ -53,14 +53,14 @@ func (r *Reader) advance() (err error) {
 		} else {
 			r.cur = io.LimitReader(r.master, int64(size))
 			if size == r.blockSizes[0] {
-				if r.d.Resetable() {
+				if rs, ok := r.d.(decompress.Resetable); ok {
 					if r.comRdr == nil {
 						r.cur, err = r.d.Reader(r.cur)
 						if err != nil {
 							return
 						}
 					} else {
-						err = r.d.Reset(r.comRdr, r.cur)
+						err = rs.Reset(r.comRdr, r.cur)
 						r.cur = r.comRdr
 					}
 				} else {

internal/decompress/gzip.go

@@ -12,8 +12,6 @@ func (g GZip) Reader(src io.Reader) (io.ReadCloser, error) {
 	return zlib.NewReader(src)
 }
 
-func (g GZip) Resetable() bool { return true }
-
 func (g GZip) Reset(old, src io.Reader) error {
 	return old.(zlib.Resetter).Reset(src, nil)
 }

internal/decompress/interface.go

@@ -1,19 +1,22 @@
 package decompress
 
 import (
-	"errors"
 	"io"
 )
 
-var ErrNotResetable = errors.New("decompressor not resetable")
-
 type Decompressor interface {
 	//Creates a new decompressor reading from src.
 	Reader(src io.Reader) (io.ReadCloser, error)
-	//Reports whether Reset will work or not.
+}
-	Resetable() bool
+
+type Resetable interface {
 	//Reset attempts to re-use an old decompressor with new data.
 	//Will return ErrNotResetable if not Resetable().
 	//Must ALWAYS be provided with a reader created with Reader.
 	Reset(old, src io.Reader) error
 }
+
+type Decoder interface {
+	//Decodes a chunk of data all at once.
+	Decode(in []byte, outSize int) ([]byte, error)
+}

internal/decompress/lz4.go

@@ -12,9 +12,16 @@ func (l Lz4) Reader(r io.Reader) (io.ReadCloser, error) {
 	return io.NopCloser(lz4.NewReader(r)), nil
 }
 
-func (l Lz4) Resetable() bool { return true }
-
 func (l Lz4) Reset(old, src io.Reader) error {
 	old.(*lz4.Reader).Reset(src)
 	return nil
 }
+
+func (l Lz4) Decode(in []byte, outSize int) (out []byte, err error) {
+	out = make([]byte, outSize)
+	outLen, err := lz4.UncompressBlock(in, out)
+	if outLen < outSize {
+		out = out[:outLen]
+	}
+	return
+}

internal/decompress/lzma.go

@@ -12,7 +12,3 @@ func (l Lzma) Reader(r io.Reader) (io.ReadCloser, error) {
 	rdr, err := lzma.NewReader(r)
 	return io.NopCloser(rdr), err
 }
-
-func (l Lzma) Resetable() bool { return false }
-
-func (l Lzma) Reset(old, src io.Reader) error { return ErrNotResetable }

internal/decompress/lzo.go

@@ -16,7 +16,3 @@ func (l Lzo) Reader(r io.Reader) (io.ReadCloser, error) {
 	}
 	return io.NopCloser(bytes.NewReader(cache)), nil
 }
-
-func (l Lzo) Resetable() bool { return false }
-
-func (l Lzo) Reset(old, src io.Reader) error { return ErrNotResetable }

internal/decompress/xz.go

@@ -13,8 +13,6 @@ func (x Xz) Reader(r io.Reader) (io.ReadCloser, error) {
 	return io.NopCloser(rdr), err
 }
 
-func (x Xz) Resetable() bool { return true }
-
 func (x Xz) Reset(old, src io.Reader) error {
 	return old.(*xz.Reader).Reset(src)
 }

internal/decompress/zstd.go

@@ -15,15 +15,13 @@ func (z Zstd) Reader(src io.Reader) (io.ReadCloser, error) {
 	return r.IOReadCloser(), err
 }
 
-func (z Zstd) Resetable() bool { return true }
-
 func (z Zstd) Reset(old, src io.Reader) error {
 	return old.(*zstd.Decoder).Reset(src)
 }
 
-func (z *Zstd) Decode(in []byte) (out []byte, err error) {
+func (z Zstd) Decode(in []byte, outSize int) ([]byte, error) {
 	if z.writeToReader == nil {
 		z.writeToReader, _ = zstd.NewReader(nil)
 	}
-	return z.writeToReader.DecodeAll(in, nil)
+	return z.writeToReader.DecodeAll(in, make([]byte, outSize))
 }

internal/directory/directory.go

@@ -29,6 +29,7 @@ type Entry struct {
 	BlockStart uint32
 	Type       uint16
 	Offset     uint16
+	Num        uint32
 }
 
 func readEntry(r io.Reader) (e entry, err error) {
@@ -72,6 +73,7 @@ func ReadEntries(rdr io.Reader, size uint32) (e []Entry, err error) {
 				BlockStart: h.InodeStart,
 				Type:       en.Type,
 				Offset:     en.Offset,
+				Num:        h.Num + uint32(en.NumOffset),
 			})
 		}
 	}

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
 }
 

internal/inode/inode.go

@@ -4,6 +4,7 @@ import (
 	"encoding/binary"
 	"errors"
 	"io"
+	"io/fs"
 	"strconv"
 )
 
@@ -77,3 +78,66 @@ func Read(r io.Reader, blockSize uint32) (i Inode, err error) {
 	}
 	return
 }
+
+func (i Inode) Mode() (out fs.FileMode) {
+	out = fs.FileMode(i.Perm)
+	switch i.Data.(type) {
+	case Directory:
+		out |= fs.ModeDir
+	case EDirectory:
+		out |= fs.ModeDir
+	case Symlink:
+		out |= fs.ModeSymlink
+	case ESymlink:
+		out |= fs.ModeSymlink
+	case Device:
+		out |= fs.ModeDevice
+	case EDevice:
+		out |= fs.ModeDevice
+	case IPC:
+		out |= fs.ModeNamedPipe
+	case EIPC:
+		out |= fs.ModeNamedPipe
+	}
+	return
+}
+
+func (i Inode) LinkCount() uint32 {
+	switch i.Data.(type) {
+	case EFile:
+		return i.Data.(EFile).LinkCount
+	case Directory:
+		return i.Data.(Directory).LinkCount
+	case EDirectory:
+		return i.Data.(EDirectory).LinkCount
+	case Device:
+		return i.Data.(Device).LinkCount
+	case EDevice:
+		return i.Data.(EDevice).LinkCount
+	case IPC:
+		return i.Data.(IPC).LinkCount
+	case EIPC:
+		return i.Data.(EIPC).LinkCount
+	case Symlink:
+		return i.Data.(Symlink).LinkCount
+	case ESymlink:
+		return i.Data.(ESymlink).LinkCount
+	default:
+		return 0
+	}
+}
+
+func (i Inode) Size() uint64 {
+	switch i.Data.(type) {
+	case File:
+		return uint64(i.Data.(File).Size)
+	case EFile:
+		return i.Data.(EFile).Size
+	// case Directory:
+	// 	return uint64(i.Data.(Directory).Size)
+	// case EDirectory:
+	// 	return uint64(i.Data.(EDirectory).Size)
+	default:
+		return 0
+	}
+}

internal/metadata/reader.go

@@ -26,7 +26,7 @@ func realSize(siz uint16) uint16 {
 }
 
 func (r *Reader) advance() (err error) {
-	if !r.d.Resetable() {
+	if _, ok := r.d.(decompress.Resetable); !ok {
 		if clr, ok := r.cur.(io.Closer); ok {
 			clr.Close()
 		}
@@ -39,14 +39,14 @@ func (r *Reader) advance() (err error) {
 	size := realSize(raw)
 	r.cur = io.LimitReader(r.master, int64(size))
 	if size == raw {
-		if r.d.Resetable() {
+		if rs, ok := r.d.(decompress.Resetable); ok {
 			if r.comRdr == nil {
 				r.cur, err = r.d.Reader(r.cur)
 				if err != nil {
 					return
 				}
 			} else {
-				err = r.d.Reset(r.comRdr, r.cur)
+				err = rs.Reset(r.comRdr, r.cur)
 				r.cur = r.comRdr
 			}
 		} else {

internal/toreader/offsetreader.go

@@ -0,0 +1,19 @@
+package toreader
+
+import "io"
+
+type OffsetReader struct {
+	r   io.ReaderAt
+	off int64
+}
+
+func NewOffsetReader(r io.ReaderAt, off int64) *OffsetReader {
+	return &OffsetReader{
+		r:   r,
+		off: off,
+	}
+}
+
+func (r OffsetReader) ReadAt(p []byte, off int64) (n int, e error) {
+	return r.r.ReadAt(p, off+r.off)
+}

internal/toreader/readerat.go

@@ -6,7 +6,8 @@ type ReaderAt struct {
 	d []byte
 }
 
-func NewReaderAt(r io.Reader) (ra ReaderAt, err error) {
+func NewReaderAt(r io.Reader) (ra *ReaderAt, err error) {
+	ra = new(ReaderAt)
 	ra.d, err = io.ReadAll(r)
 	return
 }

reader.go

@@ -40,6 +40,10 @@ const (
 	ZSTDCompression
 )
 
+func NewReaderAtOffset(r io.ReaderAt, off int64) (*Reader, error) {
+	return NewReader(toreader.NewOffsetReader(r, off))
+}
+
 // Creates a new squashfs.Reader from the given io.Reader. NOTE: All data from the io.Reader will be read and stored in memory.
 func NewReaderFromReader(r io.Reader) (*Reader, error) {
 	rdr, err := toreader.NewReaderAt(r)
@@ -96,20 +100,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

@@ -10,6 +10,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/CalebQ42/squashfs/internal/data"
 	"github.com/CalebQ42/squashfs/internal/directory"
 	"github.com/CalebQ42/squashfs/internal/inode"
 )
@@ -18,7 +19,7 @@ import (
 type File struct {
 	i        inode.Inode
 	rdr      io.Reader
-	fullRdr  io.WriterTo
+	fullRdr  *data.FullReader
 	r        *Reader
 	parent   *FS
 	e        directory.Entry
@@ -35,7 +36,7 @@ func (r Reader) newFile(en directory.Entry, parent *FS) (*File, error) {
 		return nil, err
 	}
 	var rdr io.Reader
-	var full io.WriterTo
+	var full *data.FullReader
 	if i.Type == inode.Fil || i.Type == inode.EFil {
 		full, rdr, err = r.getReaders(i)
 		if err != nil {
@@ -68,6 +69,10 @@ func (f File) Read(p []byte) (int, error) {
 	return f.rdr.Read(p)
 }
 
+func (f File) ReadAt(p []byte, off int64) (int, error) {
+	return f.fullRdr.ReadAt(p, off)
+}
+
 // 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.
 func (f File) WriteTo(w io.Writer) (int64, error) {
@@ -220,13 +225,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

@@ -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.
+// Opens the file at name. Returns a squashfs.File.
-func (f FS) Open(name string) (fs.File, error) {
+func (f FS) OpenFile(name string) (*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
 	}
@@ -73,7 +73,7 @@ func (f FS) Open(name string) (fs.File, error) {
 					Err:  err,
 				}
 			}
-			out, err := newFS.Open(strings.Join(split[1:], "/"))
+			out, err := newFS.OpenFile(strings.Join(split[1:], "/"))
 			if err != nil {
 				err.(*fs.PathError).Path = name
 			}
@@ -96,10 +96,16 @@ func (f FS) Open(name string) (fs.File, error) {
 	}
 }
 
+// Opens the file at name. Returns a io/fs.File.
+func (f FS) Open(name string) (fs.File, error) {
+	return f.OpenFile(name)
+}
+
 // Glob returns the name of the files at the given pattern.
 // All paths are relative to the FS.
 // 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 +113,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 +136,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 {
@@ -159,6 +164,7 @@ func (f FS) Glob(pattern string) (out []string, err error) {
 // ReadDir returns all the DirEntry returns all DirEntry's for the directory at name.
 // 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 +172,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 +213,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 {
@@ -258,6 +263,7 @@ func (f FS) ReadFile(name string) ([]byte, error) {
 
 // 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 +271,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 +304,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 {
@@ -327,6 +332,7 @@ func (f FS) Stat(name string) (fs.FileInfo, error) {
 
 // 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 +340,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,22 +60,30 @@ 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
-		})
+		}, fragSize)
 		var fragRdr io.Reader
 		fragRdr, err = r.fragReader(fragInd)
 		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,8 +57,22 @@ 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"
 	fil, err := preTest(tmpDir)
 	if err != nil {
@@ -142,4 +158,49 @@ 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")
+}
+
+func TestFuse(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)
+	}
+	con, err := rdr.Mount("testing/fuseTest")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer con.Close()
+	<-con.Ready
+	t.Fatal("testing")
 }