Re-Write of the Writer to make it simpler
This commit is contained in:
Caleb Gardner
@@ -2,180 +2,167 @@ package squashfs
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"io"
|
||||
"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 fileHolder struct {
|
||||
reader io.Reader
|
||||
path string
|
||||
name string
|
||||
symLocation string
|
||||
folder bool
|
||||
symlink bool
|
||||
}
|
||||
|
||||
//Writer is used to creaste squashfs archives. Currently unusable
|
||||
//TODO: Make usable
|
||||
type Writer struct {
|
||||
files map[string][]*File
|
||||
structure map[string][]*fileHolder
|
||||
symlinkTable map[string]string //[oldpath]newpath
|
||||
symTableTemp map[string]string
|
||||
directories []string
|
||||
compression int
|
||||
ResolveSymlinks bool
|
||||
AllowErrors bool
|
||||
compressionType int
|
||||
allowErrors bool //AllowErrors allows errors when adding folders and their children.
|
||||
}
|
||||
|
||||
//NewWriter creates a new squashfs.Writer with the default settings (gzip compression, autoresolving symlinks, and allowErrors)
|
||||
//NewWriter creates a new
|
||||
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) {
|
||||
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
|
||||
func NewWriterWithOptions(compressionType int, allowErrors bool) (*Writer, error) {
|
||||
|
||||
}
|
||||
|
||||
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)
|
||||
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 {
|
||||
//TODO
|
||||
return false
|
||||
//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 {
|
||||
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) {
|
||||
return 0, errors.New("I SAID DON'T")
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user