Removed close function from squashfs.File

This seems to cause issues in ver specific circumstances and ultimately, isn't needed.

README.md

@@ -1,44 +1,14 @@
-# GoSquashfs
+# squashfs (WIP)
 
-[![PkgGoDev](https://pkg.go.dev/badge/github.com/CalebQ42/GoSquashfs)](https://pkg.go.dev/github.com/CalebQ42/GoSquashfs)
+[![PkgGoDev](https://pkg.go.dev/badge/github.com/CalebQ42/squashfs)](https://pkg.go.dev/github.com/CalebQ42/squashfs) [![Go Report Card](https://goreportcard.com/badge/github.com/CalebQ42/squashfs)](https://goreportcard.com/report/github.com/CalebQ42/squashfs)
 
 A PURE Go library to read and write squashfs.
 
-Currently, you can read a squashfs and extract files (only files at the moment). Many things are public that shouldn't be, but you can use it by using NewSquashfsReader and subsequent ReadFile.
+Currently has support for reading squashfs files and extracting files and folders. Supports all compression types except LZO, but additional compression options are hit or miss.
 
-Special thanks to https://dr-emann.github.io/squashfs/ for some VERY important information in an easy to understand format.
+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).
 
-# Working
+## [TODO](https://github.com/CalebQ42/squashfs/projects/1?fullscreen=true)
-
-* Extracting files from string paths
-* Reading the header
-* Reading metadata blocks (whether encrypted or not)
-* Reading inodes
-* Reading directories
-* Basic gzip compression (Shouldn't be too hard to implement other, but for right now, this works)
-* Listing all files via a string slice
-
-# Not Working (Yet). Not necessarily in order.
-
-* Provide an easy interface to find and list files and their properties
-    * Maybe squashfs.File
-* Make device, socket, symlink, and all extended types of inode work properly. (I need to find an archive that uses it first.)
-* Extracting files
-    * from inodes.
-    * from file info.
-* Give a list of files
-    * In io.FileStat (?) form
-* Reading the UID, GUID, Xatt, Compression Options, and Export tables.
-* Implement other compression types (Should be relatively easy)
-* Squashing
-* Threading processes to speed them up
-* Reasonable tests
-
-# TODO
-
-* Go over all documentation again (especially for exported structs and functions) to make sure it's easy to understand.
-
-# Where I'm at
-
-* Working on the File interface that should make it easier to deal with squashfs files. I'm also trying to make them capable for when I get squashing working.

compression.go

@@ -1,33 +0,0 @@
-package squashfs
-
-import (
-	"bytes"
-	"compress/zlib"
-	"io"
-)
-
-//Decompressor is a squashfs decompressor interface. Allows for easy decompression no matter the type of compression.
-type decompressor interface {
-	Decompress(io.Reader) ([]byte, error)
-}
-
-type compressor interface {
-	Compress(io.Reader) ([]byte, error)
-}
-
-//ZlibDecompressor is a decompressor for gzip type compression
-type zlibDecompressor struct{}
-
-//Decompress reads the entirety of the given reader and returns it uncompressed as a byte slice.
-func (z *zlibDecompressor) Decompress(r io.Reader) ([]byte, error) {
-	rdr, err := zlib.NewReader(r)
-	if err != nil {
-		return nil, err
-	}
-	var data bytes.Buffer
-	_, err = io.Copy(&data, rdr)
-	if err != nil {
-		return nil, err
-	}
-	return data.Bytes(), nil
-}

datareader.go

@@ -18,11 +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
+	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
@@ -145,17 +145,14 @@ func (d *dataReader) readCurBlock() error {
 	return err
 }
 
-//Close frees up the curData from memory
-func (d *dataReader) Close() error {
-	d.curData = nil
-	return nil
-}
-
 func (d *dataReader) Read(p []byte) (int, error) {
 	if d.curData == nil {
-		d.readCurBlock()
+		err := d.readCurBlock()
+		if err != nil {
+			return 0, err
+		}
 	}
-	if d.curReadOffset+len(p) < len(d.curData) {
+	if d.curReadOffset+len(p) <= len(d.curData) {
 		for i := 0; i < len(p); i++ {
 			p[i] = d.curData[d.curReadOffset+i]
 		}
@@ -172,12 +169,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) {

file.go

@@ -2,7 +2,12 @@ package squashfs
 
 import (
 	"errors"
+	"fmt"
 	"io"
+	"os"
+	"path"
+	"strings"
+	"time"
 
 	"github.com/CalebQ42/squashfs/internal/directory"
 	"github.com/CalebQ42/squashfs/internal/inode"
@@ -10,24 +15,29 @@ import (
 
 var (
 	//ErrNotDirectory is returned when you're trying to do directory things with a non-directory
-	ErrNotDirectory = errors.New("File is not a 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")
+	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")
+	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 {
-	Name    string       //The name of the file or folder. Root folder will not have a name ("")
+	Reader  io.Reader
-	Parent  *File        //The parent directory. If it's the root directory, will be nil
+	Parent  *File
-	Reader  io.Reader    //Underlying reader. When writing, will probably be an os.File. When reading this is kept nil UNTIL reading to save memory.
+	r       *Reader //Underlying reader. When writing, will probably be an os.File. When reading this is kept nil UNTIL reading to save memory.
-	Path    string       //The path to the folder the File is located in.
+	in      *inode.Inode
-	r       *Reader      //The squashfs.Reader where this file is contained.
+	name    string
-	in      *inode.Inode //Underlyting inode when reading.
+	path    string
-	filType int          //The file's type, using inode types.
+	filType int //The file's type, using inode types.
+
 }
 
 //get a File from a directory.entry
@@ -37,20 +47,58 @@ func (r *Reader) newFileFromDirEntry(entry *directory.Entry) (fil *File, err err
 	if err != nil {
 		return nil, err
 	}
-	fil.Name = entry.Name
+	fil.name = entry.Name
 	fil.r = r
 	fil.filType = fil.in.Type
 	return
 }
 
+//Name is the file's name
+func (f *File) Name() string {
+	return f.name
+}
+
+//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.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 nil
+}
+
 //GetChildren returns a *squashfs.File slice of every direct child of the directory. If the File is not a directory, will return ErrNotDirectory
 func (f *File) GetChildren() (children []*File, err error) {
 	children = make([]*File, 0)
 	if f.r == nil {
-		return nil, ErrNotReading
+		return nil, errNotReading
 	}
 	if !f.IsDir() {
-		return nil, ErrNotDirectory
+		return nil, errNotDirectory
 	}
 	dir, err := f.r.readDirFromInode(f.in)
 	if err != nil {
@@ -63,8 +111,8 @@ func (f *File) GetChildren() (children []*File, err error) {
 			return
 		}
 		fil.Parent = f
-		if f.Name != "" {
+		if f.name != "" {
-			fil.Path = f.Path + "/" + f.Name
+			fil.path = f.Path()
 		}
 		children = append(children, fil)
 	}
@@ -75,49 +123,359 @@ func (f *File) GetChildren() (children []*File, err error) {
 func (f *File) GetChildrenRecursively() (children []*File, err error) {
 	children = make([]*File, 0)
 	if f.r == nil {
-		return nil, ErrNotReading
+		return nil, errNotReading
 	}
 	if !f.IsDir() {
-		return nil, ErrNotDirectory
+		return nil, errNotDirectory
 	}
-	chil, err := f.GetChildren()
+	children, err = f.GetChildren()
 	if err != nil {
 		return
 	}
 	var childFolders []*File
-	for _, child := range chil {
+	for _, child := range children {
-		children = append(children, child)
 		if child.IsDir() {
 			childFolders = append(childFolders, child)
 		}
 	}
+	foldChil := make(chan []*File)
+	errChan := make(chan error)
 	for _, folds := range childFolders {
-		var childs []*File
+		go func(fil *File) {
-		childs, err = folds.GetChildrenRecursively()
+			childs, err := fil.GetChildrenRecursively()
+			errChan <- err
+			foldChil <- childs
+		}(folds)
+	}
+	for range childFolders {
+		err = <-errChan
 		if err != nil {
 			return
 		}
-		children = append(children, childs...)
+		children = append(children, <-foldChil...)
 	}
 	return
 }
 
+//Path returns the path of the file within the archive.
+func (f *File) Path() string {
+	if f.name == "" {
+		return f.path
+	}
+	return f.path + "/" + f.name
+}
+
+//GetFileAtPath tries to return the File at the given path, relative to the file.
+//Returns nil if called on something other then a folder, OR if the path goes oustide the archive.
+//Allows wildcards supported by path.Match (namely * and ?).
+func (f *File) GetFileAtPath(dirPath string) *File {
+	if dirPath == "" {
+		return f
+	}
+	dirPath = strings.TrimSuffix(strings.TrimPrefix(dirPath, "/"), "/")
+	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.
 func (f *File) IsDir() bool {
 	return f.filType == inode.BasicDirectoryType || f.filType == inode.ExtDirType
 }
 
-//Close frees up the memory held up by the underlying reader. Should NOT be called when writing.
+//IsSymlink returns if the file is a symlink.
-//When reading, Close is safe to use, but any subsequent Read calls resets to the beginning of the file.
+func (f *File) IsSymlink() bool {
-func (f *File) Close() error {
+	return f.filType == inode.BasicSymlinkType || f.filType == inode.ExtSymlinkType
-	if f.IsDir() {
+}
-		return ErrNotFile
+
+//IsFile returns if the file is a file.
+func (f *File) IsFile() bool {
+	return f.filType == inode.BasicFileType || 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.ExtSymlinkType:
+		return f.in.Info.(inode.ExtendedSymlink).Path
+	default:
+		return ""
 	}
-	if closer, is := f.Reader.(io.Closer); is {
+}
-		closer.Close()
+
+//GetSymlinkFile tries to return the squashfs.File associated with the symlink. If the file isn't a symlink
+//or the symlink points to a location outside the archive, nil is returned.
+func (f *File) GetSymlinkFile() *File {
+	if !f.IsSymlink() {
+		return nil
 	}
-	f.Reader = nil
+	if strings.HasSuffix(f.SymlinkPath(), "/") {
-	return nil
+		return nil
+	}
+	return f.Parent.GetFileAtPath(f.SymlinkPath())
+}
+
+//GetSymlinkFileRecursive tries to return the squasfs.File associated with the symlink. It will recursively
+//try to get the symlink's file. This will return either a non-symlink File, or nil.
+func (f *File) GetSymlinkFileRecursive() *File {
+	if !f.IsSymlink() {
+		return nil
+	}
+	if strings.HasSuffix(f.SymlinkPath(), "/") {
+		return nil
+	}
+	sym := f
+	for {
+		sym = sym.GetSymlinkFile()
+		if sym == nil {
+			return nil
+		}
+		if !sym.IsSymlink() {
+			return sym
+		}
+	}
+}
+
+//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}
+	}
+	switch {
+	case f.IsDir():
+		if f.name != "" {
+			//TODO: check if folder is present, and if so, try to set it's permission
+			err = os.Mkdir(path+"/"+f.name, os.ModePerm)
+			if err != nil {
+				if verbose {
+					fmt.Println("Error while making: ", path+"/"+f.name)
+					fmt.Println(err)
+				}
+				errs = append(errs, err)
+				return
+			}
+			fil, err := os.Open(path + "/" + f.name)
+			if err != nil {
+				if verbose {
+					fmt.Println("Error while opening:", path+"/"+f.name)
+					fmt.Println(err)
+				}
+				errs = append(errs, err)
+				return
+			}
+			fil.Chown(int(f.r.idTable[f.in.Header.UID]), int(f.r.idTable[f.in.Header.GID]))
+			//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)
+			// }
+			err = fil.Chmod(f.Mode())
+			if err != nil {
+				if verbose {
+					fmt.Println("Error while changing owner:", path+"/"+f.name)
+					fmt.Println(err)
+				}
+				errs = append(errs, err)
+			}
+		}
+		children, err := f.GetChildren()
+		if err != nil {
+			if verbose {
+				fmt.Println("Error getting children for:", f.Path())
+				fmt.Println(err)
+			}
+			errs = append(errs, err)
+			return
+		}
+		finishChan := make(chan []error)
+		for _, child := range children {
+			go func(child *File) {
+				if f.name == "" {
+					finishChan <- child.ExtractWithOptions(path, dereferenceSymlink, unbreakSymlink, folderPerm, verbose)
+				} else {
+					finishChan <- child.ExtractWithOptions(path+"/"+f.name, dereferenceSymlink, unbreakSymlink, folderPerm, verbose)
+				}
+			}(child)
+		}
+		for range children {
+			errs = append(errs, (<-finishChan)...)
+		}
+		return
+	case f.IsFile():
+		fil, err := os.Create(path + "/" + f.name)
+		if os.IsExist(err) {
+			err = os.Remove(path + "/" + f.name)
+			if err != nil {
+				if verbose {
+					fmt.Println("Error while making:", path+"/"+f.name)
+					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 {
+				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 {
+				fmt.Println("Error while Copying data to:", path+"/"+f.name)
+				fmt.Println(err)
+			}
+			errs = append(errs, err)
+			return
+		}
+		fil.Chown(int(f.r.idTable[f.in.Header.UID]), int(f.r.idTable[f.in.Header.GID]))
+		//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 {
+			fil := f.GetSymlinkFile()
+			if fil == nil {
+				if verbose {
+					fmt.Println("Symlink path(", symPath, ") is outside the archive:"+path+"/"+f.name)
+				}
+				return
+			}
+			fil.name = f.name
+			extracSymErrs := fil.ExtractWithOptions(path, 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...)
+			}
+			return
+		} else if unbreakSymlink {
+			fil := f.GetSymlinkFile()
+			if fil != nil {
+				symPath = path + "/" + symPath
+				paths := strings.Split(symPath, "/")
+				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 {
+				if verbose {
+					fmt.Println("Symlink path(", symPath, ") is outside the archive:"+path+"/"+f.name)
+				}
+				return
+			}
+		}
+		err = os.Symlink(f.SymlinkPath(), path+"/"+f.name)
+		if err != nil {
+			if verbose {
+				fmt.Println("Error while making symlink:", path+"/"+f.name)
+				fmt.Println(err)
+			}
+			errs = append(errs, err)
+		}
+	}
+	return
 }
 
 //Read from the file. Doesn't do anything fancy, just pases it to the underlying io.Reader. If a directory, return io.EOF.
@@ -134,3 +492,53 @@ func (f *File) Read(p []byte) (int, error) {
 	}
 	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) {
+	var offset uint32
+	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.ExtDirType:
+		offset = i.Info.(inode.ExtendedDirectory).Init.DirectoryIndex
+		metaOffset = i.Info.(inode.ExtendedDirectory).Init.DirectoryOffset
+		size = i.Info.(inode.ExtendedDirectory).Init.DirectorySize
+	default:
+		return nil, errors.New("Not a directory inode")
+	}
+	br, err := r.newMetadataReader(int64(r.super.DirTableStart + uint64(offset)))
+	if err != nil {
+		return nil, err
+	}
+	_, err = br.Seek(int64(metaOffset), io.SeekStart)
+	if err != nil {
+		return nil, err
+	}
+	dir, err := directory.NewDirectory(br, size)
+	if err != nil {
+		return dir, err
+	}
+	return dir, 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

@@ -22,7 +22,7 @@ type fileReader struct {
 
 var (
 	//ErrPathIsNotFile returns when trying to read from a file, but the given path is NOT a file.
-	ErrPathIsNotFile = errors.New("The given path is not a file")
+	errPathIsNotFile = errors.New("The given path is not a file")
 )
 
 //ReadFile provides a squashfs.FileReader for the file at the given location.
@@ -30,7 +30,7 @@ func (r *Reader) newFileReader(in *inode.Inode) (*fileReader, error) {
 	var rdr fileReader
 	rdr.in = in
 	if in.Type != inode.BasicFileType && in.Type != inode.ExtFileType {
-		return nil, ErrPathIsNotFile
+		return nil, errPathIsNotFile
 	}
 	switch in.Type {
 	case inode.BasicFileType:
@@ -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)

go.mod

@@ -4,4 +4,15 @@ go 1.15
 
 require (
 	github.com/CalebQ42/GoAppImage v0.4.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.4
+	github.com/kr/text v0.2.0 // indirect
+	github.com/pierrec/lz4/v4 v4.1.2
+	github.com/smartystreets/assertions v1.2.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
 )

go.sum

@@ -1,9 +1,10 @@
 github.com/CalebQ42/GoAppImage v0.4.0 h1:aF+Y/vyo/RGhoyZEW1CMY6WyRWrZZO4ydsRFAtIGnaY=
 github.com/CalebQ42/GoAppImage v0.4.0/go.mod h1:qHudJKAn/dlkNWNnH4h1YKXp29EZ7Bppsn7sNP2HuvU=
-github.com/CalebQ42/GoSquashfs v0.1.0 h1:1E6oeZLxGwjFgB0M5BcDD/IpKOQq1aO0gGsN0llCFoE=
-github.com/CalebQ42/GoSquashfs v0.1.0/go.mod h1:NzAR1YC1SVKOKhRao5IiWY3GhOMI+IxBy1xeZJeVKlQ=
 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=
+github.com/adrg/xdg v0.2.3/go.mod h1:7I2hH/IT30IsupOpKZ5ue7/qNi3CoKzD6tL3HwpaRMQ=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -13,22 +14,36 @@ github.com/google/go-cmp v0.5.4 h1:L8R9j+yAqZuZjsqh/z+F1NCffTKKLShY6zXTItVIZ8M=
 github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gopherjs/gopherjs v0.0.0-20200217142428-fce0ec30dd00 h1:l5lAOZEym3oK3SQ2HBHWsJUfbNBiTXJDeW2QDxw9AQ0=
+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.4 h1:kz40R/YWls3iqT9zX9AHN3WoVsrAWVyui5sxuLqiXqU=
+github.com/klauspost/compress v1.11.4/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=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+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.2 h1:qvY3YFXRQE/XB8MlLzJH7mSzBs74eA2gg52YTk6jUPM=
+github.com/pierrec/lz4/v4 v4.1.2/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=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/assertions v1.2.0 h1:42S6lae5dvLc7BrLu/0ugRtcFVjoJNMC/N3yZFZkDFs=
+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/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.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=
@@ -48,7 +63,11 @@ golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8T
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b h1:QRR6H1YWRnHb4Y/HeNFCTJLFVxaq6wH4YuVdsUOr75U=
 gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 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-20200615113413-eeeca48fe776/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/compression/gzip.go

@@ -0,0 +1,66 @@
+package compression
+
+import (
+	"bytes"
+	"compress/zlib"
+	"encoding/binary"
+	"io"
+)
+
+type gzipInit struct {
+	CompressionLevel int32
+	WindowSize       int16
+	Strategies       int16
+}
+
+//Gzip is a decompressor for gzip type compression. Uses zlib for compression and decompression
+type Gzip struct {
+	CompressionLevel int32
+	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)
+	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
+	return &gzip, nil
+}
+
+//Decompress reads the entirety of the given reader and returns it uncompressed as a byte slice.
+func (g *Gzip) Decompress(r io.Reader) ([]byte, error) {
+	rdr, err := zlib.NewReader(r)
+	if err != nil {
+		return nil, err
+	}
+	var data bytes.Buffer
+	_, err = io.Copy(&data, rdr)
+	if err != nil {
+		return nil, err
+	}
+	return data.Bytes(), nil
+}
+
+//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)
+	if err != nil {
+		return nil, err
+	}
+	err = wrt.Flush()
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}

internal/compression/lz4.go

@@ -0,0 +1,37 @@
+package compression
+
+import (
+	"bytes"
+	"encoding/binary"
+	"io"
+
+	"github.com/pierrec/lz4/v4"
+)
+
+//Lz4 is a Lz4 Compressor/Decompressor
+type Lz4 struct {
+	HC bool
+}
+
+//NewLz4CompressorWithOptions creates a new lz4 compressor/decompressor with options read from the given reader.
+func NewLz4CompressorWithOptions(r io.Reader) (*Lz4, error) {
+	var lz4 Lz4
+	var init struct {
+		Version int32
+		Flags   int32
+	}
+	err := binary.Read(r, binary.LittleEndian, &init)
+	if err != nil {
+		return nil, err
+	}
+	lz4.HC = init.Flags == 1
+	return &lz4, nil
+}
+
+//Decompress decompresses all data from r and returns the uncompressed bytes
+func (l *Lz4) Decompress(r io.Reader) ([]byte, error) {
+	rdr := lz4.NewReader(r)
+	var buf bytes.Buffer
+	_, err := io.Copy(&buf, rdr)
+	return buf.Bytes(), err
+}

internal/compression/lzma.go

@@ -0,0 +1,25 @@
+package compression
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/ulikunitz/xz/lzma"
+)
+
+//Lzma is a lzma decompressor
+type Lzma struct{}
+
+//Decompress decompresses all the data in the given reader and returns the uncompressed bytes.
+func (l *Lzma) Decompress(rdr io.Reader) ([]byte, error) {
+	r, err := lzma.NewReader(rdr)
+	if err != nil {
+		return nil, err
+	}
+	var buf bytes.Buffer
+	_, err = io.Copy(&buf, r)
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}

internal/compression/types.go

@@ -0,0 +1,13 @@
+package compression
+
+import "io"
+
+//Compressor is a squashfs decompressor interface. Allows for easy compression.
+type Compressor interface {
+	Compress([]byte) ([]byte, error)
+}
+
+//Decompressor is a squashfs decompressor interface. Allows for easy decompression no matter the type of compression.
+type Decompressor interface {
+	Decompress(io.Reader) ([]byte, error)
+}

internal/compression/xz.go

@@ -0,0 +1,55 @@
+package compression
+
+import (
+	"bytes"
+	"encoding/binary"
+	"io"
+
+	"github.com/ulikunitz/xz"
+)
+
+type xzInit struct {
+	DictionarySize int32
+	Filters        int32
+}
+
+//Xz is a Xz decompressor.
+type Xz struct {
+	DictionarySize int32
+	HasFilters     bool
+}
+
+//NewXzCompressorWithOptions creates a new Xz compressor/decompressor that reads the compressor options from the given reader.
+func NewXzCompressorWithOptions(rdr io.Reader) (*Xz, error) {
+	var x Xz
+	var init xzInit
+	err := binary.Read(rdr, binary.LittleEndian, &init)
+	if err != nil {
+		return nil, err
+	}
+	x.DictionarySize = init.DictionarySize
+	//TODO: When I can do filters, parse the filters
+	if init.Filters != 0 {
+		x.HasFilters = true
+	}
+	return &x, nil
+}
+
+//Decompress decompresses all the data from the rdr and returns the uncompressed bytes.
+func (x *Xz) Decompress(rdr io.Reader) ([]byte, error) {
+	r, err := xz.NewReader(rdr)
+	if err != nil {
+		return nil, err
+	}
+	r.DictCap = int(x.DictionarySize)
+	err = r.Verify()
+	if err != nil {
+		return nil, err
+	}
+	var buf bytes.Buffer
+	_, err = io.Copy(&buf, r)
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}

internal/compression/zstd.go

@@ -0,0 +1,36 @@
+package compression
+
+import (
+	"bytes"
+	"encoding/binary"
+	"io"
+
+	"github.com/klauspost/compress/zstd"
+)
+
+//Zstd is a zstd compressor/decompressor
+type Zstd struct {
+	CompressionLevel int32
+}
+
+//NewZstdCompressorWithOptions creates a new Zstd with options read from the given reader
+func NewZstdCompressorWithOptions(r io.Reader) (*Zstd, error) {
+	var zstd Zstd
+	err := binary.Read(r, binary.LittleEndian, &zstd)
+	if err != nil {
+		return nil, err
+	}
+	return &zstd, nil
+}
+
+//Decompress decompresses all data from the reader and returns the uncompressed data
+func (z *Zstd) Decompress(r io.Reader) ([]byte, error) {
+	rdr, err := zstd.NewReader(r)
+	if err != nil {
+		return nil, err
+	}
+	defer rdr.Close()
+	var buf bytes.Buffer
+	_, err = io.Copy(&buf, rdr)
+	return buf.Bytes(), err
+}

internal/directory/directory.go

@@ -52,7 +52,7 @@ type Directory struct {
 }
 
 //NewDirectory reads the directory from rdr
-func NewDirectory(base io.Reader, size uint16) (*Directory, error) {
+func NewDirectory(base io.Reader, size uint32) (*Directory, error) {
 	var dir Directory
 	var err error
 	tmp := make([]byte, size)

internal/inode/inodetypes.go

@@ -2,7 +2,6 @@ package inode
 
 import (
 	"encoding/binary"
-	"fmt"
 	"io"
 )
 
@@ -66,15 +65,12 @@ func NewExtendedDirectory(rdr io.Reader) (ExtendedDirectory, error) {
 	if err != nil {
 		return inode, err
 	}
-	if inode.Init.IndexCount > 0 {
+	for i := uint16(0); i < inode.Init.IndexCount; i++ {
-		inode.Indexes = make([]DirectoryIndex, inode.Init.IndexCount)
+		tmp, err := NewDirectoryIndex(rdr)
-		for i := uint16(0); i < inode.Init.IndexCount; i++ {
+		if err != nil {
-			inode.Indexes[i], err = NewDirectoryIndex(rdr)
+			return inode, err
-			if err != nil {
-				fmt.Println("Error while reading Directory Index ", i)
-				return inode, err
-			}
 		}
+		inode.Indexes = append(inode.Indexes, tmp)
 	}
 	return inode, err
 }
@@ -89,7 +85,7 @@ type DirectoryIndexInit struct {
 //DirectoryIndex is a quick lookup provided by an ExtendedDirectory
 type DirectoryIndex struct {
 	Init DirectoryIndexInit
-	Name []byte
+	Name string
 }
 
 //NewDirectoryIndex return a new DirectoryIndex
@@ -99,9 +95,13 @@ func NewDirectoryIndex(rdr io.Reader) (DirectoryIndex, error) {
 	if err != nil {
 		return index, err
 	}
-	index.Name = make([]byte, index.Init.NameSize, index.Init.NameSize)
+	tmp := make([]byte, index.Init.NameSize+1, index.Init.NameSize+1)
-	err = binary.Read(rdr, binary.LittleEndian, &index.Name)
+	err = binary.Read(rdr, binary.LittleEndian, &tmp)
-	return index, err
+	if err != nil {
+		return index, err
+	}
+	index.Name = string(tmp)
+	return index, nil
 }
 
 //BasicFileInit is the information that can be directoy decoded
@@ -181,6 +181,7 @@ type BasicSymlinkInit struct {
 type BasicSymlink struct {
 	Init       BasicSymlinkInit
 	targetPath []byte //len is TargetPathSize
+	Path       string
 }
 
 //NewBasicSymlink creates a new BasicSymlink
@@ -192,6 +193,10 @@ func NewBasicSymlink(rdr io.Reader) (BasicSymlink, error) {
 	}
 	inode.targetPath = make([]byte, inode.Init.TargetPathSize, inode.Init.TargetPathSize)
 	err = binary.Read(rdr, binary.LittleEndian, &inode.targetPath)
+	if err != nil {
+		return inode, err
+	}
+	inode.Path = string(inode.targetPath)
 	return inode, err
 }
 
@@ -204,7 +209,8 @@ type ExtendedSymlinkInit struct {
 //ExtendedSymlink is a symlink with extra information
 type ExtendedSymlink struct {
 	Init       ExtendedSymlinkInit
-	TargetPath []uint8
+	targetPath []uint8
+	Path       string
 	XattrIndex uint32
 }
 
@@ -215,7 +221,12 @@ func NewExtendedSymlink(rdr io.Reader) (ExtendedSymlink, error) {
 	if err != nil {
 		return inode, err
 	}
-	inode.TargetPath = make([]uint8, inode.Init.TargetPathSize, inode.Init.TargetPathSize)
+	inode.targetPath = make([]uint8, inode.Init.TargetPathSize, inode.Init.TargetPathSize)
+	err = binary.Read(rdr, binary.LittleEndian, &inode.targetPath)
+	if err != nil {
+		return inode, err
+	}
+	inode.Path = string(inode.targetPath)
 	err = binary.Read(rdr, binary.LittleEndian, &inode.XattrIndex)
 	return inode, err
 }

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
 }
 
@@ -52,6 +52,17 @@ func (s *Reader) newMetadataReaderFromInodeRef(ref uint64) (*metadataReader, err
 	return br, nil
 }
 
+//ProcessInodeRef processes an inode reference and returns two values
+//
+//The first value is the inode table offset. AKA, it's where the metadata block of the inode STARTS relative to the inode table.
+//
+//The second value is the offset of the inode, INSIDE of the metadata.
+func processInodeRef(inodeRef uint64) (tableOffset uint64, metaOffset uint64) {
+	tableOffset = inodeRef >> 16
+	metaOffset = inodeRef &^ 0xFFFFFFFF0000
+	return
+}
+
 func (br *metadataReader) parseMetadata() error {
 	var raw uint16
 	err := binary.Read(io.NewSectionReader(br.s.r, br.offset, 2), binary.LittleEndian, &raw)
@@ -59,7 +70,7 @@ func (br *metadataReader) parseMetadata() error {
 		return err
 	}
 	br.offset += 2
-	compressed := !(raw&0x8000 == 0x8000)
+	compressed := raw&0x8000 != 0x8000
 	size := raw &^ 0x8000
 	br.headers = append(br.headers, &metadata{
 		raw:        raw,
@@ -93,7 +104,7 @@ func (br *metadataReader) readNextDataBlock() error {
 
 //Read reads bytes into the given byte slice. Returns the amount of data read.
 func (br *metadataReader) Read(p []byte) (int, error) {
-	if br.readOffset+len(p) < len(br.data) {
+	if br.readOffset+len(p) <= len(br.data) {
 		for i := 0; i < len(p); i++ {
 			p[i] = br.data[br.readOffset+i]
 		}

reader.go

@@ -5,8 +5,9 @@ import (
 	"errors"
 	"io"
 	"math"
-	"strings"
+	"time"
 
+	"github.com/CalebQ42/squashfs/internal/compression"
 	"github.com/CalebQ42/squashfs/internal/inode"
 )
 
@@ -16,28 +17,28 @@ const (
 
 var (
 	//ErrNoMagic is returned if the magic number in the superblock isn't correct.
-	ErrNoMagic = errors.New("Magic number doesn't match. Either isn't a squashfs or corrupted")
+	errNoMagic = errors.New("Magic number doesn't match. Either isn't a squashfs or corrupted")
 	//ErrIncompatibleCompression is returned if the compression type in the superblock doesn't work.
-	ErrIncompatibleCompression = errors.New("Compression type unsupported")
+	errIncompatibleCompression = errors.New("Compression type unsupported")
 	//ErrCompressorOptions is returned if compressor options is present. It's not currently supported.
-	ErrCompressorOptions = errors.New("Compressor options is not currently supported")
+	errCompressorOptions = errors.New("Compressor options is not currently supported")
-	//ErrFragmentTableIssues is returned if there's trouble reading the fragment table when creating a reader.
+	//ErrOptions is returned when compression options that I haven't tested is set. When this is returned, the Reader is also returned.
-	//When this is returned, the reader is still returned.
+	ErrOptions = errors.New("Possibly incompatible compressor options")
-	errFragmentTableIssues = errors.New("Trouble while reading the fragment table")
 )
 
 //Reader processes and reads a squashfs archive.
-//TODO: Give a way to actually read files :P
 type Reader struct {
 	r            io.ReaderAt
+	decompressor compression.Decompressor
+	fragOffsets  []uint64
+	idTable      []uint32
 	super        superblock
 	flags        superblockFlags
-	decompressor decompressor
-	fragOffsets  []uint64
 }
 
 //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(rdr.r, 0, int64(binary.Size(rdr.super))), binary.LittleEndian, &rdr.super)
@@ -45,20 +46,68 @@ func NewSquashfsReader(r io.ReaderAt) (*Reader, error) {
 		return nil, err
 	}
 	if rdr.super.Magic != magic {
-		return nil, ErrNoMagic
+		return nil, errNoMagic
 	}
+	// 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")
+	// }
 	rdr.flags = rdr.super.GetFlags()
-	switch rdr.super.CompressionType {
-	case gzipCompression:
-		rdr.decompressor = &zlibDecompressor{}
-	default:
-		return nil, ErrIncompatibleCompression
-	}
 	if rdr.flags.CompressorOptions {
-		//TODO: parse compressor options
+		switch rdr.super.CompressionType {
-		return nil, ErrCompressorOptions
+		case GzipCompression:
+			gzip, err := compression.NewGzipCompressorWithOptions(io.NewSectionReader(rdr.r, int64(binary.Size(rdr.super)), 8))
+			if err != nil {
+				return nil, err
+			}
+			if gzip.HasCustomWindow || gzip.HasStrategies {
+				hasUnsupportedOptions = true
+			}
+			rdr.decompressor = gzip
+		case XzCompression:
+			xz, err := compression.NewXzCompressorWithOptions(io.NewSectionReader(rdr.r, int64(binary.Size(rdr.super)), 8))
+			if err != nil {
+				return nil, err
+			}
+			if xz.HasFilters {
+				return nil, errors.New("XZ compression options has filters. These are not yet supported")
+			}
+			rdr.decompressor = xz
+		case Lz4Compression:
+			lz4, err := compression.NewLz4CompressorWithOptions(io.NewSectionReader(rdr.r, int64(binary.Size(rdr.super)), 8))
+			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))
+			if err != nil {
+				return nil, err
+			}
+			rdr.decompressor = zstd
+		default:
+			return nil, errIncompatibleCompression
+		}
+	} else {
+		switch rdr.super.CompressionType {
+		case GzipCompression:
+			rdr.decompressor = &compression.Gzip{}
+		case LzmaCompression:
+			rdr.decompressor = &compression.Lzma{}
+		case XzCompression:
+			rdr.decompressor = &compression.Xz{}
+		case Lz4Compression:
+			rdr.decompressor = &compression.Lz4{}
+		case ZstdCompression:
+			rdr.decompressor = &compression.Zstd{}
+		default:
+			//TODO: all compression types.
+			return nil, errIncompatibleCompression
+		}
 	}
-	fragBlocks := int(math.Ceil(float64(rdr.super.FragCount) / 512.0))
+	fragBlocks := int(math.Ceil(float64(rdr.super.FragCount) / 512))
 	if fragBlocks > 0 {
 		offset := int64(rdr.super.FragTableStart)
 		for i := 0; i < fragBlocks; i++ {
@@ -71,9 +120,49 @@ func NewSquashfsReader(r io.ReaderAt) (*Reader, error) {
 			offset += 8
 		}
 	}
+	unread := rdr.super.IDCount
+	blockOffsets := make([]uint64, int(math.Ceil(float64(rdr.super.IDCount)/2048)))
+	for i := range blockOffsets {
+		secRdr := io.NewSectionReader(r, int64(rdr.super.IDTableStart)+(8*int64(i)), 8)
+		err = binary.Read(secRdr, binary.LittleEndian, &blockOffsets[i])
+		if err != nil {
+			return nil, err
+		}
+		idRdr, err := rdr.newMetadataReader(int64(blockOffsets[i]))
+		if err != nil {
+			return nil, err
+		}
+		read := uint16(math.Min(float64(unread), 2048))
+		for i := uint16(0); i < read; i++ {
+			var tmp uint32
+			err = binary.Read(idRdr, binary.LittleEndian, &tmp)
+			if err != nil {
+				return nil, err
+			}
+			rdr.idTable = append(rdr.idTable, tmp)
+		}
+		unread -= read
+	}
+	if hasUnsupportedOptions {
+		return &rdr, ErrOptions
+	}
 	return &rdr, nil
 }
 
+//ModTime is the last time the file was modified/created.
+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)
@@ -85,7 +174,7 @@ func (r *Reader) GetRootFolder() (root *File, err error) {
 	if err != nil {
 		return nil, err
 	}
-	root.Path = "/"
+	root.path = "/"
 	root.filType = root.in.Type
 	root.r = r
 	return root, nil
@@ -160,34 +249,9 @@ func (r *Reader) FindAll(query func(*File) bool) (all []*File) {
 
 //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 {
-	path = strings.TrimSuffix(strings.TrimPrefix(path, "/"), "/")
-	pathDirs := strings.Split(path, "/")
 	dir, err := r.GetRootFolder()
 	if err != nil {
 		return nil
 	}
-	children, err := dir.GetChildren()
+	return dir.GetFileAtPath(path)
-	if err != nil {
-		return nil
-	}
-	for _, folder := range pathDirs {
-		for _, child := range children {
-			if child.Name == folder {
-				dir = child
-				if dir.IsDir() {
-					children, err = dir.GetChildren()
-					if err != nil {
-						return nil
-					}
-				} else {
-					children = make([]*File, 0)
-				}
-				break
-			}
-		}
-	}
-	if dir.Path+"/"+dir.Name == "/"+path {
-		return dir
-	}
-	return nil
 }

squash_test.go

@@ -5,18 +5,47 @@ import (
 	"io"
 	"net/http"
 	"os"
-	"strings"
 	"testing"
 
 	goappimage "github.com/CalebQ42/GoAppImage"
 )
 
 const (
-	downloadURL  = "https://github.com/zilti/code-oss.AppImage/releases/download/continuous/Code_OSS-x86_64.AppImage"
+	downloadURL  = "https://github.com/srevinsaju/Firefox-Appimage/releases/download/firefox-v84.0.r20201221152838/firefox-84.0.r20201221152838-x86_64.AppImage"
-	appImageName = "Code_OSS.AppImage"
+	appImageName = "firefox-84.0.r20201221152838-x86_64.AppImage"
+	squashfsName = "balenaEtcher-1.5.113-x64.AppImage.sfs" //testing with a ArchLinux root fs from the live img
 )
 
-func TestMain(t *testing.T) {
+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 {
@@ -39,44 +68,28 @@ func TestMain(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	rdr.FindAll(func(fil *File) bool {
+	os.RemoveAll(wd + "testing/firefox")
-		return strings.HasSuffix(fil.Name, ".desktop")
+	errs := rdr.ExtractTo(wd + "/testing/firefox")
-	})
+	if len(errs) > 0 {
-	fils, err := rdr.GetAllFiles()
+		t.Fatal(errs)
-	if err != nil {
-		t.Fatal(err)
 	}
-	for _, fil := range fils {
+	// os.RemoveAll(wd + "/testing/" + appImageName + ".d")
-		fmt.Println(fil.Path + "/" + fil.Name)
+	// root, _ := rdr.GetRootFolder()
-	}
+	// errs := root.ExtractWithOptions(wd+"/testing/"+appImageName+".d", true, os.ModePerm, true)
-	// extractionFil := "code-oss.desktop"
+	// t.Fatal(errs)
-	// os.Remove(wd + "/testing/" + extractionFil)
+	t.Fatal("No problemo!")
-	// desk, err := os.Create(wd + "/testing/" + extractionFil)
-	// if err != nil {
-	// 	t.Fatal(err)
-	// }
-	// ext := rdr.GetFileAtPath(extractionFil)
-	// if ext == nil {
-	// 	t.Fatal("Cannot find file")
-	// }
-	// defer ext.Close()
-	// _, err = io.Copy(desk, ext)
-	// if err != nil {
-	// 	t.Fatal(err)
-	// }
-	t.Fatal("No problems here!")
 }
 
 func downloadTestAppImage(t *testing.T, dir string) {
-	//seems to time out on slow connections. Might fix that at some point... or not
+	//seems to time out on slow connections. Might fix that at some point... or not. It's just a test...
-	os.Mkdir(dir, 0777)
+	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 {
+		CheckRedirect: func(r *http.Request, _ []*http.Request) error {
 			r.URL.Opaque = r.URL.Path
 			return nil
 		},
@@ -91,3 +104,40 @@ func downloadTestAppImage(t *testing.T, dir string) {
 		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.

utils.go

@@ -1,119 +0,0 @@
-package squashfs
-
-import (
-	"errors"
-	"io"
-	"strings"
-
-	"github.com/CalebQ42/squashfs/internal/directory"
-	"github.com/CalebQ42/squashfs/internal/inode"
-)
-
-var (
-	//ErrNotFound means that the given path is NOT present in the archive
-	ErrNotFound = errors.New("Path not found")
-)
-
-//ProcessInodeRef processes an inode reference and returns two values
-//
-//The first value is the inode table offset. AKA, it's where the metadata block of the inode STARTS relative to the inode table.
-//
-//The second value is the offset of the inode, INSIDE of the metadata.
-func processInodeRef(inodeRef uint64) (tableOffset uint64, metaOffset uint64) {
-	tableOffset = inodeRef >> 16
-	metaOffset = inodeRef &^ 0xFFFFFFFF0000
-	return
-}
-
-//ReadDirFromInode returns a fully populated directory.Directory from a given inode.Inode.
-//If the given inode is not a directory it returns an error.
-func (r *Reader) readDirFromInode(i *inode.Inode) (*directory.Directory, error) {
-	var offset uint32
-	var metaOffset uint16
-	var size uint16
-	switch i.Type {
-	case inode.BasicDirectoryType:
-		offset = i.Info.(inode.BasicDirectory).DirectoryIndex
-		metaOffset = i.Info.(inode.BasicDirectory).DirectoryOffset
-		size = i.Info.(inode.BasicDirectory).DirectorySize
-	case inode.ExtDirType:
-		offset = i.Info.(inode.ExtendedDirectory).Init.DirectoryIndex
-		metaOffset = i.Info.(inode.ExtendedDirectory).Init.DirectoryOffset
-		size = uint16(i.Info.(inode.ExtendedDirectory).Init.DirectorySize)
-	default:
-		return nil, errors.New("Not a directory inode")
-	}
-	br, err := r.newMetadataReader(int64(r.super.DirTableStart + uint64(offset)))
-	if err != nil {
-		return nil, err
-	}
-	_, err = br.Seek(int64(metaOffset), io.SeekStart)
-	if err != nil {
-		return nil, err
-	}
-	dir, err := directory.NewDirectory(br, size)
-	if err != nil {
-		return dir, err
-	}
-	return dir, 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
-}
-
-//GetInodeFromPath returns the inode at the given path, relative to root.
-//The given path can start with or without "/"
-func (r *Reader) getInodeFromPath(path string) (*inode.Inode, error) {
-	path = strings.TrimSuffix(strings.TrimPrefix(path, "/"), "/")
-	pathDirs := strings.Split(path, "/")
-	rdr, err := r.newMetadataReaderFromInodeRef(r.super.RootInodeRef)
-	if err != nil {
-		return nil, err
-	}
-	curInodeDir, err := inode.ProcessInode(rdr, r.super.BlockSize)
-	if err != nil {
-		return nil, err
-	}
-	if path == "" {
-		return curInodeDir, nil
-	}
-	for depth := 0; depth < len(pathDirs); depth++ {
-		if curInodeDir.Type != inode.BasicDirectoryType && curInodeDir.Type != inode.ExtDirType {
-			return nil, ErrNotFound
-		}
-		dir, err := r.readDirFromInode(curInodeDir)
-		if err != nil {
-			return nil, err
-		}
-		for _, entry := range dir.Entries {
-			if entry.Name == pathDirs[depth] {
-				if depth == len(pathDirs)-1 {
-					in, err := r.getInodeFromEntry(&entry)
-					if err != nil {
-						return nil, err
-					}
-					return in, nil
-				}
-				curInodeDir, err = r.getInodeFromEntry(&entry)
-				if err != nil {
-					return nil, err
-				}
-			}
-		}
-	}
-	return nil, ErrNotFound
-}

writer.go

@@ -0,0 +1,181 @@
+package squashfs
+
+import (
+	"errors"
+	"log"
+	"os"
+	"path"
+	"strings"
+
+	"github.com/CalebQ42/squashfs/internal/inode"
+)
+
+//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
+}
+
+//NewWriter creates a new squashfs.Writer with the default settings (gzip compression, autoresolving symlinks, and allowErrors)
+func NewWriter() (*Writer, error) {
+	return NewWriterWithOptions(true, true, GzipCompression)
+}
+
+//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) {
+	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")
+	}
+	out := Writer{
+		files: map[string][]*File{
+			"/": make([]*File, 0),
+		},
+		ResolveSymlinks: resolveSymlinks,
+		AllowErrors:     allowErrors,
+		compression:     compressionType,
+	}
+	if resolveSymlinks {
+		out.symlinkTable = make(map[string]string)
+	}
+	return &out, nil
+}
+
+type fileError struct {
+	err   error
+	files []*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()
+
+	if mode.IsRegular() {
+		fil.filType = inode.BasicFileType
+		goto successExit
+	} else if mode.IsDir() {
+		fil.filType = inode.BasicSymlinkType
+		subDirs, err := file.Readdirnames(-1)
+		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
+		}
+		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())
+		if err != nil {
+			if w.AllowErrors && !subDir {
+				log.Println("Error while getting symlink's information for", file.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?
+			}
+		}
+		//TODO: store the symLocation inside the File somehow....
+	}
+	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
+}
+
+//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, "/")
+	}
+	if squashfsPath == "." {
+		squashfsPath = "/"
+	}
+	fileErrChan := make(chan fileError)
+	for _, fil := range files {
+		go w.convertFile(squashfsPath, fil, false, fileErrChan)
+	}
+	return errors.New("Not yet ready")
+}
+
+//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...)
+}
+
+//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 {
+	//TODO
+	return false
+}