lib/suitar: allow Write to a sparse entry

This commit is contained in:
Nigel Tao committed 2026-09-15 15:31:04 +10:00
1 parent b77e1a67de
commit b1adeeccb1
2 files changed
+126 -29

No files matched your search

+36 -21
View File
@@ -38,6 +38,7 @@ var (
errClosed = errors.New("suitar: closed")
errHeaderSize = errors.New("suitar: inconsistent Header.Size and Write length")
errHeaderTypeflag = errors.New("suitar: inconsistent Header.Typeflag for Write")
errWriteANonNul = errors.New("suitar: Write a non-NUL byte to a sparse entry")
)
// lenMagic makes headerBlockTemplate[:lenMagic] SUITAR's magic signature.
@@ -300,7 +301,7 @@ type Writer struct {
func (w *Writer) flush() error {
if w.err != nil {
return w.err
} else if w.remaining != 0 {
} else if (w.remaining != 0) && (w.header.Typeflag != TypeGNUSparse) {
w.err = errHeaderSize
return w.err
} else if w.bIndex != 0 {
@@ -356,10 +357,6 @@ func (w *Writer) WriteHeader(h *Header) error {
}
w.remaining = w.header.Size
if w.header.Typeflag == TypeGNUSparse {
w.remaining = 0
}
return nil
}
@@ -412,11 +409,6 @@ func setI64(b *block, offset int, value int64) {
func (w *Writer) Write(b []byte) (int, error) {
if w.err != nil {
return 0, w.err
} else if (w.header.Typeflag != TypeReg) && (w.header.Typeflag != TypeGNUSparse) {
w.err = errHeaderTypeflag
return 0, w.err
} else if len(b) == 0 {
return 0, nil
}
tooMuch := int64(len(b)) > w.remaining
@@ -424,6 +416,29 @@ func (w *Writer) Write(b []byte) (int, error) {
b = b[:w.remaining]
}
ret := 0
if w.header.Typeflag == TypeReg {
ret, w.err = w.writeReg(b)
} else if w.header.Typeflag == TypeGNUSparse {
ret, w.err = w.writeSparse(b)
} else {
w.err = errHeaderTypeflag
return 0, w.err
}
w.remaining -= int64(ret)
if tooMuch && (w.err == nil) {
w.err = errHeaderSize
}
return ret, w.err
}
func (w *Writer) writeReg(b []byte) (int, error) {
if len(b) == 0 {
return 0, nil
}
ret := 0
for len(b) > 0 {
if w.bIndex == 0 {
@@ -432,17 +447,14 @@ func (w *Writer) Write(b []byte) (int, error) {
if len(prefix) > 0 {
n, err := w.w.Write(prefix)
w.remaining -= int64(n)
ret += n
if err != nil {
w.err = err
break
return ret, err
}
}
if len(suffix) > 0 {
w.bIndex = int32(copy(w.block[:], suffix))
w.remaining -= int64(w.bIndex)
ret += int(w.bIndex)
}
@@ -452,24 +464,27 @@ func (w *Writer) Write(b []byte) (int, error) {
n := copy(w.block[w.bIndex:], b)
w.bIndex += int32(n)
w.remaining -= int64(n)
ret += n
b = b[n:]
if int(w.bIndex) < len(w.block) {
continue
} else if _, err := w.w.Write(w.block[:]); err != nil {
w.err = err
break
return ret, err
}
w.bIndex = 0
}
if tooMuch && (w.err == nil) {
w.err = errHeaderSize
}
return ret, nil
}
return ret, w.err
func (w *Writer) writeSparse(b []byte) (int, error) {
for _, c := range b {
if c != 0 {
return 0, errWriteANonNul
}
}
return 0, nil
}
// Close satisfies io.Closer. It closes the entire archive, not just one entry.
+90 -8
View File
@@ -286,9 +286,10 @@ func TestWriterChunked(tt *testing.T) {
}
}
// TestWriterDir checks that a directory entry, which has no contents, can be
// written and read back.
func TestWriterDir(tt *testing.T) {
// TestWriteNonRegular checks that entries (including TypeDir entries which
// have no contents and TypeGNUSparse entries which have all-NUL contents) can
// be written and read back.
func TestWriteNonRegular(tt *testing.T) {
headers := []Header{{
Typeflag: TypeDir,
Name: "a/b",
@@ -300,10 +301,31 @@ func TestWriterDir(tt *testing.T) {
Size: 5,
Mode: Mode644,
ModTime: time.Unix(12345602, 0),
}, {
Typeflag: TypeGNUSparse,
Name: "sparse0.bin",
Size: 3,
Mode: Mode644,
ModTime: time.Unix(123000, 0),
}, {
Typeflag: TypeGNUSparse,
Name: "sparse1.bin",
Size: 3,
Mode: Mode644,
ModTime: time.Unix(123001, 0),
}, {
Typeflag: TypeGNUSparse,
Name: "sparse3.bin",
Size: 3,
Mode: Mode644,
ModTime: time.Unix(123002, 0),
}}
contents := map[string]string{
"a/b/c.txt": "hello",
"a/b/c.txt": "hello",
"sparse0.bin": "\x00\x00\x00",
"sparse1.bin": "\x00\x00\x00",
"sparse3.bin": "\x00\x00\x00",
}
buf := bytes.Buffer{}
@@ -313,10 +335,22 @@ func TestWriterDir(tt *testing.T) {
tt.Fatalf("WriteHeader(%q): %v", h.Name, err)
}
if content, ok := contents[h.Name]; ok {
if _, err := w.Write([]byte(content)); err != nil {
tt.Fatalf("Write: %v", err)
}
content, ok := contents[h.Name]
if !ok {
continue
} else if h.Name == "sparse0.bin" {
// It's OK, for TypeGNUSparse, to Write no bytes.
continue
} else if h.Name == "sparse1.bin" {
// It's OK, for TypeGNUSparse, to Write some but not all of the
// Size bytes, provided that what you're writing are NUL bytes.
content = content[:1]
} else if h.Name == "sparse3.bin" {
// No-op, going on to Write all 3 explicit NUL bytes.
}
if _, err := w.Write([]byte(content)); err != nil {
tt.Fatalf("Write(%q): %v", h.Name, err)
}
}
if err := w.Close(); err != nil {
@@ -342,3 +376,51 @@ func TestWriterDir(tt *testing.T) {
tt.Fatalf("Next after the last entry: %v", err)
}
}
func TestWriteANonNUL(tt *testing.T) {
buf := bytes.Buffer{}
w := NewWriter(&buf)
if err := w.WriteHeader(&Header{
Typeflag: TypeGNUSparse,
Name: "example.dat",
Size: 5,
Mode: Mode644,
ModTime: time.Unix(0, 0),
}); err != nil {
tt.Fatalf("WriteHeader: %v", err)
}
if _, err := w.Write([]byte("Lorem")); err != errWriteANonNul {
tt.Fatalf("Write: got %v, want %v", err, errWriteANonNul)
}
}
func testWriteTooMuch(tt *testing.T, typeflag byte) {
for i := 8; i <= 12; i++ {
buf := bytes.Buffer{}
w := NewWriter(&buf)
if err := w.WriteHeader(&Header{
Typeflag: typeflag,
Name: "example.dat",
Size: 10,
Mode: Mode644,
ModTime: time.Unix(0, 0),
}); err != nil {
tt.Fatalf("WriteHeader: %v", err)
}
errWant := error(nil)
if i > 10 {
errWant = errHeaderSize
}
if _, errGot := w.Write(make([]byte, i)); errGot != errWant {
tt.Fatalf("i=%d: Write: got %v, want %v", i, errGot, errWant)
}
}
}
func TestWriteTooMuchRegular(tt *testing.T) { testWriteTooMuch(tt, TypeReg) }
func TestWriteTooMuchSparse(tt *testing.T) { testWriteTooMuch(tt, TypeGNUSparse) }