Updated deps

fix: use correct ENODATA value on different platforms

fuse2.go

@@ -0,0 +1,150 @@
+package squashfs
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"io"
+
+	"github.com/CalebQ42/squashfs/internal/inode"
+	"github.com/seaweedfs/fuse"
+	"github.com/seaweedfs/fuse/fs"
+)
+
+// Mounts the archive to the given mountpoint using fuse2. Non-blocking.
+// If Unmount does not get called, the mount point must be unmounted using umount before the directory can be used again.
+func (r *Reader) MountFuse2(mountpoint string) (err error) {
+	if r.con != nil {
+		return errors.New("squashfs archive already mounted")
+	}
+	r.con2, err = fuse.Mount(mountpoint, fuse.ReadOnly())
+	if err != nil {
+		return
+	}
+	<-r.con2.Ready
+	r.mount2Done = make(chan struct{})
+	go func() {
+		fs.Serve(r.con2, squashFuse2{r: r})
+		close(r.mount2Done)
+	}()
+	return
+}
+
+// Blocks until the mount ends.
+// Fuse2 version.
+func (r *Reader) MountWaitFuse2() {
+	if r.mount2Done != nil {
+		<-r.mount2Done
+	}
+}
+
+// Unmounts the archive.
+// Fuse2 version.
+func (r *Reader) UnmountFuse2() error {
+	if r.con != nil {
+		defer func() { r.con = nil }()
+		return r.con.Close()
+	}
+	return errors.New("squashfs archive is not mounted")
+}
+
+type squashFuse2 struct {
+	r *Reader
+}
+
+func (s squashFuse2) Root() (fs.Node, error) {
+	return fileNode2{File: s.r.FS.File}, nil
+}
+
+type fileNode2 struct {
+	*File
+}
+
+func (f fileNode2) Attr(ctx context.Context, attr *fuse.Attr) error {
+	attr.Blocks = f.r.s.Size / 512
+	if f.r.s.Size%512 > 0 {
+		attr.Blocks++
+	}
+	attr.Gid = f.r.ids[f.i.GidInd]
+	attr.Inode = uint64(f.i.Num)
+	attr.Mode = f.i.Mode()
+	attr.Nlink = f.i.LinkCount()
+	attr.Size = f.i.Size()
+	attr.Uid = f.r.ids[f.i.UidInd]
+	return nil
+}
+
+func (f fileNode2) Id() uint64 {
+	return uint64(f.i.Num)
+}
+
+func (f fileNode2) Readlink(ctx context.Context, req *fuse.ReadlinkRequest) (string, error) {
+	return f.SymlinkPath(), nil
+}
+
+func (f fileNode2) Lookup(ctx context.Context, name string) (fs.Node, error) {
+	asFS, err := f.FS()
+	if err != nil {
+		return nil, fuse.ENOTDIR
+	}
+	ret, err := asFS.OpenFile(name)
+	if err != nil {
+		return nil, fuse.ENOENT
+	}
+	return fileNode2{File: ret}, nil
+}
+
+func (f fileNode2) ReadAll(ctx context.Context) ([]byte, error) {
+	if f.IsRegular() {
+		var buf bytes.Buffer
+		_, err := f.WriteTo(&buf)
+		return buf.Bytes(), err
+	}
+	return nil, ENODATA
+}
+
+func (f fileNode2) Read(ctx context.Context, req *fuse.ReadRequest, resp *fuse.ReadResponse) error {
+	if f.IsRegular() {
+		buf := make([]byte, req.Size)
+		n, err := f.File.ReadAt(buf, req.Offset)
+		if err == io.EOF {
+			resp.Data = buf[:n]
+		}
+		return nil
+	}
+	return ENODATA
+}
+
+func (f fileNode2) ReadDirAll(ctx context.Context) (out []fuse.Dirent, err error) {
+	asFS, err := f.FS()
+	if err != nil {
+		return nil, fuse.ENOTDIR
+	}
+	var t fuse.DirentType
+	for i := range asFS.e {
+		switch asFS.e[i].Type {
+		case inode.Fil:
+			t = fuse.DT_File
+		case inode.Dir:
+			t = fuse.DT_Dir
+		case inode.Block:
+			t = fuse.DT_Block
+		case inode.Sym:
+			t = fuse.DT_Link
+		case inode.Char:
+			t = fuse.DT_Char
+		case inode.Fifo:
+			t = fuse.DT_FIFO
+		case inode.Sock:
+			t = fuse.DT_Socket
+		default:
+			t = fuse.DT_Unknown
+		}
+		out = append(out, fuse.Dirent{
+			Inode: uint64(asFS.e[i].Num),
+			Type:  t,
+			Name:  asFS.e[i].Name,
+		})
+	}
+	return
+}

fuse3.go

@@ -24,7 +24,7 @@ func (r *Reader) Mount(mountpoint string) (err error) {
 	<-r.con.Ready
 	r.mountDone = make(chan struct{})
 	go func() {
-		fs.Serve(r.con, &squashFuse{r: r})
+		fs.Serve(r.con, squashFuse{r: r})
 		close(r.mountDone)
 	}()
 	return
@@ -50,15 +50,15 @@ type squashFuse struct {
 	r *Reader
 }
 
-func (s *squashFuse) Root() (fs.Node, error) {
+func (s squashFuse) Root() (fs.Node, error) {
-	return &fileNode{File: s.r.FS.File}, nil
+	return fileNode{File: s.r.FS.File}, nil
 }
 
 type fileNode struct {
 	*File
 }
 
-func (f *fileNode) Attr(ctx context.Context, attr *fuse.Attr) error {
+func (f fileNode) Attr(ctx context.Context, attr *fuse.Attr) error {
 	attr.Blocks = f.r.s.Size / 512
 	if f.r.s.Size%512 > 0 {
 		attr.Blocks++
@@ -72,15 +72,15 @@ func (f *fileNode) Attr(ctx context.Context, attr *fuse.Attr) error {
 	return nil
 }
 
-func (f *fileNode) Id() uint64 {
+func (f fileNode) Id() uint64 {
 	return uint64(f.i.Num)
 }
 
-func (f *fileNode) Readlink(ctx context.Context, req *fuse.ReadlinkRequest) (string, error) {
+func (f fileNode) Readlink(ctx context.Context, req *fuse.ReadlinkRequest) (string, error) {
 	return f.SymlinkPath(), nil
 }
 
-func (f *fileNode) Lookup(ctx context.Context, name string) (fs.Node, error) {
+func (f fileNode) Lookup(ctx context.Context, name string) (fs.Node, error) {
 	asFS, err := f.FS()
 	if err != nil {
 		return nil, fuse.ENOTDIR
@@ -89,19 +89,19 @@ func (f *fileNode) Lookup(ctx context.Context, name string) (fs.Node, error) {
 	if err != nil {
 		return nil, fuse.ENOENT
 	}
-	return &fileNode{File: ret}, nil
+	return fileNode{File: ret}, nil
 }
 
-func (f *fileNode) ReadAll(ctx context.Context) ([]byte, error) {
+func (f fileNode) ReadAll(ctx context.Context) ([]byte, error) {
 	if f.IsRegular() {
 		var buf bytes.Buffer
 		_, err := f.WriteTo(&buf)
 		return buf.Bytes(), err
 	}
-	return nil, fuse.ENODATA
+	return nil, ENODATA
 }
 
-func (f *fileNode) Read(ctx context.Context, req *fuse.ReadRequest, resp *fuse.ReadResponse) error {
+func (f fileNode) Read(ctx context.Context, req *fuse.ReadRequest, resp *fuse.ReadResponse) error {
 	if f.IsRegular() {
 		buf := make([]byte, req.Size)
 		n, err := f.File.ReadAt(buf, req.Offset)
@@ -110,10 +110,10 @@ func (f *fileNode) Read(ctx context.Context, req *fuse.ReadRequest, resp *fuse.R
 		}
 		return nil
 	}
-	return fuse.ENODATA
+	return ENODATA
 }
 
-func (f *fileNode) ReadDirAll(ctx context.Context) (out []fuse.Dirent, err error) {
+func (f fileNode) ReadDirAll(ctx context.Context) (out []fuse.Dirent, err error) {
 	asFS, err := f.FS()
 	if err != nil {
 		return nil, fuse.ENOTDIR

fuse_darwin.go

@@ -0,0 +1,7 @@
+package squashfs
+
+import (
+	"golang.org/x/sys/unix"
+)
+
+var ENODATA = unix.Errno(unix.ENODATA)

fuse_linux.go

@@ -0,0 +1,5 @@
+package squashfs
+
+import "github.com/CalebQ42/fuse"
+
+var ENODATA = fuse.ENODATA

fuse_windows.go

@@ -0,0 +1,3 @@
+package squashfs
+
+var ENODATA = windows.Errno(windows.ENODATA)

go.mod

@@ -1,14 +1,14 @@
 module github.com/CalebQ42/squashfs
 
-go 1.19
+go 1.20
 
 require (
 	github.com/CalebQ42/fuse v0.1.0
-	github.com/klauspost/compress v1.15.12
+	github.com/klauspost/compress v1.16.4
 	github.com/pierrec/lz4/v4 v4.1.17
 	github.com/rasky/go-lzo v0.0.0-20200203143853-96a758eda86e
+	github.com/seaweedfs/fuse v1.2.2
 	github.com/therootcompany/xz v1.0.1
-	github.com/ulikunitz/xz v0.5.10
+	github.com/ulikunitz/xz v0.5.11
+	golang.org/x/sys v0.7.0
 )
-
-require golang.org/x/sys v0.2.0 // indirect

go.sum

@@ -1,14 +1,20 @@
 github.com/CalebQ42/fuse v0.1.0 h1:KLCNjun7zcd2kBNVFfH+SWJyhuwJdE0nhw5/q8K8HGQ=
 github.com/CalebQ42/fuse v0.1.0/go.mod h1:pJpoKG03HJKVhsp8o0YQYqmfbFsr3Eowt90yQGQVO+4=
-github.com/klauspost/compress v1.15.12 h1:YClS/PImqYbn+UILDnqxQCZ3RehC9N318SU3kElDUEM=
+github.com/klauspost/compress v1.16.3 h1:XuJt9zzcnaz6a16/OU53ZjWp/v7/42WcR5t2a0PcNQY=
-github.com/klauspost/compress v1.15.12/go.mod h1:QPwzmACJjUTFsnSHH934V6woptycfrDDJnH7hvFVbGM=
+github.com/klauspost/compress v1.16.3/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
+github.com/klauspost/compress v1.16.4 h1:91KN02FnsOYhuunwU4ssRe8lc2JosWmizWa91B5v1PU=
+github.com/klauspost/compress v1.16.4/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
 github.com/pierrec/lz4/v4 v4.1.17 h1:kV4Ip+/hUBC+8T6+2EgburRtkE9ef4nbY3f4dFhGjMc=
 github.com/pierrec/lz4/v4 v4.1.17/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/rasky/go-lzo v0.0.0-20200203143853-96a758eda86e h1:dCWirM5F3wMY+cmRda/B1BiPsFtmzXqV9b0hLWtVBMs=
 github.com/rasky/go-lzo v0.0.0-20200203143853-96a758eda86e/go.mod h1:9leZcVcItj6m9/CfHY5Em/iBrCz7js8LcRQGTKEEv2M=
+github.com/seaweedfs/fuse v1.2.2 h1:01l8OjIdyATRNqVc/gDPgFobuC8ubQF3hRKOPColROw=
+github.com/seaweedfs/fuse v1.2.2/go.mod h1:iwbDQv5BZACY54r6AO/6xsLNuMaYcBKSkLTZVfmK594=
 github.com/therootcompany/xz v1.0.1 h1:CmOtsn1CbtmyYiusbfmhmkpAAETj0wBIH6kCYaX+xzw=
 github.com/therootcompany/xz v1.0.1/go.mod h1:3K3UH1yCKgBneZYhuQUvJ9HPD19UEXEI0BWbMn8qNMY=
-github.com/ulikunitz/xz v0.5.10 h1:t92gobL9l3HE202wg3rlk19F6X+JOxl9BBrCCMYEYd8=
+github.com/ulikunitz/xz v0.5.11 h1:kpFauv27b6ynzBNT/Xy+1k+fK4WswhN/6PN5WhFAGw8=
-github.com/ulikunitz/xz v0.5.10/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
+github.com/ulikunitz/xz v0.5.11/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
-golang.org/x/sys v0.2.0 h1:ljd4t30dBnAvMZaQCevtY0xLLD0A+bRZXbgLMLU1F/A=
+golang.org/x/sys v0.6.0 h1:MVltZSvRTcU2ljQOhs94SXPftV6DCNnZViHeQps87pQ=
-golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
+golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

internal/data/fullreader.go

@@ -2,7 +2,6 @@ package data
 
 import (
 	"io"
-	"sync"
 
 	"github.com/CalebQ42/squashfs/internal/decompress"
 	"github.com/CalebQ42/squashfs/internal/toreader"
@@ -27,9 +26,9 @@ func NewFullReader(r io.ReaderAt, start uint64, d decompress.Decompressor, block
 	}
 }
 
-func (r *FullReader) AddFragment(rdr func() (io.Reader, error), size uint32) {
+func (r *FullReader) AddFragment(rdr func() (io.Reader, error)) {
 	r.fragRdr = rdr
-	r.sizes = append(r.sizes, size)
+	r.sizes = append(r.sizes, 0)
 }
 
 type outDat struct {
@@ -38,50 +37,49 @@ type outDat struct {
 	i    int
 }
 
-func (r FullReader) process(index int, offset int64, od *outDat, out chan *outDat) {
+func (r FullReader) process(index int, offset int64, out chan outDat) {
-	defer func() {
+	var err error
-		out <- od
+	var dat []byte
-	}()
+	var rdr io.ReadCloser
-	od.i = index
 	size := realSize(r.sizes[index])
 	if size == 0 {
-		od.err = nil
+		out <- outDat{
-		od.data = make([]byte, r.blockSize)
+			i:    index,
+			err:  nil,
+			data: make([]byte, r.blockSize),
+		}
 		return
 	}
+	// rdr := io.LimitReader(toreader.NewReader(r.r, offset), int64(size))
 	if size == r.sizes[index] {
 		if dec, ok := r.d.(decompress.Decoder); ok {
-			dat := make([]byte, size)
+			dat = make([]byte, size)
-			_, od.err = r.r.ReadAt(dat, offset)
+			_, err = r.r.ReadAt(dat, offset)
-			if od.err != nil {
+			if err == nil {
-				return
+				dat, err = dec.Decode(dat)
 			}
-			od.data, od.err = dec.Decode(dat, int(r.blockSize))
-			return
-		}
-		var rdr io.ReadCloser
-		rdr, od.err = r.d.Reader(io.LimitReader(toreader.NewReader(r.r, offset), int64(size)))
-		if od.err != nil {
-			return
-		}
-		od.data = make([]byte, r.blockSize)
-		var read int
-		read, od.err = rdr.Read(od.data)
-		od.data = od.data[:read]
-		rdr.Close()
 		} else {
-		od.data = make([]byte, size)
+			rdr, err = r.d.Reader(io.LimitReader(toreader.NewReader(r.r, offset), int64(size)))
-		_, od.err = r.r.ReadAt(od.data, offset)
+			if err == nil {
+				dat, err = io.ReadAll(rdr)
+			}
+		}
+	} else {
+		dat = make([]byte, size)
+		_, err = r.r.ReadAt(dat, offset)
+	}
+	out <- outDat{
+		i:    index,
+		err:  err,
+		data: dat,
+	}
+	if clr, ok := rdr.(io.Closer); ok {
+		clr.Close()
 	}
 }
 
 func (r FullReader) ReadAt(p []byte, off int64) (n int, err error) {
-	pol := &sync.Pool{
+	out := make(chan outDat, len(r.sizes))
-		New: func() any {
-			return new(outDat)
-		},
-	}
-	out := make(chan *outDat, len(r.sizes))
 	offset := r.start
 	num := len(r.sizes)
 	start := off / int64(r.blockSize)
@@ -101,42 +99,40 @@ func (r FullReader) ReadAt(p []byte, off int64) (n int, err error) {
 			offset += uint64(realSize(r.sizes[i]))
 			continue
 		}
-		od := pol.Get().(*outDat)
 		if i == num-1 && r.fragRdr != nil {
 			go func() {
-				defer func() {
-					out <- od
-				}()
 				rdr, e := r.fragRdr()
 				if err != nil {
-					od.i = num - 1
+					out <- outDat{
-					od.err = e
+						i:   num - 1,
+						err: e,
+					}
 					return
 				}
-				od.data = make([]byte, r.sizes[num-1])
+				dat, e := io.ReadAll(rdr)
-				_, e = rdr.Read(od.data)
+				out <- outDat{
-				od.i = num - 1
+					i:    num - 1,
-				od.err = e
+					err:  e,
+					data: dat,
+				}
 				if clr, ok := rdr.(io.Closer); ok {
 					clr.Close()
 				}
 			}()
 			continue
 		}
-		go r.process(i, int64(offset), od, out)
+		go r.process(i, int64(offset), out)
 		offset += uint64(realSize(r.sizes[i]))
 	}
-	cur := start
 	cache := make(map[int]outDat)
-	for dat := range out {
+	for cur := start; cur < int64(end); {
+		dat := <-out
 		if dat.err != nil {
 			err = dat.err
-			pol.Put(dat)
 			return
 		}
 		if dat.i != int(cur) {
-			cache[dat.i] = *dat
+			cache[dat.i] = dat
-			pol.Put(dat)
 			continue
 		}
 		if cur == start {
@@ -147,18 +143,16 @@ func (r FullReader) ReadAt(p []byte, off int64) (n int, err error) {
 		}
 		n += len(dat.data)
 		cur++
-		pol.Put(dat)
 		var ok bool
-		var curDat outDat
 		for {
-			curDat, ok = cache[int(cur)]
+			dat, ok = cache[int(cur)]
 			if !ok {
 				break
 			}
-			for i := range curDat.data {
+			for i := range dat.data {
-				p[n+i] = curDat.data[i]
+				p[n+i] = dat.data[i]
 			}
-			n += len(curDat.data)
+			n += len(dat.data)
 			cur++
 			delete(cache, int(cur))
 		}
@@ -170,56 +164,45 @@ func (r FullReader) ReadAt(p []byte, off int64) (n int, err error) {
 }
 
 func (r FullReader) WriteTo(w io.Writer) (n int64, err error) {
-	pol := &sync.Pool{
+	out := make(chan outDat, len(r.sizes))
-		New: func() any {
-			return new(outDat)
-		},
-	}
-	out := make(chan *outDat, len(r.sizes))
 	offset := r.start
 	num := len(r.sizes)
 	for i := 0; i < num; i++ {
-		od := pol.Get().(*outDat)
 		if i == num-1 && r.fragRdr != nil {
 			go func() {
-				defer func() {
-					out <- od
-				}()
 				rdr, e := r.fragRdr()
 				if err != nil {
-					od.i = num - 1
+					out <- outDat{
-					od.err = e
+						i:   num - 1,
+						err: e,
+					}
 					return
 				}
-				buf := make([]byte, r.sizes[num-1])
+				dat, e := io.ReadAll(rdr)
-				_, e = rdr.Read(buf)
+				out <- outDat{
-				od.i = num - 1
+					i:    num - 1,
-				od.err = e
+					err:  e,
-				od.data = buf
+					data: dat,
+				}
 				if clr, ok := rdr.(io.Closer); ok {
 					clr.Close()
 				}
 			}()
 			continue
 		}
-		go r.process(i, int64(offset), od, out)
+		go r.process(i, int64(offset), out)
 		offset += uint64(realSize(r.sizes[i]))
 	}
-	wt, ok := w.(io.WriterAt)
-	if !ok {
-		var cur int
 	cache := make(map[int]outDat)
 	var tmpN int
-		var dat *outDat
+	for cur := 0; cur < num; {
-		for cur < len(r.sizes) {
+		dat := <-out
-			dat = <-out
-			defer pol.Put(dat)
 		if dat.err != nil {
 			err = dat.err
 			return
 		}
 		if dat.i != cur {
-				cache[dat.i] = *dat
+			cache[dat.i] = dat
 			continue
 		}
 		tmpN, err = w.Write(dat.data)
@@ -229,13 +212,12 @@ func (r FullReader) WriteTo(w io.Writer) (n int64, err error) {
 		}
 		cur++
 		var ok bool
-			var curDat outDat
 		for {
-				curDat, ok = cache[cur]
+			dat, ok = cache[cur]
 			if !ok {
 				break
 			}
-				tmpN, err = w.Write(curDat.data)
+			tmpN, err = w.Write(dat.data)
 			n += int64(tmpN)
 			if err != nil {
 				return
@@ -243,22 +225,5 @@ func (r FullReader) WriteTo(w io.Writer) (n int64, err error) {
 			cur++
 		}
 	}
-	} else {
-		var done int
-		var dat *outDat
-		for done < len(r.sizes) {
-			dat = <-out
-			defer pol.Put(dat)
-			if dat.err != nil {
-				err = dat.err
-				return
-			}
-			_, err = wt.WriteAt(dat.data, int64(dat.i*int(r.blockSize)))
-			if err != nil {
-				return
-			}
-			done++
-		}
-	}
 	return
 }

internal/decompress/interface.go

@@ -18,5 +18,5 @@ type Resetable interface {
 
 type Decoder interface {
 	//Decodes a chunk of data all at once.
-	Decode(in []byte, outSize int) ([]byte, error)
+	Decode(in []byte) ([]byte, error)
 }

internal/decompress/lz4.go

@@ -16,12 +16,3 @@ func (l Lz4) Reset(old, src io.Reader) error {
 	old.(*lz4.Reader).Reset(src)
 	return nil
 }
-
-func (l Lz4) Decode(in []byte, outSize int) (out []byte, err error) {
-	out = make([]byte, outSize)
-	outLen, err := lz4.UncompressBlock(in, out)
-	if outLen < outSize {
-		out = out[:outLen]
-	}
-	return
-}

internal/decompress/zstd.go

@@ -19,9 +19,9 @@ func (z Zstd) Reset(old, src io.Reader) error {
 	return old.(*zstd.Decoder).Reset(src)
 }
 
-func (z Zstd) Decode(in []byte, outSize int) ([]byte, error) {
+func (z Zstd) Decode(in []byte) ([]byte, error) {
 	if z.writeToReader == nil {
 		z.writeToReader, _ = zstd.NewReader(nil)
 	}
-	return z.writeToReader.DecodeAll(in, make([]byte, outSize))
+	return z.writeToReader.DecodeAll(in, nil)
 }

reader.go

@@ -13,12 +13,15 @@ import (
 	"github.com/CalebQ42/squashfs/internal/inode"
 	"github.com/CalebQ42/squashfs/internal/metadata"
 	"github.com/CalebQ42/squashfs/internal/toreader"
+	fuse2 "github.com/seaweedfs/fuse"
 )
 
 type Reader struct {
 	*FS
 	con         *fuse.Conn
+	con2        *fuse2.Conn
 	mountDone   chan struct{}
+	mount2Done  chan struct{}
 	d           decompress.Decompressor
 	r           io.ReaderAt
 	fragEntries []fragEntry

reader_file.go

@@ -6,6 +6,7 @@ import (
 	"io/fs"
 	"log"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strconv"
 	"strings"
@@ -146,6 +147,20 @@ func (f File) IsSymlink() bool {
 	return f.i.Type == inode.Sym || f.i.Type == inode.ESym
 }
 
+func (f File) isDeviceOrFifo() bool {
+	return f.i.Type == inode.Char || f.i.Type == inode.Block || f.i.Type == inode.EChar || f.i.Type == inode.EBlock || f.i.Type == inode.Fifo || f.i.Type == inode.EFifo
+}
+
+func (f File) deviceDevices() (maj uint32, min uint32) {
+	var dev uint32
+	if f.i.Type == inode.Char || f.i.Type == inode.Block {
+		dev = f.i.Data.(inode.Device).Dev
+	} else if f.i.Type == inode.EChar || f.i.Type == inode.EBlock {
+		dev = f.i.Data.(inode.EDevice).Dev
+	}
+	return dev >> 8, dev & 0x000FF
+}
+
 // SymlinkPath returns the symlink's target path. Is the File isn't a symlink, returns an empty string.
 func (f File) SymlinkPath() string {
 	switch f.i.Type {
@@ -232,7 +247,8 @@ func (f File) realExtract(folder string, op ExtractionOptions) error {
 		}
 		return err
 	}
-	if f.IsDir() {
+	switch {
+	case f.IsDir():
 		filFS, _ := f.FS()
 		var ents []directory.Entry
 		ents, err = f.r.readDirectory(f.i)
@@ -276,8 +292,7 @@ func (f File) realExtract(folder string, op ExtractionOptions) error {
 				return err
 			}
 		}
-		return nil
+	case f.IsRegular():
-	} else if f.IsRegular() {
 		var fil *os.File
 		fil, err = os.Create(folder + "/" + f.e.Name)
 		if os.IsExist(err) {
@@ -302,8 +317,7 @@ func (f File) realExtract(folder string, op ExtractionOptions) error {
 			}
 			return err
 		}
-		return nil
+	case f.IsSymlink():
-	} else if f.IsSymlink() {
 		symPath := f.SymlinkPath()
 		if op.DereferenceSymlink {
 			fil := f.GetSymlinkFile()
@@ -350,7 +364,40 @@ func (f File) realExtract(folder string, op ExtractionOptions) error {
 			}
 			return err
 		}
-		return nil
+	case f.isDeviceOrFifo():
+		_, err = exec.LookPath("mknod")
+		if err != nil {
+			if op.Verbose {
+				log.Println("Extracting Fifo IPC or Device and mknod is not in PATH")
 			}
+			return err
+		}
+		var typ string
+		if f.i.Type == inode.Char || f.i.Type == inode.EChar {
+			typ = "c"
+		} else if f.i.Type == inode.Block || f.i.Type == inode.EBlock {
+			typ = "b"
+		} else { //Fifo IPC
+			typ = "p"
+		}
+		cmd := exec.Command("mknod", folder+"/"+f.e.Name, typ)
+		if typ != "p" {
+			maj, min := f.deviceDevices()
+			cmd.Args = append(cmd.Args, strconv.Itoa(int(maj)), strconv.Itoa(int(min)))
+		}
+		if op.Verbose {
+			cmd.Stdout = op.LogOutput
+			cmd.Stderr = op.LogOutput
+		}
+		err = cmd.Run()
+		if err != nil {
+			if op.Verbose {
+				log.Println("Error while running mknod for", folder+"/"+f.e.Name)
+			}
+			return err
+		}
+	default:
 		return errors.New("Unsupported file type. Inode type: " + strconv.Itoa(int(f.i.Type)))
 	}
+	return nil
+}

reader_inode.go

@@ -70,7 +70,7 @@ func (r Reader) getReaders(i inode.Inode) (full *data.FullReader, rdr *data.Read
 			}
 			fragRdr = io.LimitReader(fragRdr, int64(fragSize))
 			return fragRdr, nil
-		}, fragSize)
+		})
 		var fragRdr io.Reader
 		fragRdr, err = r.fragReader(fragInd)
 		if err != nil {