Handle symlinks and hardlinks better

Previously (and probably right now for cases I haven't considered), we
would fail to traverse symlinked directories properly. This attempts to
handle that in a performant-but-probably-not-entirely-correct way by
looking at parent directories and traversing any symlinks if the file
doesn't exist at the originally requested path.

Signed-off-by: Jon Johnson <[email protected]>

Author: jonjohnsonjr

go.mod

@@ -1,8 +1,3 @@
 module github.com/jonjohnsonjr/targz
 
-go 1.22.0
-
-require (
-	golang.org/x/exp v0.0.0-20240325151524-a685a6edb6d8 // indirect
-	golang.org/x/sync v0.7.0 // indirect
-)
+go 1.23.0

go.sum

@@ -1,4 +0,0 @@
-golang.org/x/exp v0.0.0-20240325151524-a685a6edb6d8 h1:aAcj0Da7eBAtrTp03QXWvm88pSyOt+UgdZw2BFZ+lEw=
-golang.org/x/exp v0.0.0-20240325151524-a685a6edb6d8/go.mod h1:CQ1k9gNrJ50XIzaKCRR2hssIjF07kZFEiieALBM/ARQ=
-golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
-golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=

tarfs/tarfs.go

@@ -24,6 +24,7 @@ import (
 	"fmt"
 	"io"
 	"io/fs"
+	"iter"
 	"path"
 	"strings"
 	"testing/iotest"
@@ -144,6 +145,18 @@ func (fsys *FS) Readlink(name string) (string, error) {
 	return "", fmt.Errorf("Readlink(%q): file is not a link", name)
 }
 
+func dirs(name string) iter.Seq[string] {
+	return func(yield func(string) bool) {
+		for i, v := range name {
+			if v == '/' {
+				if !yield(name[0:i]) {
+					return
+				}
+			}
+		}
+	}
+}
+
 // arbitrary number stolen from filepath.EvalSymlinks
 // this seems to be 40 in linux (MAXSYMLINKS), which might be more reasonable
 const maxHops = 255
@@ -156,14 +169,38 @@ func (fsys *FS) open(name string, hops int) (fs.File, error) {
 
 	e, err := fsys.Entry(name)
 	if err != nil {
+		if errors.Is(err, fs.ErrNotExist) {
+			// Deal with symlinked dirs.
+			for dir := range dirs(name) {
+				e, err := fsys.Entry(dir)
+				if err != nil {
+					continue
+				}
+
+				if e.Header.Typeflag != tar.TypeSymlink {
+					continue
+				}
+
+				// We need to rewrite what comes after the symlinked dir.
+				rest := strings.TrimPrefix(name, dir)
+
+				link := e.Header.Linkname
+				if path.IsAbs(link) {
+					return fsys.open(normalize(path.Join(link, rest)), hops+1)
+				}
+
+				return fsys.open(path.Join(e.dir, link, rest), hops+1)
+			}
+		}
+
 		return nil, err
 	}
 
 	switch e.Header.Typeflag {
 	case tar.TypeSymlink, tar.TypeLink:
 		link := e.Header.Linkname
-		if path.IsAbs(link) {
-			return fsys.open(link, hops+1)
+		if path.IsAbs(link) || e.Header.Typeflag == tar.TypeLink {
+			return fsys.open(normalize(link), hops+1)
 		}
 
 		return fsys.open(path.Join(e.dir, link), hops+1)

tarfs/tarfs_test.go

@@ -1,6 +1,9 @@
 package tarfs
 
 import (
+	"archive/tar"
+	"bytes"
+	"io/fs"
 	"os"
 	"testing"
 	"testing/fstest"
@@ -37,3 +40,73 @@ func TestFS(t *testing.T) {
 		t.Fatal(err)
 	}
 }
+
+func TestSymlinkedDirs(t *testing.T) {
+	buf := &bytes.Buffer{}
+
+	tw := tar.NewWriter(buf)
+
+	want := "pretend this is a binary"
+
+	tw.WriteHeader(&tar.Header{
+		Name:     "usr",
+		Typeflag: tar.TypeDir,
+	})
+	tw.WriteHeader(&tar.Header{
+		Name:     "usr/bin",
+		Typeflag: tar.TypeDir,
+	})
+	tw.WriteHeader(&tar.Header{
+		Name:     "usr/bin/binary",
+		Typeflag: tar.TypeReg,
+		Size:     int64(len(want)),
+	})
+	tw.Write([]byte(want))
+	tw.WriteHeader(&tar.Header{
+		Name:     "weird",
+		Typeflag: tar.TypeDir,
+	})
+	tw.WriteHeader(&tar.Header{
+		Name:     "weird/linked",
+		Typeflag: tar.TypeSymlink,
+		Linkname: "/usr/bin",
+	})
+	tw.WriteHeader(&tar.Header{
+		Name:     "weird/absolute",
+		Typeflag: tar.TypeDir,
+	})
+	tw.WriteHeader(&tar.Header{
+		Name:     "weird/absolute/binary",
+		Typeflag: tar.TypeSymlink,
+		Linkname: "/weird/linked/binary",
+	})
+	tw.WriteHeader(&tar.Header{
+		Name:     "weird/relative",
+		Typeflag: tar.TypeDir,
+	})
+	tw.WriteHeader(&tar.Header{
+		Name:     "weird/relative/binary",
+		Typeflag: tar.TypeSymlink,
+		Linkname: "../linked/binary",
+	})
+
+	if err := tw.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	fsys, err := New(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for _, name := range []string{
+		"weird/linked/binary",
+		"weird/absolute/binary",
+	} {
+		if b, err := fs.ReadFile(fsys, name); err != nil {
+			t.Fatalf("ReadFile(%q): %v", name, err)
+		} else if string(b) != want {
+			t.Fatalf("want %q, got %q", want, b)
+		}
+	}
+}