Fix Zip64 behavior in zip2zip

This was blindly copying the zip64 extra fields from the central
directory of the original zip file to the new one. The zip64 extra
fields depend on the contents of the header it's attached toa, and in
this case we were copying the zip64 file header offset from the central
directory entry into the destination local file header, which makes no
sense, especially since the offset changed in the new file.

So strip all zip64 extra entries, and we'll create them as necessary
when writing ou the new file.

Bug: 34704111
Test: zip2zip on the original target-files -> img that was broken
Test: m -j blueprint_tools (new android_test.go)
Change-Id: Ie3c0540b13d3afcf42f3d47fff319065952b126f

3 files changed, 101 insertions, 0 deletions

diff --git a/third_party/zip/Android.bp b/third_party/zip/Android.bp
index 044e6f8e..ec89c0c0 100644
--- a/third_party/zip/Android.bp
+++ b/third_party/zip/Android.bp
@@ -24,6 +24,7 @@ bootstrap_go_package {
         "android.go",
     ],
     testSrcs: [
+        "android_test.go",
         "reader_test.go",
         "writer_test.go",
         "zip_test.go",
diff --git a/third_party/zip/android.go b/third_party/zip/android.go
index e2e46ffd..f3b60555 100644
--- a/third_party/zip/android.go
+++ b/third_party/zip/android.go
@@ -32,6 +32,12 @@ func (w *Writer) CopyFrom(orig *File, newName string) error {
 	fh := &fileHeader
 	fh.Flags |= 0x8
 
+	// The zip64 extras change between the Central Directory and Local File Header, while we use
+	// the same structure for both. The Local File Haeder is taken care of by us writing a data
+	// descriptor with the zip64 values. The Central Directory Entry is written by Close(), where
+	// the zip64 extra is automatically created and appended when necessary.
+	fh.Extra = stripZip64Extras(fh.Extra)
+
 	h := &header{
 		FileHeader: fh,
 		offset:     uint64(w.cw.count),
@@ -70,6 +76,29 @@ func (w *Writer) CopyFrom(orig *File, newName string) error {
 	return err
 }
 
+// Strip any Zip64 extra fields
+func stripZip64Extras(input []byte) []byte {
+	ret := []byte{}
+
+	for len(input) >= 4 {
+		r := readBuf(input)
+		tag := r.uint16()
+		size := r.uint16()
+		if int(size) > len(r) {
+			break
+		}
+		if tag != zip64ExtraId {
+			ret = append(ret, input[:4+size]...)
+		}
+		input = input[4+size:]
+	}
+
+	// Keep any trailing data
+	ret = append(ret, input...)
+
+	return ret
+}
+
 // CreateCompressedHeader adds a file to the zip file using the provied
 // FileHeader for the file metadata.
 // It returns a Writer to which the already compressed file contents
diff --git a/third_party/zip/android_test.go b/third_party/zip/android_test.go
new file mode 100644
index 00000000..cdf66ff6
--- /dev/null
+++ b/third_party/zip/android_test.go
@@ -0,0 +1,71 @@
+// Copyright 2017 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package zip
+
+import (
+	"bytes"
+	"testing"
+)
+
+var stripZip64Testcases = []struct {
+	name string
+	in   []byte
+	out  []byte
+}{
+	{
+		name: "empty",
+		in:   []byte{},
+		out:  []byte{},
+	},
+	{
+		name: "trailing data",
+		in:   []byte{1, 2, 3},
+		out:  []byte{1, 2, 3},
+	},
+	{
+		name: "valid non-zip64 extra",
+		in:   []byte{2, 0, 2, 0, 1, 2},
+		out:  []byte{2, 0, 2, 0, 1, 2},
+	},
+	{
+		name: "two valid non-zip64 extras",
+		in:   []byte{2, 0, 2, 0, 1, 2, 2, 0, 0, 0},
+		out:  []byte{2, 0, 2, 0, 1, 2, 2, 0, 0, 0},
+	},
+	{
+		name: "simple zip64 extra",
+		in:   []byte{1, 0, 8, 0, 1, 2, 3, 4, 5, 6, 7, 8},
+		out:  []byte{},
+	},
+	{
+		name: "zip64 extra and valid non-zip64 extra",
+		in:   []byte{1, 0, 8, 0, 1, 2, 3, 4, 5, 6, 7, 8, 2, 0, 0, 0},
+		out:  []byte{2, 0, 0, 0},
+	},
+	{
+		name: "invalid extra",
+		in:   []byte{0, 0, 8, 0, 0, 0},
+		out:  []byte{0, 0, 8, 0, 0, 0},
+	},
+}
+
+func TestStripZip64Extras(t *testing.T) {
+	for _, testcase := range stripZip64Testcases {
+		got := stripZip64Extras(testcase.in)
+		if !bytes.Equal(got, testcase.out) {
+			t.Errorf("Failed testcase %s\ninput: %v\n want: %v\n  got: %v\n", testcase.name, testcase.in, testcase.out, got)
+		}
+	}
+}