mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 00:32:11 +01:00
lib/suitar: allow Write to a sparse entry
This commit is contained in:
1 parent
b77e1a67de
commit
b1adeeccb1
2 files changed
+126
-29
No files matched your search
+36
-21
@@ -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.
|
||||
|
||||
@@ -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) }
|
||||
Reference in new issue
Block a user