Rename squashfs/squashfs to squashfs/low

squashfs/low library name is now squashfslow
2023-12-27 23:25:49 -06:00
parent 17d45eea50
commit bfba5d5b60
21 changed files with 49 additions and 49 deletions
@@ -0,0 +1,65 @@
+package inode
+
+import (
+	"encoding/binary"
+	"io"
+)
+
+type Directory struct {
+	BlockStart uint32
+	LinkCount  uint32
+	Size       uint16
+	Offset     uint16
+	ParentNum  uint32
+}
+
+type eDirectoryInit struct {
+	LinkCount  uint32
+	Size       uint32
+	BlockStart uint32
+	ParentNum  uint32
+	IndCount   uint16
+	Offset     uint16
+	XattrInd   uint32
+}
+
+type EDirectory struct {
+	eDirectoryInit
+	Indexes []DirectoryIndex
+}
+
+type directoryIndexInit struct {
+	Ind      uint32
+	Start    uint32
+	NameSize uint32
+}
+
+type DirectoryIndex struct {
+	directoryIndexInit
+	Name []byte
+}
+
+func ReadDir(r io.Reader) (d Directory, err error) {
+	err = binary.Read(r, binary.LittleEndian, &d)
+	return
+}
+
+func ReadEDir(r io.Reader) (d EDirectory, err error) {
+	err = binary.Read(r, binary.LittleEndian, &d.eDirectoryInit)
+	if err != nil {
+		return
+	}
+	d.Indexes = make([]DirectoryIndex, d.IndCount)
+	for i := range d.Indexes {
+		err = binary.Read(r, binary.LittleEndian, &d.Indexes[i].directoryIndexInit)
+		if err != nil {
+			return
+		}
+		d.Indexes[i].Name = make([]byte, d.Indexes[i].NameSize+1)
+		err = binary.Read(r, binary.LittleEndian, &d.Indexes[i].Name)
+		if err != nil {
+			return
+		}
+	}
+	return
+}
@@ -0,0 +1,62 @@
+package inode
+
+import (
+	"encoding/binary"
+	"io"
+	"math"
+)
+
+type fileInit struct {
+	BlockStart uint32
+	FragInd    uint32
+	FragOffset uint32
+	Size       uint32
+}
+
+type File struct {
+	fileInit
+	BlockSizes []uint32
+}
+
+type eFileInit struct {
+	BlockStart uint64
+	Size       uint64
+	Sparse     uint64
+	LinkCount  uint32
+	FragInd    uint32
+	FragOffset uint32
+	XattrInd   uint32
+}
+
+type EFile struct {
+	eFileInit
+	BlockSizes []uint32
+}
+
+func ReadFile(r io.Reader, blockSize uint32) (f File, err error) {
+	err = binary.Read(r, binary.LittleEndian, &f.fileInit)
+	if err != nil {
+		return
+	}
+	toRead := int(math.Floor(float64(f.Size) / float64(blockSize)))
+	if f.FragInd == 0xFFFFFFFF && f.Size%blockSize > 0 {
+		toRead++
+	}
+	f.BlockSizes = make([]uint32, toRead)
+	err = binary.Read(r, binary.LittleEndian, &f.BlockSizes)
+	return
+}
+
+func ReadEFile(r io.Reader, blockSize uint32) (f EFile, err error) {
+	err = binary.Read(r, binary.LittleEndian, &f.eFileInit)
+	if err != nil {
+		return
+	}
+	toRead := int(math.Floor(float64(f.Size) / float64(blockSize)))
+	if f.FragInd == 0xFFFFFFFF && f.Size%uint64(blockSize) > 0 {
+		toRead++
+	}
+	f.BlockSizes = make([]uint32, toRead)
+	err = binary.Read(r, binary.LittleEndian, &f.BlockSizes)
+	return
+}
@@ -0,0 +1,144 @@
+package inode
+
+import (
+	"encoding/binary"
+	"errors"
+	"io"
+	"io/fs"
+	"strconv"
+)
+
+const (
+	Dir = uint16(iota + 1)
+	Fil
+	Sym
+	Block
+	Char
+	Fifo
+	Sock
+	EDir
+	EFil
+	ESym
+	EBlock
+	EChar
+	EFifo
+	ESock
+)
+
+type Header struct {
+	Type    uint16
+	Perm    uint16
+	UidInd  uint16
+	GidInd  uint16
+	ModTime uint32
+	Num     uint32
+}
+
+type Inode struct {
+	Header
+	Data any
+}
+
+func Read(r io.Reader, blockSize uint32) (i *Inode, err error) {
+	i = new(Inode)
+	err = binary.Read(r, binary.LittleEndian, &i.Header)
+	if err != nil {
+		return
+	}
+	switch i.Type {
+	case Dir:
+		i.Data, err = ReadDir(r)
+	case Fil:
+		i.Data, err = ReadFile(r, blockSize)
+	case Sym:
+		i.Data, err = ReadSym(r)
+	case Block:
+		fallthrough
+	case Char:
+		i.Data, err = ReadDevice(r)
+	case Fifo:
+		fallthrough
+	case Sock:
+		i.Data, err = ReadIPC(r)
+	case EDir:
+		i.Data, err = ReadEDir(r)
+	case EFil:
+		i.Data, err = ReadEFile(r, blockSize)
+	case ESym:
+		i.Data, err = ReadESym(r)
+	case EBlock:
+		fallthrough
+	case EChar:
+		i.Data, err = ReadEDevice(r)
+	case EFifo:
+		fallthrough
+	case ESock:
+		i.Data, err = ReadEIPC(r)
+	default:
+		return i, errors.New("invalid inode type " + strconv.Itoa(int(i.Type)))
+	}
+	return
+}
+
+func (i Inode) Mode() (out fs.FileMode) {
+	out = fs.FileMode(i.Perm)
+	switch i.Data.(type) {
+	case Directory:
+		out |= fs.ModeDir
+	case EDirectory:
+		out |= fs.ModeDir
+	case Symlink:
+		out |= fs.ModeSymlink
+	case ESymlink:
+		out |= fs.ModeSymlink
+	case Device:
+		out |= fs.ModeDevice
+	case EDevice:
+		out |= fs.ModeDevice
+	case IPC:
+		out |= fs.ModeNamedPipe
+	case EIPC:
+		out |= fs.ModeNamedPipe
+	}
+	return
+}
+
+func (i Inode) LinkCount() uint32 {
+	switch i.Data.(type) {
+	case EFile:
+		return i.Data.(EFile).LinkCount
+	case Directory:
+		return i.Data.(Directory).LinkCount
+	case EDirectory:
+		return i.Data.(EDirectory).LinkCount
+	case Device:
+		return i.Data.(Device).LinkCount
+	case EDevice:
+		return i.Data.(EDevice).LinkCount
+	case IPC:
+		return i.Data.(IPC).LinkCount
+	case EIPC:
+		return i.Data.(EIPC).LinkCount
+	case Symlink:
+		return i.Data.(Symlink).LinkCount
+	case ESymlink:
+		return i.Data.(ESymlink).LinkCount
+	default:
+		return 0
+	}
+}
+
+func (i Inode) Size() uint64 {
+	switch i.Data.(type) {
+	case File:
+		return uint64(i.Data.(File).Size)
+	case EFile:
+		return i.Data.(EFile).Size
+	// case Directory:
+	// 	return uint64(i.Data.(Directory).Size)
+	// case EDirectory:
+	// 	return uint64(i.Data.(EDirectory).Size)
+	default:
+		return 0
+	}
+}
@@ -0,0 +1,45 @@
+package inode
+
+import (
+	"encoding/binary"
+	"io"
+)
+
+type Device struct {
+	LinkCount uint32
+	Dev       uint32
+}
+
+type EDevice struct {
+	Device
+	XattrInd uint32
+}
+
+func ReadDevice(r io.Reader) (d Device, err error) {
+	err = binary.Read(r, binary.LittleEndian, &d)
+	return
+}
+
+func ReadEDevice(r io.Reader) (d EDevice, err error) {
+	err = binary.Read(r, binary.LittleEndian, &d)
+	return
+}
+
+type IPC struct {
+	LinkCount uint32
+}
+
+type EIPC struct {
+	IPC
+	XattrInd uint32
+}
+
+func ReadIPC(r io.Reader) (i IPC, err error) {
+	err = binary.Read(r, binary.LittleEndian, &i)
+	return
+}
+
+func ReadEIPC(r io.Reader) (i EIPC, err error) {
+	err = binary.Read(r, binary.LittleEndian, &i)
+	return
+}
@@ -0,0 +1,46 @@
+package inode
+
+import (
+	"encoding/binary"
+	"io"
+)
+
+type symlinkInit struct {
+	LinkCount  uint32
+	TargetSize uint32
+}
+
+type Symlink struct {
+	symlinkInit
+	Target []byte
+}
+
+type ESymlink struct {
+	symlinkInit
+	Target   []byte
+	XattrInd uint32
+}
+
+func ReadSym(r io.Reader) (s Symlink, err error) {
+	err = binary.Read(r, binary.LittleEndian, &s.symlinkInit)
+	if err != nil {
+		return
+	}
+	s.Target = make([]byte, s.TargetSize)
+	err = binary.Read(r, binary.LittleEndian, &s.Target)
+	return
+}
+
+func ReadESym(r io.Reader) (s ESymlink, err error) {
+	err = binary.Read(r, binary.LittleEndian, &s.symlinkInit)
+	if err != nil {
+		return
+	}
+	s.Target = make([]byte, s.TargetSize)
+	err = binary.Read(r, binary.LittleEndian, &s.Target)
+	if err != nil {
+		return
+	}
+	err = binary.Read(r, binary.LittleEndian, &s.XattrInd)
+	return
+}