From 7a9e7c0afa79caf4a2dc8a70b14745d6c8f912bb Mon Sep 17 00:00:00 2001 From: Cristian Staretu Date: Thu, 17 Jul 2014 10:00:29 +1000 Subject: [PATCH] archive/tar: fix writing of pax headers "archive/tar: reuse temporary buffer in writeHeader" introduced a change which was supposed to help lower the number of allocations from 512 bytes for every call to writeHeader. This change broke the writing of PAX headers. writeHeader calls writePAXHeader and writePAXHeader calls writeHeader again. writeHeader will end up writing the PAX header twice. example broken header: PaxHeaders.4007/NetLock_Arany_=Class_Gold=_Ftanstvny.crt0000000000000000000000000000007112301216634021512 xustar0000000000000000 PaxHeaders.4007/NetLock_Arany_=Class_Gold=_Ftanstvny.crt0000000000000000000000000000007112301216634021512 xustar0000000000000000 example correct header: PaxHeaders.4290/NetLock_Arany_=Class_Gold=_Ftanstvny.crt0000000000000000000000000000007112301216634021516 xustar0000000000000000 0100644000000000000000000000270412301216634007250 0ustar0000000000000000 This commit adds a dedicated buffer for pax headers to the Writer struct. This change increases the size of the struct by 512 bytes, but allows tar/writer to avoid allocating 512 bytes for all written headers and it avoids allocating 512 more bytes for pax headers. LGTM=dsymonds R=dsymonds, dave, iant CC=golang-codereviews https://golang.org/cl/110480043 --- src/pkg/archive/tar/writer.go | 15 +++++++++++-- src/pkg/archive/tar/writer_test.go | 35 ++++++++++++++++++++++++++++++ 2 files changed, 48 insertions(+), 2 deletions(-) diff --git a/src/pkg/archive/tar/writer.go b/src/pkg/archive/tar/writer.go index d107dbbb51..dafb2cabf3 100644 --- a/src/pkg/archive/tar/writer.go +++ b/src/pkg/archive/tar/writer.go @@ -39,7 +39,8 @@ type Writer struct { closed bool usedBinary bool // whether the binary numeric field extension was used preferPax bool // use pax header instead of binary numeric header - hdrBuff [blockSize]byte // buffer to use in writeHeader + hdrBuff [blockSize]byte // buffer to use in writeHeader when writing a regular header + paxHdrBuff [blockSize]byte // buffer to use in writeHeader when writing a pax header } // NewWriter creates a new Writer writing to w. @@ -161,7 +162,17 @@ func (tw *Writer) writeHeader(hdr *Header, allowPax bool) error { // subsecond time resolution, but for now let's just capture // too long fields or non ascii characters - header := tw.hdrBuff[:] + var header []byte + + // We need to select which scratch buffer to use carefully, + // since this method is called recursively to write PAX headers. + // If allowPax is true, this is the non-recursive call, and we will use hdrBuff. + // If allowPax is false, we are being called by writePAXHeader, and hdrBuff is + // already being used by the non-recursive call, so we must use paxHdrBuff. + header = tw.hdrBuff[:] + if !allowPax { + header = tw.paxHdrBuff[:] + } copy(header, zeroBlock) s := slicer(header) diff --git a/src/pkg/archive/tar/writer_test.go b/src/pkg/archive/tar/writer_test.go index 512fab1a6f..5e42e322f9 100644 --- a/src/pkg/archive/tar/writer_test.go +++ b/src/pkg/archive/tar/writer_test.go @@ -454,3 +454,38 @@ func TestUSTARLongName(t *testing.T) { t.Fatal("Couldn't recover long name") } } + +func TestValidTypeflagWithPAXHeader(t *testing.T) { + var buffer bytes.Buffer + tw := NewWriter(&buffer) + + fileName := strings.Repeat("ab", 100) + + hdr := &Header{ + Name: fileName, + Size: 4, + Typeflag: 0, + } + if err := tw.WriteHeader(hdr); err != nil { + t.Fatalf("Failed to write header: %s", err) + } + if _, err := tw.Write([]byte("fooo")); err != nil { + t.Fatalf("Failed to write the file's data: %s", err) + } + tw.Close() + + tr := NewReader(&buffer) + + for { + header, err := tr.Next() + if err == io.EOF { + break + } + if err != nil { + t.Fatalf("Failed to read header: %s", err) + } + if header.Typeflag != 0 { + t.Fatalf("Typeflag should've been 0, found %d", header.Typeflag) + } + } +} -- 2.48.1