diff --git a/lib/suitar/suitar.go b/lib/suitar/suitar.go index 6bb103da..9ad3dda6 100644 --- a/lib/suitar/suitar.go +++ b/lib/suitar/suitar.go @@ -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. diff --git a/lib/suitar/suitar_test.go b/lib/suitar/suitar_test.go index 4e827fd4..d3d4513b 100644 --- a/lib/suitar/suitar_test.go +++ b/lib/suitar/suitar_test.go @@ -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) }