Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

refactor(preview): 合并 tar.zst 读取函数重复的成员校验与文件数上限判断 (#390)

fx-kurumi27a95642740e
diff --git a/internal/preview/archive.go b/internal/preview/archive.go
index b0ce5d83..a059b51e 100644
--- a/internal/preview/archive.go
+++ b/internal/preview/archive.go
@@ -262,23 +262,19 @@ func InspectTarZst(src io.Reader, indexFile string, limits Limits) (Result, erro
if err != nil {
return Result{}, fmt.Errorf("read preview tar: %w", err)
}
- switch hdr.Typeflag {
- case tar.TypeDir:
- continue
- case tar.TypeReg, tar.TypeRegA:
- default:
- return Result{}, fmt.Errorf("%w: tar type %v", ErrUnsupportedEntry, hdr.Typeflag)
- }
- name, err := SanitizeArchiveMember(hdr.Name)
+ name, skip, err := tarRegularMember(hdr)
if err != nil {
return Result{}, err
}
+ if skip {
+ continue
+ }
if hdr.Linkname != "" {
return Result{}, fmt.Errorf("%w: link %s", ErrUnsupportedEntry, name)
}
files++
- if limits.MaxFiles > 0 && files > limits.MaxFiles {
- return Result{}, fmt.Errorf("%w: more than %d files", ErrLimitExceeded, limits.MaxFiles)
+ if err := checkTarFileCount(files, limits); err != nil {
+ return Result{}, err
}
expanded += hdr.Size
if limits.MaxExpanded > 0 && expanded > limits.MaxExpanded {
@@ -342,19 +338,16 @@ func ExtractTarZst(src io.Reader, dest string, limits Limits) error {
if err != nil {
return err
}
- if hdr.Typeflag == tar.TypeDir {
- continue
- }
- if hdr.Typeflag != tar.TypeReg && hdr.Typeflag != tar.TypeRegA {
- return fmt.Errorf("%w: tar type %v", ErrUnsupportedEntry, hdr.Typeflag)
- }
- name, err := SanitizeArchiveMember(hdr.Name)
+ name, skip, err := tarRegularMember(hdr)
if err != nil {
return err
}
+ if skip {
+ continue
+ }
files++
- if limits.MaxFiles > 0 && files > limits.MaxFiles {
- return fmt.Errorf("%w: more than %d files", ErrLimitExceeded, limits.MaxFiles)
+ if err := checkTarFileCount(files, limits); err != nil {
+ return err
}
expanded += hdr.Size
if limits.MaxExpanded > 0 && expanded > limits.MaxExpanded {
@@ -387,6 +380,33 @@ func ExtractTarZst(src io.Reader, dest string, limits Limits) error {
return nil
}
+// tarRegularMember validates one entry read from a preview tar. Directories are
+// reported as skip; anything other than a regular file is rejected with
+// ErrUnsupportedEntry. For regular files it returns the sanitized member name.
+func tarRegularMember(hdr *tar.Header) (name string, skip bool, err error) {
+ switch hdr.Typeflag {
+ case tar.TypeDir:
+ return "", true, nil
+ case tar.TypeReg, tar.TypeRegA:
+ default:
+ return "", false, fmt.Errorf("%w: tar type %v", ErrUnsupportedEntry, hdr.Typeflag)
+ }
+ name, err = SanitizeArchiveMember(hdr.Name)
+ if err != nil {
+ return "", false, err
+ }
+ return name, false, nil
+}
+
+// checkTarFileCount enforces limits.MaxFiles (0 means unlimited) after files
+// regular members have been seen.
+func checkTarFileCount(files int, limits Limits) error {
+ if limits.MaxFiles > 0 && files > limits.MaxFiles {
+ return fmt.Errorf("%w: more than %d files", ErrLimitExceeded, limits.MaxFiles)
+ }
+ return nil
+}
+
// ReadTarZstMember extracts one regular file from a compressed archive into
// memory. The rest of the tree is never written to disk.
func ReadTarZstMember(src io.Reader, name string, limits Limits) ([]byte, error) {
@@ -409,19 +429,16 @@ func ReadTarZstMember(src io.Reader, name string, limits Limits) ([]byte, error)
if err != nil {
return nil, err
}
- if hdr.Typeflag == tar.TypeDir {
- continue
- }
- if hdr.Typeflag != tar.TypeReg && hdr.Typeflag != tar.TypeRegA {
- return nil, fmt.Errorf("%w: tar type %v", ErrUnsupportedEntry, hdr.Typeflag)
- }
- member, err := SanitizeArchiveMember(hdr.Name)
+ member, skip, err := tarRegularMember(hdr)
if err != nil {
return nil, err
}
+ if skip {
+ continue
+ }
files++
- if limits.MaxFiles > 0 && files > limits.MaxFiles {
- return nil, fmt.Errorf("%w: more than %d files", ErrLimitExceeded, limits.MaxFiles)
+ if err := checkTarFileCount(files, limits); err != nil {
+ return nil, err
}
if member != want {
if _, err := io.Copy(io.Discard, io.LimitReader(tr, hdr.Size+1)); err != nil {
@@ -468,8 +485,8 @@ func UsesHistoryAPI(src io.Reader, limits Limits) (bool, error) {
continue
}
files++
- if limits.MaxFiles > 0 && files > limits.MaxFiles {
- return false, fmt.Errorf("%w: more than %d files", ErrLimitExceeded, limits.MaxFiles)
+ if err := checkTarFileCount(files, limits); err != nil {
+ return false, err
}
switch strings.ToLower(path.Ext(hdr.Name)) {
case ".js", ".mjs", ".cjs", ".html", ".htm":
diff --git a/internal/preview/tar_member_test.go b/internal/preview/tar_member_test.go
new file mode 100644
index 00000000..ad1c19c8
--- /dev/null
+++ b/internal/preview/tar_member_test.go
@@ -0,0 +1,53 @@
+package preview
+
+import (
+ "archive/tar"
+ "errors"
+ "testing"
+)
+
+func TestTarRegularMember(t *testing.T) {
+ t.Parallel()
+ cases := []struct {
+ name string
+ hdr tar.Header
+ wantName string
+ wantSkip bool
+ wantErr error
+ }{
+ {"directory", tar.Header{Name: "assets/", Typeflag: tar.TypeDir}, "", true, nil},
+ {"regular", tar.Header{Name: "./assets/app.js", Typeflag: tar.TypeReg}, "assets/app.js", false, nil},
+ {"legacy regular", tar.Header{Name: "index.html", Typeflag: tar.TypeRegA}, "index.html", false, nil},
+ {"symlink", tar.Header{Name: "index.html", Typeflag: tar.TypeSymlink, Linkname: "secret"}, "", false, ErrUnsupportedEntry},
+ {"hardlink", tar.Header{Name: "index.html", Typeflag: tar.TypeLink, Linkname: "secret"}, "", false, ErrUnsupportedEntry},
+ }
+ for _, tc := range cases {
+ name, skip, err := tarRegularMember(&tc.hdr)
+ if tc.wantErr != nil {
+ if !errors.Is(err, tc.wantErr) {
+ t.Fatalf("%s: err = %v, want %v", tc.name, err, tc.wantErr)
+ }
+ continue
+ }
+ if err != nil || name != tc.wantName || skip != tc.wantSkip {
+ t.Fatalf("%s: got (%q, %v, %v), want (%q, %v, nil)", tc.name, name, skip, err, tc.wantName, tc.wantSkip)
+ }
+ }
+ if _, _, err := tarRegularMember(&tar.Header{Name: "../escape.html", Typeflag: tar.TypeReg}); !errors.Is(err, ErrUnsafePath) {
+ t.Fatal("path escaping the archive root must be rejected")
+ }
+}
+
+func TestCheckTarFileCount(t *testing.T) {
+ t.Parallel()
+ if err := checkTarFileCount(100, Limits{}); err != nil {
+ t.Fatalf("zero MaxFiles must mean unlimited: %v", err)
+ }
+ if err := checkTarFileCount(2, Limits{MaxFiles: 2}); err != nil {
+ t.Fatalf("count equal to limit must pass: %v", err)
+ }
+ err := checkTarFileCount(3, Limits{MaxFiles: 2})
+ if !errors.Is(err, ErrLimitExceeded) || err.Error() != ErrLimitExceeded.Error()+": more than 2 files" {
+ t.Fatalf("over limit err = %v", err)
+ }
+}