feat: handle hardlinks

internal/deb/extract.go

@@ -246,11 +246,22 @@ func extractData(dataReader io.Reader, options *ExtractOptions) error {
 				}
 			}
 			// Create the entry itself.
+			link := tarHeader.Linkname
+			if tarHeader.Typeflag == tar.TypeLink {
+				// The hard link requires the real path of the target file.
+				// For a hard link, we assume:
+				// - the target file is already created (the target file should
+				//   exist before the hard link in a valid tarball)
+				// - the hard link is identified in `fsutil.CreateOptions` as a
+				//   regular file but with a non-empty `Link` field.
+				link = filepath.Join(options.TargetDir, link)
+			}
+
 			createOptions := &fsutil.CreateOptions{
 				Path:        filepath.Join(options.TargetDir, targetPath),
 				Mode:        tarHeader.FileInfo().Mode(),
 				Data:        pathReader,
-				Link:        tarHeader.Linkname,
+				Link:        link,
 				MakeParents: true,
 			}
 			err := options.Create(extractInfos, createOptions)

internal/deb/extract_test.go

@@ -352,6 +352,84 @@ var extractTests = []extractTest{{
 		},
 	},
 	error: `cannot extract from package "test-package": path /dir/ requested twice with diverging mode: 0777 != 0000`,
+}, {
+	summary: "Hard link is extracted",
+	pkgdata: testutil.MustMakeDeb([]testutil.TarEntry{
+		testutil.Dir(0755, "./"),
+		testutil.Reg(0644, "./file.txt", "text for file.txt"),
+		testutil.Hln(0644, "./link-to-file.txt", "./file.txt"),
+	}),
+	options: deb.ExtractOptions{
+		Extract: map[string][]deb.ExtractInfo{
+			"/**": []deb.ExtractInfo{{
+				Path: "/**",
+			}},
+		},
+	},
+	result: map[string]string{
+		"/file.txt":         "file 0644 e940b71b",
+		"/link-to-file.txt": "file 0644 e940b71b",
+	},
+	notCreated: []string{},
+}, {
+	summary: "Dangling hard link",
+	pkgdata: testutil.MustMakeDeb([]testutil.TarEntry{
+		testutil.Dir(0755, "./"),
+		// The file.txt is left out to create a dangling hard link link-to-file.txt
+		testutil.Hln(0644, "./link-to-file.txt", "./file.txt"),
+	}),
+	options: deb.ExtractOptions{
+		Extract: map[string][]deb.ExtractInfo{
+			"/**": []deb.ExtractInfo{{
+				Path: "/**",
+			}},
+		},
+	},
+	error: `cannot extract from package "test-package": the target file does not exist: .*\/file.txt`,
+}, {
+	summary: "Hard link to symlink",
+	pkgdata: testutil.MustMakeDeb([]testutil.TarEntry{
+		testutil.Dir(0755, "./"),
+		testutil.Lnk(0644, "./symlink-to-file.txt", "./file.txt"),
+		testutil.Hln(0644, "./link-to-symlink.txt", "./symlink-to-file.txt"),
+	}),
+	options: deb.ExtractOptions{
+		Extract: map[string][]deb.ExtractInfo{
+			"/**": []deb.ExtractInfo{{
+				Path: "/**",
+			}},
+		},
+	},
+	result: map[string]string{
+		"/link-to-symlink.txt": "symlink ./file.txt",
+		"/symlink-to-file.txt": "symlink ./file.txt",
+	},
+	notCreated: []string{},
+}, {
+	summary: "Extract all types of files",
+	pkgdata: testutil.MustMakeDeb([]testutil.TarEntry{
+		testutil.Dir(0755, "./"),
+		testutil.Dir(0755, "./dir/"),
+		testutil.Reg(0644, "./dir/file.txt", "text for file.txt"),
+		testutil.Lnk(0644, "./symlink-to-file.txt", "./dir/file.txt"),
+		testutil.Hln(0644, "./link-to-file.txt", "./dir/file.txt"),
+		testutil.Hln(0644, "./link-to-symlink.txt", "./symlink-to-file.txt"),
+	}),
+	options: deb.ExtractOptions{
+		Extract: map[string][]deb.ExtractInfo{
+			"/**": []deb.ExtractInfo{{
+				Path: "/**",
+			}},
+		},
+	},
+	result: map[string]string{
+		"/dir/":                "dir 0755",
+		"/dir/file.txt":        "file 0644 e940b71b",
+		"/link-to-file.txt":    "file 0644 e940b71b",
+		"/link-to-symlink.txt": "symlink ./dir/file.txt",
+		"/symlink-to-file.txt": "symlink ./dir/file.txt",
+	},
+	notCreated: []string{},
 }}
 
 func (s *S) TestExtract(c *C) {

internal/fsutil/create.go

@@ -48,8 +48,15 @@ func Create(options *CreateOptions) (*Entry, error) {
 
 	switch o.Mode & fs.ModeType {
 	case 0:
-		err = createFile(o)
-		hash = hex.EncodeToString(rp.h.Sum(nil))
+		if o.Link != "" {
+			// Creating the hard link does not occurs file reads. Therefore,
+			// its size and hash is not calculated here but in
+			// `testutil.TreeDumpEntry` for testing purpose instead.
+			err = createHardLink(o)
+		} else {
+			err = createFile(o)
+			hash = hex.EncodeToString(rp.h.Sum(nil))
+		}
 	case fs.ModeDir:
 		err = createDir(o)
 	case fs.ModeSymlink:
@@ -121,6 +128,28 @@ func createSymlink(o *CreateOptions) error {
 	return os.Symlink(o.Link, o.Path)
 }
 
+func createHardLink(o *CreateOptions) error {
+	debugf("Creating hard link: %s => %s", o.Path, o.Link)
+	targetInfo, err := os.Lstat(o.Link)
+	if err != nil && os.IsNotExist(err) {
+		return fmt.Errorf("the target file does not exist: %s", o.Link)
+	} else if err != nil {
+		return err
+	}
+
+	linkInfo, err := os.Lstat(o.Path)
+	if err == nil || os.IsExist(err) {
+		if os.SameFile(targetInfo, linkInfo) {
+			return nil
+		}
+		return fmt.Errorf("the link already exists: %s", o.Path)
+	} else if !os.IsNotExist(err) {
+		return err
+	}
+
+	return os.Link(o.Link, o.Path)
+}
+
 // readerProxy implements the io.Reader interface proxying the calls to its
 // inner io.Reader. On each read, the proxy keeps track of the file size and hash.
 type readerProxy struct {

internal/fsutil/create_test.go

@@ -16,7 +16,7 @@ import (
 
 type createTest struct {
 	options fsutil.CreateOptions
-	hackdir func(c *C, dir string)
+	hackopt func(c *C, dir string, options *fsutil.CreateOptions)
 	result  map[string]string
 	error   string
 }
@@ -72,7 +72,7 @@ var createTests = []createTest{{
 		Path: "foo",
 		Mode: fs.ModeDir | 0775,
 	},
-	hackdir: func(c *C, dir string) {
+	hackopt: func(c *C, dir string, options *fsutil.CreateOptions) {
 		c.Assert(os.Mkdir(filepath.Join(dir, "foo/"), fs.ModeDir|0765), IsNil)
 	},
 	result: map[string]string{
@@ -86,13 +86,74 @@ var createTests = []createTest{{
 		Mode: 0644,
 		Data: bytes.NewBufferString("changed"),
 	},
-	hackdir: func(c *C, dir string) {
+	hackopt: func(c *C, dir string, options *fsutil.CreateOptions) {
 		c.Assert(os.WriteFile(filepath.Join(dir, "foo"), []byte("data"), 0666), IsNil)
 	},
 	result: map[string]string{
 		// mode is not updated.
 		"/foo": "file 0666 d67e2e94",
 	},
+}, {
+	// Create a hard link to `file`
+	options: fsutil.CreateOptions{
+		Path:        "dir/link-to-file",
+		Link:        "file",
+		Mode:        0644,
+		MakeParents: true,
+	},
+	hackopt: func(c *C, dir string, options *fsutil.CreateOptions) {
+		c.Assert(os.WriteFile(filepath.Join(dir, "file"), []byte("data"), 0644), IsNil)
+		options.Link = filepath.Join(dir, options.Link)
+	},
+	result: map[string]string{
+		"/file":             "file 0644 3a6eb079",
+		"/dir/":             "dir 0755",
+		"/dir/link-to-file": "file 0644 3a6eb079",
+	},
+}, {
+	// The target file for the hard link does not exist.
+	options: fsutil.CreateOptions{
+		Path:        "dir/link-to-file",
+		Link:        "file-no-exist",
+		Mode:        0644,
+		MakeParents: true,
+	},
+	hackopt: func(c *C, dir string, options *fsutil.CreateOptions) {
+		c.Assert(os.WriteFile(filepath.Join(dir, "file-exist"), []byte("data"), 0644), IsNil)
+		options.Link = filepath.Join(dir, options.Link)
+	},
+	error: `the target file does not exist: .*\/file-no-exist`,
+}, {
+	// The hard link exists but is same as the target.
+	options: fsutil.CreateOptions{
+		Path:        "link-to-file",
+		Link:        "file",
+		Mode:        0644,
+		MakeParents: true,
+	},
+	hackopt: func(c *C, dir string, options *fsutil.CreateOptions) {
+		c.Assert(os.WriteFile(filepath.Join(dir, "file"), []byte("data"), 0644), IsNil)
+		c.Assert(os.Link(filepath.Join(dir, "file"), filepath.Join(dir, "link-to-file")), IsNil)
+		options.Link = filepath.Join(dir, options.Link)
+	},
+	result: map[string]string{
+		"/file":         "file 0644 3a6eb079",
+		"/link-to-file": "file 0644 3a6eb079",
+	},
+}, {
+	// The hard link exists but is not the same as the target.
+	options: fsutil.CreateOptions{
+		Path:        "link-to-file",
+		Link:        "file",
+		Mode:        0644,
+		MakeParents: true,
+	},
+	hackopt: func(c *C, dir string, options *fsutil.CreateOptions) {
+		c.Assert(os.WriteFile(filepath.Join(dir, "file"), []byte("data"), 0644), IsNil)
+		c.Assert(os.WriteFile(filepath.Join(dir, "link-to-file"), []byte("data"), 0644), IsNil)
+		options.Link = filepath.Join(dir, options.Link)
+	},
+	error: `the link already exists: .*\/link-to-file`,
 }}
 
 func (s *S) TestCreate(c *C) {
@@ -108,8 +169,8 @@ func (s *S) TestCreate(c *C) {
 		}
 		c.Logf("Options: %v", test.options)
 		dir := c.MkDir()
-		if test.hackdir != nil {
-			test.hackdir(c, dir)
+		if test.hackopt != nil {
+			test.hackopt(c, dir, &test.options)
 		}
 		options := test.options
 		options.Path = filepath.Join(dir, options.Path)
@@ -122,14 +183,24 @@ func (s *S) TestCreate(c *C) {
 
 		c.Assert(err, IsNil)
 		c.Assert(testutil.TreeDump(dir), DeepEquals, test.result)
-		// [fsutil.Create] does not return information about parent directories
-		// created implicitly. We only check for the requested path.
-		entry.Path = strings.TrimPrefix(entry.Path, dir)
-		// Add the slashes that TreeDump adds to the path.
-		slashPath := "/" + test.options.Path
-		if test.options.Mode.IsDir() {
-			slashPath = slashPath + "/"
+
+		if entry.Link != "" && entry.Mode&fs.ModeSymlink == 0 {
+			// Entry is a hardlink.
+			pathInfo, err := os.Lstat(entry.Path)
+			c.Assert(err, IsNil)
+			linkInfo, err := os.Lstat(entry.Link)
+			c.Assert(err, IsNil)
+			os.SameFile(pathInfo, linkInfo)
+		} else {
+			// [fsutil.Create] does not return information about parent directories
+			// created implicitly. We only check for the requested path.
+			entry.Path = strings.TrimPrefix(entry.Path, dir)
+			// Add the slashes that TreeDump adds to the path.
+			slashPath := "/" + test.options.Path
+			if test.options.Mode.IsDir() {
+				slashPath = slashPath + "/"
+			}
+			c.Assert(testutil.TreeDumpEntry(entry), DeepEquals, test.result[slashPath])
 		}
-		c.Assert(testutil.TreeDumpEntry(entry), DeepEquals, test.result[slashPath])
 	}
 }

internal/testutil/pkgdata.go

@@ -197,3 +197,16 @@ func Lnk(mode int64, path, target string) TarEntry {
 		},
 	}
 }
+
+// Hln is a shortcut for creating a hard link TarEntry structure (with
+// tar.Typeflag set to tar.TypeLink). Hln stands for "Hard LiNk".
+func Hln(mode int64, path, target string) TarEntry {
+	return TarEntry{
+		Header: tar.Header{
+			Typeflag: tar.TypeLink,
+			Name:     path,
+			Mode:     mode,
+			Linkname: target,
+		},
+	}
+}