Belac/squashfs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 55 Wiki Activity

Working on file reading (Not working right now)

Browse Source
This commit is contained in:
Caleb Gardner
2020-11-24 22:26:16 -06:00
parent 5761ad59cf
commit 4f058f2f31
5 changed files with 122 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files
datareader.go
+41 -3
View File
@@ -3,7 +3,15 @@ package squashfs
import (
"bytes"
"errors"
"fmt"
"io"
"github.com/CalebQ42/GoSquashfs/internal/inode"
)
var (
//ErrInodeNotFile is given when giving an inode, but the function requires a file inode.
ErrInodeNotFile = errors.New("Given inode is NOT a file type")
)
//DataReader reads data from data blocks.
@@ -24,8 +32,8 @@ type DataBlock struct {
uncompressedSize uint32
}
//NewDataBlockSize creates a new squashfs.datablock from a given size.
func NewDataBlockSize(raw uint32) (dbs DataBlock) {
//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 {
@@ -40,7 +48,7 @@ func (r *Reader) NewDataReader(offset int64, sizes []uint32) (*DataReader, error
dr.r = r
dr.offset = offset
for _, size := range sizes {
dr.blocks = append(dr.blocks, NewDataBlockSize(size))
dr.blocks = append(dr.blocks, NewDataBlock(size))
}
err := dr.readCurBlock()
if err != nil {
@@ -49,6 +57,32 @@ func (r *Reader) NewDataReader(offset int64, sizes []uint32) (*DataReader, error
return &dr, nil
}
//NewDataReaderFromInode creates a new DataReader from a given inode. Inode must be of BasicFile or ExtendedFile types
func (r *Reader) NewDataReaderFromInode(i *inode.Inode) (*DataReader, error) {
var rdr DataReader
switch i.Type {
case inode.BasicFileType:
fil := i.Info.(inode.BasicFile)
rdr.offset = int64(fil.Init.BlockStart)
for _, sizes := range fil.BlockSizes {
rdr.blocks = append(rdr.blocks, NewDataBlock(sizes))
}
case inode.ExtFileType:
fil := i.Info.(inode.ExtendedFile)
rdr.offset = int64(fil.Init.BlockStart)
for _, sizes := range fil.BlockSizes {
rdr.blocks = append(rdr.blocks, NewDataBlock(sizes))
}
default:
return nil, ErrInodeNotFile
}
err := rdr.readCurBlock()
if err != nil {
return nil, err
}
return &rdr, nil
}
func (d *DataReader) readNextBlock() error {
d.curBlock++
if d.curBlock >= len(d.blocks) {
@@ -94,10 +128,14 @@ func (d *DataReader) readCurBlock() error {
d.curData = buf.Bytes()
d.blocks[d.curBlock].begOffset = d.offset
d.offset += int64(d.blocks[d.curBlock].size)
fmt.Println("dat red")
fmt.Println(len(d.curData))
return err
}
func (d *DataReader) Read(p []byte) (int, error) {
fmt.Println("dat")
fmt.Println(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]
filereader.go
+71 -3
View File
@@ -1,17 +1,85 @@
package squashfs
import (
"bytes"
"errors"
"fmt"
"io"
"github.com/CalebQ42/GoSquashfs/internal/inode"
)
//FileReader provides a io.Reader interface for files within
type FileReader struct {
r *Reader
data *DataReader
fragmentData []byte
fragged bool
fragOnly bool
read int
FileSize int //FileSize is the total size of the given file
}
//TODO: Yes
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")
)
//ReadFile provides a squashfs.FileReader for the file at the given location.
func (r *Reader) ReadFile(location string) (*FileReader, error) {
var rdr FileReader
rdr.r = r
in, err := r.GetInodeFromPath(location)
if err != nil {
return nil, err
}
if in.Type != inode.BasicFileType && in.Type != inode.ExtFileType {
return nil, ErrPathIsNotFile
}
var offset uint32
var sizes []uint32
switch in.Type {
case inode.BasicFileType:
rdr.fragged = in.Info.(inode.BasicFile).Fragmented
rdr.fragOnly = in.Info.(inode.BasicFile).Init.BlockStart == 0
rdr.FileSize = int(in.Info.(inode.BasicFile).Init.Size)
offset = in.Info.(inode.BasicFile).Init.BlockStart
sizes = in.Info.(inode.BasicFile).BlockSizes
case inode.ExtFileType:
rdr.fragged = in.Info.(inode.ExtendedFile).Fragmented
rdr.fragOnly = in.Info.(inode.ExtendedFile).Init.BlockStart == 0
rdr.FileSize = int(in.Info.(inode.ExtendedFile).Init.Size)
offset = in.Info.(inode.ExtendedFile).Init.BlockStart
sizes = in.Info.(inode.ExtendedFile).BlockSizes
}
fmt.Println("HIIII")
if rdr.fragged {
rdr.fragmentData, err = r.GetFragmentDataFromInode(in)
if err != nil {
return nil, err
}
}
if rdr.fragged {
rdr.data, err = r.NewDataReader(int64(offset), sizes[:len(sizes)-1])
} else {
rdr.data, err = r.NewDataReader(int64(offset), sizes)
}
return &rdr, nil
}
func (f *FileReader) Read(p []byte) (int, error) {
fmt.Println("reading!")
var read int
n, err := f.data.Read(p)
read += n
if f.fragged && err == io.EOF {
n, err = bytes.NewBuffer(f.fragmentData).Read(p[read:])
read += n
if err != nil {
return read, err
}
} else if err != nil {
return read, err
}
return read, nil
}
fragment.go
+2 -8
View File
@@ -1,7 +1,6 @@
package squashfs
import (
"bytes"
"encoding/binary"
"errors"
"fmt"
@@ -35,7 +34,6 @@ func (r *Reader) GetFragmentDataFromInode(in *inode.Inode) ([]byte, error) {
}
fragIndex = bf.Init.FragmentIndex
fragOffset = bf.Init.FragmentOffset
fmt.Println(fragIndex, fragOffset, size)
} else if in.Type == inode.ExtFileType {
bf := in.Info.(inode.ExtendedFile)
if !bf.Fragmented {
@@ -51,6 +49,7 @@ func (r *Reader) GetFragmentDataFromInode(in *inode.Inode) ([]byte, error) {
} else {
return nil, errors.New("Inode type not supported")
}
fmt.Println(fragIndex, fragOffset, size)
fmt.Println("fragment index", fragIndex)
//reading the fragment entry first
fragEntryRdr, err := r.NewMetadataReader(int64(r.fragOffsets[int(fragIndex/512)]))
@@ -80,10 +79,5 @@ func (r *Reader) GetFragmentDataFromInode(in *inode.Inode) ([]byte, error) {
if err != nil {
return nil, err
}
dataRdr := bytes.NewBuffer(tmp)
dta, err := r.decompressor.Decompress(dataRdr)
if err != nil {
return nil, err
}
return dta, nil
return tmp, nil
}
squash_test.go
+7 -8
View File
@@ -1,6 +1,7 @@
package squashfs
import (
"fmt"
"io"
"net/http"
"os"
@@ -35,23 +36,21 @@ func TestMain(t *testing.T) {
if err != nil {
t.Fatal(err)
}
rdr.GetFileStructure()
extractionFil := ".DirIcon"
i, err := rdr.GetInodeFromPath(extractionFil)
if err != nil {
t.Fatal(err)
}
//testing code to print out the directory structure
// rdr.GetFileStructure()
extractionFil := "code-oss.desktop"
os.Remove(wd + "/testing/" + extractionFil)
desk, err := os.Create(wd + "/testing/" + extractionFil)
if err != nil {
t.Fatal(err)
}
btys, err := rdr.GetFragmentDataFromInode(i)
ext, err := rdr.ReadFile(extractionFil)
if err != nil {
t.Fatal(err)
}
_, err = desk.Write(btys)
n, err := io.Copy(desk, ext)
if err != nil {
fmt.Println("Read", n)
t.Fatal(err)
}
t.Fatal("No problems here!")
utils.go
+1 -1
View File
@@ -76,7 +76,7 @@ func (r *Reader) GetInodeFromEntry(en *directory.Entry) (*inode.Inode, error) {
}
//GetInodeFromPath returns the inode at the given path, relative to root.
//The given path can start or without "/".
//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, "/")