Fixed issue with not all data being extracted with ExtractTo

Added a drag race benchmark (for the fun of it)

README.md

@@ -11,4 +11,8 @@ 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.
 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).
 
+## 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 libarary and about half a second with `unsquashfs`)
+
 ## [TODO](https://github.com/CalebQ42/squashfs/projects/1?fullscreen=true)

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
+}

datareader.go

@@ -18,39 +18,19 @@ var (
 //DataReader reads data from data blocks.
 type dataReader struct {
 	r             *Reader
-	blocks        []dataBlock
 	curData       []byte
+	sizes         []uint32
 	offset        int64 //offset relative to the beginning of the squash file
 	curBlock      int   //Which block in sizes is currently cached
 	curReadOffset int   //offset relative to the currently cached data
 }
 
-//DataBlock holds info about a given data block from it's size
-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
 func (r *Reader) newDataReader(offset int64, sizes []uint32) (*dataReader, error) {
 	var dr dataReader
 	dr.r = r
 	dr.offset = offset
-	for _, size := range sizes {
-		dr.blocks = append(dr.blocks, newDataBlock(size))
-	}
+	dr.sizes = sizes
 	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:
-		fil := i.Info.(inode.BasicFile)
-		if fil.Init.BlockStart == 0 {
+	case inode.FileType:
+		fil := i.Info.(inode.File)
+		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)
-		if fil.Init.BlockStart == 0 {
+		fil := i.Info.(inode.ExtFile)
+		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,37 +97,47 @@ func (d *dataReader) readNextBlock() error {
 	return nil
 }
 
-func (d *dataReader) readCurBlock() error {
-	if d.curBlock >= len(d.blocks) {
-		return io.EOF
+func (d *dataReader) readBlockAt(offset int64, size uint32) ([]byte, error) {
+	compressed := size&(1<<24) != (1 << 24)
+	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 {
-		d.curData = make([]byte, d.r.super.BlockSize)
-		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 {
+	sec := io.NewSectionReader(d.r.r, offset, int64(size))
+	if compressed {
 		btys, err := d.r.decompressor.Decompress(sec)
 		if err != nil {
-			return err
+			return nil, err
 		}
-		d.blocks[d.curBlock].uncompressedSize = uint32(len(btys))
-		d.curData = btys
-		d.blocks[d.curBlock].begOffset = d.offset
-		d.offset += int64(d.blocks[d.curBlock].size)
-		return nil
+		return btys, nil
 	}
 	var buf bytes.Buffer
 	_, err := io.Copy(&buf, sec)
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+func (d *dataReader) offsetForBlock(index int) int64 {
+	out := d.offset
+	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 = buf.Bytes()
-	d.blocks[d.curBlock].begOffset = d.offset
-	d.offset += int64(d.blocks[d.curBlock].size)
-	return err
+	d.curData = data
+	return nil
 }
 
 func (d *dataReader) Read(p []byte) (int, error) {
@@ -182,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)
+		}
+	}
+}

file.go

@@ -61,10 +61,10 @@ func (f *File) Name() string {
 //Size is the complete size of the file. Zero if it's not a file.
 func (f *File) Size() int64 {
 	switch f.filType {
-	case inode.BasicFileType:
-		return int64(f.in.Info.(inode.BasicFile).Init.Size)
+	case inode.FileType:
+		return int64(f.in.Info.(inode.File).Size)
 	case inode.ExtFileType:
-		return int64(f.in.Info.(inode.ExtendedFile).Init.Size)
+		return int64(f.in.Info.(inode.ExtFile).Size)
 	default:
 		return 0
 	}
@@ -204,27 +204,27 @@ func (f *File) GetFileAtPath(dirPath string) *File {
 
 //IsDir returns if the file is a directory.
 func (f *File) IsDir() bool {
-	return f.filType == inode.BasicDirectoryType || f.filType == inode.ExtDirType
+	return f.filType == inode.DirType || f.filType == inode.ExtDirType
 }
 
 //IsSymlink returns if the file is a symlink.
 func (f *File) IsSymlink() bool {
-	return f.filType == inode.BasicSymlinkType || f.filType == inode.ExtSymlinkType
+	return f.filType == inode.SymType || f.filType == inode.ExtSymlinkType
 }
 
 //IsFile returns if the file is a file.
 func (f *File) IsFile() bool {
-	return f.filType == inode.BasicFileType || f.filType == inode.ExtFileType
+	return f.filType == inode.FileType || f.filType == inode.ExtFileType
 }
 
 //SymlinkPath returns the path the symlink is pointing to. If the file ISN'T a symlink, will return an empty string.
 //If a path begins with "/" then the symlink is pointing to an absolute path (starting from root, and not a file inside the archive)
 func (f *File) SymlinkPath() string {
 	switch f.filType {
-	case inode.BasicSymlinkType:
-		return f.in.Info.(inode.BasicSymlink).Path
+	case inode.SymType:
+		return f.in.Info.(inode.Sym).Path
 	case inode.ExtSymlinkType:
-		return f.in.Info.(inode.ExtendedSymlink).Path
+		return f.in.Info.(inode.Sym).Path
 	default:
 		return ""
 	}
@@ -398,7 +398,18 @@ func (f *File) ExtractWithOptions(path string, dereferenceSymlink, unbreakSymlin
 			errs = append(errs, err)
 			return
 		} //Since we will be reading from the file
-		_, err = io.Copy(fil, f)
+		if f.Reader == nil && f.r != nil {
+			f.Reader, err = f.r.newFileReader(f.in)
+			if err != nil {
+				if verbose {
+					fmt.Println("Error while Copying data to:", path+"/"+f.name)
+					fmt.Println(err)
+				}
+				errs = append(errs, err)
+				return
+			}
+		}
+		_, err = io.Copy(fil, f.Reader)
 		if err != nil {
 			if verbose {
 				fmt.Println("Error while Copying data to:", path+"/"+f.name)
@@ -480,7 +491,7 @@ func (f *File) ExtractWithOptions(path string, dereferenceSymlink, unbreakSymlin
 
 //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() {
+	if !f.IsFile() {
 		return 0, io.EOF
 	}
 	var err error
@@ -500,14 +511,14 @@ func (r *Reader) readDirFromInode(i *inode.Inode) (*directory.Directory, error)
 	var metaOffset uint16
 	var size uint32
 	switch i.Type {
-	case inode.BasicDirectoryType:
-		offset = i.Info.(inode.BasicDirectory).DirectoryIndex
-		metaOffset = i.Info.(inode.BasicDirectory).DirectoryOffset
-		size = uint32(i.Info.(inode.BasicDirectory).DirectorySize)
+	case inode.DirType:
+		offset = i.Info.(inode.Dir).DirectoryIndex
+		metaOffset = i.Info.(inode.Dir).DirectoryOffset
+		size = uint32(i.Info.(inode.Dir).DirectorySize)
 	case inode.ExtDirType:
-		offset = i.Info.(inode.ExtendedDirectory).Init.DirectoryIndex
-		metaOffset = i.Info.(inode.ExtendedDirectory).Init.DirectoryOffset
-		size = i.Info.(inode.ExtendedDirectory).Init.DirectorySize
+		offset = i.Info.(inode.ExtDir).DirectoryIndex
+		metaOffset = i.Info.(inode.ExtDir).DirectoryOffset
+		size = i.Info.(inode.ExtDir).DirectorySize
 	default:
 		return nil, errors.New("Not a directory inode")
 	}
@@ -532,7 +543,7 @@ func (r *Reader) getInodeFromEntry(en *directory.Entry) (*inode.Inode, error) {
 	if err != nil {
 		return nil, err
 	}
-	_, err = br.Seek(int64(en.Init.Offset), io.SeekStart)
+	_, err = br.Seek(int64(en.Offset), io.SeekStart)
 	if err != nil {
 		return nil, err
 	}

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:
-		fil := in.Info.(inode.BasicFile)
+	case inode.FileType:
+		fil := in.Info.(inode.File)
 		rdr.fragged = fil.Fragmented
-		rdr.fragOnly = fil.Init.BlockStart == 0
-		rdr.FileSize = int(fil.Init.Size)
+		rdr.fragOnly = fil.BlockStart == 0
+		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.FileSize = int(fil.Init.Size)
+		rdr.fragOnly = fil.BlockStart == 0
+		rdr.FileSize = int(fil.Size)
 	}
 	var err error
 	if rdr.fragged {
@@ -83,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

@@ -21,30 +21,30 @@ func (r *Reader) getFragmentDataFromInode(in *inode.Inode) ([]byte, error) {
 	var size uint32
 	var fragIndex uint32
 	var fragOffset uint32
-	if in.Type == inode.BasicFileType {
-		bf := in.Info.(inode.BasicFile)
+	if in.Type == inode.FileType {
+		bf := in.Info.(inode.File)
 		if !bf.Fragmented {
 			return make([]byte, 0), nil
 		}
-		if bf.Init.BlockStart == 0 {
-			size = bf.Init.Size
+		if bf.BlockStart == 0 {
+			size = bf.Size
 		} else {
 			size = bf.BlockSizes[len(bf.BlockSizes)-1]
 		}
-		fragIndex = bf.Init.FragmentIndex
-		fragOffset = bf.Init.FragmentOffset
+		fragIndex = bf.FragmentIndex
+		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 {
-			size = bf.Init.Size
+		if bf.BlockStart == 0 {
+			size = bf.Size
 		} else {
 			size = bf.BlockSizes[len(bf.BlockSizes)-1]
 		}
-		fragIndex = bf.Init.FragmentIndex
-		fragOffset = bf.Init.FragmentOffset
+		fragIndex = bf.FragmentIndex
+		fragOffset = bf.FragmentOffset
 	} else {
 		return nil, errors.New("Inode type not supported")
 	}

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
-	HasCustomWindow  bool
-	HasStrategies    bool
+	wrt *zlib.Writer
+	gzipInit
+	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, &init)
+	err := binary.Read(r, binary.LittleEndian, &gzip.gzipInit)
 	if err != nil {
 		return nil, err
 	}
-	gzip.CompressionLevel = init.CompressionLevel
 	//TODO: proper support for window size and strategies
-	gzip.HasCustomWindow = init.WindowSize != 15
-	gzip.HasStrategies = init.Strategies != 0 && init.Strategies != 1
+	gzip.HasCustomWindow = gzip.WindowSize != 15
+	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)
-	defer wrt.Close()
-	_, err := wrt.Write(data)
+	var err error
+	if g.wrt == nil {
+		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
-type EntryInit struct {
+//EntryRaw is the values that can be easily decoded
+type EntryRaw struct {
 	Offset      uint16
 	InodeOffset int16
 	Type        uint16
@@ -23,19 +23,19 @@ type EntryInit struct {
 
 //Entry is an entry in a directory.
 type Entry struct {
-	Init   EntryInit
-	Name   string
-	Header *Header
+	*Header
+	Name string
+	EntryRaw
 }
 
 //NewEntry creates a new directory entry
 func NewEntry(rdr io.Reader) (Entry, error) {
 	var entry Entry
-	err := binary.Read(rdr, binary.LittleEndian, &entry.Init)
+	err := binary.Read(rdr, binary.LittleEndian, &entry.EntryRaw)
 	if err != nil {
 		return Entry{}, err
 	}
-	tmp := make([]byte, entry.Init.NameSize+1)
+	tmp := make([]byte, entry.EntryRaw.NameSize+1)
 	err = binary.Read(rdr, binary.LittleEndian, &tmp)
 	if err != nil {
 		return Entry{}, err

internal/inode/inodetypes.go

@@ -5,14 +5,15 @@ import (
 	"io"
 )
 
+//The different types of inodes as defined by inodetype
 const (
-	BasicDirectoryType = iota + 1
-	BasicFileType
-	BasicSymlinkType
-	BasicBlockDeviceType
-	BasicCharDeviceType
-	BasicFifoType
-	BasicSocketType
+	DirType = iota + 1
+	FileType
+	SymType
+	BlockDevType
+	CharDevType
+	FifoType
+	SocketType
 	ExtDirType
 	ExtFileType
 	ExtSymlinkType
@@ -32,8 +33,8 @@ type Header struct {
 	Number       uint32
 }
 
-//BasicDirectory is self explainatory
-type BasicDirectory struct {
+//Dir is self explainatory
+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
-type ExtendedDirectoryInit struct {
+//ExtDirInit is the information that can be directoy decoded
+type ExtDirInit struct {
 	HardLinks         uint32
 	DirectorySize     uint32
 	DirectoryIndex    uint32
@@ -52,20 +53,20 @@ type ExtendedDirectoryInit struct {
 	XattrIndex        uint32
 }
 
-//ExtendedDirectory is a directory with extra info
-type ExtendedDirectory struct {
-	Init    ExtendedDirectoryInit
-	Indexes []DirectoryIndex
+//ExtDir is a directory with extra info
+type ExtDir struct {
+	Indexes []DirIndex
+	ExtDirInit
 }
 
 //NewExtendedDirectory creates a new ExtendedDirectory
-func NewExtendedDirectory(rdr io.Reader) (ExtendedDirectory, error) {
-	var inode ExtendedDirectory
-	err := binary.Read(rdr, binary.LittleEndian, &inode.Init)
+func NewExtendedDirectory(rdr io.Reader) (ExtDir, error) {
+	var inode ExtDir
+	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)
 		if err != nil {
 			return inode, err
@@ -75,27 +76,27 @@ func NewExtendedDirectory(rdr io.Reader) (ExtendedDirectory, error) {
 	return inode, err
 }
 
-//DirectoryIndexInit holds the values that can be easily decoded
-type DirectoryIndexInit struct {
+//DirIndexInit holds the values that can be easily decoded
+type DirIndexInit struct {
 	Offset         uint32
 	DirTableOffset uint32
 	NameSize       uint32
 }
 
-//DirectoryIndex is a quick lookup provided by an ExtendedDirectory
-type DirectoryIndex struct {
-	Init DirectoryIndexInit
+//DirIndex is a quick lookup provided by an ExtendedDirectory
+type DirIndex struct {
 	Name string
+	DirIndexInit
 }
 
 //NewDirectoryIndex return a new DirectoryIndex
-func NewDirectoryIndex(rdr io.Reader) (DirectoryIndex, error) {
-	var index DirectoryIndex
-	err := binary.Read(rdr, binary.LittleEndian, &index.Init)
+func NewDirectoryIndex(rdr io.Reader) (DirIndex, error) {
+	var index DirIndex
+	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 +105,31 @@ func NewDirectoryIndex(rdr io.Reader) (DirectoryIndex, error) {
 	return index, nil
 }
 
-//BasicFileInit is the information that can be directoy decoded
-type BasicFileInit struct {
+//FileInit is the information that can be directly decoded
+type FileInit struct {
 	BlockStart     uint32
 	FragmentIndex  uint32
 	FragmentOffset uint32
 	Size           uint32
 }
 
-//BasicFile is self explainatory
-type BasicFile struct {
-	Init       BasicFileInit
+//File is self explainatory
+type File struct {
 	BlockSizes []uint32
 	Fragmented bool
+	FileInit
 }
 
-//NewBasicFile creates a new BasicFile
-func NewBasicFile(rdr io.Reader, blockSize uint32) (BasicFile, error) {
-	var inode BasicFile
-	err := binary.Read(rdr, binary.LittleEndian, &inode.Init)
+//NewFile creates a new File
+func NewFile(rdr io.Reader, blockSize uint32) (File, error) {
+	var inode File
+	err := binary.Read(rdr, binary.LittleEndian, &inode.FileInit)
 	if err != nil {
 		return inode, err
 	}
-	inode.Fragmented = inode.Init.FragmentIndex != 0xFFFFFFFF
-	blocks := inode.Init.Size / blockSize
-	if inode.Init.Size%blockSize > 0 {
+	inode.Fragmented = inode.FragmentIndex != 0xFFFFFFFF
+	blocks := inode.Size / blockSize
+	if inode.Size%blockSize > 0 {
 		blocks++
 	}
 	inode.BlockSizes = make([]uint32, blocks, blocks)
@@ -136,8 +137,8 @@ func NewBasicFile(rdr io.Reader, blockSize uint32) (BasicFile, error) {
 	return inode, err
 }
 
-//ExtendedFileInit is the information that can be directly decoded
-type ExtendedFileInit struct {
+//ExtFileInit is the information that can be directly decoded
+type ExtFileInit struct {
 	BlockStart     uint32
 	Size           uint32
 	Sparse         uint64
@@ -147,23 +148,23 @@ type ExtendedFileInit struct {
 	XattrIndex     uint32
 }
 
-//ExtendedFile is a file with more information
-type ExtendedFile struct {
-	Init       ExtendedFileInit
+//ExtFile is a file with more information
+type ExtFile struct {
 	BlockSizes []uint32
 	Fragmented bool
+	ExtFileInit
 }
 
 //NewExtendedFile creates a new ExtendedFile
-func NewExtendedFile(rdr io.Reader, blockSize uint32) (ExtendedFile, error) {
-	var inode ExtendedFile
-	err := binary.Read(rdr, binary.LittleEndian, &inode.Init)
+func NewExtendedFile(rdr io.Reader, blockSize uint32) (ExtFile, error) {
+	var inode ExtFile
+	err := binary.Read(rdr, binary.LittleEndian, &inode.ExtFileInit)
 	if err != nil {
 		return inode, err
 	}
-	inode.Fragmented = inode.Init.FragmentIndex != 0xFFFFFFFF
-	blocks := inode.Init.Size / blockSize
-	if inode.Init.Size%blockSize > 0 {
+	inode.Fragmented = inode.FragmentIndex != 0xFFFFFFFF
+	blocks := inode.Size / blockSize
+	if inode.Size%blockSize > 0 {
 		blocks++
 	}
 	inode.BlockSizes = make([]uint32, blocks, blocks)
@@ -171,27 +172,27 @@ func NewExtendedFile(rdr io.Reader, blockSize uint32) (ExtendedFile, error) {
 	return inode, err
 }
 
-//BasicSymlinkInit is all the values that can be directly decoded
-type BasicSymlinkInit struct {
+//SymInit is all the values that can be directly decoded
+type SymInit struct {
 	HardLinks      uint32
 	TargetPathSize uint32
 }
 
-//BasicSymlink is a symlink
-type BasicSymlink struct {
-	Init       BasicSymlinkInit
-	targetPath []byte //len is TargetPathSize
+//Sym is a symlink
+type Sym struct {
 	Path       string
+	targetPath []byte //len is TargetPathSize
+	SymInit
 }
 
-//NewBasicSymlink creates a new BasicSymlink
-func NewBasicSymlink(rdr io.Reader) (BasicSymlink, error) {
-	var inode BasicSymlink
-	err := binary.Read(rdr, binary.LittleEndian, &inode.Init)
+//NewSymlink creates a new Symlink
+func NewSymlink(rdr io.Reader) (Sym, error) {
+	var inode Sym
+	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 +201,28 @@ func NewBasicSymlink(rdr io.Reader) (BasicSymlink, error) {
 	return inode, err
 }
 
-//ExtendedSymlinkInit is all the values that can be directly decoded
-type ExtendedSymlinkInit struct {
+//ExtSymInit is all the values that can be directly decoded
+type ExtSymInit struct {
 	HardLinks      uint32
 	TargetPathSize uint32
 }
 
-//ExtendedSymlink is a symlink with extra information
-type ExtendedSymlink struct {
-	Init       ExtendedSymlinkInit
-	targetPath []uint8
+//ExtSym is a symlink with extra information
+type ExtSym struct {
 	Path       string
+	targetPath []uint8
+	ExtSymInit
 	XattrIndex uint32
 }
 
 //NewExtendedSymlink creates a new ExtendedSymlink
-func NewExtendedSymlink(rdr io.Reader) (ExtendedSymlink, error) {
-	var inode ExtendedSymlink
-	err := binary.Read(rdr, binary.LittleEndian, &inode.Init)
+func NewExtendedSymlink(rdr io.Reader) (ExtSym, error) {
+	var inode ExtSym
+	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 +232,25 @@ func NewExtendedSymlink(rdr io.Reader) (ExtendedSymlink, error) {
 	return inode, err
 }
 
-//BasicDevice is a device
-type BasicDevice struct {
+//Device is a device
+type Device struct {
 	HardLinks uint32
 	Device    uint32
 }
 
-//ExtendedDevice is a device with more info
-type ExtendedDevice struct {
-	BasicDevice
+//ExtDevice is a device with more info
+type ExtDevice struct {
+	Device
 	XattrIndex uint32
 }
 
-//BasicIPC is a Fifo or Socket device
-type BasicIPC struct {
+//IPC is a Fifo or Socket device
+type IPC struct {
 	HardLink uint32
 }
 
-//ExtendedIPC is a IPC device with extra info
-type ExtendedIPC struct {
-	BasicIPC
+//ExtIPC is a IPC device with extra info
+type ExtIPC struct {
+	IPC
 	XattrIndex uint32
 }

internal/inode/process.go

@@ -9,9 +9,9 @@ import (
 //
 //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
-	Type   int         //Type the inode type defined in the header. Here so it's easy to access
-	Info   interface{} //Info is the parsed specific data. It's type is defined by Type.
+	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
 }
 
 //ProcessInode tries to read an inode from the BlockReader
@@ -23,48 +23,48 @@ func ProcessInode(br io.Reader, blockSize uint32) (*Inode, error) {
 	}
 	var info interface{}
 	switch head.InodeType {
-	case BasicDirectoryType:
-		var inode BasicDirectory
+	case DirType:
+		var inode Dir
 		err = binary.Read(br, binary.LittleEndian, &inode)
 		if err != nil {
 			return nil, err
 		}
 		info = inode
-	case BasicFileType:
-		inode, err := NewBasicFile(br, blockSize)
+	case FileType:
+		inode, err := NewFile(br, blockSize)
 		if err != nil {
 			return nil, err
 		}
 		info = inode
-	case BasicSymlinkType:
-		inode, err := NewBasicSymlink(br)
+	case SymType:
+		inode, err := NewSymlink(br)
 		if err != nil {
 			return nil, err
 		}
 		info = inode
-	case BasicBlockDeviceType:
-		var inode BasicDevice
+	case BlockDevType:
+		var inode Device
 		err = binary.Read(br, binary.LittleEndian, &inode)
 		if err != nil {
 			return nil, err
 		}
 		info = inode
-	case BasicCharDeviceType:
-		var inode BasicDevice
+	case CharDevType:
+		var inode Device
 		err = binary.Read(br, binary.LittleEndian, &inode)
 		if err != nil {
 			return nil, err
 		}
 		info = inode
-	case BasicFifoType:
-		var inode BasicIPC
+	case FifoType:
+		var inode IPC
 		err = binary.Read(br, binary.LittleEndian, &inode)
 		if err != nil {
 			return nil, err
 		}
 		info = inode
-	case BasicSocketType:
-		var inode BasicIPC
+	case SocketType:
+		var inode IPC
 		err = binary.Read(br, binary.LittleEndian, &inode)
 		if err != nil {
 			return nil, err
@@ -89,28 +89,28 @@ func ProcessInode(br io.Reader, blockSize uint32) (*Inode, error) {
 		}
 		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
 	case ExtCharDeviceType:
-		var inode ExtendedDevice
+		var inode ExtDevice
 		err = binary.Read(br, binary.LittleEndian, &inode)
 		if err != nil {
 			return nil, err
 		}
 		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
 	case ExtSocketType:
-		var inode ExtendedIPC
+		var inode ExtIPC
 		err = binary.Read(br, binary.LittleEndian, &inode)
 		if err != nil {
 			return nil, err

reader.go

@@ -77,9 +77,6 @@ func NewSquashfsReader(r io.ReaderAt) (*Reader, error) {
 			if err != nil {
 				return nil, err
 			}
-			if lz4.HC {
-				hasUnsupportedOptions = true
-			}
 			rdr.decompressor = lz4
 		case ZstdCompression:
 			zstd, err := compression.NewZstdCompressorWithOptions(io.NewSectionReader(rdr.r, int64(binary.Size(rdr.super)), 4))

squash_test.go

@@ -5,7 +5,10 @@ import (
 	"io"
 	"net/http"
 	"os"
+	"os/exec"
+	"strconv"
 	"testing"
+	"time"
 
 	goappimage "github.com/CalebQ42/GoAppImage"
 )
@@ -53,7 +56,10 @@ func TestAppImage(t *testing.T) {
 	}
 	aiFil, err := os.Open(wd + "/testing/" + appImageName)
 	if os.IsNotExist(err) {
-		downloadTestAppImage(t, wd+"/testing")
+		err = downloadTestAppImage(wd + "/testing")
+		if err != nil {
+			t.Fatal(err)
+		}
 		aiFil, err = os.Open(wd + "/testing/" + appImageName)
 		if err != nil {
 			t.Fatal(err)
@@ -63,12 +69,13 @@ func TestAppImage(t *testing.T) {
 	}
 	defer aiFil.Close()
 	stat, _ := aiFil.Stat()
+	os.RemoveAll(wd + "/testing/firefox")
 	ai := goappimage.NewAppImage(wd + "/testing/" + appImageName)
+	start := time.Now()
 	rdr, err := NewSquashfsReader(io.NewSectionReader(aiFil, ai.Offset, stat.Size()-ai.Offset))
 	if err != nil {
 		t.Fatal(err)
 	}
-	os.RemoveAll(wd + "testing/firefox")
 	errs := rdr.ExtractTo(wd + "/testing/firefox")
 	if len(errs) > 0 {
 		t.Fatal(errs)
@@ -77,15 +84,93 @@ func TestAppImage(t *testing.T) {
 	// root, _ := rdr.GetRootFolder()
 	// errs := root.ExtractWithOptions(wd+"/testing/"+appImageName+".d", true, os.ModePerm, true)
 	// t.Fatal(errs)
+	fmt.Println(time.Since(start))
 	t.Fatal("No problemo!")
 }
 
-func downloadTestAppImage(t *testing.T, dir string) {
+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)
+	}
+	errs := rdr.ExtractTo(wd + "/testing/firefox")
+	if len(errs) > 0 {
+		b.Fatal(errs)
+	}
+	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 {
-		t.Fatal(err)
+		return err
 	}
 	defer appImage.Close()
 	check := http.Client{
@@ -96,13 +181,14 @@ func downloadTestAppImage(t *testing.T, dir string) {
 	}
 	resp, err := check.Get(downloadURL)
 	if err != nil {
-		t.Fatal(err)
+		return err
 	}
 	defer resp.Body.Close()
 	_, err = io.Copy(appImage, resp.Body)
 	if err != nil {
-		t.Fatal(err)
+		return err
 	}
+	return nil
 }
 
 func TestCreateSquashFromAppImage(t *testing.T) {
@@ -116,7 +202,10 @@ func TestCreateSquashFromAppImage(t *testing.T) {
 	}
 	_, err = os.Open(wd + "/testing/" + appImageName)
 	if os.IsNotExist(err) {
-		downloadTestAppImage(t, wd+"/testing")
+		err = downloadTestAppImage(wd + "/testing")
+		if err != nil {
+			t.Fatal(err)
+		}
 		_, err = os.Open(wd + "/testing/" + appImageName)
 		if err != nil {
 			t.Fatal(err)

writer.go

@@ -2,180 +2,208 @@ package squashfs
 
 import (
 	"errors"
+	"io"
 	"log"
 	"os"
 	"path"
+	"sort"
 	"strings"
+	"syscall"
 
-	"github.com/CalebQ42/squashfs/internal/inode"
+	"github.com/CalebQ42/squashfs/internal/compression"
 )
 
-//Writer is an interface to write a squashfs. Doesn't write until you call Write (TODO: maybe not do Write...).
-//If AllowErrors is true, when errors are encountered, it just prints to the log instead of failing.
-type Writer struct {
-	files           map[string][]*File
-	symlinkTable    map[string]string //[oldpath]newpath
-	symTableTemp    map[string]string
-	directories     []string
-	compression     int
-	ResolveSymlinks bool
-	AllowErrors     bool
+type fileHolder struct {
+	reader      io.Reader
+	path        string
+	name        string
+	symLocation string
+	UID         int
+	GUID        int
+	perm        int
+	folder      bool
+	symlink     bool
 }
 
-//NewWriter creates a new squashfs.Writer with the default settings (gzip compression, autoresolving symlinks, and allowErrors)
+//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 //[oldpath]newpath
+	uidGUIDTable    []int
+	compressionType int
+	allowErrors     bool
+}
+
+//NewWriter creates a new with the default options (Gzip compression and allow errors)
 func NewWriter() (*Writer, error) {
-	return NewWriterWithOptions(true, true, GzipCompression)
+	return NewWriterWithOptions(GzipCompression, true)
 }
 
 //NewWriterWithOptions creates a new squashfs.Writer with the given options.
-//ResolveSymlinks tries to make sure symlinks aren't broken. It will either try to make the link's location work
-func NewWriterWithOptions(resolveSymlinks, allowErrors bool, compressionType int) (*Writer, error) {
+//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")
+		return nil, errors.New("LZO compression is not (currently) supported")
 	}
-	out := Writer{
-		files: map[string][]*File{
-			"/": make([]*File, 0),
+	return &Writer{
+		structure: map[string][]*fileHolder{
+			"/": make([]*fileHolder, 0),
 		},
-		ResolveSymlinks: resolveSymlinks,
-		AllowErrors:     allowErrors,
-		compression:     compressionType,
-	}
-	if resolveSymlinks {
-		out.symlinkTable = make(map[string]string)
-	}
-	return &out, nil
+		symlinkTable:    make(map[string]string),
+		compressionType: compressionType,
+		allowErrors:     allowErrors,
+	}, nil
 }
 
-type fileError struct {
-	err   error
-	files []*File
+//AddFile attempts to add an os.File to the archive at it's root.
+func (w *Writer) AddFile(file *os.File) error {
+	return w.AddFileToFolder("/", file)
 }
 
-//convertFile converts the given os.File to a squashfs.File. Returns the errors and converted file to the channels.
-func (w *Writer) convertFile(squashfsPath string, file *os.File, subDir bool, fileErrChan chan fileError) {
-	var out fileError
-	var fil File
-	fil.Reader = file
-	fil.path = squashfsPath
-	fil.name = path.Base(file.Name())
-	mode := fil.Mode()
+//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)
+}
 
-	if mode.IsRegular() {
-		fil.filType = inode.BasicFileType
-		goto successExit
-	} else if mode.IsDir() {
-		fil.filType = inode.BasicSymlinkType
-		subDirs, err := file.Readdirnames(-1)
+//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
+	}
+	var holder fileHolder
+	holder.path, holder.name = path.Split(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 {
+		target, err := os.Readlink(file.Name())
 		if err != nil {
-			if w.AllowErrors && !subDir {
-				log.Println("Can't get sub-directories for", file.Name())
-				log.Println(err)
-			} else {
-				out.err = err
-			}
-			goto failExit
+			return err
 		}
-		subDirChan := make(chan fileError)
-		for _, filName := range subDirs {
-			go func(filename string, returnChan chan fileError) {
-				subFil, err := os.Open(filename)
-				if err != nil {
-					out.err = err
-					returnChan <- fileError{
-						err: err,
-					}
-					return
-				}
-				w.convertFile(fil.Path(), subFil, true, subDirChan)
-			}(file.Name()+filName, subDirChan)
-		}
-		for range subDirs {
-			filErr := <-subDirChan
-			if filErr.err != nil {
-				if w.AllowErrors && !subDir {
-					log.Println("Error while adding subdirectory of", file.Name())
-					log.Println(filErr.err)
-				} else if subDir {
-					if out.err == nil {
-						out.err = filErr.err
-					}
-				} else {
-					out.err = err
-					goto failExit
-				}
-				continue
-			}
-			out.files = append(out.files, filErr.files...)
-		}
-		goto successExit
-	} else if mode&os.ModeSymlink == os.ModeSymlink {
-		fil.filType = inode.BasicSymlinkType
-		symLocation, err := os.Readlink(file.Name())
+		holder.symLocation = target
+	} else if holder.folder {
+		subDirNames, err := file.Readdirnames(-1)
 		if err != nil {
-			if w.AllowErrors && !subDir {
-				log.Println("Error while getting symlink's information for", file.Name())
+			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)
-			} else {
-				out.err = err
 			}
-			goto failExit
-		}
-		if w.ResolveSymlinks {
-			if val, ok := w.symlinkTable[symLocation]; ok {
-				symLocation = val
-			} else if val, ok := w.symTableTemp[symLocation]; ok {
-				symLocation = val
-			} else {
-				//TODO: either add the file, or place the file in this location. Maybe defer this until after all the other files are added?
+			if !w.allowErrors {
+				dirsAdded = append(dirsAdded, holder.path+"/"+holder.name)
 			}
 		}
-		//TODO: store the symLocation inside the File somehow....
+	} else if !stat.Mode().IsRegular() {
+		return errors.New("Unsupported file type " + file.Name())
 	}
-	if w.AllowErrors && !subDir {
-		log.Println("Unsupported file type for", file.Name())
-	} else {
-		out.err = errors.New("Unsupported file type")
-	}
-failExit: //before this is used, make sure to log or set the error.
-	fileErrChan <- out
-	return
-successExit:
-	out.files = []*File{&fil}
-	fileErrChan <- out
-	return
+	w.structure[holder.path] = append(w.structure[holder.path], &holder)
+	return nil
 }
 
-//AddFilesToPath adds the give os.Files to the given path within the squashfs archive.
-//If AllowErrors is true, this will ALWAYS return nil
-func (w *Writer) AddFilesToPath(squashfsPath string, files ...*os.File) error {
-	squashfsPath = path.Clean(squashfsPath)
-	if strings.HasPrefix(squashfsPath, "/") {
-		squashfsPath = strings.TrimPrefix(squashfsPath, "/")
+//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) error {
+	filepath = path.Clean(filepath)
+	if !strings.HasPrefix(filepath, "/") {
+		filepath = "/" + filepath
 	}
-	if squashfsPath == "." {
-		squashfsPath = "/"
-	}
-	fileErrChan := make(chan fileError)
-	for _, fil := range files {
-		go w.convertFile(squashfsPath, fil, false, fileErrChan)
-	}
-	return errors.New("Not yet ready")
+	var holder fileHolder
+	holder.path, holder.name = path.Split(filepath)
+	holder.reader = reader
+	w.structure[holder.path] = append(w.structure[holder.path], &holder)
+	return nil
 }
 
-//AddFiles adds all files given to the root directory
-//If AllowErrors is true, this will ALWAYS return nil
-func (w *Writer) AddFiles(files ...*os.File) error {
-	return w.AddFilesToPath("/", files...)
+//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 i != len(files)-1 {
+						w.structure[structDir] = append(w.structure[structDir][:i], w.structure[structDir][i+1:]...)
+					} else {
+						w.structure[structDir] = w.structure[structDir][:i]
+					}
+				}
+			}
+		}
+	}
+	return matchFound
 }
 
-//RemoveFileAt removes the file at filepath from the Writer.
-//If multiple files match the given filepath (such as if there are wildcards), all matching files are removed.
-//If one or more files are removed, returns true.
-func (w *Writer) RemoveFileAt(filepath string) bool {
+//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 this is not run before writing, you may end up with broken symlinks.
+func (w *Writer) FixSymlinks() error {
 	//TODO
-	return false
+	return errors.New("DON'T")
+}
+
+//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
+}
+
+//WriteTo attempts to write the archive to the given io.Writer.
+func (w *Writer) WriteTo(write io.Writer) (int64, error) {
+	//TODO
+	return 0, errors.New("I SAID DON'T")
 }

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