diff --git a/docs/changelog.rst b/docs/changelog.rst index d96d8b104..4b272310e 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -384,7 +384,8 @@ Detailed list of changes - Clipboard kitten: Fix a race when replacing an existing output file and losing the original file if writing it fails. Also preserve the permissions - of and follow symlinks at existing output files (:pull:`10738`) + of existing output files and follow symlinks even when their targets do not + exist (:pull:`10738`) - Kittens: Fix laggy mouse selection and failures comparing remote directories in the diff kitten, Unicode quotes not being removed from around diff --git a/kittens/clipboard/read_test.go b/kittens/clipboard/read_test.go index 9af8cd1f8..825e90ebb 100644 --- a/kittens/clipboard/read_test.go +++ b/kittens/clipboard/read_test.go @@ -162,6 +162,63 @@ func TestClipboardOutputCommitSymlink(t *testing.T) { } } +func TestClipboardOutputCommitDanglingSymlink(t *testing.T) { + for _, link_type := range []string{"absolute", "relative"} { + for _, data_type := range []string{"text", "image"} { + t.Run(link_type+"/"+data_type, func(t *testing.T) { + dir := t.TempDir() + target := filepath.Join(dir, "target") + dest := filepath.Join(dir, "link") + link := target + if link_type == "relative" { + link = "target" + } + if err := os.Symlink(link, dest); err != nil { + t.Fatal(err) + } + data := []byte("new contents") + output := Output{arg: dest} + defer output.cleanup() + if data_type == "image" { + var buf bytes.Buffer + if err := png.Encode(&buf, image.NewRGBA(image.Rect(0, 0, 2, 3))); err != nil { + t.Fatal(err) + } + data = buf.Bytes() + output.image_needs_conversion = true + output.mime_type = "image/jpeg" + } + output.add_data(data) + output.commit() + if output.err != nil { + t.Fatal(output.err) + } + if actual, err := os.Readlink(dest); err != nil || actual != link { + t.Errorf("Symlink at destination changed: %q %v", actual, err) + } + actual, err := os.ReadFile(target) + if err != nil { + t.Fatalf("Symlink target not created: %v", err) + } + if data_type == "image" { + img, format, err := image.Decode(bytes.NewReader(actual)) + if err != nil { + t.Fatal(err) + } + if format != "jpeg" || img.Bounds() != image.Rect(0, 0, 2, 3) { + t.Fatalf("Incorrect converted image: %s %v", format, img.Bounds()) + } + } else if !bytes.Equal(actual, data) { + t.Fatalf("Incorrect contents in symlink target: %q", actual) + } + if names := list_dir(t, dir); !slices.Equal(names, []string{"link", "target"}) { + t.Fatalf("Stray files left behind after commit: %v", names) + } + }) + } + } +} + func TestClipboardOutputImageEncodeFailure(t *testing.T) { dest := filepath.Join(t.TempDir(), "output") old_data := []byte("old contents") diff --git a/tools/utils/atomic-write.go b/tools/utils/atomic-write.go index aa22fb7c7..cfa2aff77 100644 --- a/tools/utils/atomic-write.go +++ b/tools/utils/atomic-write.go @@ -41,11 +41,7 @@ func AtomicCreateSymlink(oldname, newname string) (err error) { } func AtomicWriteFile(path string, data io.Reader, perm os.FileMode) (err error) { - npath, err := filepath.EvalSymlinks(path) - if errors.Is(err, fs.ErrNotExist) { - err = nil - npath = path - } + npath, err := EvalSymlinksThatExist(path) if err == nil { path = npath path, err = filepath.Abs(path) diff --git a/tools/utils/atomic-write_test.go b/tools/utils/atomic-write_test.go new file mode 100644 index 000000000..20480e670 --- /dev/null +++ b/tools/utils/atomic-write_test.go @@ -0,0 +1,63 @@ +// License: GPLv3 Copyright: 2026, Kovid Goyal, + +package utils + +import ( + "os" + "path/filepath" + "strings" + "testing" +) + +func TestAtomicWriteFileSymlinkChain(t *testing.T) { + dir := t.TempDir() + t.Chdir(dir) + for _, name := range []string{"nested", "real"} { + if err := os.Mkdir(name, 0o700); err != nil { + t.Fatal(err) + } + } + links := map[string]string{"nested/link": "../link", "link": "parent/target", "parent": "real"} + for path, target := range links { + if err := os.Symlink(target, path); err != nil { + t.Fatal(err) + } + } + if err := AtomicWriteFile(filepath.Join("nested", "link"), strings.NewReader("new contents"), 0o640); err != nil { + t.Fatal(err) + } + for path, target := range links { + if actual, err := os.Readlink(path); err != nil || actual != target { + t.Errorf("Symlink %s changed: %q %v", path, actual, err) + } + } + target := filepath.Join("real", "target") + assert_file_contents(t, target, "new contents") + if st, err := os.Stat(target); err != nil || st.Mode().Perm() != 0o640 { + t.Fatalf("Incorrect target permissions: %v %v", st, err) + } + if entries, err := os.ReadDir("real"); err != nil || len(entries) != 1 || entries[0].Name() != "target" { + t.Fatalf("Stray files left behind after write: %v %v", entries, err) + } +} + +func TestAtomicWriteFileSymlinkFailure(t *testing.T) { + for _, link := range []string{"missing/target", "link"} { + t.Run(link, func(t *testing.T) { + dir := t.TempDir() + dest := filepath.Join(dir, "link") + if err := os.Symlink(link, dest); err != nil { + t.Fatal(err) + } + if err := AtomicWriteFile(dest, strings.NewReader("new contents"), 0o600); err == nil { + t.Error("Expected write to fail with a missing parent directory or a symlink loop") + } + if actual, err := os.Readlink(dest); err != nil || actual != link { + t.Errorf("Symlink at destination changed: %q %v", actual, err) + } + if entries, err := os.ReadDir(dir); err != nil || len(entries) != 1 || entries[0].Name() != "link" { + t.Fatalf("Stray files left behind after failed write: %v %v", entries, err) + } + }) + } +}