Caleb Gardner
619 lines
15 KiB
Go
619 lines
15 KiB
Go
package squashfs
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"log"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"syscall"
|
|
"time"
|
|
|
|
"golang.org/x/xerrors"
|
|
)
|
|
|
|
type Reader struct {
|
|
r io.ReaderAt
|
|
super superblock
|
|
}
|
|
|
|
func NewReader(r io.ReaderAt) (*Reader, error) {
|
|
var sb superblock
|
|
|
|
if err := binary.Read(io.NewSectionReader(r, 0, int64(binary.Size(sb))), binary.LittleEndian, &sb); err != nil {
|
|
return nil, fmt.Errorf("reading superblock: %v", err)
|
|
}
|
|
|
|
if got, want := sb.Magic, uint32(magic); got != want {
|
|
return nil, fmt.Errorf("invalid magic (not a SquashFS image?): got %x, want %x", got, want)
|
|
}
|
|
|
|
//log.Printf("superblock: %+v", sb)
|
|
return &Reader{
|
|
r: r,
|
|
super: sb,
|
|
}, nil
|
|
}
|
|
|
|
// TODO: maybe mmap instead of seeking?
|
|
|
|
func (r *Reader) inode(i Inode) (blockoffset int64, offset int64) {
|
|
return int64(i >> 16), int64(i & 0xFFFF)
|
|
}
|
|
|
|
type blockReader struct {
|
|
r io.ReadSeeker
|
|
lenBuf [2]byte
|
|
buf []byte
|
|
i int64
|
|
|
|
off int64 // TODO: remove this once using mmap
|
|
}
|
|
|
|
func (br *blockReader) Read(p []byte) (n int, err error) {
|
|
if br.i >= int64(len(br.buf)) {
|
|
br.i = 0
|
|
if _, err := io.ReadFull(br.r, br.lenBuf[:]); err != nil {
|
|
return 0, err
|
|
}
|
|
l := binary.LittleEndian.Uint16(br.lenBuf[:])
|
|
//uncompressed := l&0x8000 > 0
|
|
l &= 0x7FFF
|
|
//log.Printf("block of len %d, uncompressed: %v", l, uncompressed)
|
|
if int(l) > cap(br.buf) {
|
|
br.buf = make([]byte, int(l))
|
|
}
|
|
br.buf = br.buf[:l]
|
|
if _, err := io.ReadFull(br.r, br.buf); err != nil {
|
|
return 0, err
|
|
}
|
|
//log.Printf("(retry) n = %v, err = %v", n, err)
|
|
}
|
|
n = copy(p, br.buf[br.i:])
|
|
br.i += int64(n)
|
|
return n, err
|
|
}
|
|
|
|
func (br *blockReader) Close() error {
|
|
blockReaderPool.Put(br)
|
|
return nil
|
|
}
|
|
|
|
var blockReaderPool = sync.Pool{
|
|
New: func() interface{} {
|
|
return &blockReader{
|
|
buf: make([]byte, 0, metadataBlockSize),
|
|
}
|
|
},
|
|
}
|
|
|
|
func (r *Reader) blockReader(blockoffset, offset int64) (io.ReadCloser, error) {
|
|
//log.Printf("blockoffset %v (%x), offset %v (%x)", blockoffset, blockoffset, offset, offset)
|
|
br := blockReaderPool.Get().(*blockReader)
|
|
br.buf = br.buf[:0]
|
|
br.r = io.NewSectionReader(r.r, blockoffset, 5500*1024*1024) // TODO: correct limit? can we use IntMax
|
|
br.off = blockoffset
|
|
br.i = 0
|
|
//log.Printf("discarding %d bytes", offset)
|
|
for n := int64(0); n < offset; {
|
|
remaining := offset - n
|
|
if remaining > metadataBlockSize {
|
|
remaining = metadataBlockSize
|
|
}
|
|
nn, err := br.Read(br.buf[:remaining])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
n += int64(nn)
|
|
}
|
|
return br, nil
|
|
}
|
|
|
|
// TODO: define an inode type to use instead of interface{}?
|
|
func (r *Reader) readInode(i Inode) (interface{}, error) {
|
|
blockoffset, offset := r.inode(i)
|
|
br, err := r.blockReader(r.super.InodeTableStart+blockoffset, offset)
|
|
if err != nil {
|
|
fmt.Println("oops! ", err)
|
|
return nil, err
|
|
}
|
|
defer br.Close()
|
|
fmt.Println("Hello There")
|
|
|
|
// We need the inode type before we know which type to pass to binary.Read,
|
|
// so we need to read it twice:
|
|
var inodeType uint16
|
|
typeBuf := bytes.NewBuffer(make([]byte, 0, binary.Size(inodeType)))
|
|
if err := binary.Read(io.TeeReader(br, typeBuf), binary.LittleEndian, &inodeType); err != nil {
|
|
return nil, err
|
|
}
|
|
br = ioutil.NopCloser(io.MultiReader(typeBuf, br))
|
|
|
|
// var ih inodeHeader
|
|
// if err := binary.Read(br, binary.LittleEndian, &ih); err != nil {
|
|
// return err
|
|
// }
|
|
// //log.Printf("ih: %+v", ih)
|
|
|
|
//log.Printf("inode type: %v", inodeType)
|
|
switch inodeType {
|
|
case dirType:
|
|
var di dirInodeHeader
|
|
if err := binary.Read(br, binary.LittleEndian, &di); err != nil {
|
|
return nil, err
|
|
}
|
|
return di, nil
|
|
|
|
case fileType:
|
|
var ri regInodeHeader
|
|
if err := binary.Read(br, binary.LittleEndian, &ri); err != nil {
|
|
return nil, err
|
|
}
|
|
return ri, nil
|
|
|
|
case symlinkType:
|
|
var si symlinkInodeHeader
|
|
if err := binary.Read(br, binary.LittleEndian, &si); err != nil {
|
|
return nil, err
|
|
}
|
|
return si, nil
|
|
|
|
case ldirType:
|
|
var di ldirInodeHeader
|
|
if err := binary.Read(br, binary.LittleEndian, &di); err != nil {
|
|
return nil, err
|
|
}
|
|
return di, nil
|
|
|
|
case lregType:
|
|
var di lregInodeHeader
|
|
if err := binary.Read(br, binary.LittleEndian, &di); err != nil {
|
|
return nil, err
|
|
}
|
|
return di, nil
|
|
|
|
// TODO:
|
|
// blkdevType
|
|
// chrdevType
|
|
// fifoType
|
|
// socketType
|
|
// // The larger types are used for e.g. sparse files, xattrs, etc.
|
|
// ldirType
|
|
// lsymlinkType
|
|
// lblkdevType
|
|
// lchrdevType
|
|
// lfifoType
|
|
// lsocketType
|
|
|
|
}
|
|
return nil, fmt.Errorf("unknown inode type %d", inodeType)
|
|
}
|
|
|
|
func (r *Reader) RootInode() Inode {
|
|
return r.super.RootInode
|
|
}
|
|
|
|
func (r *Reader) Stat(name string, i Inode) (os.FileInfo, error) {
|
|
inode, err := r.readInode(i)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
//log.Printf("i %d, inode: %T, %+v", i, inode, inode)
|
|
switch x := inode.(type) {
|
|
case dirInodeHeader:
|
|
return &FileInfo{
|
|
name: name,
|
|
size: int64(x.FileSize),
|
|
mode: os.ModeDir | os.FileMode(x.Mode),
|
|
modTime: time.Unix(int64(x.Mtime), 0),
|
|
Inode: i,
|
|
}, nil
|
|
|
|
case ldirInodeHeader:
|
|
return &FileInfo{
|
|
name: name,
|
|
size: int64(x.FileSize),
|
|
mode: os.ModeDir | os.FileMode(x.Mode),
|
|
modTime: time.Unix(int64(x.Mtime), 0),
|
|
Inode: i,
|
|
}, nil
|
|
|
|
case regInodeHeader:
|
|
mode := os.FileMode(x.Mode & 0777)
|
|
if x.Mode&syscall.S_ISUID != 0 {
|
|
mode |= os.ModeSetuid
|
|
}
|
|
return &FileInfo{
|
|
name: name,
|
|
size: int64(x.FileSize),
|
|
mode: mode,
|
|
modTime: time.Unix(int64(x.Mtime), 0),
|
|
Inode: i,
|
|
}, nil
|
|
|
|
case lregInodeHeader:
|
|
mode := os.FileMode(x.Mode & 0777)
|
|
if x.Mode&syscall.S_ISUID != 0 {
|
|
mode |= os.ModeSetuid
|
|
}
|
|
return &FileInfo{
|
|
name: name,
|
|
size: int64(x.FileSize),
|
|
mode: mode,
|
|
modTime: time.Unix(int64(x.Mtime), 0),
|
|
Inode: i,
|
|
}, nil
|
|
|
|
case symlinkInodeHeader:
|
|
return &FileInfo{
|
|
name: name,
|
|
size: int64(x.SymlinkSize),
|
|
mode: os.ModeSymlink | os.FileMode(x.Mode),
|
|
modTime: time.Unix(int64(x.Mtime), 0),
|
|
Inode: i,
|
|
}, nil
|
|
}
|
|
|
|
return nil, fmt.Errorf("unknown inode type %T", inode)
|
|
}
|
|
|
|
func (r *Reader) ReadLink(i Inode) (string, error) {
|
|
// TODO: reduce code duplication with readInode
|
|
blockoffset, offset := r.inode(i)
|
|
br, err := r.blockReader(r.super.InodeTableStart+blockoffset, offset)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer br.Close()
|
|
|
|
// We need the inode type before we know which type to pass to binary.Read,
|
|
// so we need to read it twice:
|
|
var inodeType uint16
|
|
typeBuf := bytes.NewBuffer(make([]byte, 0, binary.Size(inodeType)))
|
|
if err := binary.Read(io.TeeReader(br, typeBuf), binary.LittleEndian, &inodeType); err != nil {
|
|
return "", err
|
|
}
|
|
br = ioutil.NopCloser(io.MultiReader(typeBuf, br))
|
|
|
|
if inodeType != symlinkType {
|
|
return "", fmt.Errorf("invalid inode type: got %d instead of symlink", inodeType)
|
|
}
|
|
var si symlinkInodeHeader
|
|
if err := binary.Read(br, binary.LittleEndian, &si); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// Assumption: r.r is positioned right after the inode
|
|
buf := make([]byte, si.SymlinkSize)
|
|
if _, err := io.ReadFull(br, buf); err != nil {
|
|
return "", err
|
|
}
|
|
return string(buf), nil
|
|
}
|
|
|
|
func (r *Reader) FileReader(inode Inode) (*io.SectionReader, error) {
|
|
//log.Printf("Readfile(%v)", inode)
|
|
i, err := r.readInode(inode)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
//log.Printf("i: %+v", i)
|
|
// TODO(compression): read the blocksizes to read compressed blocks
|
|
switch ri := i.(type) {
|
|
case regInodeHeader:
|
|
off := int64(ri.StartBlock) + int64(ri.Offset)
|
|
return io.NewSectionReader(r.r, off, int64(ri.FileSize)), nil
|
|
case lregInodeHeader:
|
|
off := int64(ri.StartBlock) + int64(ri.Offset)
|
|
return io.NewSectionReader(r.r, off, int64(ri.FileSize)), nil
|
|
default:
|
|
return nil, fmt.Errorf("BUG: non-file inode type")
|
|
}
|
|
}
|
|
|
|
type FileNotFoundError struct {
|
|
path string
|
|
}
|
|
|
|
func (e *FileNotFoundError) Error() string {
|
|
return fmt.Sprintf("%q not found", e.path)
|
|
}
|
|
|
|
func (r *Reader) lookupComponent(parent Inode, component string) (Inode, error) {
|
|
rfis, err := r.readdir(parent, false)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
for _, rfi := range rfis {
|
|
if rfi.Name() == component {
|
|
return rfi.Sys().(*FileInfo).Inode, nil
|
|
}
|
|
}
|
|
return 0, &FileNotFoundError{path: component}
|
|
}
|
|
|
|
func (r *Reader) lookupPath(path string, followSymlink bool) (Inode, error) {
|
|
inode := r.RootInode()
|
|
parts := strings.Split(path, "/")
|
|
for idx, part := range parts {
|
|
var err error
|
|
inode, err = r.lookupComponent(inode, part)
|
|
if err != nil {
|
|
if _, ok := err.(*FileNotFoundError); ok {
|
|
return 0, &FileNotFoundError{path: path}
|
|
}
|
|
return 0, err
|
|
}
|
|
if !followSymlink {
|
|
continue
|
|
}
|
|
i, err := r.readInode(inode)
|
|
if err != nil {
|
|
return 0, xerrors.Errorf("Stat(%d): %v", inode, err)
|
|
}
|
|
if _, ok := i.(symlinkInodeHeader); ok {
|
|
target, err := r.ReadLink(inode)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
//log.Printf("component %q (full: %q) resolved to %q", part, parts[:idx+1], target)
|
|
target = filepath.Clean(filepath.Join(append(parts[:idx] /* parent */, target)...))
|
|
//log.Printf("-> %s", target)
|
|
i, err := r.LookupPath(target)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
inode = i
|
|
}
|
|
}
|
|
return inode, nil
|
|
}
|
|
|
|
func (r *Reader) LookupPath(path string) (Inode, error) {
|
|
return r.lookupPath(path, true)
|
|
}
|
|
|
|
// LlookupPath is like LookupPath, but does not follow symbolic links, i.e. will
|
|
// instead return the inode of the link itself.
|
|
func (r *Reader) LlookupPath(path string) (Inode, error) {
|
|
return r.lookupPath(path, false)
|
|
}
|
|
|
|
func (r *Reader) Readdir(dirInode Inode) ([]os.FileInfo, error) {
|
|
return r.readdir(dirInode, true)
|
|
}
|
|
|
|
// Like Readdir, but does not call Stat on each file. The returned FileInfo
|
|
// structs will still have a filled in Name, partly filled in Mode, and filled
|
|
// in Inode.
|
|
func (r *Reader) ReaddirNoStat(dirInode Inode) ([]os.FileInfo, error) {
|
|
return r.readdir(dirInode, false)
|
|
}
|
|
|
|
var nameBufPool = sync.Pool{
|
|
New: func() interface{} {
|
|
return &bytes.Buffer{}
|
|
},
|
|
}
|
|
|
|
func (r *Reader) readdir(dirInode Inode, stat bool) ([]os.FileInfo, error) {
|
|
//log.Printf("Readdir(%v (%x))", dirInode, dirInode)
|
|
i, err := r.readInode(dirInode)
|
|
fmt.Println("Yodle")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var (
|
|
startBlock int64
|
|
fileSize int64
|
|
offset int64
|
|
)
|
|
switch x := i.(type) {
|
|
case dirInodeHeader:
|
|
startBlock = int64(x.StartBlock)
|
|
fileSize = int64(x.FileSize)
|
|
offset = int64(x.Offset)
|
|
|
|
case ldirInodeHeader:
|
|
startBlock = int64(x.StartBlock)
|
|
fileSize = int64(x.FileSize)
|
|
offset = int64(x.Offset)
|
|
|
|
default:
|
|
return nil, fmt.Errorf("unknown directory inode type %T", i)
|
|
}
|
|
|
|
br, err := r.blockReader(r.super.DirectoryTableStart+startBlock, offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer br.Close()
|
|
|
|
// See also https://elixir.bootlin.com/linux/v4.18.9/source/fs/squashfs/dir.c#L63
|
|
limit := fileSize - int64(len(".")) - int64(len(".."))
|
|
br = ioutil.NopCloser(io.LimitReader(br, limit))
|
|
|
|
var fis []os.FileInfo
|
|
var dh dirHeader
|
|
var de dirEntry
|
|
var dhBuf [12]byte
|
|
var deBuf [8]byte
|
|
nameBuf := nameBufPool.Get().(*bytes.Buffer)
|
|
defer nameBufPool.Put(nameBuf)
|
|
for {
|
|
if _, err := io.ReadFull(br, dhBuf[:]); err != nil {
|
|
if err == io.EOF {
|
|
return fis, nil
|
|
}
|
|
return nil, err
|
|
}
|
|
dh.Unmarshal(dhBuf[:])
|
|
dh.Count++ // SquashFS stores count-1
|
|
//log.Printf("dh: %+v", dh)
|
|
|
|
for i := 0; i < int(dh.Count); i++ {
|
|
if _, err := io.ReadFull(br, deBuf[:]); err != nil {
|
|
return nil, err
|
|
}
|
|
de.Unmarshal(deBuf[:])
|
|
de.Size++ // SquashFS stores size-1
|
|
//log.Printf("de: %+v", de)
|
|
nameBuf.Reset()
|
|
nameBuf.Grow(int(de.Size))
|
|
nb := nameBuf.Bytes()[:de.Size]
|
|
if _, err := io.ReadFull(br, nb); err != nil {
|
|
return nil, err
|
|
}
|
|
name := string(nb)
|
|
//log.Printf("name: %q", string(name))
|
|
|
|
var fi os.FileInfo
|
|
if stat {
|
|
var err error
|
|
fi, err = r.Stat(name, Inode(int64(dh.StartBlock)<<16|int64(de.Offset)))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
ffi := &FileInfo{
|
|
name: name,
|
|
Inode: Inode(int64(dh.StartBlock)<<16 | int64(de.Offset)),
|
|
}
|
|
switch de.EntryType {
|
|
case dirType, ldirType:
|
|
ffi.mode |= os.ModeDir
|
|
case symlinkType, lsymlinkType:
|
|
ffi.mode |= os.ModeSymlink
|
|
}
|
|
fi = ffi
|
|
}
|
|
fis = append(fis, fi)
|
|
}
|
|
}
|
|
|
|
return fis, nil
|
|
}
|
|
|
|
type FileInfo struct {
|
|
name string
|
|
size int64
|
|
mode os.FileMode
|
|
modTime time.Time
|
|
Inode Inode
|
|
}
|
|
|
|
func (fi *FileInfo) Name() string { return fi.name }
|
|
func (fi *FileInfo) Size() int64 { return fi.size }
|
|
func (fi *FileInfo) Mode() os.FileMode { return fi.mode }
|
|
func (fi *FileInfo) IsDir() bool { return fi.mode.IsDir() }
|
|
func (fi *FileInfo) ModTime() time.Time { return fi.modTime }
|
|
func (fi *FileInfo) Sys() interface{} { return fi }
|
|
|
|
func (r *Reader) readXattr(tableHeader xattrTableHeader, id xattrId) (*Xattr, error) {
|
|
blockoffset, offset := r.inode(Inode(id.Xattr))
|
|
br, err := r.blockReader(int64(tableHeader.XattrTableStart)+blockoffset, offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer br.Close()
|
|
var typ, nameSize uint16
|
|
if err := binary.Read(br, binary.LittleEndian, &typ); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := binary.Read(br, binary.LittleEndian, &nameSize); err != nil {
|
|
return nil, err
|
|
}
|
|
log.Printf("type = %v, nameSize = %v", typ, nameSize)
|
|
name := make([]byte, nameSize)
|
|
if _, err := io.ReadFull(br, name); err != nil {
|
|
return nil, err
|
|
}
|
|
log.Printf("name = %v", string(name))
|
|
var valSize uint32
|
|
if err := binary.Read(br, binary.LittleEndian, &valSize); err != nil {
|
|
return nil, err
|
|
}
|
|
val := make([]byte, valSize)
|
|
if _, err := io.ReadFull(br, val); err != nil {
|
|
return nil, err
|
|
}
|
|
log.Printf("val = %x", val)
|
|
return &Xattr{
|
|
Type: typ,
|
|
FullName: xattrPrefix[int(typ)] + string(name),
|
|
Value: val,
|
|
}, nil
|
|
}
|
|
|
|
func (r *Reader) ReadXattrs(inode Inode) ([]Xattr, error) {
|
|
//log.Printf("Readdir(%v (%x))", dirInode, dirInode)
|
|
i, err := r.readInode(inode)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var xid uint32
|
|
switch x := i.(type) {
|
|
case regInodeHeader,
|
|
dirInodeHeader,
|
|
ldirInodeHeader,
|
|
symlinkInodeHeader:
|
|
return nil, nil // no extended attributes
|
|
|
|
case lregInodeHeader:
|
|
if x.Xattr == invalidXattr {
|
|
return nil, nil // file has no extended attributes
|
|
}
|
|
xid = x.Xattr
|
|
|
|
default:
|
|
return nil, fmt.Errorf("unknown inode type %T", i)
|
|
}
|
|
|
|
const idEntriesPerBlock = 512 // = 8192 / 16 /* sizeof(xattrId) */
|
|
block := xid / idEntriesPerBlock
|
|
offset := (xid % idEntriesPerBlock) * 16
|
|
log.Printf("xattr id %d, block %d, offset %d", xid, block, offset)
|
|
log.Printf("r.super.XattrIdTableStart = 0x%x, r.super.XattrIdTableStart = %v", r.super.XattrIdTableStart, r.super.XattrIdTableStart)
|
|
br := ioutil.NopCloser(io.NewSectionReader(r.r, r.super.XattrIdTableStart, int64(16 /* sizeof(xattrTableHeader) */ +(block+1)*4 /* sizeof(uint32) */)))
|
|
var tableHeader xattrTableHeader
|
|
if err := binary.Read(br, binary.LittleEndian, &tableHeader); err != nil {
|
|
return nil, err
|
|
}
|
|
// index starts here
|
|
if _, err := io.CopyN(ioutil.Discard, br, int64(block*4 /* sizeof(uint32) */)); err != nil {
|
|
return nil, err
|
|
}
|
|
var blockOffset uint32
|
|
if err := binary.Read(br, binary.LittleEndian, &blockOffset); err != nil {
|
|
return nil, err
|
|
}
|
|
log.Printf("blockOffset = 0x%x (%d)", blockOffset, blockOffset)
|
|
br, err = r.blockReader(int64(blockOffset), int64(offset))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer br.Close()
|
|
var id xattrId
|
|
if err := binary.Read(br, binary.LittleEndian, &id); err != nil {
|
|
return nil, err
|
|
}
|
|
log.Printf("id: %+v", id)
|
|
log.Printf("tableHeader: %+v (start 0x%x)", tableHeader, tableHeader.XattrTableStart)
|
|
|
|
var xattrs []Xattr
|
|
for i := 0; i < int(id.Count); i++ {
|
|
xattr, err := r.readXattr(tableHeader, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
xattrs = append(xattrs, *xattr)
|
|
}
|
|
|
|
return xattrs, nil
|
|
}
|