From 05a8209fa708db240d9e5134a05c3184ee80dfa1 Mon Sep 17 00:00:00 2001 From: rootkiller6788 <17553215+rootkiller6788@user.noreply.gitee.com> Date: Sat, 12 Sep 2026 23:48:01 +0800 Subject: [PATCH 1/3] lib/suitar: reset bIndex after flushing a full block Write left w.bIndex at 512 once a full block had been written out, so the next loop iteration took the "partial block" branch, copied zero bytes and went round again forever, writing the same 512 bytes over and over. Calling Write with sizes that aren't multiples of 512 is enough to hit this. It also duplicated the last data block when a Write call happened to end exactly on a block boundary, because flush then saw a non-zero bIndex and wrote the block out a second time. --- lib/suitar/suitar.go | 1 + 1 file changed, 1 insertion(+) diff --git a/lib/suitar/suitar.go b/lib/suitar/suitar.go index 6055806c..9da6a16c 100644 --- a/lib/suitar/suitar.go +++ b/lib/suitar/suitar.go @@ -457,6 +457,7 @@ func (w *Writer) Write(b []byte) (int, error) { w.err = err break } + w.bIndex = 0 } if tooMuch && (w.err == nil) { From 26ce8600a135e693eeec3fc2aef75fcceef3d4d3 Mon Sep 17 00:00:00 2001 From: rootkiller6788 <17553215+rootkiller6788@user.noreply.gitee.com> Date: Sat, 12 Sep 2026 23:48:18 +0800 Subject: [PATCH 2/3] lib/suitar: let WriteHeader write a directory entry WriteHeader copied h into w.header before calling w.Write to emit the GNUTYPE_LONGNAME block holding the name. Write only accepts TypeReg and TypeGNUSparse, so a TypeDir header failed that call and left the Writer permanently in an error state - every later entry on the same Writer failed too. Set w.header after the name block has gone out instead. --- lib/suitar/suitar.go | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/lib/suitar/suitar.go b/lib/suitar/suitar.go index 9da6a16c..3a6212c1 100644 --- a/lib/suitar/suitar.go +++ b/lib/suitar/suitar.go @@ -322,10 +322,8 @@ func (w *Writer) WriteHeader(h *Header) error { w.err = errBadHeader return w.err } - w.header = *h - - n := len(w.header.Name) - copy(w.nameBuf[:], w.header.Name) + n := len(h.Name) + copy(w.nameBuf[:], h.Name) w.nameBuf[n] = 0 initBlock(&w.block, typeGNULongName, int64(n+1), Mode644, 0) @@ -334,6 +332,10 @@ func (w *Writer) WriteHeader(h *Header) error { return w.err } + // The w.Write call below writes this entry's name, not its contents, so + // w.header must not (yet) say TypeDir or Write would reject it. Set + // w.header after that call. + w.header = Header{Typeflag: TypeReg} w.remaining = int64(n + 1) if _, err := w.Write(w.nameBuf[:n+1]); err != nil { @@ -344,6 +346,7 @@ func (w *Writer) WriteHeader(h *Header) error { return w.err } + w.header = *h initBlock(&w.block, w.header.Typeflag, w.header.Size, w.header.Mode, w.header.ModTime.Unix()) if _, err := w.w.Write(w.block[:]); err != nil { w.err = err From 193d0354b4624bb0f3071f145fc40fbd7d0f158d Mon Sep 17 00:00:00 2001 From: rootkiller6788 <17553215+rootkiller6788@user.noreply.gitee.com> Date: Sat, 12 Sep 2026 23:48:25 +0800 Subject: [PATCH 3/3] lib/suitar: test chunked writes and directory entries TestWriterChunked writes one file several times, splitting the contents over Write calls differently each time, and checks the archive bytes come out identical. The capped writer makes a runaway Write fail the test instead of hanging it. TestWriterDir writes a directory and then a file inside it, and reads both back. --- lib/suitar/suitar_test.go | 162 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 162 insertions(+) diff --git a/lib/suitar/suitar_test.go b/lib/suitar/suitar_test.go index 7fed0f56..33e2aa19 100644 --- a/lib/suitar/suitar_test.go +++ b/lib/suitar/suitar_test.go @@ -13,11 +13,13 @@ package suitar import ( "archive/tar" "bytes" + "errors" "fmt" "hash/crc32" "io" "os" "testing" + "time" ) type crcWriter uint32 @@ -184,3 +186,163 @@ func TestReaderDenseCheck(tt *testing.T) { testReader(tt, false, false) } func TestReaderDenseIgnore(tt *testing.T) { testReader(tt, false, true) } func TestReaderSparseCheck(tt *testing.T) { testReader(tt, true, false) } func TestReaderSparseIgnore(tt *testing.T) { testReader(tt, true, true) } + +// cappedWriter returns an error once the total number of bytes written would +// exceed limit, so that a Writer which runs away fails this test instead of +// hanging it. +type cappedWriter struct { + buf bytes.Buffer + limit int +} + +func (w *cappedWriter) Write(b []byte) (int, error) { + if w.buf.Len()+len(b) > w.limit { + return 0, errCappedWriter + } + return w.buf.Write(b) +} + +var errCappedWriter = errors.New("suitar_test: capped writer") + +// writeOneFile returns a SUITAR archive holding a single file whose contents +// are size bytes long, written in chunks of chunk bytes (or all at once if +// chunk is non-positive). +func writeOneFile(tt *testing.T, size int, chunk int) []byte { + tt.Helper() + + cw := &cappedWriter{limit: 0x10000} + w := NewWriter(cw) + err := w.WriteHeader(&Header{ + Typeflag: TypeReg, + Name: "file.bin", + Size: int64(size), + Mode: Mode644, + ModTime: time.Unix(0x5E3A5C50, 0), + }) + if err != nil { + tt.Fatalf("size=%d chunk=%d: WriteHeader: %v", size, chunk, err) + } + + pix := make([]byte, size) + for i := range pix { + pix[i] = byte(i) + } + + if chunk <= 0 { + if _, err := w.Write(pix); err != nil { + tt.Fatalf("size=%d chunk=%d: Write: %v", size, chunk, err) + } + } else { + for i := 0; i < size; i += chunk { + j := min(i+chunk, size) + if _, err := w.Write(pix[i:j]); err != nil { + tt.Fatalf("size=%d chunk=%d: Write[%d:%d]: %v", size, chunk, i, j, err) + } + } + } + + if err := w.Close(); err != nil { + tt.Fatalf("size=%d chunk=%d: Close: %v", size, chunk, err) + } + return cw.buf.Bytes() +} + +// TestWriterChunked checks that how the file contents are split up over Write +// calls doesn't matter, as long as the total is Header.Size bytes long. A +// chunk size that isn't a multiple of 512 used to loop forever, writing +// 512-byte blocks non-stop, and also to duplicate one 512-byte block. +func TestWriterChunked(tt *testing.T) { + for _, size := range []int{0, 1, 300, 511, 512, 513, 700, 1000, 1024, 5000} { + want := writeOneFile(tt, size, 0) + + for _, chunk := range []int{1, 100, 300, 511, 512, 700, 1024} { + if got := writeOneFile(tt, size, chunk); !bytes.Equal(got, want) { + tt.Fatalf("size=%d chunk=%d: chunk size changed the archive bytes", size, chunk) + } + } + + r := NewReader(bytes.NewReader(want)) + h, err := r.Next() + if err != nil { + tt.Fatalf("size=%d: Next: %v", size, err) + } else if (h.Typeflag != TypeReg) || (h.Size != int64(size)) { + tt.Fatalf("size=%d: got T:'%c' S:%d", size, h.Typeflag, h.Size) + } + got, err := io.ReadAll(r) + if err != nil { + tt.Fatalf("size=%d: ReadAll: %v", size, err) + } else if len(got) != size { + tt.Fatalf("size=%d: read back %d bytes", size, len(got)) + } else { + for i, c := range got { + if c != byte(i) { + tt.Fatalf("size=%d: contents differ at %d", size, i) + break + } + } + } + if _, err := r.Next(); err != io.EOF { + tt.Fatalf("size=%d: Next after the last entry: %v", size, err) + } + } +} + +// TestWriterDir checks that a directory entry, which has no contents, can be +// written and read back. +func TestWriterDir(tt *testing.T) { + buf := bytes.Buffer{} + w := NewWriter(&buf) + for _, h := range []*Header{ + { + Typeflag: TypeDir, + Name: "a/b", + Mode: Mode755, + ModTime: time.Unix(0x5E3A5C50, 0), + }, + { + Typeflag: TypeReg, + Name: "a/b/c.txt", + Size: 5, + Mode: Mode644, + ModTime: time.Unix(0x5E3A5C50, 0), + }, + } { + if err := w.WriteHeader(h); err != nil { + tt.Fatalf("WriteHeader(%q): %v", h.Name, err) + } + if h.Typeflag == TypeReg { + if _, err := w.Write([]byte("hello")); err != nil { + tt.Fatalf("Write: %v", err) + } + } + } + if err := w.Close(); err != nil { + tt.Fatalf("Close: %v", err) + } + + r := NewReader(bytes.NewReader(buf.Bytes())) + for _, want := range []struct { + typeflag byte + name string + contents string + }{ + {TypeDir, "a/b", ""}, + {TypeReg, "a/b/c.txt", "hello"}, + } { + h, err := r.Next() + if err != nil { + tt.Fatalf("Next: %v", err) + } else if (h.Typeflag != want.typeflag) || (h.Name != want.name) { + tt.Fatalf("got T:'%c' N:%s, want T:'%c' N:%s", + h.Typeflag, h.Name, want.typeflag, want.name) + } + if got, err := io.ReadAll(r); err != nil { + tt.Fatalf("ReadAll: %v", err) + } else if string(got) != want.contents { + tt.Fatalf("N:%s: got %q, want %q", want.name, got, want.contents) + } + } + if _, err := r.Next(); err != io.EOF { + tt.Fatalf("Next after the last entry: %v", err) + } +}