Added fragment calculations (untested).

Added 1.16 io/fs interfaces

README.md

@@ -8,7 +8,11 @@ Currently has support for reading squashfs files and extracting files and folder
 
 The only major thing missing from squashfs reading is Xattr parsing.
 
-Special thanks to https://dr-emann.github.io/squashfs/ for some VERY important information in an easy to understand format.
+Special thanks to <https://dr-emann.github.io/squashfs/> for some VERY important information in an easy to understand format.
 Thanks also to [distri's squashfs library](https://github.com/distr1/distri/tree/master/internal/squashfs) as I referenced it to figure some things out (and double check others).
 
-# [TODO](https://github.com/CalebQ42/squashfs/projects/1?fullscreen=true)
+## Performane
+
+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`)
+
+## [TODO](https://github.com/CalebQ42/squashfs/projects/1?fullscreen=true)

bufferedwriter.go

@@ -0,0 +1,63 @@
+package squashfs
+
+import (
+	"io"
+)
+
+type bufferedBytes struct {
+	data []byte
+	r    offsetRange
+}
+
+type offsetRange struct {
+	beg int
+	end int
+}
+
+func (o *offsetRange) offset(off int) {
+	o.beg += off
+	o.end += off
+}
+
+func (o offsetRange) within(check int) bool {
+	return check >= o.beg || check <= o.end
+}
+
+type bufferedWriter struct {
+	w          io.Writer
+	buffer     []bufferedBytes
+	mainOffset int
+}
+
+func newBufferedWriter(w io.Writer) *bufferedWriter {
+	var out bufferedWriter
+	out.w = w
+	return &out
+}
+
+func (b *bufferedWriter) WriteTo(data []byte, offset int64) (n int, err error) {
+	if int(offset) == b.mainOffset {
+		n, err = b.Write(data)
+		if err != nil {
+			return
+		}
+	}
+	newBuff := bufferedBytes{
+		data: data,
+		r: offsetRange{
+			beg: int(offset),
+			end: int(offset) + len(data),
+		},
+	}
+	b.buffer = append(b.buffer, newBuff)
+	return 0, nil
+}
+
+func (b *bufferedWriter) Write(data []byte) (int, error) {
+	n, err := b.w.Write(data)
+	b.mainOffset += n
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}

datareader.go

@@ -18,29 +18,11 @@ var (
 //DataReader reads data from data blocks.
 type dataReader struct {
 	r             *Reader
-	offset        int64 //offset relative to the beginning of the squash file
-	blocks        []dataBlock
-	curBlock      int //Which block in sizes is currently cached
 	curData       []byte
-	curReadOffset int //offset relative to the currently cached data
+	sizes         []uint32
-}
+	offset        int64 //offset relative to the beginning of the squash file
-
+	curBlock      int   //Which block in sizes is currently cached
-//DataBlock holds info about a given data block from it's size
+	curReadOffset int   //offset relative to the currently cached data
-type dataBlock struct {
-	begOffset        int64 //The offset relative to the beginning of the squash file. Makes it easier to seek to it.
-	size             uint32
-	compressed       bool
-	uncompressedSize uint32
-}
-
-//NewDataBlock creates a new squashfs.datablock from a given size.
-func newDataBlock(raw uint32) (dbs dataBlock) {
-	dbs.compressed = raw&(1<<24) != (1 << 24)
-	dbs.size = raw &^ (1 << 24)
-	if !dbs.compressed {
-		dbs.uncompressedSize = dbs.size
-	}
-	return
 }
 
 //NewDataReader creates a new data reader at the given offset, with the blocks defined by sizes
@@ -48,9 +30,7 @@ func (r *Reader) newDataReader(offset int64, sizes []uint32) (*dataReader, error
 	var dr dataReader
 	dr.r = r
 	dr.offset = offset
-	for _, size := range sizes {
+	dr.sizes = sizes
-		dr.blocks = append(dr.blocks, newDataBlock(size))
-	}
 	err := dr.readCurBlock()
 	if err != nil {
 		return nil, err
@@ -63,29 +43,29 @@ func (r *Reader) newDataReaderFromInode(i *inode.Inode) (*dataReader, error) {
 	var rdr dataReader
 	rdr.r = r
 	switch i.Type {
-	case inode.BasicFileType:
+	case inode.FileType:
-		fil := i.Info.(inode.BasicFile)
+		fil := i.Info.(inode.File)
-		if fil.Init.BlockStart == 0 {
+		if fil.BlockStart == 0 {
 			return nil, errInodeOnlyFragment
 		}
-		rdr.offset = int64(fil.Init.BlockStart)
+		rdr.offset = int64(fil.BlockStart)
 		for _, sizes := range fil.BlockSizes {
-			rdr.blocks = append(rdr.blocks, newDataBlock(sizes))
+			rdr.sizes = append(rdr.sizes, sizes)
 		}
 		if fil.Fragmented {
-			rdr.blocks = rdr.blocks[:len(rdr.blocks)-1]
+			rdr.sizes = rdr.sizes[:len(rdr.sizes)-1]
 		}
 	case inode.ExtFileType:
-		fil := i.Info.(inode.ExtendedFile)
+		fil := i.Info.(inode.ExtFile)
-		if fil.Init.BlockStart == 0 {
+		if fil.BlockStart == 0 {
 			return nil, errInodeOnlyFragment
 		}
-		rdr.offset = int64(fil.Init.BlockStart)
+		rdr.offset = int64(fil.BlockStart)
 		for _, sizes := range fil.BlockSizes {
-			rdr.blocks = append(rdr.blocks, newDataBlock(sizes))
+			rdr.sizes = append(rdr.sizes, sizes)
 		}
 		if fil.Fragmented {
-			rdr.blocks = rdr.blocks[:len(rdr.blocks)-1]
+			rdr.sizes = rdr.sizes[:len(rdr.sizes)-1]
 		}
 	default:
 		return nil, errInodeNotFile
@@ -97,9 +77,14 @@ func (r *Reader) newDataReaderFromInode(i *inode.Inode) (*dataReader, error) {
 	return &rdr, nil
 }
 
+//removed the compression bit from a data block size
+func actualDataSize(size uint32) uint32 {
+	return size &^ (1 << 24)
+}
+
 func (d *dataReader) readNextBlock() error {
 	d.curBlock++
-	if d.curBlock >= len(d.blocks) {
+	if d.curBlock >= len(d.sizes) {
 		d.curBlock--
 		return io.EOF
 	}
@@ -112,42 +97,46 @@ func (d *dataReader) readNextBlock() error {
 	return nil
 }
 
-func (d *dataReader) readCurBlock() error {
+func (d *dataReader) readBlockAt(offset int64, size uint32) ([]byte, error) {
-	if d.curBlock >= len(d.blocks) {
+	compressed := size&(1<<24) != (1 << 24)
-		return io.EOF
+	size = size &^ (1 << 24)
+	if d.sizes[d.curBlock] == 0 {
+		return make([]byte, d.r.super.BlockSize), nil
 	}
-	if d.blocks[d.curBlock].size == 0 {
+	sec := io.NewSectionReader(d.r.r, offset, int64(size))
-		d.curData = make([]byte, d.r.super.BlockSize)
+	if compressed {
-		d.blocks[d.curBlock].uncompressedSize = d.r.super.BlockSize
-		d.blocks[d.curBlock].begOffset = d.offset
-		return nil
-	}
-	sec := io.NewSectionReader(d.r.r, d.offset, int64(d.blocks[d.curBlock].size))
-	if d.blocks[d.curBlock].compressed {
 		btys, err := d.r.decompressor.Decompress(sec)
 		if err != nil {
-			return err
+			return nil, err
 		}
-		d.blocks[d.curBlock].uncompressedSize = uint32(len(btys))
+		return btys, nil
-		d.curData = btys
-		d.blocks[d.curBlock].begOffset = d.offset
-		d.offset += int64(d.blocks[d.curBlock].size)
-		return nil
 	}
 	var buf bytes.Buffer
 	_, err := io.Copy(&buf, sec)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	d.curData = buf.Bytes()
+	return buf.Bytes(), nil
-	d.blocks[d.curBlock].begOffset = d.offset
-	d.offset += int64(d.blocks[d.curBlock].size)
-	return err
 }
 
-//Close frees up the curData from memory
+func (d *dataReader) offsetForBlock(index int) int64 {
-func (d *dataReader) Close() error {
+	out := d.offset
-	d.curData = nil
+	for i := 0; i < index; i++ {
+		out += int64(actualDataSize(d.sizes[i]))
+	}
+	return out
+}
+
+func (d *dataReader) readCurBlock() error {
+	if d.curBlock >= len(d.sizes) {
+		return io.EOF
+	}
+	offset := d.offsetForBlock(d.curBlock)
+	data, err := d.readBlockAt(offset, d.sizes[d.curBlock])
+	if err != nil {
+		return err
+	}
+	d.curData = data
 	return nil
 }
 
@@ -175,12 +164,12 @@ func (d *dataReader) Read(p []byte) (int, error) {
 			d.curReadOffset = 0
 		}
 		for ; read < len(p); read++ {
-			d.curReadOffset++
 			if d.curReadOffset < len(d.curData) {
 				p[read] = d.curData[d.curReadOffset]
 			} else {
 				break
 			}
+			d.curReadOffset++
 		}
 	}
 	if read != len(p) {
@@ -188,3 +177,71 @@ func (d *dataReader) Read(p []byte) (int, error) {
 	}
 	return read, nil
 }
+
+// WriteTo writes all the data in the datablock to the writer. MUST BE USED ON A FRESH DATA READER.
+func (d *dataReader) WriteTo(w io.Writer) (int64, error) {
+	type dataCache struct {
+		err   error
+		data  []byte
+		index int
+	}
+	dataChan := make(chan *dataCache)
+	for i := range d.sizes {
+		go func(index int, c chan *dataCache) {
+			var cache dataCache
+			cache.index = index
+			defer func() {
+				c <- &cache
+			}()
+			data, err := d.readBlockAt(d.offsetForBlock(index), d.sizes[index])
+			if err != nil {
+				cache.err = err
+				return
+			}
+			cache.data = data
+			return
+		}(i, dataChan)
+	}
+	curIndex := 0
+	totalWrite := int64(0)
+	var backlog []*dataCache
+mainLoop:
+	for {
+		if curIndex == len(d.sizes) {
+			return totalWrite, nil
+		}
+		if len(backlog) > 0 {
+			for i, cache := range backlog {
+				if cache.index == curIndex {
+					writen, err := w.Write(cache.data)
+					totalWrite += int64(writen)
+					if err != nil {
+						return totalWrite, err
+					}
+					if len(backlog) > 0 {
+						backlog[i] = backlog[len(backlog)-1]
+						backlog = backlog[:len(backlog)-1]
+					} else {
+						backlog = nil
+					}
+					curIndex++
+					continue mainLoop
+				}
+			}
+		}
+		cache := <-dataChan
+		if cache.err != nil {
+			return totalWrite, cache.err
+		}
+		if cache.index == curIndex {
+			writen, err := w.Write(cache.data)
+			totalWrite += int64(writen)
+			if err != nil {
+				return totalWrite, err
+			}
+			curIndex++
+		} else {
+			backlog = append(backlog, cache)
+		}
+	}
+}

direntry_fileinfo.go

@@ -0,0 +1,137 @@
+package squashfs
+
+import (
+	"io"
+	"io/fs"
+	"time"
+
+	"github.com/CalebQ42/squashfs/internal/directory"
+	"github.com/CalebQ42/squashfs/internal/inode"
+)
+
+//DirEntry is a child of a directory.
+type DirEntry struct {
+	en     *directory.Entry
+	parent *FS
+	r      *Reader
+}
+
+func (r *Reader) newDirEntry(en *directory.Entry, parent *FS) *DirEntry {
+	return &DirEntry{
+		en:     en,
+		parent: parent,
+		r:      r,
+	}
+}
+
+//Name returns the DirEntry's name
+func (d DirEntry) Name() string {
+	return d.en.Name
+}
+
+//IsDir Yep.
+func (d DirEntry) IsDir() bool {
+	return d.en.Type == inode.DirType
+}
+
+//Type returns the type bits of fs.FileMode of the DirEntry.
+func (d DirEntry) Type() fs.FileMode {
+	switch d.en.Type {
+	case inode.DirType:
+		return fs.ModeDir
+	case inode.SymType:
+		return fs.ModeSymlink
+	default:
+		return 0
+	}
+}
+
+//Info returns the fs.FileInfo for the given DirEntry.
+func (d DirEntry) Info() (fs.FileInfo, error) {
+	in, err := d.r.getInodeFromEntry(d.en)
+	if err != nil {
+		return nil, err
+	}
+	return &FileInfo{
+		name:   d.en.Name,
+		i:      in,
+		parent: d.parent,
+		r:      d.r,
+	}, nil
+}
+
+//GetInodeFromEntry returns the inode associated with a given directory.Entry
+func (r *Reader) getInodeFromEntry(en *directory.Entry) (*inode.Inode, error) {
+	br, err := r.newMetadataReader(int64(r.super.InodeTableStart + uint64(en.InodeOffset)))
+	if err != nil {
+		return nil, err
+	}
+	_, err = br.Seek(int64(en.InodeBlockOffset), io.SeekStart)
+	if err != nil {
+		return nil, err
+	}
+	i, err := inode.ProcessInode(br, r.super.BlockSize)
+	if err != nil {
+		return nil, err
+	}
+	return i, nil
+}
+
+//FileInfo is a fs.FileInfo for a file.
+type FileInfo struct {
+	i      *inode.Inode
+	parent *FS
+	r      *Reader
+	name   string
+}
+
+//Name is the file's name.
+func (f FileInfo) Name() string {
+	return f.name
+}
+
+//Size is the file's size if it's a regular file. Otherwise, returns 0.
+func (f FileInfo) Size() int64 {
+	switch f.i.Type {
+	case inode.FileType:
+		return int64(f.i.Info.(inode.File).Size)
+	case inode.ExtFileType:
+		return int64(f.i.Info.(inode.ExtFile).Size)
+	}
+	return 0
+}
+
+//Mode returns the fs.FileMode bits of the file.
+func (f FileInfo) Mode() fs.FileMode {
+	mode := fs.FileMode(f.i.Permissions)
+	switch f.i.Type {
+	case inode.DirType | inode.ExtDirType:
+		return mode | fs.ModeDir
+	case inode.ExtDirType:
+		return mode | fs.ModeDir
+	case inode.SymType:
+		return mode | fs.ModeSymlink
+	case inode.ExtSymType:
+		return mode | fs.ModeSymlink
+	}
+	return mode
+}
+
+//ModTime is the last time the file was modified.
+func (f FileInfo) ModTime() time.Time {
+	return time.Unix(int64(f.i.ModifiedTime), 0)
+}
+
+//IsDir yep.
+func (f FileInfo) IsDir() bool {
+	return f.i.Type == inode.DirType || f.i.Type == inode.ExtDirType
+}
+
+//Sys returns the File for the FileInfo. If something goes wrong, nil is returned.
+func (f FileInfo) Sys() interface{} {
+	fil, err := f.File()
+	if err != nil {
+		return nil
+	}
+	return fil
+}

file.go

@@ -2,506 +2,364 @@ package squashfs
 
 import (
 	"errors"
-	"fmt"
 	"io"
+	"io/fs"
+	"log"
 	"os"
 	"path"
+	"strconv"
 	"strings"
-	"time"
 
 	"github.com/CalebQ42/squashfs/internal/directory"
 	"github.com/CalebQ42/squashfs/internal/inode"
 )
 
-var (
+//File represents a file inside a squashfs archive.
-	//ErrNotDirectory is returned when you're trying to do directory things with a non-directory
-	errNotDirectory = errors.New("File is not a directory")
-	//ErrNotFile is returned when you're trying to do file things with a directory
-	errNotFile = errors.New("File is not a file")
-	//ErrNotReading is returned when running functions that are only meant to be used when reading a squashfs
-	errNotReading = errors.New("Function only supported when reading a squashfs")
-	//ErrBrokenSymlink is returned when using ExtractWithOptions with the unbreakSymlink set to true, but the symlink's file cannot be extracted.
-	ErrBrokenSymlink = errors.New("Extracted symlink is probably broken")
-)
-
-//File is the main way to interact with files within squashfs, or when putting files into a squashfs.
-//File can be either a file or folder. When reading from a squashfs, it reads from the datablocks.
-//When writing, this holds the information on WHERE the file will be placed inside the archive.
-//
-//Implements os.FileInfo and io.ReadCloser
 type File struct {
-	Parent  *File        //The parent directory. Should ALWAYS be a folder. If it's the root directory, will be nil
+	i        *inode.Inode
-	Reader  io.Reader    //Underlying reader. When writing, will probably be an os.File. When reading this is kept nil UNTIL reading to save memory.
+	parent   *FS
-	name    string       //The name of the file or folder. Root folder will not have a name ("")
+	r        *Reader
-	path    string       //The path to the folder the File is located in.
+	reader   *fileReader
-	r       *Reader      //The squashfs.Reader where this file is contained.
+	name     string
-	in      *inode.Inode //Underlyting inode when reading.
+	dirsRead int
-	filType int          //The file's type, using inode types.
 }
 
-//get a File from a directory.entry
+//File creates a File from the FileInfo.
-func (r *Reader) newFileFromDirEntry(entry *directory.Entry) (fil *File, err error) {
+//*File satisfies fs.File and fs.ReadDirFile.
-	fil = new(File)
+func (f FileInfo) File() (file *File, err error) {
-	fil.in, err = r.getInodeFromEntry(entry)
+	file = &File{
+		name:   f.name,
+		r:      f.r,
+		parent: f.parent,
+		i:      f.i,
+	}
+	if file.IsRegular() {
+		file.reader, err = f.r.newFileReader(f.i)
+	}
+	return
+}
+
+//File creates a File from the DirEntry.
+func (d DirEntry) File() (file *File, err error) {
+	return d.r.newFileFromDirEntry(d.en, d.parent)
+}
+
+func (r Reader) newFileFromDirEntry(en *directory.Entry, parent *FS) (file *File, err error) {
+	file = &File{
+		name:   en.Name,
+		r:      &r,
+		parent: parent,
+	}
+	file.i, err = r.getInodeFromEntry(en)
 	if err != nil {
 		return nil, err
 	}
-	fil.name = entry.Name
+	if file.IsRegular() {
-	fil.r = r
+		file.reader, err = r.newFileReader(file.i)
-	fil.filType = fil.in.Type
+	}
 	return
 }
 
-//Name is the file's name
+//Stat returns the File's fs.FileInfo
-func (f *File) Name() string {
+func (f File) Stat() (fs.FileInfo, error) {
-	return f.name
+	return &FileInfo{
+		i:      f.i,
+		name:   f.name,
+		parent: f.parent,
+		r:      f.r,
+	}, nil
 }
 
-//Size is the complete size of the file. Zero if it's not a file.
+//Read reads the data from the file. Only works if file is a normal file.
-func (f *File) Size() int64 {
+func (f File) Read(p []byte) (int, error) {
-	switch f.filType {
+	if f.i.Type == inode.FileType || f.i.Type == inode.ExtFileType {
-	case inode.BasicFileType:
+		if f.reader == nil {
-		return int64(f.in.Info.(inode.BasicFile).Init.Size)
+			return 0, fs.ErrClosed
-	case inode.ExtFileType:
-		return int64(f.in.Info.(inode.ExtendedFile).Init.Size)
-	default:
-		return 0
-	}
-}
-
-//ModTime is the time of last modification.
-func (f *File) ModTime() time.Time {
-	return time.Unix(int64(f.in.Header.ModifiedTime), 0)
-}
-
-//Sys returns the underlying reader, file.Reader. If the reader isn't initialized, it will initialize it.
-//If called on something other then a file, returns nil.
-func (f *File) Sys() interface{} {
-	if f.IsFile() {
-		if f.Reader == nil && f.r != nil {
-			var err error
-			f.Reader, err = f.r.newFileReader(f.in)
-			if err != nil {
-				return nil
-			}
 		}
-		return f.Reader
+		return f.reader.Read(p)
 	}
+	return 0, errors.New("Can only read files")
+}
+
+//WriteTo writes all data from the file to the writer. This is multi-threaded.
+func (f File) WriteTo(w io.Writer) (int64, error) {
+	if f.i.Type == inode.FileType || f.i.Type == inode.ExtFileType {
+		if f.reader == nil {
+			return 0, fs.ErrClosed
+		}
+		return f.reader.WriteTo(w)
+	}
+	return 0, errors.New("Can only read files")
+}
+
+//Close simply nils the underlying reader. Here mostly to satisfy fs.File
+func (f *File) Close() error {
+	f.reader = nil
 	return nil
 }
 
-//GetChildren returns a *squashfs.File slice of every direct child of the directory. If the File is not a directory, will return ErrNotDirectory
+//ReadDir returns n fs.DirEntry's that's contained in the File (if it's a directory).
-func (f *File) GetChildren() (children []*File, err error) {
+//If n <= 0 all fs.DirEntry's are returned.
-	children = make([]*File, 0)
+func (f File) ReadDir(n int) ([]fs.DirEntry, error) {
-	if f.r == nil {
-		return nil, errNotReading
-	}
 	if !f.IsDir() {
-		return nil, errNotDirectory
+		return nil, errors.New("File is not a directory")
 	}
-	dir, err := f.r.readDirFromInode(f.in)
+	ffs, err := f.FS()
 	if err != nil {
-		return
+		return nil, err
 	}
-	var fil *File
+	var beg, end int
-	for _, entry := range dir.Entries {
+	if n <= 0 {
-		fil, err = f.r.newFileFromDirEntry(&entry)
+		beg, end = 0, len(ffs.entries)
-		if err != nil {
+	} else {
-			return
+		beg, end = f.dirsRead, f.dirsRead+n
+		if end > len(ffs.entries) {
+			end = len(ffs.entries)
+			err = io.EOF
 		}
-		fil.Parent = f
-		if f.name != "" {
-			fil.path = f.Path()
-		}
-		children = append(children, fil)
 	}
-	return
+	out := make([]fs.DirEntry, end-beg)
+	for i, ent := range ffs.entries[beg:end] {
+		out[i] = f.r.newDirEntry(ent, ffs)
+	}
+	return out, err
 }
 
-//GetChildrenRecursively returns ALL children. Goes down ALL folder paths.
+//FS returns the File as a FS.
-func (f *File) GetChildrenRecursively() (children []*File, err error) {
+func (f File) FS() (*FS, error) {
-	children = make([]*File, 0)
-	if f.r == nil {
-		return nil, errNotReading
-	}
 	if !f.IsDir() {
-		return nil, errNotDirectory
+		return nil, errors.New("File is not a directory")
 	}
-	children, err = f.GetChildren()
+	ents, err := f.r.readDirFromInode(f.i)
 	if err != nil {
-		return
+		return nil, err
 	}
-	var childFolders []*File
+	return &FS{
-	for _, child := range children {
+		entries: ents,
-		if child.IsDir() {
+		parent:  f.parent,
-			childFolders = append(childFolders, child)
+		r:       f.r,
-		}
+		name:    f.name,
-	}
+	}, nil
-	foldChil := make(chan []*File)
-	errChan := make(chan error)
-	for _, folds := range childFolders {
-		go func(fil *File) {
-			childs, err := fil.GetChildrenRecursively()
-			errChan <- err
-			foldChil <- childs
-		}(folds)
-	}
-	for range childFolders {
-		err = <-errChan
-		if err != nil {
-			return
-		}
-		children = append(children, <-foldChil...)
-	}
-	return
 }
 
-//Path returns the path of the file within the archive.
+//IsDir Yep.
-func (f *File) Path() string {
+func (f File) IsDir() bool {
-	if f.name == "" {
+	return f.i.Type == inode.DirType || f.i.Type == inode.ExtDirType
-		return f.path
-	}
-	return f.path + "/" + f.name
 }
 
-//GetFileAtPath tries to return the File at the given path, relative to the file.
+func (f File) path() string {
-//Returns nil if called on something other then a folder, OR if the path goes oustide the archive.
+	if f.name == "/" {
-//Allows wildcards supported by path.Match (namely * and ?).
+		return f.name
-func (f *File) GetFileAtPath(dirPath string) *File {
-	if dirPath == "" {
-		return f
 	}
-	dirPath = strings.TrimSuffix(strings.TrimPrefix(dirPath, "/"), "/")
+	return f.parent.path() + "/" + f.name
-	if dirPath != "" && !f.IsDir() {
-		return nil
-	}
-	for strings.HasSuffix(dirPath, "./") {
-		//since you can TECHNICALLY have an infinite amount of ./ and it would still be valid.
-		dirPath = strings.TrimPrefix(dirPath, "./")
-	}
-	split := strings.Split(dirPath, "/")
-	if split[0] == ".." && f.name == "" {
-		return nil
-	} else if split[0] == ".." {
-		if f.Parent != nil {
-			return f.Parent.GetFileAtPath(strings.Join(split[1:], "/"))
-		}
-		return nil
-	}
-	children, err := f.GetChildren()
-	if err != nil {
-		return nil
-	}
-	for _, child := range children {
-		eq, _ := path.Match(split[0], child.name)
-		if eq {
-			return child.GetFileAtPath(strings.Join(split[1:], "/"))
-		}
-	}
-	return nil
 }
 
-//IsDir returns if the file is a directory.
+//IsRegular yep.
-func (f *File) IsDir() bool {
+func (f File) IsRegular() bool {
-	return f.filType == inode.BasicDirectoryType || f.filType == inode.ExtDirType
+	return f.i.Type == inode.FileType || f.i.Type == inode.ExtFileType
 }
 
-//IsSymlink returns if the file is a symlink.
+//IsSymlink yep.
-func (f *File) IsSymlink() bool {
+func (f File) IsSymlink() bool {
-	return f.filType == inode.BasicSymlinkType || f.filType == inode.ExtSymlinkType
+	return f.i.Type == inode.SymType || f.i.Type == inode.ExtSymType
 }
 
-//IsFile returns if the file is a file.
+//SymlinkPath returns the symlink's target path. Is the File isn't a symlink, returns an empty string.
-func (f *File) IsFile() bool {
+func (f File) SymlinkPath() string {
-	return f.filType == inode.BasicFileType || f.filType == inode.ExtFileType
+	switch f.i.Type {
-}
+	case inode.SymType:
-
+		return f.i.Info.(inode.Sym).Path
-//SymlinkPath returns the path the symlink is pointing to. If the file ISN'T a symlink, will return an empty string.
+	case inode.ExtSymType:
-//If a path begins with "/" then the symlink is pointing to an absolute path (starting from root, and not a file inside the archive)
+		return f.i.Info.(inode.ExtSym).Path
-func (f *File) SymlinkPath() string {
-	switch f.filType {
-	case inode.BasicSymlinkType:
-		return f.in.Info.(inode.BasicSymlink).Path
-	case inode.ExtSymlinkType:
-		return f.in.Info.(inode.ExtendedSymlink).Path
-	default:
-		return ""
 	}
+	return ""
 }
 
-//GetSymlinkFile tries to return the squashfs.File associated with the symlink
+//GetSymlinkFile returns the File the symlink is pointing to.
-func (f *File) GetSymlinkFile() *File {
+//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
 	}
-	if strings.HasSuffix(f.SymlinkPath(), "/") {
+	if strings.HasPrefix(f.SymlinkPath(), "/") {
 		return nil
 	}
-	return f.r.GetFileAtPath(f.SymlinkPath())
+	sym, err := f.parent.Open(f.SymlinkPath())
-}
-
-//Mode returns the os.FileMode of the File. Sets mode bits for directories and symlinks.
-func (f *File) Mode() os.FileMode {
-	mode := os.FileMode(f.in.Header.Permissions)
-	switch {
-	case f.IsDir():
-		mode = mode | os.ModeDir
-	case f.IsSymlink():
-		mode = mode | os.ModeSymlink
-	}
-	return mode
-}
-
-//ExtractTo extracts the file to the given path. This is the same as ExtractWithOptions(path, false, false, os.ModePerm, false).
-//Will NOT try to keep symlinks valid, folders extracted will have the permissions set by the squashfs, but the folder to make path will have full permissions (777).
-//
-//Will try it's best to extract all files, and if any errors come up, they will be appended to the error slice that's returned.
-func (f *File) ExtractTo(path string) []error {
-	return f.ExtractWithOptions(path, false, false, os.ModePerm, false)
-}
-
-//ExtractSymlink is similar to ExtractTo, but when it extracts a symlink, it instead extracts the file associated with the symlink in it's place.
-//This is the same as ExtractWithOptions(path, true, false, os.ModePerm, false)
-func (f *File) ExtractSymlink(path string) []error {
-	return f.ExtractWithOptions(path, true, false, os.ModePerm, false)
-}
-
-//ExtractWithOptions will extract the file to the given path, while allowing customization on how it works. ExtractTo is the "default" options.
-//Will try it's best to extract all files, and if any errors come up, they will be appended to the error slice that's returned.
-//Should only return multiple errors if extracting a folder.
-//
-//If dereferenceSymlink is set, instead of extracting a symlink, it will extract the file the symlink is pointed to in it's place.
-//If both dereferenceSymlink and unbreakSymlink is set, dereferenceSymlink takes precendence.
-//
-//If unbreakSymlink is set, it will also try to extract the symlink's associated file. WARNING: the symlink's file may have to go up the directory to work.
-//If unbreakSymlink is set and the file cannot be extracted, a ErrBrokenSymlink will be appended to the returned error slice.
-//
-//folderPerm only applies to the folders created to get to path. Folders from the archive are given the correct permissions defined by the archive.
-func (f *File) ExtractWithOptions(path string, dereferenceSymlink, unbreakSymlink bool, folderPerm os.FileMode, verbose bool) (errs []error) {
-	errs = make([]error, 0)
-	err := os.MkdirAll(path, folderPerm)
 	if err != nil {
-		return []error{err}
+		return nil
 	}
-	switch {
+	return sym.(*File)
-	case f.IsDir():
+}
-		if f.name != "" {
+
-			//TODO: check if folder is present, and if so, try to set it's permission
+//ExtractionOptions are available options on how to extract.
-			err = os.Mkdir(path+"/"+f.name, os.ModePerm)
+type ExtractionOptions struct {
-			if err != nil {
+	notBase            bool
-				if verbose {
+	DereferenceSymlink bool        //Replace symlinks with the target file
-					fmt.Println("Error while making: ", path+"/"+f.name)
+	UnbreakSymlink     bool        //Try to make sure symlinks remain unbroken when extracted, without changing the symlink
-					fmt.Println(err)
+	Verbose            bool        //Prints extra info to log on an error
-				}
+	FolderPerm         fs.FileMode //The permissions used when creating the extraction folder
-				errs = append(errs, err)
+}
-				return
+
-			}
+//DefaultOptions is the default ExtractionOptions.
-			fil, err := os.Open(path + "/" + f.name)
+func DefaultOptions() ExtractionOptions {
-			if err != nil {
+	return ExtractionOptions{
-				if verbose {
+		DereferenceSymlink: false,
-					fmt.Println("Error while opening:", path+"/"+f.name)
+		UnbreakSymlink:     false,
-					fmt.Println(err)
+		Verbose:            false,
-				}
+		FolderPerm:         fs.ModePerm,
-				errs = append(errs, err)
+	}
-				return
+}
-			}
+
-			fil.Chown(int(f.r.idTable[f.in.Header.UID]), int(f.r.idTable[f.in.Header.GID]))
+//ExtractTo extracts the File to the given folder with the default options.
-			//don't mention anything when it fails. Because it fails often. Probably has something to do about uid & gid 0
+//If the File is a directory, it instead extracts the directory's contents to the folder.
-			// if err != nil {
+func (f File) ExtractTo(folder string) error {
-			// 	if verbose {
+	return f.ExtractWithOptions(folder, DefaultOptions())
-			// 		fmt.Println("Error while changing owner:", path+"/"+f.Name)
+}
-			// 		fmt.Println(err)
+
-			// 	}
+//ExtractSymlink extracts the File to the folder with the DereferenceSymlink option.
-			// 	errs = append(errs, err)
+//If the File is a directory, it instead extracts the directory's contents to the folder.
-			// }
+func (f File) ExtractSymlink(folder string) error {
-			err = fil.Chmod(f.Mode())
+	return f.ExtractWithOptions(folder, ExtractionOptions{
-			if err != nil {
+		DereferenceSymlink: true,
-				if verbose {
+		FolderPerm:         fs.ModePerm,
-					fmt.Println("Error while changing owner:", path+"/"+f.name)
+	})
-					fmt.Println(err)
+}
-				}
+
-				errs = append(errs, err)
+//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.
-		}
+func (f File) ExtractWithOptions(folder string, op ExtractionOptions) error {
-		children, err := f.GetChildren()
+	folder = path.Clean(folder)
+	if !op.notBase {
+		err := os.MkdirAll(folder, op.FolderPerm)
 		if err != nil {
-			if verbose {
+			return err
-				fmt.Println("Error getting children for:", f.Path())
+		}
-				fmt.Println(err)
+	}
+	stat, err := f.Stat()
+	if f.IsDir() {
+		if op.notBase {
+			err = os.Mkdir(folder+"/"+f.name, stat.Mode())
+			if err != nil && !os.IsExist(err) {
+				return err
 			}
-			errs = append(errs, err)
+		} else {
-			return
+			op.notBase = true
 		}
-		finishChan := make(chan []error)
+		var ents []fs.DirEntry
-		defer close(finishChan)
+		ents, err = f.ReadDir(0)
-		for _, child := range children {
+		if err != nil {
-			go func(child *File) {
+			if op.Verbose {
-				if f.name == "" {
+				log.Println("Error while reading children of", f.path())
-					finishChan <- child.ExtractWithOptions(path, dereferenceSymlink, unbreakSymlink, folderPerm, verbose)
+			}
-				} else {
+			return err
-					finishChan <- child.ExtractWithOptions(path+"/"+f.name, dereferenceSymlink, unbreakSymlink, folderPerm, verbose)
+		}
+		errChan := make(chan error)
+		for i := 0; i < len(ents); i++ {
+			go func(ent *DirEntry) {
+				fil, goErr := ent.File()
+				if goErr != nil {
+					errChan <- goErr
+					fil.Close()
+					return
 				}
-			}(child)
+				errChan <- fil.ExtractWithOptions(folder+"/"+f.name, op)
+				fil.Close()
+				return
+			}(ents[i].(*DirEntry))
 		}
-		for range children {
+		for i := 0; i < len(ents); i++ {
-			errs = append(errs, (<-finishChan)...)
+			err = <-errChan
+			if err != nil {
+				return err
+			}
 		}
-		return
+		return nil
-	case f.IsFile():
+	} else if f.IsRegular() {
-		fil, err := os.Create(path + "/" + f.name)
+		var fil *os.File
+		fil, err = os.Create(folder + "/" + f.name)
 		if os.IsExist(err) {
-			err = os.Remove(path + "/" + f.name)
+			os.Remove(folder + "/" + f.name)
+			fil, err = os.Create(folder + "/" + f.name)
 			if err != nil {
-				if verbose {
+				log.Println("Error while creating", folder+"/"+f.name)
-					fmt.Println("Error while making:", path+"/"+f.name)
+				return err
-					fmt.Println(err)
-				}
-				errs = append(errs, err)
-				return
-			}
-			fil, err = os.Create(path + "/" + f.name)
-			if err != nil {
-				if verbose {
-					fmt.Println("Error while making:", path+"/"+f.name)
-					fmt.Println(err)
-				}
-				errs = append(errs, err)
-				return
 			}
 		} else if err != nil {
-			if verbose {
+			return err
-				fmt.Println("Error while making:", path+"/"+f.name)
+		}
-				fmt.Println(err)
-			}
-			errs = append(errs, err)
-			return
-		} //Since we will be reading from the file
 		_, err = io.Copy(fil, f)
 		if err != nil {
-			if verbose {
+			log.Println("Error while copying data to", folder+"/"+f.name)
-				fmt.Println("Error while Copying data to:", path+"/"+f.name)
+			return err
-				fmt.Println(err)
-			}
-			errs = append(errs, err)
-			return
 		}
-		f.Close()
+		return nil
-		fil.Chown(int(f.r.idTable[f.in.Header.UID]), int(f.r.idTable[f.in.Header.GID]))
+	} else if f.IsSymlink() {
-		//don't mention anything when it fails. Because it fails often. Probably has something to do about uid & gid 0
-		// if err != nil {
-		// 	if verbose {
-		// 		fmt.Println("Error while changing owner:", path+"/"+f.Name)
-		// 		fmt.Println(err)
-		// 	}
-		// 	errs = append(errs, err)
-		// 	return
-		// }
-		err = fil.Chmod(f.Mode())
-		if err != nil {
-			if verbose {
-				fmt.Println("Error while setting permissions for:", path+"/"+f.name)
-				fmt.Println(err)
-			}
-			errs = append(errs, err)
-		}
-		return
-	case f.IsSymlink():
 		symPath := f.SymlinkPath()
-		if dereferenceSymlink {
+		if op.DereferenceSymlink {
 			fil := f.GetSymlinkFile()
 			if fil == nil {
-				if verbose {
+				if op.Verbose {
-					fmt.Println("Symlink path(", symPath, ") is outside the archive:"+path+"/"+f.name)
+					log.Println("Symlink path(", symPath, ") is unobtainable:", folder+"/"+f.name)
 				}
-				return
+				return errors.New("Cannot get symlink target")
 			}
 			fil.name = f.name
-			extracSymErrs := fil.ExtractWithOptions(path, dereferenceSymlink, unbreakSymlink, folderPerm, verbose)
+			err = fil.ExtractWithOptions(folder, op)
-			if len(extracSymErrs) > 0 {
+			if err != nil {
-				if verbose {
+				if op.Verbose {
-					fmt.Println("Error(s) while extracting the symlink's file:", path+"/"+f.name)
+					log.Println("Error while extracting the symlink's file:", folder+"/"+f.name)
-					fmt.Println(extracSymErrs)
 				}
-				errs = append(errs, extracSymErrs...)
+				return err
 			}
-			return
+			return nil
-		} else if unbreakSymlink {
+		} else if op.UnbreakSymlink {
 			fil := f.GetSymlinkFile()
-			if fil != nil {
+			if fil == nil {
-				symPath = path + "/" + symPath
+				if op.Verbose {
-				paths := strings.Split(symPath, "/")
+					log.Println("Symlink path(", symPath, ") is unobtainable:", folder+"/"+f.name)
-				extracSymErrs := fil.ExtractWithOptions(strings.Join(paths[:len(paths)-1], "/"), dereferenceSymlink, unbreakSymlink, folderPerm, verbose)
-				if len(extracSymErrs) > 0 {
-					if verbose {
-						fmt.Println("Error(s) while extracting the symlink's file:", path+"/"+f.name)
-						fmt.Println(extracSymErrs)
-					}
-					errs = append(errs, extracSymErrs...)
 				}
-			} else {
+				return errors.New("Cannot get symlink target")
-				if verbose {
+			}
-					fmt.Println("Symlink path(", symPath, ") is outside the archive:"+path+"/"+f.name)
+			extractLoc := path.Clean(folder + "/" + path.Dir(symPath))
+			err = fil.ExtractWithOptions(extractLoc, op)
+			if err != nil {
+				if op.Verbose {
+					log.Println("Error while extracting ", folder+"/"+f.name)
 				}
-				return
+				return err
 			}
 		}
-		err = os.Symlink(f.SymlinkPath(), path+"/"+f.name)
+		err = os.Symlink(f.SymlinkPath(), folder+"/"+f.name)
+		if os.IsExist(err) {
+			os.Remove(folder + "/" + f.name)
+			err = os.Symlink(f.SymlinkPath(), folder+"/"+f.name)
+		}
 		if err != nil {
-			if verbose {
+			if op.Verbose {
-				fmt.Println("Error while making symlink:", path+"/"+f.name)
+				log.Println("Error while making symlink:", folder+"/"+f.name)
-				fmt.Println(err)
 			}
-			errs = append(errs, err)
+			return err
 		}
+		return nil
 	}
-	return
+	return errors.New("Unsupported file type. Inode type: " + strconv.Itoa(int(f.i.Type)))
-}
-
-//Close frees up the memory held up by the underlying reader. Should NOT be called when writing.
-//When reading, Close is safe to use, but any subsequent Read calls resets to the beginning of the file.
-func (f *File) Close() error {
-	if f.IsDir() {
-		return errNotFile
-	}
-	if f.Reader != nil {
-		if closer, is := f.Reader.(io.Closer); is {
-			closer.Close()
-		}
-		f.Reader = nil
-	}
-	return nil
-}
-
-//Read from the file. Doesn't do anything fancy, just pases it to the underlying io.Reader. If a directory, return io.EOF.
-func (f *File) Read(p []byte) (int, error) {
-	if f.IsDir() {
-		return 0, io.EOF
-	}
-	var err error
-	if f.Reader == nil && f.r != nil {
-		f.Reader, err = f.r.newFileReader(f.in)
-		if err != nil {
-			return 0, err
-		}
-	}
-	return f.Reader.Read(p)
 }
 
 //ReadDirFromInode returns a fully populated Directory from a given Inode.
 //If the given inode is not a directory it returns an error.
-func (r *Reader) readDirFromInode(i *inode.Inode) (*directory.Directory, error) {
+func (r *Reader) readDirFromInode(i *inode.Inode) ([]*directory.Entry, error) {
 	var offset uint32
 	var metaOffset uint16
 	var size uint32
 	switch i.Type {
-	case inode.BasicDirectoryType:
+	case inode.DirType:
-		offset = i.Info.(inode.BasicDirectory).DirectoryIndex
+		offset = i.Info.(inode.Dir).DirectoryIndex
-		metaOffset = i.Info.(inode.BasicDirectory).DirectoryOffset
+		metaOffset = i.Info.(inode.Dir).DirectoryOffset
-		size = uint32(i.Info.(inode.BasicDirectory).DirectorySize)
+		size = uint32(i.Info.(inode.Dir).DirectorySize)
 	case inode.ExtDirType:
-		offset = i.Info.(inode.ExtendedDirectory).Init.DirectoryIndex
+		offset = i.Info.(inode.ExtDir).DirectoryIndex
-		metaOffset = i.Info.(inode.ExtendedDirectory).Init.DirectoryOffset
+		metaOffset = i.Info.(inode.ExtDir).DirectoryOffset
-		size = i.Info.(inode.ExtendedDirectory).Init.DirectorySize
+		size = i.Info.(inode.ExtDir).DirectorySize
 	default:
 		return nil, errors.New("Not a directory inode")
 	}
@@ -513,26 +371,9 @@ func (r *Reader) readDirFromInode(i *inode.Inode) (*directory.Directory, error)
 	if err != nil {
 		return nil, err
 	}
-	dir, err := directory.NewDirectory(br, size)
+	ents, err := directory.NewDirectory(br, size)
 	if err != nil {
-		return dir, err
+		return nil, err
 	}
-	return dir, nil
+	return ents, nil
-}
-
-//GetInodeFromEntry returns the inode associated with a given directory.Entry
-func (r *Reader) getInodeFromEntry(en *directory.Entry) (*inode.Inode, error) {
-	br, err := r.newMetadataReader(int64(r.super.InodeTableStart + uint64(en.Header.InodeOffset)))
-	if err != nil {
-		return nil, err
-	}
-	_, err = br.Seek(int64(en.Init.Offset), io.SeekStart)
-	if err != nil {
-		return nil, err
-	}
-	i, err := inode.ProcessInode(br, r.super.BlockSize)
-	if err != nil {
-		return nil, err
-	}
-	return i, nil
 }

filereader.go

@@ -29,20 +29,20 @@ var (
 func (r *Reader) newFileReader(in *inode.Inode) (*fileReader, error) {
 	var rdr fileReader
 	rdr.in = in
-	if in.Type != inode.BasicFileType && in.Type != inode.ExtFileType {
+	if in.Type != inode.FileType && in.Type != inode.ExtFileType {
 		return nil, errPathIsNotFile
 	}
 	switch in.Type {
-	case inode.BasicFileType:
+	case inode.FileType:
-		fil := in.Info.(inode.BasicFile)
+		fil := in.Info.(inode.File)
 		rdr.fragged = fil.Fragmented
-		rdr.fragOnly = fil.Init.BlockStart == 0
+		rdr.fragOnly = fil.BlockStart == 0
-		rdr.FileSize = int(fil.Init.Size)
+		rdr.FileSize = int(fil.Size)
 	case inode.ExtFileType:
-		fil := in.Info.(inode.ExtendedFile)
+		fil := in.Info.(inode.ExtFile)
 		rdr.fragged = fil.Fragmented
-		rdr.fragOnly = fil.Init.BlockStart == 0
+		rdr.fragOnly = fil.BlockStart == 0
-		rdr.FileSize = int(fil.Init.Size)
+		rdr.FileSize = int(fil.Size)
 	}
 	var err error
 	if rdr.fragged {
@@ -57,15 +57,6 @@ func (r *Reader) newFileReader(in *inode.Inode) (*fileReader, error) {
 	return &rdr, nil
 }
 
-//Close runs Close on the data reader and frees the fragmentdata
-func (f *fileReader) Close() error {
-	if f.data != nil {
-		f.data.Close()
-	}
-	f.fragmentData = nil
-	return nil
-}
-
 func (f *fileReader) Read(p []byte) (int, error) {
 	if f.fragOnly {
 		n, err := bytes.NewBuffer(f.fragmentData[f.read:]).Read(p)
@@ -92,3 +83,19 @@ func (f *fileReader) Read(p []byte) (int, error) {
 	}
 	return read, nil
 }
+
+func (f *fileReader) WriteTo(w io.Writer) (int64, error) {
+	if f.fragOnly {
+		n, err := w.Write(f.fragmentData)
+		return int64(n), err
+	}
+	if !f.fragged {
+		return f.data.WriteTo(w)
+	}
+	n, err := f.data.WriteTo(w)
+	if err != nil {
+		return int64(n), err
+	}
+	nn, err := w.Write(f.fragmentData)
+	return int64(nn) + n, err
+}

fragment.go

@@ -10,41 +10,41 @@ import (
 
 //FragmentEntry is an entry in the fragment table
 type fragmentEntry struct {
-	Start  uint64
+	Start uint64
-	Size   uint32
+	Size  uint32
-	Unused uint32
+	// Unused uint32
 }
 
 //GetFragmentDataFromInode returns the fragment data for a given inode.
 //If the inode does not have a fragment, harmlessly returns an empty slice without an error.
 func (r *Reader) getFragmentDataFromInode(in *inode.Inode) ([]byte, error) {
-	var size uint32
+	var size uint64
 	var fragIndex uint32
 	var fragOffset uint32
-	if in.Type == inode.BasicFileType {
+	if in.Type == inode.FileType {
-		bf := in.Info.(inode.BasicFile)
+		bf := in.Info.(inode.File)
 		if !bf.Fragmented {
 			return make([]byte, 0), nil
 		}
-		if bf.Init.BlockStart == 0 {
+		if bf.BlockStart == 0 {
-			size = bf.Init.Size
+			size = uint64(bf.Size)
 		} else {
-			size = bf.BlockSizes[len(bf.BlockSizes)-1]
+			size = uint64(bf.BlockSizes[len(bf.BlockSizes)-1])
 		}
-		fragIndex = bf.Init.FragmentIndex
+		fragIndex = bf.FragmentIndex
-		fragOffset = bf.Init.FragmentOffset
+		fragOffset = bf.FragmentOffset
 	} else if in.Type == inode.ExtFileType {
-		bf := in.Info.(inode.ExtendedFile)
+		bf := in.Info.(inode.ExtFile)
 		if !bf.Fragmented {
 			return make([]byte, 0), nil
 		}
-		if bf.Init.BlockStart == 0 {
+		if bf.BlockStart == 0 {
-			size = bf.Init.Size
+			size = bf.Size
 		} else {
-			size = bf.BlockSizes[len(bf.BlockSizes)-1]
+			size = uint64(bf.BlockSizes[len(bf.BlockSizes)-1])
 		}
-		fragIndex = bf.Init.FragmentIndex
+		fragIndex = bf.FragmentIndex
-		fragOffset = bf.Init.FragmentOffset
+		fragOffset = bf.FragmentOffset
 	} else {
 		return nil, errors.New("Inode type not supported")
 	}

fs.go

@@ -0,0 +1,489 @@
+package squashfs
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"io/fs"
+	"os"
+	"path"
+	"strings"
+
+	"github.com/CalebQ42/squashfs/internal/directory"
+)
+
+//FS is a fs.FS representation of a squashfs directory.
+//Implements fs.GlobFS, fs.ReadDirFS, fs.ReadFileFS, fs.StatFS, and fs.SubFS
+type FS struct {
+	r       *Reader
+	parent  *FS
+	name    string
+	entries []*directory.Entry
+}
+
+//Open opens the file at name. Returns a squashfs.File.
+func (f FS) Open(name string) (fs.File, error) {
+	if !fs.ValidPath(name) {
+		return nil, &fs.PathError{
+			Op:   "open",
+			Path: name,
+			Err:  fs.ErrInvalid,
+		}
+	}
+	name = path.Clean(strings.TrimPrefix(name, "/"))
+	split := strings.Split(name, "/")
+	if split[0] == ".." {
+		if f.parent == nil {
+			//This should only happen on the root FS
+			return nil, &fs.PathError{
+				Op:   "open",
+				Path: name,
+				//TODO: make error clearer
+				Err: errors.New("Trying to get file outside of squashfs"),
+			}
+		}
+		return f.parent.Open(strings.Join(split[1:], "/"))
+	}
+	for i := 0; i < len(f.entries); i++ {
+		if match, _ := path.Match(split[0], f.entries[i].Name); match {
+			if len(split) == 1 {
+				return f.r.newFileFromDirEntry(f.entries[i], &f)
+			}
+			sub, err := f.Sub(split[0])
+			if err != nil {
+				if pathErr, ok := err.(*fs.PathError); ok {
+					pathErr.Op = "open"
+					pathErr.Path = name
+					return nil, err
+				}
+				return nil, &fs.PathError{
+					Op:   "open",
+					Path: name,
+					Err:  err,
+				}
+			}
+			fil, err := sub.Open(strings.Join(split[1:], "/"))
+			if err != nil {
+				if pathErr, ok := err.(*fs.PathError); ok {
+					if pathErr.Err == fs.ErrNotExist {
+						continue
+					}
+					pathErr.Op = "open"
+					pathErr.Path = name
+					return nil, err
+				}
+				return nil, &fs.PathError{
+					Op:   "open",
+					Path: name,
+					Err:  err,
+				}
+			}
+			return fil, nil
+		}
+	}
+	return nil, &fs.PathError{
+		Op:   "open",
+		Path: name,
+		Err:  fs.ErrNotExist,
+	}
+}
+
+//Glob returns the name of the files at the given pattern.
+//All paths are relative to the FS.
+func (f FS) Glob(pattern string) (out []string, err error) {
+	if !fs.ValidPath(pattern) {
+		return nil, &fs.PathError{
+			Op:   "glob",
+			Path: pattern,
+			Err:  fs.ErrInvalid,
+		}
+	}
+	pattern = path.Clean(strings.TrimPrefix(pattern, "/"))
+	split := strings.Split(pattern, "/")
+	if split[0] == ".." {
+		if f.parent == nil {
+			//This should only happen on the root FS
+			return nil, &fs.PathError{
+				Op:   "readdir",
+				Path: pattern,
+				//TODO: make error clearer
+				Err: errors.New("Trying to get file outside of squashfs"),
+			}
+		}
+		return f.parent.Glob(strings.Join(split[1:], "/"))
+	}
+	for i := 0; i < len(f.entries); i++ {
+		if match, _ := path.Match(split[0], f.entries[i].Name); match {
+			if len(split) == 1 {
+				out = append(out, f.entries[i].Name)
+				continue
+			}
+			sub, err := f.Sub(split[0])
+			if err != nil {
+				if pathErr, ok := err.(*fs.PathError); ok {
+					if pathErr.Err == fs.ErrNotExist {
+						continue
+					}
+					pathErr.Op = "glob"
+					pathErr.Path = pattern
+					return nil, pathErr
+				}
+				return nil, &fs.PathError{
+					Op:   "glob",
+					Path: pattern,
+					Err:  err,
+				}
+			}
+			subGlob, err := sub.(FS).Glob(strings.Join(split[1:], "/"))
+			if err != nil {
+				if pathErr, ok := err.(*fs.PathError); ok {
+					if pathErr.Err == fs.ErrNotExist {
+						continue
+					}
+					pathErr.Op = "glob"
+					pathErr.Path = pattern
+					return nil, pathErr
+				}
+				return nil, &fs.PathError{
+					Op:   "glob",
+					Path: pattern,
+					Err:  err,
+				}
+			}
+			for i := 0; i < len(subGlob); i++ {
+				subGlob[i] = f.name + "/" + subGlob[i]
+			}
+			out = append(out, subGlob...)
+		}
+	}
+	return
+}
+
+//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) {
+	if !fs.ValidPath(name) {
+		return nil, &fs.PathError{
+			Op:   "readdir",
+			Path: name,
+			Err:  fs.ErrInvalid,
+		}
+	}
+	name = path.Clean(strings.TrimPrefix(name, "/"))
+	split := strings.Split(name, "/")
+	if split[0] == ".." {
+		if f.parent == nil {
+			//This should only happen on the root FS
+			return nil, &fs.PathError{
+				Op:   "readdir",
+				Path: name,
+				//TODO: make error clearer
+				Err: errors.New("Trying to get file outside of squashfs"),
+			}
+		}
+		return f.parent.ReadDir(strings.Join(split[1:], "/"))
+	}
+	for i := 0; i < len(f.entries); i++ {
+		if match, _ := path.Match(split[0], f.entries[i].Name); match {
+			if len(split) == 1 {
+				in, err := f.r.getInodeFromEntry(f.entries[i])
+				if err != nil {
+					return nil, &fs.PathError{
+						Op:   "readdir",
+						Path: name,
+						Err:  err,
+					}
+				}
+				ents, err := f.r.readDirFromInode(in)
+				if err != nil {
+					return nil, &fs.PathError{
+						Op:   "readdir",
+						Path: name,
+						Err:  err,
+					}
+				}
+				out := make([]fs.DirEntry, len(f.entries))
+				for i, ent := range ents {
+					out[i] = &DirEntry{
+						en:     ent,
+						parent: &f,
+						r:      f.r,
+					}
+				}
+				return out, nil
+			}
+			sub, err := f.Sub(split[0])
+			if err != nil {
+				if pathErr, ok := err.(*fs.PathError); ok {
+					if pathErr.Err == fs.ErrNotExist {
+						continue
+					}
+					pathErr.Op = "readir"
+					pathErr.Path = name
+					return nil, pathErr
+				}
+				return nil, &fs.PathError{
+					Op:   "readdir",
+					Path: name,
+					Err:  err,
+				}
+			}
+			redDir, err := sub.(FS).ReadDir(strings.Join(split[1:], "/"))
+			if err != nil {
+				if pathErr, ok := err.(*fs.PathError); ok {
+					if pathErr.Err == fs.ErrNotExist {
+						continue
+					}
+					pathErr.Op = "readdir"
+					pathErr.Path = name
+					return nil, pathErr
+				}
+				return nil, &fs.PathError{
+					Op:   "readdir",
+					Path: name,
+					Err:  err,
+				}
+			}
+			return redDir, nil
+		}
+	}
+	return nil, &fs.PathError{
+		Op:   "readdir",
+		Path: name,
+		Err:  fs.ErrNotExist,
+	}
+}
+
+//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 {
+		if pathErr, ok := err.(*fs.PathError); ok {
+			pathErr.Op = "readfile"
+			pathErr.Path = name
+			return nil, pathErr
+		}
+	}
+	var buf bytes.Buffer
+	_, err = io.Copy(&buf, fil)
+	if err != nil {
+		return nil, &fs.PathError{
+			Op:   "readfile",
+			Path: name,
+			Err:  err,
+		}
+	}
+	return buf.Bytes(), nil
+}
+
+//Stat returns the fs.FileInfo for the file at name.
+func (f FS) Stat(name string) (fs.FileInfo, error) {
+	if !fs.ValidPath(name) {
+		return nil, &fs.PathError{
+			Op:   "stat",
+			Path: name,
+			Err:  fs.ErrInvalid,
+		}
+	}
+	name = path.Clean(strings.TrimPrefix(name, "/"))
+	split := strings.Split(name, "/")
+	if split[0] == ".." {
+		if f.parent == nil {
+			//This should only happen on the root FS
+			return nil, &fs.PathError{
+				Op:   "stat",
+				Path: name,
+				//TODO: make error clearer
+				Err: errors.New("Trying to get file outside of squashfs"),
+			}
+		}
+		return f.parent.Stat(strings.Join(split[1:], "/"))
+	}
+	for i := 0; i < len(f.entries); i++ {
+		if match, _ := path.Match(split[0], f.entries[i].Name); match {
+			if len(split) == 1 {
+				in, err := f.r.getInodeFromEntry(f.entries[i])
+				if err != nil {
+					return nil, &fs.PathError{
+						Op:   "stat",
+						Path: name,
+						Err:  err,
+					}
+				}
+				return FileInfo{
+					i:      in,
+					parent: &f,
+					r:      f.r,
+					name:   f.entries[i].Name,
+				}, nil
+			}
+			sub, err := f.Sub(split[0])
+			if err != nil {
+				if pathErr, ok := err.(*fs.PathError); ok {
+					if pathErr.Err == fs.ErrNotExist {
+						continue
+					}
+					pathErr.Op = "stat"
+					pathErr.Path = name
+					return nil, pathErr
+				}
+				return nil, &fs.PathError{
+					Op:   "stat",
+					Path: name,
+					Err:  err,
+				}
+			}
+			stat, err := sub.(FS).Stat(strings.Join(split[1:], "/"))
+			if err != nil {
+				if pathErr, ok := err.(*fs.PathError); ok {
+					if pathErr.Err == fs.ErrNotExist {
+						continue
+					}
+					pathErr.Op = "stat"
+					pathErr.Path = name
+					return nil, pathErr
+				}
+				return nil, &fs.PathError{
+					Op:   "stat",
+					Path: name,
+					Err:  err,
+				}
+			}
+			return stat, nil
+		}
+	}
+	return nil, &fs.PathError{
+		Op:   "stat",
+		Path: name,
+		Err:  fs.ErrNotExist,
+	}
+}
+
+//Sub returns the FS at dir
+func (f FS) Sub(dir string) (fs.FS, error) {
+	if !fs.ValidPath(dir) {
+		return nil, &fs.PathError{
+			Op:   "sub",
+			Path: dir,
+			Err:  fs.ErrInvalid,
+		}
+	}
+	dir = path.Clean(strings.TrimPrefix(dir, "/"))
+	split := strings.Split(dir, "/")
+	if split[0] == ".." {
+		if f.parent == nil {
+			//This should only happen on the root FS
+			return nil, &fs.PathError{
+				Op:   "sub",
+				Path: dir,
+				//TODO: make error clearer
+				Err: errors.New("Trying to get file outside of squashfs"),
+			}
+		}
+		return f.parent.Sub(strings.Join(split[1:], "/"))
+	}
+	for i := 0; i < len(f.entries); i++ {
+		if match, _ := path.Match(split[0], f.entries[i].Name); match {
+			if len(split) == 1 {
+				in, err := f.r.getInodeFromEntry(f.entries[i])
+				if err != nil {
+					return nil, &fs.PathError{
+						Op:   "sub",
+						Path: dir,
+						Err:  err,
+					}
+				}
+				ents, err := f.r.readDirFromInode(in)
+				if err != nil {
+					return nil, &fs.PathError{
+						Op:   "sub",
+						Path: dir,
+						Err:  err,
+					}
+				}
+				return &FS{
+					r:       f.r,
+					parent:  &f,
+					name:    f.entries[i].Name,
+					entries: ents,
+				}, nil
+			}
+			sub, err := f.Sub(strings.Join(split[1:], "/"))
+			if err != nil {
+				if pathErr, ok := err.(*fs.PathError); ok {
+					if pathErr.Err == fs.ErrNotExist {
+						continue
+					}
+					pathErr.Op = "sub"
+					pathErr.Path = dir
+					return nil, pathErr
+				}
+				return nil, &fs.PathError{
+					Op:   "sub",
+					Path: dir,
+					Err:  err,
+				}
+			}
+			return sub, nil
+		}
+	}
+	return nil, &fs.PathError{
+		Op:   "sub",
+		Path: dir,
+		Err:  fs.ErrNotExist,
+	}
+}
+
+func (f FS) path() string {
+	return f.parent.path() + "/" + f.name
+}
+
+//ExtractTo extracts the File to the given folder with the default options.
+//It extracts the directory's contents to the folder.
+func (f FS) ExtractTo(folder string) error {
+	return f.ExtractWithOptions(folder, DefaultOptions())
+}
+
+//ExtractSymlink extracts the File to the folder with the DereferenceSymlink option.
+//It extracts the directory's contents to the folder.
+func (f FS) ExtractSymlink(folder string) error {
+	return f.ExtractWithOptions(folder, ExtractionOptions{
+		DereferenceSymlink: true,
+		FolderPerm:         fs.ModePerm,
+	})
+}
+
+//ExtractWithOptions extracts the File to the given folder with the given ExtrationOptions.
+//It extracts the directory's contents to the folder.
+func (f FS) ExtractWithOptions(folder string, op ExtractionOptions) error {
+	op.notBase = true
+	folder = path.Clean(folder)
+	err := os.MkdirAll(folder, op.FolderPerm)
+	if err != nil {
+		return err
+	}
+	errChan := make(chan error)
+	for i := 0; i < len(f.entries); i++ {
+		go func(ent *DirEntry) {
+			fil, goErr := ent.File()
+			if goErr != nil {
+				errChan <- goErr
+				return
+			}
+			errChan <- fil.ExtractWithOptions(folder, op)
+			fil.Close()
+			return
+		}(&DirEntry{
+			en:     f.entries[i],
+			parent: &f,
+			r:      f.r,
+		})
+	}
+	for i := 0; i < len(f.entries); i++ {
+		err := <-errChan
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

go.mod

@@ -3,16 +3,17 @@ module github.com/CalebQ42/squashfs
 go 1.15
 
 require (
-	github.com/CalebQ42/GoAppImage v0.4.0
+	github.com/CalebQ42/GoAppImage v0.5.0
 	github.com/adrg/xdg v0.2.3 // indirect
 	github.com/google/go-cmp v0.5.4 // indirect
 	github.com/gopherjs/gopherjs v0.0.0-20200217142428-fce0ec30dd00 // indirect
-	github.com/klauspost/compress v1.11.3
+	github.com/klauspost/compress v1.11.6
 	github.com/kr/text v0.2.0 // indirect
-	github.com/pierrec/lz4/v4 v4.1.1
+	github.com/pierrec/lz4/v4 v4.1.3
 	github.com/smartystreets/assertions v1.2.0 // indirect
-	github.com/ulikunitz/xz v0.5.8
+	github.com/stretchr/testify v1.7.0 // indirect
+	github.com/ulikunitz/xz v0.5.9
 	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
-	gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776 // indirect
+	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
 )

go.sum

@@ -1,5 +1,5 @@
-github.com/CalebQ42/GoAppImage v0.4.0 h1:aF+Y/vyo/RGhoyZEW1CMY6WyRWrZZO4ydsRFAtIGnaY=
+github.com/CalebQ42/GoAppImage v0.5.0 h1:znoKNXtliH754tS9sYwyOIg/0wFDjFN5Twc7PAh1rSM=
-github.com/CalebQ42/GoAppImage v0.4.0/go.mod h1:qHudJKAn/dlkNWNnH4h1YKXp29EZ7Bppsn7sNP2HuvU=
+github.com/CalebQ42/GoAppImage v0.5.0/go.mod h1:qHudJKAn/dlkNWNnH4h1YKXp29EZ7Bppsn7sNP2HuvU=
 github.com/adrg/xdg v0.2.2 h1:A7ZHKRz5KGOLJX/bg7IPzStryhvCzAE1wX+KWawPiAo=
 github.com/adrg/xdg v0.2.2/go.mod h1:7I2hH/IT30IsupOpKZ5ue7/qNi3CoKzD6tL3HwpaRMQ=
 github.com/adrg/xdg v0.2.3 h1:GxXngdYxNDkoUvZXjNJGwqZxWXi43MKbOOlA/00qZi4=
@@ -18,8 +18,8 @@ github.com/gopherjs/gopherjs v0.0.0-20200217142428-fce0ec30dd00 h1:l5lAOZEym3oK3
 github.com/gopherjs/gopherjs v0.0.0-20200217142428-fce0ec30dd00/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
-github.com/klauspost/compress v1.11.3 h1:dB4Bn0tN3wdCzQxnS8r06kV74qN/TAfaIS0bVE8h3jc=
+github.com/klauspost/compress v1.11.6 h1:EgWPCW6O3n1D5n99Zq3xXBt9uCwRGvpwGOusOLNBRSQ=
-github.com/klauspost/compress v1.11.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
+github.com/klauspost/compress v1.11.6/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
 github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
@@ -29,8 +29,8 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
 github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
-github.com/pierrec/lz4/v4 v4.1.1 h1:cS6aGkNLJr4u+UwaA21yp+gbWN3WJWtKo1axmPDObMA=
+github.com/pierrec/lz4/v4 v4.1.3 h1:/dvQpkb0o1pVlSgKNQqfkavlnXaIK+hJ0LXsKRUN9D4=
-github.com/pierrec/lz4/v4 v4.1.1/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
+github.com/pierrec/lz4/v4 v4.1.3/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=
@@ -39,11 +39,14 @@ github.com/smartystreets/assertions v1.2.0 h1:42S6lae5dvLc7BrLu/0ugRtcFVjoJNMC/N
 github.com/smartystreets/assertions v1.2.0/go.mod h1:tcbTF8ujkAEcZ8TElKY+i30BzYlVhC/LOxJk7iOWnoo=
 github.com/smartystreets/goconvey v1.6.4 h1:fv0U8FUIMPNf1L9lnHLvLhgicrIVChEkdzIKYqbNC9s=
 github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
+github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/ulikunitz/xz v0.5.8 h1:ERv8V6GKqVi23rgu5cj9pVfVzJbOqAY2Ntl88O6c2nQ=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
-github.com/ulikunitz/xz v0.5.8/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/ulikunitz/xz v0.5.9 h1:RsKRIA2MO8x56wkkcd3LbtcE/uMszhb6DpRf+3uwa3I=
+github.com/ulikunitz/xz v0.5.9/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
 go.lsp.dev/uri v0.3.0 h1:KcZJmh6nFIBeJzTugn5JTU6OOyG0lDOo3R9KwTxTYbo=
 go.lsp.dev/uri v0.3.0/go.mod h1:P5sbO1IQR+qySTWOCnhnK7phBx+W3zbLqSMDJNTw88I=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2 h1:VklqNMn3ovrHsnt90PveolxSbWFaJdECFbxSq0Mqo2M=
@@ -69,5 +72,5 @@ gopkg.in/ini.v1 v1.62.0 h1:duBzk771uxoUuOlyRLkHsygud9+5lrlGjdFBb4mSKDU=
 gopkg.in/ini.v1 v1.62.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776 h1:tQIYjPdBoyREyB9XMu+nnTclpTYkz2zFM+lzLJFO4gQ=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
-gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/compression/gzip.go

@@ -15,23 +15,22 @@ type gzipInit struct {
 
 //Gzip is a decompressor for gzip type compression. Uses zlib for compression and decompression
 type Gzip struct {
-	CompressionLevel int32
+	wrt *zlib.Writer
-	HasCustomWindow  bool
+	gzipInit
-	HasStrategies    bool
+	HasCustomWindow bool
+	HasStrategies   bool
 }
 
 //NewGzipCompressorWithOptions creates a new gzip compressor/decompressor with options read from the given reader.
 func NewGzipCompressorWithOptions(r io.Reader) (*Gzip, error) {
 	var gzip Gzip
-	var init gzipInit
+	err := binary.Read(r, binary.LittleEndian, &gzip.gzipInit)
-	err := binary.Read(r, binary.LittleEndian, &init)
 	if err != nil {
 		return nil, err
 	}
-	gzip.CompressionLevel = init.CompressionLevel
 	//TODO: proper support for window size and strategies
-	gzip.HasCustomWindow = init.WindowSize != 15
+	gzip.HasCustomWindow = gzip.WindowSize != 15
-	gzip.HasStrategies = init.Strategies != 0 && init.Strategies != 1
+	gzip.HasStrategies = gzip.Strategies != 0 && gzip.Strategies != 1
 	return &gzip, nil
 }
 
@@ -52,15 +51,25 @@ func (g *Gzip) Decompress(r io.Reader) ([]byte, error) {
 //Compress compresses the given data (as a byte array) and returns the compressed data.
 func (g *Gzip) Compress(data []byte) ([]byte, error) {
 	var buf bytes.Buffer
-	wrt := zlib.NewWriter(&buf)
+	var err error
-	defer wrt.Close()
+	if g.wrt == nil {
-	_, err := wrt.Write(data)
+		if g.CompressionLevel == 0 {
+			g.wrt = zlib.NewWriter(&buf)
+		} else {
+			g.wrt, err = zlib.NewWriterLevel(&buf, int(g.CompressionLevel))
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+	wrt, err := zlib.NewWriterLevel(&buf, int(g.CompressionLevel))
 	if err != nil {
 		return nil, err
 	}
-	err = wrt.Flush()
+	_, err = wrt.Write(data)
 	if err != nil {
 		return nil, err
 	}
+	wrt.Close()
 	return buf.Bytes(), nil
 }

internal/compression/lz4.go

@@ -35,3 +35,21 @@ func (l *Lz4) Decompress(r io.Reader) ([]byte, error) {
 	_, err := io.Copy(&buf, rdr)
 	return buf.Bytes(), err
 }
+
+//Compress implements compression.Compress
+func (l *Lz4) Compress(data []byte) ([]byte, error) {
+	var buf bytes.Buffer
+	w := lz4.NewWriter(&buf)
+	if l.HC {
+		err := w.Apply(lz4.CompressionLevelOption(lz4.Level9))
+		if err != nil {
+			return nil, err
+		}
+	}
+	_, err := w.Write(data)
+	if err != nil {
+		return nil, err
+	}
+	w.Close()
+	return buf.Bytes(), nil
+}

internal/compression/lzma.go

@@ -23,3 +23,18 @@ func (l *Lzma) Decompress(rdr io.Reader) ([]byte, error) {
 	}
 	return buf.Bytes(), nil
 }
+
+//Compress implements compression.Compress
+func (l *Lzma) Compress(data []byte) ([]byte, error) {
+	var buf bytes.Buffer
+	w, err := lzma.NewWriter(&buf)
+	if err != nil {
+		return nil, err
+	}
+	_, err = w.Write(data)
+	if err != nil {
+		return nil, err
+	}
+	w.Close()
+	return buf.Bytes(), nil
+}

internal/compression/xz.go

@@ -53,3 +53,23 @@ func (x *Xz) Decompress(rdr io.Reader) ([]byte, error) {
 	}
 	return buf.Bytes(), nil
 }
+
+//Compress implements compression.Compress
+func (x *Xz) Compress(data []byte) ([]byte, error) {
+	var buf bytes.Buffer
+	w, err := xz.NewWriter(&buf)
+	if err != nil {
+		return nil, err
+	}
+	w.DictCap = int(x.DictionarySize)
+	err = w.Verify()
+	if err != nil {
+		return nil, err
+	}
+	_, err = w.Write(data)
+	if err != nil {
+		return nil, err
+	}
+	w.Close()
+	return buf.Bytes(), nil
+}

internal/compression/zstd.go

@@ -34,3 +34,18 @@ func (z *Zstd) Decompress(r io.Reader) ([]byte, error) {
 	_, err = io.Copy(&buf, rdr)
 	return buf.Bytes(), err
 }
+
+//Compress impelements compression.Compress
+func (z *Zstd) Compress(data []byte) ([]byte, error) {
+	var buf bytes.Buffer
+	w, err := zstd.NewWriter(&buf, zstd.WithEncoderLevel(zstd.EncoderLevel(z.CompressionLevel)))
+	if err != nil {
+		return nil, err
+	}
+	_, err = w.Write(data)
+	if err != nil {
+		return nil, err
+	}
+	w.Close()
+	return buf.Bytes(), nil
+}

internal/directory/directory.go

@@ -13,8 +13,8 @@ type Header struct {
 	InodeNumber uint32
 }
 
-//EntryInit is the values that can be easily decoded
+//EntryRaw is the values that can be easily decoded
-type EntryInit struct {
+type EntryRaw struct {
 	Offset      uint16
 	InodeOffset int16
 	Type        uint16
@@ -23,38 +23,33 @@ type EntryInit struct {
 
 //Entry is an entry in a directory.
 type Entry struct {
-	Init   EntryInit
+	Name             string
-	Name   string
+	InodeOffset      uint32
-	Header *Header
+	InodeBlockOffset uint16
+	Type             uint16
 }
 
 //NewEntry creates a new directory entry
-func NewEntry(rdr io.Reader) (Entry, error) {
+func NewEntry(rdr io.Reader) (*Entry, error) {
-	var entry Entry
+	var raw EntryRaw
-	err := binary.Read(rdr, binary.LittleEndian, &entry.Init)
+	err := binary.Read(rdr, binary.LittleEndian, &raw)
 	if err != nil {
-		return Entry{}, err
+		return nil, err
 	}
-	tmp := make([]byte, entry.Init.NameSize+1)
+	tmp := make([]byte, raw.NameSize+1)
 	err = binary.Read(rdr, binary.LittleEndian, &tmp)
 	if err != nil {
-		return Entry{}, err
+		return nil, err
 	}
-	entry.Name = string(tmp)
+	return &Entry{
-	return entry, err
+		InodeBlockOffset: raw.Offset,
-}
+		Type:             raw.Type,
-
+		Name:             string(tmp),
-//Directory is an entry in the directory table of a squashfs.
+	}, nil
-//Will only have multiple headers if there are more then 256 entries
-type Directory struct {
-	Headers []Header
-	Entries []Entry
 }
 
 //NewDirectory reads the directory from rdr
-func NewDirectory(base io.Reader, size uint32) (*Directory, error) {
+func NewDirectory(base io.Reader, size uint32) (entries []*Entry, err error) {
-	var dir Directory
-	var err error
 	tmp := make([]byte, size)
 	base.Read(tmp)
 	rdr := bytes.NewBuffer(tmp)
@@ -62,6 +57,7 @@ func NewDirectory(base io.Reader, size uint32) (*Directory, error) {
 		var hdr Header
 		err = binary.Read(rdr, binary.LittleEndian, &hdr)
 		if err == io.ErrUnexpectedEOF {
+			err = nil
 			break
 		} else if err != nil {
 			return nil, err
@@ -71,24 +67,21 @@ func NewDirectory(base io.Reader, size uint32) (*Directory, error) {
 		if hdr.Count%256 > 0 {
 			headers++
 		}
-		dir.Headers = append(dir.Headers, hdr)
 		for i := uint32(0); i < hdr.Count; i++ {
 			if i != 0 && i%256 == 0 {
-				var newHdr Header
+				err = binary.Read(rdr, binary.LittleEndian, &hdr)
-				err = binary.Read(rdr, binary.LittleEndian, &newHdr)
 				if err != nil {
 					return nil, err
 				}
-				dir.Headers = append(dir.Headers, newHdr)
 			}
-			var ent Entry
+			var ent *Entry
 			ent, err = NewEntry(rdr)
 			if err != nil {
 				return nil, err
 			}
-			ent.Header = &dir.Headers[len(dir.Headers)-1]
+			ent.InodeOffset = hdr.InodeOffset
-			dir.Entries = append(dir.Entries, ent)
+			entries = append(entries, ent)
 		}
 	}
-	return &dir, nil
+	return
 }

internal/inode/inodetypes.go

@@ -5,17 +5,18 @@ import (
 	"io"
 )
 
+//The different types of inodes as defined by inodetype
 const (
-	BasicDirectoryType = iota + 1
+	DirType = iota + 1
-	BasicFileType
+	FileType
-	BasicSymlinkType
+	SymType
-	BasicBlockDeviceType
+	BlockDevType
-	BasicCharDeviceType
+	CharDevType
-	BasicFifoType
+	FifoType
-	BasicSocketType
+	SocketType
 	ExtDirType
 	ExtFileType
-	ExtSymlinkType
+	ExtSymType
 	ExtBlockDeviceType
 	ExtCharDeviceType
 	ExtFifoType
@@ -24,7 +25,7 @@ const (
 
 //Header is the common header for all inodes
 type Header struct {
-	InodeType    uint16
+	Type         uint16
 	Permissions  uint16
 	UID          uint16
 	GID          uint16
@@ -32,8 +33,8 @@ type Header struct {
 	Number       uint32
 }
 
-//BasicDirectory is self explainatory
+//Dir is self explainatory
-type BasicDirectory struct {
+type Dir struct {
 	DirectoryIndex    uint32
 	HardLinks         uint32
 	DirectorySize     uint16
@@ -41,8 +42,8 @@ type BasicDirectory struct {
 	ParentInodeNumber uint32
 }
 
-//ExtendedDirectoryInit is the information that can be directoy decoded
+//ExtDirInit is the information that can be directoy decoded
-type ExtendedDirectoryInit struct {
+type ExtDirInit struct {
 	HardLinks         uint32
 	DirectorySize     uint32
 	DirectoryIndex    uint32
@@ -52,21 +53,22 @@ type ExtendedDirectoryInit struct {
 	XattrIndex        uint32
 }
 
-//ExtendedDirectory is a directory with extra info
+//ExtDir is a directory with extra info
-type ExtendedDirectory struct {
+type ExtDir struct {
-	Init    ExtendedDirectoryInit
+	Indexes []DirIndex
-	Indexes []DirectoryIndex
+	ExtDirInit
 }
 
 //NewExtendedDirectory creates a new ExtendedDirectory
-func NewExtendedDirectory(rdr io.Reader) (ExtendedDirectory, error) {
+func NewExtendedDirectory(rdr io.Reader) (ExtDir, error) {
-	var inode ExtendedDirectory
+	var inode ExtDir
-	err := binary.Read(rdr, binary.LittleEndian, &inode.Init)
+	err := binary.Read(rdr, binary.LittleEndian, &inode.ExtDirInit)
 	if err != nil {
 		return inode, err
 	}
-	for i := uint16(0); i < inode.Init.IndexCount; i++ {
+	for i := uint16(0); i < inode.IndexCount; i++ {
-		tmp, err := NewDirectoryIndex(rdr)
+		var tmp DirIndex
+		tmp, err = NewDirectoryIndex(rdr)
 		if err != nil {
 			return inode, err
 		}
@@ -75,27 +77,27 @@ func NewExtendedDirectory(rdr io.Reader) (ExtendedDirectory, error) {
 	return inode, err
 }
 
-//DirectoryIndexInit holds the values that can be easily decoded
+//DirIndexInit holds the values that can be easily decoded
-type DirectoryIndexInit struct {
+type DirIndexInit struct {
 	Offset         uint32
 	DirTableOffset uint32
 	NameSize       uint32
 }
 
-//DirectoryIndex is a quick lookup provided by an ExtendedDirectory
+//DirIndex is a quick lookup provided by an ExtendedDirectory
-type DirectoryIndex struct {
+type DirIndex struct {
-	Init DirectoryIndexInit
 	Name string
+	DirIndexInit
 }
 
 //NewDirectoryIndex return a new DirectoryIndex
-func NewDirectoryIndex(rdr io.Reader) (DirectoryIndex, error) {
+func NewDirectoryIndex(rdr io.Reader) (DirIndex, error) {
-	var index DirectoryIndex
+	var index DirIndex
-	err := binary.Read(rdr, binary.LittleEndian, &index.Init)
+	err := binary.Read(rdr, binary.LittleEndian, &index.DirIndexInit)
 	if err != nil {
 		return index, err
 	}
-	tmp := make([]byte, index.Init.NameSize+1, index.Init.NameSize+1)
+	tmp := make([]byte, index.NameSize+1, index.NameSize+1)
 	err = binary.Read(rdr, binary.LittleEndian, &tmp)
 	if err != nil {
 		return index, err
@@ -104,31 +106,31 @@ func NewDirectoryIndex(rdr io.Reader) (DirectoryIndex, error) {
 	return index, nil
 }
 
-//BasicFileInit is the information that can be directoy decoded
+//FileInit is the information that can be directly decoded
-type BasicFileInit struct {
+type FileInit struct {
 	BlockStart     uint32
 	FragmentIndex  uint32
 	FragmentOffset uint32
 	Size           uint32
 }
 
-//BasicFile is self explainatory
+//File is self explainatory
-type BasicFile struct {
+type File struct {
-	Init       BasicFileInit
 	BlockSizes []uint32
 	Fragmented bool
+	FileInit
 }
 
-//NewBasicFile creates a new BasicFile
+//NewFile creates a new File
-func NewBasicFile(rdr io.Reader, blockSize uint32) (BasicFile, error) {
+func NewFile(rdr io.Reader, blockSize uint32) (File, error) {
-	var inode BasicFile
+	var inode File
-	err := binary.Read(rdr, binary.LittleEndian, &inode.Init)
+	err := binary.Read(rdr, binary.LittleEndian, &inode.FileInit)
 	if err != nil {
 		return inode, err
 	}
-	inode.Fragmented = inode.Init.FragmentIndex != 0xFFFFFFFF
+	inode.Fragmented = inode.FragmentIndex != 0xFFFFFFFF
-	blocks := inode.Init.Size / blockSize
+	blocks := inode.Size / blockSize
-	if inode.Init.Size%blockSize > 0 {
+	if inode.Size%blockSize > 0 {
 		blocks++
 	}
 	inode.BlockSizes = make([]uint32, blocks, blocks)
@@ -136,10 +138,10 @@ func NewBasicFile(rdr io.Reader, blockSize uint32) (BasicFile, error) {
 	return inode, err
 }
 
-//ExtendedFileInit is the information that can be directly decoded
+//ExtFileInit is the information that can be directly decoded
-type ExtendedFileInit struct {
+type ExtFileInit struct {
-	BlockStart     uint32
+	BlockStart     uint64
-	Size           uint32
+	Size           uint64
 	Sparse         uint64
 	HardLinks      uint32
 	FragmentIndex  uint32
@@ -147,23 +149,23 @@ type ExtendedFileInit struct {
 	XattrIndex     uint32
 }
 
-//ExtendedFile is a file with more information
+//ExtFile is a file with more information
-type ExtendedFile struct {
+type ExtFile struct {
-	Init       ExtendedFileInit
 	BlockSizes []uint32
 	Fragmented bool
+	ExtFileInit
 }
 
 //NewExtendedFile creates a new ExtendedFile
-func NewExtendedFile(rdr io.Reader, blockSize uint32) (ExtendedFile, error) {
+func NewExtendedFile(rdr io.Reader, blockSize uint32) (ExtFile, error) {
-	var inode ExtendedFile
+	var inode ExtFile
-	err := binary.Read(rdr, binary.LittleEndian, &inode.Init)
+	err := binary.Read(rdr, binary.LittleEndian, &inode.ExtFileInit)
 	if err != nil {
 		return inode, err
 	}
-	inode.Fragmented = inode.Init.FragmentIndex != 0xFFFFFFFF
+	inode.Fragmented = inode.FragmentIndex != 0xFFFFFFFF
-	blocks := inode.Init.Size / blockSize
+	blocks := inode.Size / uint64(blockSize)
-	if inode.Init.Size%blockSize > 0 {
+	if inode.Size%uint64(blockSize) > 0 {
 		blocks++
 	}
 	inode.BlockSizes = make([]uint32, blocks, blocks)
@@ -171,27 +173,27 @@ func NewExtendedFile(rdr io.Reader, blockSize uint32) (ExtendedFile, error) {
 	return inode, err
 }
 
-//BasicSymlinkInit is all the values that can be directly decoded
+//SymInit is all the values that can be directly decoded
-type BasicSymlinkInit struct {
+type SymInit struct {
 	HardLinks      uint32
 	TargetPathSize uint32
 }
 
-//BasicSymlink is a symlink
+//Sym is a symlink
-type BasicSymlink struct {
+type Sym struct {
-	Init       BasicSymlinkInit
-	targetPath []byte //len is TargetPathSize
 	Path       string
+	targetPath []byte //len is TargetPathSize
+	SymInit
 }
 
-//NewBasicSymlink creates a new BasicSymlink
+//NewSymlink creates a new Symlink
-func NewBasicSymlink(rdr io.Reader) (BasicSymlink, error) {
+func NewSymlink(rdr io.Reader) (Sym, error) {
-	var inode BasicSymlink
+	var inode Sym
-	err := binary.Read(rdr, binary.LittleEndian, &inode.Init)
+	err := binary.Read(rdr, binary.LittleEndian, &inode.SymInit)
 	if err != nil {
 		return inode, err
 	}
-	inode.targetPath = make([]byte, inode.Init.TargetPathSize, inode.Init.TargetPathSize)
+	inode.targetPath = make([]byte, inode.TargetPathSize, inode.TargetPathSize)
 	err = binary.Read(rdr, binary.LittleEndian, &inode.targetPath)
 	if err != nil {
 		return inode, err
@@ -200,28 +202,28 @@ func NewBasicSymlink(rdr io.Reader) (BasicSymlink, error) {
 	return inode, err
 }
 
-//ExtendedSymlinkInit is all the values that can be directly decoded
+//ExtSymInit is all the values that can be directly decoded
-type ExtendedSymlinkInit struct {
+type ExtSymInit struct {
 	HardLinks      uint32
 	TargetPathSize uint32
 }
 
-//ExtendedSymlink is a symlink with extra information
+//ExtSym is a symlink with extra information
-type ExtendedSymlink struct {
+type ExtSym struct {
-	Init       ExtendedSymlinkInit
-	targetPath []uint8
 	Path       string
+	targetPath []uint8
+	ExtSymInit
 	XattrIndex uint32
 }
 
 //NewExtendedSymlink creates a new ExtendedSymlink
-func NewExtendedSymlink(rdr io.Reader) (ExtendedSymlink, error) {
+func NewExtendedSymlink(rdr io.Reader) (ExtSym, error) {
-	var inode ExtendedSymlink
+	var inode ExtSym
-	err := binary.Read(rdr, binary.LittleEndian, &inode.Init)
+	err := binary.Read(rdr, binary.LittleEndian, &inode.ExtSymInit)
 	if err != nil {
 		return inode, err
 	}
-	inode.targetPath = make([]uint8, inode.Init.TargetPathSize, inode.Init.TargetPathSize)
+	inode.targetPath = make([]uint8, inode.TargetPathSize, inode.TargetPathSize)
 	err = binary.Read(rdr, binary.LittleEndian, &inode.targetPath)
 	if err != nil {
 		return inode, err
@@ -231,25 +233,25 @@ func NewExtendedSymlink(rdr io.Reader) (ExtendedSymlink, error) {
 	return inode, err
 }
 
-//BasicDevice is a device
+//Device is a device
-type BasicDevice struct {
+type Device struct {
 	HardLinks uint32
 	Device    uint32
 }
 
-//ExtendedDevice is a device with more info
+//ExtDevice is a device with more info
-type ExtendedDevice struct {
+type ExtDevice struct {
-	BasicDevice
+	Device
 	XattrIndex uint32
 }
 
-//BasicIPC is a Fifo or Socket device
+//IPC is a Fifo or Socket device
-type BasicIPC struct {
+type IPC struct {
 	HardLink uint32
 }
 
-//ExtendedIPC is a IPC device with extra info
+//ExtIPC is a IPC device with extra info
-type ExtendedIPC struct {
+type ExtIPC struct {
-	BasicIPC
+	IPC
 	XattrIndex uint32
 }

internal/inode/process.go

@@ -2,124 +2,127 @@ package inode
 
 import (
 	"encoding/binary"
+	"errors"
 	"io"
+	"strconv"
 )
 
 //Inode holds an inode. Header is the header that's common for all inodes.
 //
 //Info holds the actual Inode. Due to each inode type being a different type, it's store as an interface{}
 type Inode struct {
-	Header Header
+	Info interface{} //Info is the parsed specific data. It's type is defined by Type.
-	Type   int         //Type the inode type defined in the header. Here so it's easy to access
+	Header
-	Info   interface{} //Info is the parsed specific data. It's type is defined by Type.
 }
 
 //ProcessInode tries to read an inode from the BlockReader
 func ProcessInode(br io.Reader, blockSize uint32) (*Inode, error) {
-	var head Header
+	var in Inode
-	err := binary.Read(br, binary.LittleEndian, &head)
+	err := binary.Read(br, binary.LittleEndian, &in.Header)
 	if err != nil {
 		return nil, err
 	}
-	var info interface{}
+	switch in.Type {
-	switch head.InodeType {
+	case DirType:
-	case BasicDirectoryType:
+		var inode Dir
-		var inode BasicDirectory
 		err = binary.Read(br, binary.LittleEndian, &inode)
 		if err != nil {
 			return nil, err
 		}
-		info = inode
+		in.Info = inode
-	case BasicFileType:
+	case FileType:
-		inode, err := NewBasicFile(br, blockSize)
+		var inode File
+		inode, err = NewFile(br, blockSize)
 		if err != nil {
 			return nil, err
 		}
-		info = inode
+		in.Info = inode
-	case BasicSymlinkType:
+	case SymType:
-		inode, err := NewBasicSymlink(br)
+		var inode Sym
+		inode, err = NewSymlink(br)
 		if err != nil {
 			return nil, err
 		}
-		info = inode
+		in.Info = inode
-	case BasicBlockDeviceType:
+	case BlockDevType:
-		var inode BasicDevice
+		var inode Device
 		err = binary.Read(br, binary.LittleEndian, &inode)
 		if err != nil {
 			return nil, err
 		}
-		info = inode
+		in.Info = inode
-	case BasicCharDeviceType:
+	case CharDevType:
-		var inode BasicDevice
+		var inode Device
 		err = binary.Read(br, binary.LittleEndian, &inode)
 		if err != nil {
 			return nil, err
 		}
-		info = inode
+		in.Info = inode
-	case BasicFifoType:
+	case FifoType:
-		var inode BasicIPC
+		var inode IPC
 		err = binary.Read(br, binary.LittleEndian, &inode)
 		if err != nil {
 			return nil, err
 		}
-		info = inode
+		in.Info = inode
-	case BasicSocketType:
+	case SocketType:
-		var inode BasicIPC
+		var inode IPC
 		err = binary.Read(br, binary.LittleEndian, &inode)
 		if err != nil {
 			return nil, err
 		}
-		info = inode
+		in.Info = inode
 	case ExtDirType:
-		inode, err := NewExtendedDirectory(br)
+		var inode ExtDir
+		inode, err = NewExtendedDirectory(br)
 		if err != nil {
 			return nil, err
 		}
-		info = inode
+		in.Info = inode
 	case ExtFileType:
-		inode, err := NewExtendedFile(br, blockSize)
+		var inode ExtFile
+		inode, err = NewExtendedFile(br, blockSize)
 		if err != nil {
 			return nil, err
 		}
-		info = inode
+		in.Info = inode
-	case ExtSymlinkType:
+	case ExtSymType:
-		inode, err := NewExtendedSymlink(br)
+		var inode ExtSym
+		inode, err = NewExtendedSymlink(br)
 		if err != nil {
 			return nil, err
 		}
-		info = inode
+		in.Info = inode
 	case ExtBlockDeviceType:
-		var inode ExtendedDevice
+		var inode ExtDevice
 		err = binary.Read(br, binary.LittleEndian, &inode)
 		if err != nil {
 			return nil, err
 		}
-		info = inode
+		in.Info = inode
 	case ExtCharDeviceType:
-		var inode ExtendedDevice
+		var inode ExtDevice
 		err = binary.Read(br, binary.LittleEndian, &inode)
 		if err != nil {
 			return nil, err
 		}
-		info = inode
+		in.Info = inode
 	case ExtFifoType:
-		var inode ExtendedIPC
+		var inode ExtIPC
 		err = binary.Read(br, binary.LittleEndian, &inode)
 		if err != nil {
 			return nil, err
 		}
-		info = inode
+		in.Info = inode
 	case ExtSocketType:
-		var inode ExtendedIPC
+		var inode ExtIPC
 		err = binary.Read(br, binary.LittleEndian, &inode)
 		if err != nil {
 			return nil, err
 		}
-		info = inode
+		in.Info = inode
+	default:
+		return nil, errors.New("Unsupported inode type: " + strconv.Itoa(int(in.Type)))
 	}
-	return &Inode{
+	return &in, nil
-		Type:   int(head.InodeType),
-		Header: head,
-		Info:   info,
-	}, nil
 }

metadata.go

@@ -16,9 +16,9 @@ type metadata struct {
 //MetadataReader is a block reader for metadata. It will automatically read the next block, when it reaches the end of a block.
 type metadataReader struct {
 	s          *Reader
-	offset     int64
 	headers    []*metadata
 	data       []byte
+	offset     int64
 	readOffset int
 }
 

reader.go

@@ -12,7 +12,7 @@ import (
 )
 
 const (
-	magic = 0x73717368
+	magic uint32 = 0x73717368
 )
 
 var (
@@ -26,36 +26,42 @@ var (
 	ErrOptions = errors.New("Possibly incompatible compressor options")
 )
 
+//TODO: implement fs.FS, possibly more FS types for compatibility. Most of this work will mostly be handed off to root anyway so this shouldn't be too difficult.
+
 //Reader processes and reads a squashfs archive.
 type Reader struct {
-	r            io.ReaderAt
+	FS
-	super        superblock
+	r            *io.SectionReader
-	flags        superblockFlags
 	decompressor compression.Decompressor
+	root         *File
 	fragOffsets  []uint64
 	idTable      []uint32
+	super        superblock
+	flags        SuperblockFlags
 }
 
 //NewSquashfsReader returns a new squashfs.Reader from an io.ReaderAt
 func NewSquashfsReader(r io.ReaderAt) (*Reader, error) {
-	hasUnsupportedOptions := false
 	var rdr Reader
-	rdr.r = r
+	err := binary.Read(io.NewSectionReader(r, 0, int64(binary.Size(rdr.super))), binary.LittleEndian, &rdr.super)
-	err := binary.Read(io.NewSectionReader(rdr.r, 0, int64(binary.Size(rdr.super))), binary.LittleEndian, &rdr.super)
 	if err != nil {
 		return nil, err
 	}
+	rdr.r = io.NewSectionReader(r, 0, int64(rdr.super.BytesUsed))
 	if rdr.super.Magic != magic {
 		return nil, errNoMagic
 	}
-	// if rdr.super.BlockLog == uint16(math.Log2(float64(rdr.super.BlockSize))) {
+	if rdr.super.BlockLog != uint16(math.Log2(float64(rdr.super.BlockSize))) {
-	// 	return nil, errors.New("BlockSize and BlockLog doesn't match. The archive is probably corrupt")
+		return nil, errors.New("BlockSize and BlockLog doesn't match. The archive is probably corrupt")
-	// }
+	}
+	rdr.r.Seek(96, io.SeekStart)
+	hasUnsupportedOptions := false
 	rdr.flags = rdr.super.GetFlags()
-	if rdr.flags.CompressorOptions {
+	if rdr.flags.compressorOptions {
 		switch rdr.super.CompressionType {
-		case gzipCompression:
+		case GzipCompression:
-			gzip, err := compression.NewGzipCompressorWithOptions(io.NewSectionReader(rdr.r, int64(binary.Size(rdr.super)), 8))
+			var gzip *compression.Gzip
+			gzip, err = compression.NewGzipCompressorWithOptions(rdr.r)
 			if err != nil {
 				return nil, err
 			}
@@ -63,8 +69,9 @@ func NewSquashfsReader(r io.ReaderAt) (*Reader, error) {
 				hasUnsupportedOptions = true
 			}
 			rdr.decompressor = gzip
-		case xzCompression:
+		case XzCompression:
-			xz, err := compression.NewXzCompressorWithOptions(io.NewSectionReader(rdr.r, int64(binary.Size(rdr.super)), 8))
+			var xz *compression.Xz
+			xz, err = compression.NewXzCompressorWithOptions(rdr.r)
 			if err != nil {
 				return nil, err
 			}
@@ -72,35 +79,34 @@ func NewSquashfsReader(r io.ReaderAt) (*Reader, error) {
 				return nil, errors.New("XZ compression options has filters. These are not yet supported")
 			}
 			rdr.decompressor = xz
-		case lz4Compression:
+		case Lz4Compression:
-			lz4, err := compression.NewLz4CompressorWithOptions(io.NewSectionReader(rdr.r, int64(binary.Size(rdr.super)), 8))
+			var lz4 *compression.Lz4
+			lz4, err = compression.NewLz4CompressorWithOptions(rdr.r)
 			if err != nil {
 				return nil, err
 			}
-			if lz4.HC {
-				hasUnsupportedOptions = true
-			}
 			rdr.decompressor = lz4
-		case zstdCompression:
+		case ZstdCompression:
-			zstd, err := compression.NewZstdCompressorWithOptions(io.NewSectionReader(rdr.r, int64(binary.Size(rdr.super)), 4))
+			var zstd *compression.Zstd
+			zstd, err = compression.NewZstdCompressorWithOptions(rdr.r)
 			if err != nil {
 				return nil, err
 			}
 			rdr.decompressor = zstd
 		default:
-			return nil, errCompressorOptions
+			return nil, errIncompatibleCompression
 		}
 	} else {
 		switch rdr.super.CompressionType {
-		case gzipCompression:
+		case GzipCompression:
 			rdr.decompressor = &compression.Gzip{}
-		case lzmaCompression:
+		case LzmaCompression:
 			rdr.decompressor = &compression.Lzma{}
-		case xzCompression:
+		case XzCompression:
 			rdr.decompressor = &compression.Xz{}
-		case lz4Compression:
+		case Lz4Compression:
 			rdr.decompressor = &compression.Lz4{}
-		case zstdCompression:
+		case ZstdCompression:
 			rdr.decompressor = &compression.Zstd{}
 		default:
 			//TODO: all compression types.
@@ -122,13 +128,14 @@ func NewSquashfsReader(r io.ReaderAt) (*Reader, error) {
 	}
 	unread := rdr.super.IDCount
 	blockOffsets := make([]uint64, int(math.Ceil(float64(rdr.super.IDCount)/2048)))
+	rdr.r.Seek(int64(rdr.super.IDTableStart), io.SeekStart)
 	for i := range blockOffsets {
-		secRdr := io.NewSectionReader(r, int64(rdr.super.IDTableStart)+(8*int64(i)), 8)
+		err = binary.Read(rdr.r, binary.LittleEndian, &blockOffsets[i])
-		err = binary.Read(secRdr, binary.LittleEndian, &blockOffsets[i])
 		if err != nil {
 			return nil, err
 		}
-		idRdr, err := rdr.newMetadataReader(int64(blockOffsets[i]))
+		var idRdr *metadataReader
+		idRdr, err = rdr.newMetadataReader(int64(blockOffsets[i]))
 		if err != nil {
 			return nil, err
 		}
@@ -143,6 +150,23 @@ func NewSquashfsReader(r io.ReaderAt) (*Reader, error) {
 		}
 		unread -= read
 	}
+	metaRdr, err := rdr.newMetadataReaderFromInodeRef(rdr.super.RootInodeRef)
+	if err != nil {
+		return nil, err
+	}
+	i, err := inode.ProcessInode(metaRdr, rdr.super.BlockSize)
+	if err != nil {
+		return nil, err
+	}
+	entries, err := rdr.readDirFromInode(i)
+	if err != nil {
+		return nil, err
+	}
+	rdr.FS = FS{
+		r:       &rdr,
+		name:    "/",
+		entries: entries,
+	}
 	if hasUnsupportedOptions {
 		return &rdr, ErrOptions
 	}
@@ -153,105 +177,3 @@ func NewSquashfsReader(r io.ReaderAt) (*Reader, error) {
 func (r *Reader) ModTime() time.Time {
 	return time.Unix(int64(r.super.CreationTime), 0)
 }
-
-//ExtractTo tries to extract ALL files to the given path. This is the same as getting the root folder and extracting that.
-func (r *Reader) ExtractTo(path string) []error {
-	root, err := r.GetRootFolder()
-	if err != nil {
-		return []error{err}
-	}
-	return root.ExtractTo(path)
-}
-
-//GetRootFolder returns a squashfs.File that references the root directory of the squashfs archive.
-func (r *Reader) GetRootFolder() (root *File, err error) {
-	root = new(File)
-	mr, err := r.newMetadataReaderFromInodeRef(r.super.RootInodeRef)
-	if err != nil {
-		return nil, err
-	}
-	root.in, err = inode.ProcessInode(mr, r.super.BlockSize)
-	if err != nil {
-		return nil, err
-	}
-	root.path = "/"
-	root.filType = root.in.Type
-	root.r = r
-	return root, nil
-}
-
-//GetAllFiles returns a slice of ALL files and folders contained in the squashfs.
-func (r *Reader) GetAllFiles() (fils []*File, err error) {
-	root, err := r.GetRootFolder()
-	if err != nil {
-		return nil, err
-	}
-	return root.GetChildrenRecursively()
-}
-
-//FindFile returns the first file (in the same order as Reader.GetAllFiles) that the given function returns true for. Returns nil if nothing is found.
-func (r *Reader) FindFile(query func(*File) bool) *File {
-	root, err := r.GetRootFolder()
-	if err != nil {
-		return nil
-	}
-	fils, err := root.GetChildren()
-	if err != nil {
-		return nil
-	}
-	var childrenDirs []*File
-	for _, fil := range fils {
-		if query(fil) {
-			return fil
-		}
-		if fil.IsDir() {
-			childrenDirs = append(childrenDirs, fil)
-		}
-	}
-	for len(childrenDirs) != 0 {
-		var tmp []*File
-		for _, dirs := range childrenDirs {
-			chil, err := dirs.GetChildren()
-			if err != nil {
-				return nil
-			}
-			for _, child := range chil {
-				if query(child) {
-					return child
-				}
-				if child.IsDir() {
-					tmp = append(tmp, child)
-				}
-			}
-		}
-		childrenDirs = tmp
-	}
-	return nil
-}
-
-//FindAll returns all files where the given function returns true.
-func (r *Reader) FindAll(query func(*File) bool) (all []*File) {
-	root, err := r.GetRootFolder()
-	if err != nil {
-		return nil
-	}
-	fils, err := root.GetChildrenRecursively()
-	if err != nil {
-		return nil
-	}
-	for _, fil := range fils {
-		if query(fil) {
-			all = append(all, fil)
-		}
-	}
-	return
-}
-
-//GetFileAtPath will return the file at the given path. If the file cannot be found, will return nil.
-func (r *Reader) GetFileAtPath(path string) *File {
-	dir, err := r.GetRootFolder()
-	if err != nil {
-		return nil
-	}
-	return dir.GetFileAtPath(path)
-}

reader_test.go

@@ -0,0 +1,223 @@
+package squashfs
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"strconv"
+	"testing"
+	"time"
+
+	goappimage "github.com/CalebQ42/GoAppImage"
+)
+
+const (
+	downloadURL  = "https://github.com/srevinsaju/Firefox-Appimage/releases/download/firefox-v84.0.r20201221152838/firefox-84.0.r20201221152838-x86_64.AppImage"
+	appImageName = "firefox-84.0.r20201221152838-x86_64.AppImage"
+	squashfsName = "balenaEtcher-1.5.113-x64.AppImage.sfs"
+)
+
+func TestSquashfs(t *testing.T) {
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	squashFil, err := os.Open(wd + "/testing/" + squashfsName)
+	if err != nil {
+		t.Fatal(err)
+	}
+	rdr, err := NewSquashfsReader(squashFil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fmt.Println("stuff", rdr.super.CompressionType)
+	// fil := rdr.GetFileAtPath("*.desktop")
+	// if fil == nil {
+	// 	t.Fatal("Can't find desktop fil")
+	// }
+	// errs := fil.ExtractTo(wd + "/testing")
+	// if len(errs) > 0 {
+	// 	t.Fatal(errs)
+	// }
+	// errs = rdr.ExtractTo(wd + "/testing/" + squashfsName + ".d")
+	// if len(errs) > 0 {
+	// 	t.Fatal(errs)
+	// }
+	t.Fatal("No Problems")
+}
+
+func TestAppImage(t *testing.T) {
+	t.Parallel()
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	aiFil, err := os.Open(wd + "/testing/" + appImageName)
+	if os.IsNotExist(err) {
+		err = downloadTestAppImage(wd + "/testing")
+		if err != nil {
+			t.Fatal(err)
+		}
+		aiFil, err = os.Open(wd + "/testing/" + appImageName)
+		if err != nil {
+			t.Fatal(err)
+		}
+	} else if err != nil {
+		t.Fatal(err)
+	}
+	defer aiFil.Close()
+	stat, _ := aiFil.Stat()
+	ai := goappimage.NewAppImage(wd + "/testing/" + appImageName)
+	rdr, err := NewSquashfsReader(io.NewSectionReader(aiFil, ai.Offset, stat.Size()-ai.Offset))
+	if err != nil {
+		t.Fatal(err)
+	}
+	os.RemoveAll(wd + "/testing/firefox")
+	err = rdr.ExtractTo(wd + "/testing/firefox")
+	t.Fatal(err)
+}
+
+func TestUnsquashfs(t *testing.T) {
+	t.Parallel()
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	aiFil, err := os.Open(wd + "/testing/" + appImageName)
+	if os.IsNotExist(err) {
+		err = downloadTestAppImage(wd + "/testing")
+		if err != nil {
+			t.Fatal(err)
+		}
+		aiFil, err = os.Open(wd + "/testing/" + appImageName)
+		if err != nil {
+			t.Fatal(err)
+		}
+	} else if err != nil {
+		t.Fatal(err)
+	}
+	os.RemoveAll(wd + "/testing/unsquashFirefox")
+	os.RemoveAll(wd + "/testing/firefox")
+	ai := goappimage.NewAppImage(wd + "/testing/" + appImageName)
+	fmt.Println("Command:", "unsquashfs", "-d", wd+"/testing/unsquashFirefox", "-o", strconv.Itoa(int(ai.Offset)), aiFil.Name())
+	cmd := exec.Command("unsquashfs", "-d", wd+"/testing/unsquashFirefox", "-o", strconv.Itoa(int(ai.Offset)), aiFil.Name())
+	start := time.Now()
+	err = cmd.Run()
+	if err != nil {
+		t.Fatal(err)
+	}
+	fmt.Println(time.Since(start))
+	t.Fatal("HI")
+}
+
+func BenchmarkDragRace(b *testing.B) {
+	wd, err := os.Getwd()
+	if err != nil {
+		b.Fatal(err)
+	}
+	aiFil, err := os.Open(wd + "/testing/" + appImageName)
+	if os.IsNotExist(err) {
+		err = downloadTestAppImage(wd + "/testing")
+		if err != nil {
+			b.Fatal(err)
+		}
+		aiFil, err = os.Open(wd + "/testing/" + appImageName)
+		if err != nil {
+			b.Fatal(err)
+		}
+	} else if err != nil {
+		b.Fatal(err)
+	}
+	stat, _ := aiFil.Stat()
+	ai := goappimage.NewAppImage(wd + "/testing/" + appImageName)
+	os.RemoveAll(wd + "/testing/unsquashFirefox")
+	os.RemoveAll(wd + "/testing/firefox")
+	cmd := exec.Command("unsquashfs", "-d", wd+"/testing/unsquashFirefox", "-o", strconv.Itoa(int(ai.Offset)), aiFil.Name())
+	start := time.Now()
+	err = cmd.Run()
+	if err != nil {
+		b.Fatal(err)
+	}
+	unsquashTime := time.Since(start)
+	start = time.Now()
+	rdr, err := NewSquashfsReader(io.NewSectionReader(aiFil, ai.Offset, stat.Size()-ai.Offset))
+	if err != nil {
+		b.Fatal(err)
+	}
+	err = rdr.ExtractTo(wd + "/testing/firefox")
+	if err != nil {
+		b.Fatal(err)
+	}
+	libTime := time.Since(start)
+	b.Log("Unsqushfs:", unsquashTime.Round(time.Millisecond))
+	b.Log("Library:", libTime.Round(time.Millisecond))
+	b.Log("unsquashfs is", strconv.FormatFloat(float64(libTime.Milliseconds())/float64(unsquashTime.Milliseconds()), 'f', 2, 64)+"x faster")
+}
+
+func downloadTestAppImage(dir string) error {
+	//seems to time out on slow connections. Might fix that at some point... or not. It's just a test...
+	os.Mkdir(dir, os.ModePerm)
+	appImage, err := os.Create(dir + "/" + appImageName)
+	if err != nil {
+		return err
+	}
+	defer appImage.Close()
+	check := http.Client{
+		CheckRedirect: func(r *http.Request, _ []*http.Request) error {
+			r.URL.Opaque = r.URL.Path
+			return nil
+		},
+	}
+	resp, err := check.Get(downloadURL)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	_, err = io.Copy(appImage, resp.Body)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func TestCreateSquashFromAppImage(t *testing.T) {
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = os.Mkdir(wd+"/testing", 0777)
+	if err != nil && !os.IsExist(err) {
+		t.Fatal(err)
+	}
+	_, err = os.Open(wd + "/testing/" + appImageName)
+	if os.IsNotExist(err) {
+		err = downloadTestAppImage(wd + "/testing")
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, err = os.Open(wd + "/testing/" + appImageName)
+		if err != nil {
+			t.Fatal(err)
+		}
+	} else if err != nil {
+		t.Fatal(err)
+	}
+	ai := goappimage.NewAppImage(wd + "/testing/" + appImageName)
+	aiFil, err := os.Open(wd + "/testing/" + appImageName)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer aiFil.Close()
+	aiFil.Seek(ai.Offset, 0)
+	os.Remove(wd + "/testing/" + appImageName + ".squashfs")
+	aiSquash, err := os.Create(wd + "/testing/" + appImageName + ".squashfs")
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = io.Copy(aiSquash, aiFil)
+	if err != nil {
+		t.Fatal(err)
+	}
+}

squash_test.go

@@ -1,132 +0,0 @@
-package squashfs
-
-import (
-	"io"
-	"net/http"
-	"os"
-	"testing"
-
-	goappimage "github.com/CalebQ42/GoAppImage"
-)
-
-const (
-	downloadURL  = "https://github.com/Swordfish90/cool-retro-term/releases/download/1.1.1/Cool-Retro-Term-1.1.1-x86_64.AppImage"
-	appImageName = "Cool-Retro-Term.AppImage"
-	squashfsName = "airootfs.sfs" //testing with a ArchLinux root fs from the live img
-)
-
-//Right now, don't use. Arch linux sfs uses XZ compression with filters, which isn't supported
-func TestSquashfs(t *testing.T) {
-	wd, err := os.Getwd()
-	if err != nil {
-		t.Fatal(err)
-	}
-	squashFil, err := os.Open(wd + "/testing/" + squashfsName)
-	if err != nil {
-		t.Fatal(err)
-	}
-	rdr, err := NewSquashfsReader(squashFil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	os.RemoveAll(wd + "/testing/" + squashfsName + ".d")
-	root, _ := rdr.GetRootFolder()
-	errs := root.ExtractWithOptions(wd+"/testing/"+squashfsName+".d", false, false, os.ModePerm, true)
-	t.Fatal(errs)
-}
-
-func TestAppImage(t *testing.T) {
-	t.Parallel()
-	wd, err := os.Getwd()
-	if err != nil {
-		t.Fatal(err)
-	}
-	aiFil, err := os.Open(wd + "/testing/" + appImageName)
-	if os.IsNotExist(err) {
-		downloadTestAppImage(t, wd+"/testing")
-		aiFil, err = os.Open(wd + "/testing/" + appImageName)
-		if err != nil {
-			t.Fatal(err)
-		}
-	} else if err != nil {
-		t.Fatal(err)
-	}
-	defer aiFil.Close()
-	stat, _ := aiFil.Stat()
-	ai := goappimage.NewAppImage(wd + "/testing/" + appImageName)
-	rdr, err := NewSquashfsReader(io.NewSectionReader(aiFil, ai.Offset, stat.Size()-ai.Offset))
-	if err != nil {
-		t.Fatal(err)
-	}
-	errs := rdr.ExtractTo(wd + "/testing/cool-retro")
-	if len(errs) > 0 {
-		t.Fatal(errs)
-	}
-	// os.RemoveAll(wd + "/testing/" + appImageName + ".d")
-	// root, _ := rdr.GetRootFolder()
-	// errs := root.ExtractWithOptions(wd+"/testing/"+appImageName+".d", true, os.ModePerm, true)
-	// t.Fatal(errs)
-	t.Fatal("No problemo!")
-}
-
-func downloadTestAppImage(t *testing.T, dir string) {
-	//seems to time out on slow connections. Might fix that at some point... or not. It's just a test...
-	os.Mkdir(dir, os.ModePerm)
-	appImage, err := os.Create(dir + "/" + appImageName)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer appImage.Close()
-	check := http.Client{
-		CheckRedirect: func(r *http.Request, via []*http.Request) error {
-			r.URL.Opaque = r.URL.Path
-			return nil
-		},
-	}
-	resp, err := check.Get(downloadURL)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer resp.Body.Close()
-	_, err = io.Copy(appImage, resp.Body)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestCreateSquashFromAppImage(t *testing.T) {
-	wd, err := os.Getwd()
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = os.Mkdir(wd+"/testing", 0777)
-	if err != nil && !os.IsExist(err) {
-		t.Fatal(err)
-	}
-	_, err = os.Open(wd + "/testing/" + appImageName)
-	if os.IsNotExist(err) {
-		downloadTestAppImage(t, wd+"/testing")
-		_, err = os.Open(wd + "/testing/" + appImageName)
-		if err != nil {
-			t.Fatal(err)
-		}
-	} else if err != nil {
-		t.Fatal(err)
-	}
-	ai := goappimage.NewAppImage(wd + "/testing/" + appImageName)
-	aiFil, err := os.Open(wd + "/testing/" + appImageName)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer aiFil.Close()
-	aiFil.Seek(ai.Offset, 0)
-	os.Remove(wd + "/testing/" + appImageName + ".squashfs")
-	aiSquash, err := os.Create(wd + "/testing/" + appImageName + ".squashfs")
-	if err != nil {
-		t.Fatal(err)
-	}
-	_, err = io.Copy(aiSquash, aiFil)
-	if err != nil {
-		t.Fatal(err)
-	}
-}

superblock.go

@@ -1,12 +1,13 @@
 package squashfs
 
+//The types of compression supported by squashfs.
 const (
-	gzipCompression = 1 + iota
+	GzipCompression = 1 + iota
-	lzmaCompression
+	LzmaCompression
-	lzoCompression
+	LzoCompression
-	xzCompression
+	XzCompression
-	lz4Compression
+	Lz4Compression
-	zstdCompression
+	ZstdCompression
 )
 
 //Superblock contains important information about a squashfs file. Located at the very front of the archive.
@@ -32,36 +33,94 @@ type superblock struct {
 	ExportTableStart uint64
 }
 
-//SuperblockFlags is the parsed version of Superblock.Flags
+//SuperblockFlags is the series of flags describing how a squashfs archive is packed.
-type superblockFlags struct {
+type SuperblockFlags struct {
-	UncompressedInodes    bool
+	//If true, inodes are stored uncompressed.
-	UncompressedData      bool
+	UncompressedInodes bool
-	Check                 bool
+	//If true, data is stored uncompressed.
+	UncompressedData bool
+	check            bool
+	//If true, fragments are stored uncompressed.
 	UncompressedFragments bool
-	NoFragments           bool
+	//If true, ALL data is stored in sequential data blocks instead of utilizing fragments.
-	AlwaysFragments       bool
+	NoFragments bool
-	Duplicates            bool
+	//If true, the last block of data will always be stored as a fragment if it's less then the block size.
-	Exportable            bool
+	AlwaysFragment bool
-	UncompressedXattr     bool
+	//If true, duplicate files are only stored once. (Currently unsupported)
-	NoXattr               bool
+	RemoveDuplicates bool
-	CompressorOptions     bool
+	//If true, the export table is populated. (Currently unsupported)
-	UncompressedIDs       bool
+	Exportable bool
+	//If true, the xattr table is uncompressed. (Currently unsupported)
+	UncompressedXattr bool
+	//If true, the xattr table is not populated. (Currently unsupported)
+	NoXattr           bool
+	compressorOptions bool
+	//If true, the UID/GID table is stored uncompressed.
+	UncompressedIDs bool
+}
+
+//DefaultFlags are the default SuperblockFlags that are used.
+var DefaultFlags = SuperblockFlags{
+	RemoveDuplicates: true,
+	Exportable:       true,
 }
 
 //GetFlags returns a SuperblockFlags for a given superblock.
-func (s *superblock) GetFlags() superblockFlags {
+func (s *superblock) GetFlags() SuperblockFlags {
-	return superblockFlags{
+	return SuperblockFlags{
 		UncompressedInodes:    s.Flags&0x1 == 0x1,
 		UncompressedData:      s.Flags&0x2 == 0x2,
-		Check:                 s.Flags&0x4 == 0x4,
+		check:                 s.Flags&0x4 == 0x4,
 		UncompressedFragments: s.Flags&0x8 == 0x8,
 		NoFragments:           s.Flags&0x10 == 0x10,
-		AlwaysFragments:       s.Flags&0x20 == 0x20,
+		AlwaysFragment:        s.Flags&0x20 == 0x20,
-		Duplicates:            s.Flags&0x40 == 0x40,
+		RemoveDuplicates:      s.Flags&0x40 == 0x40,
 		Exportable:            s.Flags&0x80 == 0x80,
 		UncompressedXattr:     s.Flags&0x100 == 0x100,
 		NoXattr:               s.Flags&0x200 == 0x200,
-		CompressorOptions:     s.Flags&0x400 == 0x400,
+		compressorOptions:     s.Flags&0x400 == 0x400,
 		UncompressedIDs:       s.Flags&0x800 == 0x800,
 	}
 }
+
+//ToUint returns the uint16 representation of the given SuperblockFlags
+func (s *SuperblockFlags) ToUint() uint16 {
+	var out uint16
+	if s.UncompressedInodes {
+		out = out | 0x1
+	}
+	if s.UncompressedData {
+		out = out | 0x2
+	}
+	if s.check {
+		out = out | 0x4
+	}
+	if s.UncompressedFragments {
+		out = out | 0x8
+	}
+	if s.NoFragments {
+		out = out | 0x10
+	}
+	if s.AlwaysFragment {
+		out = out | 0x20
+	}
+	if s.RemoveDuplicates {
+		out = out | 0x40
+	}
+	if s.Exportable {
+		out = out | 0x80
+	}
+	if s.UncompressedXattr {
+		out = out | 0x100
+	}
+	if s.NoXattr {
+		out = out | 0x200
+	}
+	if s.compressorOptions {
+		out = out | 0x400
+	}
+	if s.UncompressedIDs {
+		out = out | 0x800
+	}
+	return out
+}

writer.go

@@ -0,0 +1,390 @@
+package squashfs
+
+import (
+	"errors"
+	"io"
+	"io/fs"
+	"log"
+	"os"
+	"path"
+	"sort"
+	"strings"
+	"syscall"
+
+	"github.com/CalebQ42/squashfs/internal/compression"
+)
+
+//Writer is used to creaste squashfs archives. Currently unusable.
+//TODO: Make usable
+type Writer struct {
+	compressor      compression.Compressor
+	structure       map[string][]*fileHolder
+	symlinkTable    map[string]string
+	folders         []string
+	uidGUIDTable    []int
+	frags           []fragment
+	superblock      superblock
+	compressionType int
+	//BlockSize is how large the data blocks are. Can be between 4096 (4KB) and 1048576 (1 MB).
+	//If BlockSize is not inside that range, it will be set to within the range before writing.
+	//Default is 1048576.
+	BlockSize uint32
+	//Flags are the SuperblockFlags used when writing the archive.
+	//Currently Duplicates, Exportable, UncompressedXattr, NoXattr values are ignored
+	Flags       SuperblockFlags
+	allowErrors bool
+}
+
+//NewWriter creates a new with the default options (Gzip compression and allow errors)
+func NewWriter() (*Writer, error) {
+	return NewWriterWithOptions(GzipCompression, true)
+}
+
+//NewWriterWithOptions creates a new squashfs.Writer with the given options.
+//compressionType can be of any types, except LZO (which this library doesn't have support for yet)
+//allowErrors determines if, when adding folders, it allows errors encountered with it's sub-directories and instead logs the errors.
+func NewWriterWithOptions(compressionType int, allowErrors bool) (*Writer, error) {
+	if compressionType < 0 || compressionType > 6 {
+		return nil, errors.New("Incorrect compression type")
+	}
+	if compressionType == 3 {
+		return nil, errors.New("Lzo compression is not (currently) supported")
+	}
+	writer := &Writer{
+		structure: map[string][]*fileHolder{
+			"/": make([]*fileHolder, 0),
+		},
+		folders: []string{
+			"/",
+		},
+		symlinkTable:    make(map[string]string),
+		compressionType: compressionType,
+		allowErrors:     allowErrors,
+		BlockSize:       uint32(1048576),
+		Flags:           DefaultFlags,
+	}
+	switch compressionType {
+	case 1:
+		writer.compressor = &compression.Gzip{}
+	case 2:
+		writer.compressor = &compression.Lzma{}
+	case 4:
+		writer.compressor = &compression.Xz{}
+	case 5:
+		writer.compressor = &compression.Lz4{}
+	case 6:
+		writer.compressor = &compression.Zstd{}
+	}
+	return writer, nil
+}
+
+//fileHolder holds the necessary information about a given file inside of a squashfs
+type fileHolder struct {
+	reader      io.Reader
+	path        string
+	name        string
+	symLocation string
+	blockSizes  []uint32
+	GUID        int
+	perm        int
+	size        uint64
+	UID         int
+	folder      bool
+	symlink     bool
+
+	fragIndex  int
+	fragOffset int
+}
+
+//AddFile attempts to add an os.File to the archive's root directory.
+func (w *Writer) AddFile(file *os.File) error {
+	return w.AddFileToFolder("/", file)
+}
+
+//AddFileToFolder adds the given file to the squashfs archive, placing it inside the given folder.
+func (w *Writer) AddFileToFolder(folder string, file *os.File) error {
+	name := path.Base(file.Name())
+	if !strings.HasSuffix(folder, "/") {
+		folder += "/"
+	}
+	return w.AddFileTo(folder+name, file)
+}
+
+//AddFileTo adds the given file to the squashfs archive at the given filepath.
+func (w *Writer) AddFileTo(filepath string, file *os.File) error {
+	filepath = path.Clean(filepath)
+	if !strings.HasPrefix(filepath, "/") {
+		filepath = "/" + filepath
+	}
+	if w.Contains(filepath) {
+		return errors.New("File already exists at " + filepath)
+	}
+	var holder fileHolder
+	holder.path = path.Dir(filepath)
+	holder.name = path.Base(filepath)
+	holder.reader = file
+	stat, err := file.Stat()
+	if err != nil {
+		return err
+	}
+	holder.folder = stat.IsDir()
+	holder.symlink = (stat.Mode()&os.ModeSymlink == os.ModeSymlink)
+	holder.perm = int(stat.Mode().Perm())
+	//Thanks to https://stackoverflow.com/questions/58179647/getting-uid-and-gid-of-a-file for uid and guid getting
+	if stat, ok := stat.Sys().(*syscall.Stat_t); ok {
+		holder.UID = int(stat.Uid)
+		holder.GUID = int(stat.Gid)
+	}
+	if sort.SearchInts(w.uidGUIDTable, holder.UID) == len(w.uidGUIDTable) {
+		w.uidGUIDTable = append(w.uidGUIDTable, holder.UID)
+		sort.Ints(w.uidGUIDTable)
+	}
+	if sort.SearchInts(w.uidGUIDTable, holder.GUID) == len(w.uidGUIDTable) {
+		w.uidGUIDTable = append(w.uidGUIDTable, holder.GUID)
+		sort.Ints(w.uidGUIDTable)
+	}
+	if holder.symlink {
+		holder.reader = file
+		target, err := os.Readlink(file.Name())
+		if err != nil {
+			return err
+		}
+		holder.symLocation = target
+	} else if holder.folder {
+		subDirNames, err := file.Readdirnames(-1)
+		if err != nil {
+			return err
+		}
+		dirsAdded := make([]string, 0)
+		for _, subDir := range subDirNames {
+			fil, err := os.Open(file.Name() + subDir)
+			if err != nil {
+				return err
+			}
+			err = w.AddFileToFolder(holder.path+"/"+holder.name, fil)
+			if err != nil && !w.allowErrors {
+				for _, dir := range dirsAdded {
+					w.Remove(dir)
+				}
+				return err
+			} else if err != nil {
+				log.Println("Error while adding", fil.Name())
+				log.Println(err)
+			}
+			if !w.allowErrors {
+				dirsAdded = append(dirsAdded, holder.path+"/"+holder.name)
+			}
+		}
+	} else if stat.Mode().IsRegular() {
+		holder.reader = file
+	} else {
+		return errors.New("Unsupported file type " + file.Name())
+	}
+	if _, ok := w.structure[holder.path]; ok {
+		w.folders = append(w.folders, holder.path)
+		sort.Strings(w.folders)
+	}
+	w.structure[holder.path] = append(w.structure[holder.path], &holder)
+	return nil
+}
+
+//AddReaderTo adds the data from the given reader to the archive as a file located at the given filepath.
+//Data from the reader is not read until the squashfs archive is writen.
+//If the given reader implements io.Closer, it will be closed after it is fully read.
+func (w *Writer) AddReaderTo(filepath string, reader io.Reader, size uint64) error {
+	filepath = path.Clean(filepath)
+	if !strings.HasPrefix(filepath, "/") {
+		filepath = "/" + filepath
+	}
+	if w.Contains(filepath) {
+		return errors.New("File already exists at " + filepath)
+	}
+	var holder fileHolder
+	holder.path = path.Dir(filepath)
+	holder.name = path.Base(filepath)
+	holder.size = size
+	holder.reader = reader
+	if _, ok := w.structure[holder.path]; ok {
+		w.folders = append(w.folders, holder.path)
+		sort.Strings(w.folders)
+	}
+	w.structure[holder.path] = append(w.structure[holder.path], &holder)
+	return nil
+}
+
+//AddFolderTo adds a folder at the given path. IF the folder is already present, it sets the folder's permissions.
+//If the path points to a non-folder (such as a file or symlink), an error is returned
+func (w *Writer) AddFolderTo(folderpath string, permission fs.FileMode) error {
+	folderpath = path.Clean(folderpath)
+	tmp := w.holderAt(folderpath)
+	if tmp != nil {
+		if !tmp.folder {
+			return errors.New("Path is not a folder: " + folderpath)
+		}
+		tmp.perm = int(permission.Perm())
+		return nil
+	}
+	file := fileHolder{
+		path:   path.Dir(folderpath),
+		name:   path.Base(folderpath),
+		perm:   int(permission | fs.ModePerm),
+		folder: true,
+	}
+	w.structure[file.path] = append(w.structure[file.path], &file)
+	return nil
+}
+
+//Remove tries to remove the file(s) at the given filepath. If wildcards are used, it will remove all files that match.
+//Returns true if one or more files are removed.
+func (w *Writer) Remove(filepath string) bool {
+	var matchFound bool
+	filepath = path.Clean(filepath)
+	if !strings.HasPrefix(filepath, "/") {
+		filepath = "/" + filepath
+	}
+	dir, name := path.Split(filepath)
+	for structDir, files := range w.structure {
+		if match, _ := path.Match(dir, structDir); match {
+			for i, fil := range files {
+				if match, _ = path.Match(name, fil.name); match {
+					matchFound = true
+					if len(w.structure[structDir]) > 1 {
+						w.structure[structDir][i] = w.structure[structDir][len(w.structure[structDir])-1]
+						w.structure[structDir] = w.structure[structDir][:len(w.structure[structDir])-1]
+					} else {
+						w.structure[structDir] = nil
+					}
+				}
+			}
+		}
+	}
+	return matchFound
+}
+
+//FixSymlinks will scan through the squashfs archive and try to find broken symlinks and fix them.
+//This done by replacing the symlink with the target file and then pointing other symlinks to that file.
+//If all symlinks can be resolved, the error slice will be nil, and the bool false, otherwise all errors occured will be in the slice.
+func (w *Writer) FixSymlinks() (errs []error, problems bool) {
+	for dir, holderSlice := range w.structure {
+		for i, holder := range holderSlice {
+			if !holder.symlink {
+				continue
+			}
+			sym := holder.symLocation
+			if !path.IsAbs(holder.symLocation) {
+				sym = path.Join(dir, holder.symLocation)
+			}
+			if path, ok := w.symlinkTable[sym]; ok {
+				w.structure[dir][i].symLocation = path
+				continue
+			}
+			if path.IsAbs(sym) || strings.HasPrefix(sym, "../") {
+				var symFil *os.File
+				var err error
+				if strings.HasPrefix(sym, "../") {
+					holderFil, ok := holder.reader.(*os.File)
+					if !ok {
+						problems = true
+						errs = append(errs, errors.New("Cannot resolve symlink at "+dir+holder.name))
+						continue
+					}
+					symFilPath := path.Dir(holderFil.Name())
+					symFilPath = path.Join(symFilPath, holder.symLocation)
+					symFil, err = os.Open(symFilPath)
+				} else {
+					symFil, err = os.Open(sym)
+				}
+				if err != nil {
+					problems = true
+					errs = append(errs, err)
+					continue
+				}
+				suc := w.Remove(dir + holder.name)
+				if !suc {
+					problems = true
+					errs = append(errs, errors.New("Cannot resolve symlink at "+dir+holder.name))
+					continue
+				}
+				err = w.AddFileTo(dir+holder.name, symFil)
+				if err != nil {
+					w.structure[dir] = append(w.structure[dir], holder)
+					problems = true
+					errs = append(errs, err)
+					continue
+				}
+				w.symlinkTable[sym] = dir + holder.name
+			} else {
+				symHolder := w.holderAt(sym)
+				if symHolder != nil {
+					w.symlinkTable[sym] = sym
+					continue
+				}
+				holderFil, ok := holder.reader.(*os.File)
+				if !ok {
+					problems = true
+					errs = append(errs, errors.New("Cannot resolve symlink at "+dir+holder.name))
+					continue
+				}
+				symFilPath := path.Dir(holderFil.Name())
+				symFilPath = path.Join(symFilPath, holder.symLocation)
+				symFil, err := os.Open(symFilPath)
+				if err != nil {
+					problems = true
+					errs = append(errs, err)
+					continue
+				}
+				err = w.AddFileTo(sym, symFil)
+				if err != nil {
+					problems = true
+					errs = append(errs, err)
+					continue
+				}
+				w.symlinkTable[sym] = sym
+			}
+		}
+	}
+	return
+}
+
+func (w *Writer) holderAt(filepath string) *fileHolder {
+	filepath = path.Clean(filepath)
+	if !strings.HasPrefix(filepath, "/") {
+		filepath = "/" + filepath
+	}
+	dir, name := path.Split(filepath)
+	if holderSlice, ok := w.structure[dir]; ok {
+		for _, holder := range holderSlice {
+			if holder.name == name {
+				return holder
+			}
+		}
+	}
+	return nil
+}
+
+//Contains returns whether a file is present at the given filepath
+func (w *Writer) Contains(filepath string) bool {
+	filepath = path.Clean(filepath)
+	if !strings.HasPrefix(filepath, "/") {
+		filepath = "/" + filepath
+	}
+	dir, name := path.Split(filepath)
+	if holderSlice, ok := w.structure[dir]; ok {
+		for _, holder := range holderSlice {
+			if holder.name == name {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+//WriteToFilename creates the squashfs archive with the given filepath.
+func (w *Writer) WriteToFilename(filepath string) error {
+	newFil, err := os.Create(filepath)
+	if err != nil {
+		return err
+	}
+	_, err = w.WriteTo(newFil)
+	return err
+}

writer_compress.go

@@ -0,0 +1,17 @@
+package squashfs
+
+import "reflect"
+
+func (w *Writer) compressData(data []byte) ([]byte, error) {
+	if reflect.DeepEqual(data, make([]byte, len(data))) {
+		return nil, nil
+	}
+	compressedData, err := w.compressor.Compress(data)
+	if err != nil {
+		return nil, err
+	}
+	if len(data) <= len(compressedData) {
+		return data, nil
+	}
+	return compressedData, nil
+}

writer_compression_options.go

@@ -0,0 +1,15 @@
+package squashfs
+
+//TODO: Allow settings the options
+
+// func (w *Writer) SetGzipOptions() error {}
+
+// func (w *Writer) SetLzmaOptions() error {}
+
+// func (w *Writer) SetLzoOptions() error {}
+
+// func (w *Writer) SetXzOptions() error {}
+
+// func (w *Writer) SetLz4Options() error {}
+
+// func (w *Writer) SetZstdOptions() error {}

writer_fragment.go

@@ -0,0 +1,69 @@
+package squashfs
+
+type fragment struct {
+	w     *Writer
+	files []*fileHolder
+	sizes []uint32
+}
+
+func (f *fragment) SizeLeft() uint32 {
+	totalSize := uint32(0)
+	for _, siz := range f.sizes {
+		totalSize += siz
+	}
+	return f.w.BlockSize - uint32(totalSize)
+}
+
+func (f *fragment) AddFragment(fil *fileHolder) {
+	//SizeLeft should already be checked
+	fil.fragOffset = len(f.files)
+	f.files = append(f.files, fil)
+	f.sizes = append(f.sizes, fil.blockSizes[len(fil.blockSizes)-1])
+}
+
+func (w *Writer) addToFragments(fil *fileHolder) {
+	fragSize := fil.blockSizes[len(fil.blockSizes)-1]
+	//only fragment if the final block is less then 80% of a full block or AlwaysFragment
+	if w.Flags.AlwaysFragment || fragSize < uint32(float32(w.BlockSize)*0.8) {
+		var possibleFrags []int
+		for i := range w.frags {
+			left := w.frags[i].SizeLeft()
+			if left == fragSize {
+				fil.fragIndex = i
+				w.frags[i].AddFragment(fil)
+				return
+			} else if left > fragSize {
+				possibleFrags = append(possibleFrags, i)
+			}
+		}
+		if len(possibleFrags) > 0 {
+			fil.fragIndex = possibleFrags[0]
+		} else {
+			fil.fragIndex = len(w.frags)
+			w.frags = append(w.frags, fragment{
+				w:     w,
+				files: []*fileHolder{fil},
+				sizes: []uint32{fragSize},
+			})
+		}
+	}
+}
+
+func (w *Writer) calculateFragsAndBlockSizes() {
+	for _, files := range w.structure {
+		for i := range files {
+			files[i].fragIndex = -1
+			files[i].blockSizes = make([]uint32, files[i].size/uint64(w.BlockSize))
+			for j := range files[i].blockSizes {
+				files[i].blockSizes[j] = w.BlockSize
+			}
+			fragSize := uint32(files[i].size % uint64(w.BlockSize))
+			if fragSize > 0 {
+				files[i].blockSizes = append(files[i].blockSizes, fragSize)
+				if !w.Flags.NoFragments {
+					w.addToFragments(files[i])
+				}
+			}
+		}
+	}
+}

writer_inodes.go

@@ -0,0 +1,9 @@
+package squashfs
+
+func (w *Writer) countInodes() (out uint32) {
+	for _, files := range w.structure {
+		out++
+		out += uint32(len(files))
+	}
+	return
+}

writer_write.go

@@ -0,0 +1,56 @@
+package squashfs
+
+import (
+	"errors"
+	"io"
+	"io/fs"
+	"math"
+	"time"
+)
+
+func (w *Writer) fixFolders() error {
+	for folder := range w.structure {
+		if folder == "/" || w.Contains(folder) {
+			continue
+		}
+		err := w.AddFolderTo(folder, fs.ModePerm)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+//WriteTo attempts to write the archive to the given io.Writer.
+//Folder that aren't present (such as if you add a file at /folder/file, but not the folder /folder)
+//are added with full permission (777).
+//
+//Not working. Yet.
+func (w *Writer) WriteTo(write io.Writer) (int64, error) {
+	err := w.fixFolders()
+	if err != nil {
+		return 0, err
+	}
+	if w.BlockSize > 1048576 {
+		w.BlockSize = 1048576
+	} else if w.BlockSize < 4096 {
+		w.BlockSize = 4096
+	}
+	w.Flags.RemoveDuplicates = false
+	w.Flags.Exportable = false
+	w.Flags.NoXattr = true
+	w.calculateFragsAndBlockSizes()
+	w.superblock = superblock{
+		Magic:           magic,
+		InodeCount:      w.countInodes(),
+		CreationTime:    uint32(time.Now().Unix()),
+		BlockSize:       w.BlockSize,
+		CompressionType: uint16(w.compressionType),
+		BlockLog:        uint16(math.Log2(float64(w.BlockSize))),
+		Flags:           w.Flags.ToUint(),
+		IDCount:         uint16(len(w.uidGUIDTable)),
+		MajorVersion:    4,
+		MinorVersion:    0,
+	}
+	return 0, errors.New("I SAID DON'T")
+}