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

diff --git a/src/pkg/archive/tar/writer.go b/src/pkg/archive/tar/writer.go
index d107dbbb51cf3f158306f94adb68eec4c6302294..dafb2cabf37a8c4194b49ac37f0b65df860ae3c0 100644 (file)
--- 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 512fab1a6f1c18496f7ca834dff08347c814f0cf..5e42e322f9c722f66d730793cfdab18895a25c30 100644 (file)
--- 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)
+               }
+       }
+}