Adds logic to untar hard links

-Zip does not support hard links so this is a consideration only needed
for TAR

Author: ForestEckhardt

vacation/init_test.go

@@ -10,8 +10,8 @@ import (
 func TestVacation(t *testing.T) {
 	suite := spec.New("vacation", spec.Report(report.Terminal{}))
 	suite("Archive", testArchive)
+	suite("LinkSorting", testLinkSorting)
 	suite("NopArchive", testNopArchive)
-	suite("SymlinkSorting", testSymlinkSorting)
 	suite("TarArchive", testTarArchive)
 	suite("TarBzip2Archive", testTarBzip2Archive)
 	suite("TarGzipArchive", testTarGzipArchive)

vacation/symlink_sorting.go vacation/link_sorting.go

@@ -6,12 +6,12 @@ import (
 	"strings"
 )
 
-type symlink struct {
+type link struct {
 	name string
 	path string
 }
 
-func sortSymlinks(symlinks []symlink) ([]symlink, error) {
+func sortLinks(symlinks []link) ([]link, error) {
 	// Create a map of all of the symlink names and where they are pointing to to
 	// act as a quasi-graph
 	index := map[string]string{}
@@ -40,7 +40,7 @@ func sortSymlinks(symlinks []symlink) ([]symlink, error) {
 	// Iterate over the symlink map for every link that is found this ensures
 	// that all symlinks that can be created will be created and any that are
 	// left over are cyclically dependent
-	var links []symlink
+	var links []link
 	maxIterations := len(index)
 	for i := 0; i < maxIterations; i++ {
 		for path, name := range index {
@@ -50,7 +50,7 @@ func sortSymlinks(symlinks []symlink) ([]symlink, error) {
 				continue
 			}
 
-			links = append(links, symlink{
+			links = append(links, link{
 				name: name,
 				path: path,
 			})
@@ -65,7 +65,7 @@ func sortSymlinks(symlinks []symlink) ([]symlink, error) {
 	// Check to see if there are any symlinks left in the map which would
 	// indicate a cyclical dependency
 	if len(index) > 0 {
-		return nil, fmt.Errorf("failed: max iterations reached: this symlink graph contains a cycle")
+		return nil, fmt.Errorf("failed: max iterations reached: this link graph contains a cycle")
 	}
 
 	return links, nil

vacation/symlink_sorting_test.go vacation/link_sorting_test.go

@@ -15,7 +15,7 @@ import (
 	. "github.com/onsi/gomega"
 )
 
-func testSymlinkSorting(t *testing.T, context spec.G, it spec.S) {
+func testLinkSorting(t *testing.T, context spec.G, it spec.S) {
 	var (
 		Expect = NewWithT(t).Expect
 	)

vacation/tar_archive.go

@@ -30,7 +30,8 @@ func (ta TarArchive) Decompress(destination string) error {
 	// metadata.
 	directories := map[string]interface{}{}
 
-	var symlinks []symlink
+	var symlinks []link
+	var links []link
 
 	tarReader := tar.NewReader(ta.reader)
 	for {
@@ -106,17 +107,25 @@ func (ta TarArchive) Decompress(destination string) error {
 				return err
 			}
 
+		case tar.TypeLink:
+			// Collect all of the headers for links so that they can be verified
+			// after all other files are written
+			links = append(links, link{
+				name: hdr.Linkname,
+				path: path,
+			})
+
 		case tar.TypeSymlink:
 			// Collect all of the headers for symlinks so that they can be verified
 			// after all other files are written
-			symlinks = append(symlinks, symlink{
+			symlinks = append(symlinks, link{
 				name: hdr.Linkname,
 				path: path,
 			})
 		}
 	}
 
-	symlinks, err := sortSymlinks(symlinks)
+	symlinks, err := sortLinks(symlinks)
 	if err != nil {
 		return err
 	}
@@ -134,6 +143,18 @@ func (ta TarArchive) Decompress(destination string) error {
 		}
 	}
 
+	links, err = sortLinks(links)
+	if err != nil {
+		return err
+	}
+
+	for _, link := range links {
+		err := os.Link(linknameFullPath(link.path, link.name), link.path)
+		if err != nil {
+			return fmt.Errorf("failed to extract link: %s", err)
+		}
+	}
+
 	return nil
 }
 

vacation/tar_archive_test.go

@@ -51,6 +51,10 @@ func testTarArchive(t *testing.T, context spec.G, it spec.S) {
 			_, err = tw.Write([]byte{})
 			Expect(err).NotTo(HaveOccurred())
 
+			Expect(tw.WriteHeader(&tar.Header{Name: "hardlink", Mode: 0755, Size: int64(0), Typeflag: tar.TypeLink, Linkname: "first"})).To(Succeed())
+			_, err = tw.Write([]byte{})
+			Expect(err).NotTo(HaveOccurred())
+
 			nestedFile := filepath.Join("some-dir", "some-other-dir", "some-file")
 			Expect(tw.WriteHeader(&tar.Header{Name: nestedFile, Mode: 0755, Size: int64(len(nestedFile))})).To(Succeed())
 			_, err = tw.Write([]byte(nestedFile))
@@ -80,10 +84,11 @@ func testTarArchive(t *testing.T, context spec.G, it spec.S) {
 			Expect(err).NotTo(HaveOccurred())
 			Expect(files).To(ConsistOf([]string{
 				filepath.Join(tempDir, "first"),
+				filepath.Join(tempDir, "hardlink"),
 				filepath.Join(tempDir, "second"),
-				filepath.Join(tempDir, "third"),
 				filepath.Join(tempDir, "some-dir"),
 				filepath.Join(tempDir, "symlink"),
+				filepath.Join(tempDir, "third"),
 			}))
 
 			info, err := os.Stat(filepath.Join(tempDir, "first"))
@@ -96,6 +101,10 @@ func testTarArchive(t *testing.T, context spec.G, it spec.S) {
 			data, err := os.ReadFile(filepath.Join(tempDir, "symlink"))
 			Expect(err).NotTo(HaveOccurred())
 			Expect(data).To(Equal([]byte(`first`)))
+
+			data, err = os.ReadFile(filepath.Join(tempDir, "hardlink"))
+			Expect(err).NotTo(HaveOccurred())
+			Expect(data).To(Equal([]byte(`first`)))
 		})
 
 		it("unpackages the archive into the path but also strips the first component", func() {
@@ -235,26 +244,54 @@ func testTarArchive(t *testing.T, context spec.G, it spec.S) {
 				})
 			})
 
+			context("when there is a symlink cycle", func() {
+				var cyclicalSymlinkTar vacation.TarArchive
+
+				it.Before(func() {
+					var err error
+
+					buffer := bytes.NewBuffer(nil)
+					tw := tar.NewWriter(buffer)
+
+					Expect(tw.WriteHeader(&tar.Header{Name: "a-symlink", Mode: 0755, Size: int64(0), Typeflag: tar.TypeSymlink, Linkname: "b-symlink"})).To(Succeed())
+					_, err = tw.Write([]byte{})
+					Expect(err).NotTo(HaveOccurred())
+
+					Expect(tw.WriteHeader(&tar.Header{Name: "b-symlink", Mode: 0755, Size: int64(0), Typeflag: tar.TypeSymlink, Linkname: "a-symlink"})).To(Succeed())
+					_, err = tw.Write([]byte{})
+					Expect(err).NotTo(HaveOccurred())
+
+					Expect(tw.Close()).To(Succeed())
+
+					cyclicalSymlinkTar = vacation.NewTarArchive(bytes.NewReader(buffer.Bytes()))
+				})
+
+				it("returns an error", func() {
+					err := cyclicalSymlinkTar.Decompress(tempDir)
+					Expect(err).To(MatchError(ContainSubstring("failed: max iterations reached: this link graph contains a cycle")))
+				})
+			})
+
 			context("when it tries to symlink to a file that does not exist", func() {
-				var zipSlipSymlinkTar vacation.TarArchive
+				var symlinkNotExistTar vacation.TarArchive
 
 				it.Before(func() {
 					var err error
 
 					buffer := bytes.NewBuffer(nil)
 					tw := tar.NewWriter(buffer)
 
-					Expect(tw.WriteHeader(&tar.Header{Name: "symlink", Mode: 0755, Size: int64(0), Typeflag: tar.TypeSymlink, Linkname: filepath.Join("..", "some-file")})).To(Succeed())
+					Expect(tw.WriteHeader(&tar.Header{Name: "symlink", Mode: 0755, Size: int64(0), Typeflag: tar.TypeSymlink, Linkname: "some-file"})).To(Succeed())
 					_, err = tw.Write([]byte{})
 					Expect(err).NotTo(HaveOccurred())
 
 					Expect(tw.Close()).To(Succeed())
 
-					zipSlipSymlinkTar = vacation.NewTarArchive(bytes.NewReader(buffer.Bytes()))
+					symlinkNotExistTar = vacation.NewTarArchive(bytes.NewReader(buffer.Bytes()))
 				})
 
 				it("returns an error", func() {
-					err := zipSlipSymlinkTar.Decompress(tempDir)
+					err := symlinkNotExistTar.Decompress(tempDir)
 					Expect(err).To(MatchError(ContainSubstring("failed to evaluate symlink")))
 					Expect(err).To(MatchError(ContainSubstring("no such file or directory")))
 				})
@@ -290,31 +327,56 @@ func testTarArchive(t *testing.T, context spec.G, it spec.S) {
 			})
 		})
 
-		context("when there is a symlink cycle", func() {
-			var cyclicalSymlinkTar vacation.TarArchive
+		context("when there is a link cycle", func() {
+			var cyclicalLinkTar vacation.TarArchive
 
 			it.Before(func() {
 				var err error
 
 				buffer := bytes.NewBuffer(nil)
 				tw := tar.NewWriter(buffer)
 
-				Expect(tw.WriteHeader(&tar.Header{Name: "a-symlink", Mode: 0755, Size: int64(0), Typeflag: tar.TypeSymlink, Linkname: "b-symlink"})).To(Succeed())
+				Expect(tw.WriteHeader(&tar.Header{Name: "a-link", Mode: 0755, Size: int64(0), Typeflag: tar.TypeLink, Linkname: "b-link"})).To(Succeed())
 				_, err = tw.Write([]byte{})
 				Expect(err).NotTo(HaveOccurred())
 
-				Expect(tw.WriteHeader(&tar.Header{Name: "b-symlink", Mode: 0755, Size: int64(0), Typeflag: tar.TypeSymlink, Linkname: "a-symlink"})).To(Succeed())
+				Expect(tw.WriteHeader(&tar.Header{Name: "b-link", Mode: 0755, Size: int64(0), Typeflag: tar.TypeLink, Linkname: "a-link"})).To(Succeed())
+				_, err = tw.Write([]byte{})
+				Expect(err).NotTo(HaveOccurred())
+
+				Expect(tw.Close()).To(Succeed())
+
+				cyclicalLinkTar = vacation.NewTarArchive(bytes.NewReader(buffer.Bytes()))
+			})
+
+			it("returns an error", func() {
+				err := cyclicalLinkTar.Decompress(tempDir)
+				Expect(err).To(MatchError(ContainSubstring("failed: max iterations reached: this link graph contains a cycle")))
+			})
+		})
+
+		context("when it tries to symlink to a file that does not exist", func() {
+			var linkNotExistTar vacation.TarArchive
+
+			it.Before(func() {
+				var err error
+
+				buffer := bytes.NewBuffer(nil)
+				tw := tar.NewWriter(buffer)
+
+				Expect(tw.WriteHeader(&tar.Header{Name: "link", Mode: 0755, Size: int64(0), Typeflag: tar.TypeLink, Linkname: "some-file"})).To(Succeed())
 				_, err = tw.Write([]byte{})
 				Expect(err).NotTo(HaveOccurred())
 
 				Expect(tw.Close()).To(Succeed())
 
-				cyclicalSymlinkTar = vacation.NewTarArchive(bytes.NewReader(buffer.Bytes()))
+				linkNotExistTar = vacation.NewTarArchive(bytes.NewReader(buffer.Bytes()))
 			})
 
 			it("returns an error", func() {
-				err := cyclicalSymlinkTar.Decompress(tempDir)
-				Expect(err).To(MatchError(ContainSubstring("failed: max iterations reached: this symlink graph contains a cycle")))
+				err := linkNotExistTar.Decompress(tempDir)
+				Expect(err).To(MatchError(ContainSubstring("failed to extract link")))
+				Expect(err).To(MatchError(ContainSubstring("no such file or directory")))
 			})
 		})
 	})

vacation/zip_archive.go

@@ -43,7 +43,7 @@ func (z ZipArchive) Decompress(destination string) error {
 		return fmt.Errorf("failed to create zip reader: %w", err)
 	}
 
-	var symlinks []symlink
+	var symlinks []link
 	for _, f := range zr.File {
 		// Clean the name in the header to prevent './filename' being stripped to
 		// 'filename' also to skip if the destination it the destination directory
@@ -87,7 +87,7 @@ func (z ZipArchive) Decompress(destination string) error {
 
 			// Collect all of the headers for symlinks so that they can be verified
 			// after all other files are written
-			symlinks = append(symlinks, symlink{
+			symlinks = append(symlinks, link{
 				name: string(linkname),
 				path: path,
 			})
@@ -123,7 +123,7 @@ func (z ZipArchive) Decompress(destination string) error {
 		}
 	}
 
-	symlinks, err = sortSymlinks(symlinks)
+	symlinks, err = sortLinks(symlinks)
 	if err != nil {
 		return err
 	}