13 files changed, 1022 insertions, 0 deletions

diff --git a/src/pkg/archive/zip/Makefile b/src/pkg/archive/zip/Makefile
new file mode 100644
index 000000000..9071690f0
--- /dev/null
+++ b/src/pkg/archive/zip/Makefile
@@ -0,0 +1,13 @@
+# Copyright 2010 The Go Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+include ../../../Make.inc
+
+TARG=archive/zip
+GOFILES=\
+	reader.go\
+	struct.go\
+	writer.go\
+
+include ../../../Make.pkg
diff --git a/src/pkg/archive/zip/reader.go b/src/pkg/archive/zip/reader.go
new file mode 100644
index 000000000..f92f9297a
--- /dev/null
+++ b/src/pkg/archive/zip/reader.go
@@ -0,0 +1,311 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package zip
+
+import (
+	"bufio"
+	"compress/flate"
+	"hash"
+	"hash/crc32"
+	"encoding/binary"
+	"io"
+	"io/ioutil"
+	"os"
+)
+
+var (
+	FormatError       = os.NewError("zip: not a valid zip file")
+	UnsupportedMethod = os.NewError("zip: unsupported compression algorithm")
+	ChecksumError     = os.NewError("zip: checksum error")
+)
+
+type Reader struct {
+	r       io.ReaderAt
+	File    []*File
+	Comment string
+}
+
+type ReadCloser struct {
+	f *os.File
+	Reader
+}
+
+type File struct {
+	FileHeader
+	zipr         io.ReaderAt
+	zipsize      int64
+	headerOffset int64
+}
+
+func (f *File) hasDataDescriptor() bool {
+	return f.Flags&0x8 != 0
+}
+
+// OpenReader will open the Zip file specified by name and return a ReadCloser.
+func OpenReader(name string) (*ReadCloser, os.Error) {
+	f, err := os.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	fi, err := f.Stat()
+	if err != nil {
+		f.Close()
+		return nil, err
+	}
+	r := new(ReadCloser)
+	if err := r.init(f, fi.Size); err != nil {
+		f.Close()
+		return nil, err
+	}
+	return r, nil
+}
+
+// NewReader returns a new Reader reading from r, which is assumed to
+// have the given size in bytes.
+func NewReader(r io.ReaderAt, size int64) (*Reader, os.Error) {
+	zr := new(Reader)
+	if err := zr.init(r, size); err != nil {
+		return nil, err
+	}
+	return zr, nil
+}
+
+func (z *Reader) init(r io.ReaderAt, size int64) os.Error {
+	end, err := readDirectoryEnd(r, size)
+	if err != nil {
+		return err
+	}
+	z.r = r
+	z.File = make([]*File, 0, end.directoryRecords)
+	z.Comment = end.comment
+	rs := io.NewSectionReader(r, 0, size)
+	if _, err = rs.Seek(int64(end.directoryOffset), os.SEEK_SET); err != nil {
+		return err
+	}
+	buf := bufio.NewReader(rs)
+
+	// The count of files inside a zip is truncated to fit in a uint16.
+	// Gloss over this by reading headers until we encounter
+	// a bad one, and then only report a FormatError or UnexpectedEOF if
+	// the file count modulo 65536 is incorrect.
+	for {
+		f := &File{zipr: r, zipsize: size}
+		err = readDirectoryHeader(f, buf)
+		if err == FormatError || err == io.ErrUnexpectedEOF {
+			break
+		}
+		if err != nil {
+			return err
+		}
+		z.File = append(z.File, f)
+	}
+	if uint16(len(z.File)) != end.directoryRecords {
+		// Return the readDirectoryHeader error if we read
+		// the wrong number of directory entries.
+		return err
+	}
+	return nil
+}
+
+// Close closes the Zip file, rendering it unusable for I/O.
+func (rc *ReadCloser) Close() os.Error {
+	return rc.f.Close()
+}
+
+// Open returns a ReadCloser that provides access to the File's contents.
+// It is safe to Open and Read from files concurrently.
+func (f *File) Open() (rc io.ReadCloser, err os.Error) {
+	bodyOffset, err := f.findBodyOffset()
+	if err != nil {
+		return
+	}
+	size := int64(f.CompressedSize)
+	if size == 0 && f.hasDataDescriptor() {
+		// permit SectionReader to see the rest of the file
+		size = f.zipsize - (f.headerOffset + bodyOffset)
+	}
+	r := io.NewSectionReader(f.zipr, f.headerOffset+bodyOffset, size)
+	switch f.Method {
+	case Store: // (no compression)
+		rc = ioutil.NopCloser(r)
+	case Deflate:
+		rc = flate.NewReader(r)
+	default:
+		err = UnsupportedMethod
+	}
+	if rc != nil {
+		rc = &checksumReader{rc, crc32.NewIEEE(), f, r}
+	}
+	return
+}
+
+type checksumReader struct {
+	rc   io.ReadCloser
+	hash hash.Hash32
+	f    *File
+	zipr io.Reader // for reading the data descriptor
+}
+
+func (r *checksumReader) Read(b []byte) (n int, err os.Error) {
+	n, err = r.rc.Read(b)
+	r.hash.Write(b[:n])
+	if err != os.EOF {
+		return
+	}
+	if r.f.hasDataDescriptor() {
+		if err = readDataDescriptor(r.zipr, r.f); err != nil {
+			return
+		}
+	}
+	if r.hash.Sum32() != r.f.CRC32 {
+		err = ChecksumError
+	}
+	return
+}
+
+func (r *checksumReader) Close() os.Error { return r.rc.Close() }
+
+func readFileHeader(f *File, r io.Reader) os.Error {
+	var b [fileHeaderLen]byte
+	if _, err := io.ReadFull(r, b[:]); err != nil {
+		return err
+	}
+	c := binary.LittleEndian
+	if sig := c.Uint32(b[:4]); sig != fileHeaderSignature {
+		return FormatError
+	}
+	f.ReaderVersion = c.Uint16(b[4:6])
+	f.Flags = c.Uint16(b[6:8])
+	f.Method = c.Uint16(b[8:10])
+	f.ModifiedTime = c.Uint16(b[10:12])
+	f.ModifiedDate = c.Uint16(b[12:14])
+	f.CRC32 = c.Uint32(b[14:18])
+	f.CompressedSize = c.Uint32(b[18:22])
+	f.UncompressedSize = c.Uint32(b[22:26])
+	filenameLen := int(c.Uint16(b[26:28]))
+	extraLen := int(c.Uint16(b[28:30]))
+	d := make([]byte, filenameLen+extraLen)
+	if _, err := io.ReadFull(r, d); err != nil {
+		return err
+	}
+	f.Name = string(d[:filenameLen])
+	f.Extra = d[filenameLen:]
+	return nil
+}
+
+// findBodyOffset does the minimum work to verify the file has a header
+// and returns the file body offset.
+func (f *File) findBodyOffset() (int64, os.Error) {
+	r := io.NewSectionReader(f.zipr, f.headerOffset, f.zipsize-f.headerOffset)
+	var b [fileHeaderLen]byte
+	if _, err := io.ReadFull(r, b[:]); err != nil {
+		return 0, err
+	}
+	c := binary.LittleEndian
+	if sig := c.Uint32(b[:4]); sig != fileHeaderSignature {
+		return 0, FormatError
+	}
+	filenameLen := int(c.Uint16(b[26:28]))
+	extraLen := int(c.Uint16(b[28:30]))
+	return int64(fileHeaderLen + filenameLen + extraLen), nil
+}
+
+// readDirectoryHeader attempts to read a directory header from r.
+// It returns io.ErrUnexpectedEOF if it cannot read a complete header,
+// and FormatError if it doesn't find a valid header signature.
+func readDirectoryHeader(f *File, r io.Reader) os.Error {
+	var b [directoryHeaderLen]byte
+	if _, err := io.ReadFull(r, b[:]); err != nil {
+		return err
+	}
+	c := binary.LittleEndian
+	if sig := c.Uint32(b[:4]); sig != directoryHeaderSignature {
+		return FormatError
+	}
+	f.CreatorVersion = c.Uint16(b[4:6])
+	f.ReaderVersion = c.Uint16(b[6:8])
+	f.Flags = c.Uint16(b[8:10])
+	f.Method = c.Uint16(b[10:12])
+	f.ModifiedTime = c.Uint16(b[12:14])
+	f.ModifiedDate = c.Uint16(b[14:16])
+	f.CRC32 = c.Uint32(b[16:20])
+	f.CompressedSize = c.Uint32(b[20:24])
+	f.UncompressedSize = c.Uint32(b[24:28])
+	filenameLen := int(c.Uint16(b[28:30]))
+	extraLen := int(c.Uint16(b[30:32]))
+	commentLen := int(c.Uint16(b[32:34]))
+	// startDiskNumber := c.Uint16(b[34:36])    // Unused
+	// internalAttributes := c.Uint16(b[36:38]) // Unused
+	// externalAttributes := c.Uint32(b[38:42]) // Unused
+	f.headerOffset = int64(c.Uint32(b[42:46]))
+	d := make([]byte, filenameLen+extraLen+commentLen)
+	if _, err := io.ReadFull(r, d); err != nil {
+		return err
+	}
+	f.Name = string(d[:filenameLen])
+	f.Extra = d[filenameLen : filenameLen+extraLen]
+	f.Comment = string(d[filenameLen+extraLen:])
+	return nil
+}
+
+func readDataDescriptor(r io.Reader, f *File) os.Error {
+	var b [dataDescriptorLen]byte
+	if _, err := io.ReadFull(r, b[:]); err != nil {
+		return err
+	}
+	c := binary.LittleEndian
+	f.CRC32 = c.Uint32(b[:4])
+	f.CompressedSize = c.Uint32(b[4:8])
+	f.UncompressedSize = c.Uint32(b[8:12])
+	return nil
+}
+
+func readDirectoryEnd(r io.ReaderAt, size int64) (dir *directoryEnd, err os.Error) {
+	// look for directoryEndSignature in the last 1k, then in the last 65k
+	var b []byte
+	for i, bLen := range []int64{1024, 65 * 1024} {
+		if bLen > size {
+			bLen = size
+		}
+		b = make([]byte, int(bLen))
+		if _, err := r.ReadAt(b, size-bLen); err != nil && err != os.EOF {
+			return nil, err
+		}
+		if p := findSignatureInBlock(b); p >= 0 {
+			b = b[p:]
+			break
+		}
+		if i == 1 || bLen == size {
+			return nil, FormatError
+		}
+	}
+
+	// read header into struct
+	c := binary.LittleEndian
+	d := new(directoryEnd)
+	d.diskNbr = c.Uint16(b[4:6])
+	d.dirDiskNbr = c.Uint16(b[6:8])
+	d.dirRecordsThisDisk = c.Uint16(b[8:10])
+	d.directoryRecords = c.Uint16(b[10:12])
+	d.directorySize = c.Uint32(b[12:16])
+	d.directoryOffset = c.Uint32(b[16:20])
+	d.commentLen = c.Uint16(b[20:22])
+	d.comment = string(b[22 : 22+int(d.commentLen)])
+	return d, nil
+}
+
+func findSignatureInBlock(b []byte) int {
+	for i := len(b) - directoryEndLen; i >= 0; i-- {
+		// defined from directoryEndSignature in struct.go
+		if b[i] == 'P' && b[i+1] == 'K' && b[i+2] == 0x05 && b[i+3] == 0x06 {
+			// n is length of comment
+			n := int(b[i+directoryEndLen-2]) | int(b[i+directoryEndLen-1])<<8
+			if n+directoryEndLen+i == len(b) {
+				return i
+			}
+		}
+	}
+	return -1
+}
diff --git a/src/pkg/archive/zip/reader_test.go b/src/pkg/archive/zip/reader_test.go
new file mode 100644
index 000000000..fd5fed2af
--- /dev/null
+++ b/src/pkg/archive/zip/reader_test.go
@@ -0,0 +1,233 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package zip
+
+import (
+	"bytes"
+	"encoding/binary"
+	"io"
+	"io/ioutil"
+	"os"
+	"testing"
+	"time"
+)
+
+type ZipTest struct {
+	Name    string
+	Comment string
+	File    []ZipTestFile
+	Error   os.Error // the error that Opening this file should return
+}
+
+type ZipTestFile struct {
+	Name    string
+	Content []byte // if blank, will attempt to compare against File
+	File    string // name of file to compare to (relative to testdata/)
+	Mtime   string // modified time in format "mm-dd-yy hh:mm:ss"
+}
+
+// Caution: The Mtime values found for the test files should correspond to
+//          the values listed with unzip -l <zipfile>. However, the values
+//          listed by unzip appear to be off by some hours. When creating
+//          fresh test files and testing them, this issue is not present.
+//          The test files were created in Sydney, so there might be a time
+//          zone issue. The time zone information does have to be encoded
+//          somewhere, because otherwise unzip -l could not provide a different
+//          time from what the archive/zip package provides, but there appears
+//          to be no documentation about this.
+
+var tests = []ZipTest{
+	{
+		Name:    "test.zip",
+		Comment: "This is a zipfile comment.",
+		File: []ZipTestFile{
+			{
+				Name:    "test.txt",
+				Content: []byte("This is a test text file.\n"),
+				Mtime:   "09-05-10 12:12:02",
+			},
+			{
+				Name:  "gophercolor16x16.png",
+				File:  "gophercolor16x16.png",
+				Mtime: "09-05-10 15:52:58",
+			},
+		},
+	},
+	{
+		Name: "r.zip",
+		File: []ZipTestFile{
+			{
+				Name:  "r/r.zip",
+				File:  "r.zip",
+				Mtime: "03-04-10 00:24:16",
+			},
+		},
+	},
+	{Name: "readme.zip"},
+	{Name: "readme.notzip", Error: FormatError},
+	{
+		Name: "dd.zip",
+		File: []ZipTestFile{
+			{
+				Name:    "filename",
+				Content: []byte("This is a test textfile.\n"),
+				Mtime:   "02-02-11 13:06:20",
+			},
+		},
+	},
+}
+
+func TestReader(t *testing.T) {
+	for _, zt := range tests {
+		readTestZip(t, zt)
+	}
+}
+
+func readTestZip(t *testing.T, zt ZipTest) {
+	z, err := OpenReader("testdata/" + zt.Name)
+	if err != zt.Error {
+		t.Errorf("error=%v, want %v", err, zt.Error)
+		return
+	}
+
+	// bail if file is not zip
+	if err == FormatError {
+		return
+	}
+	defer z.Close()
+
+	// bail here if no Files expected to be tested
+	// (there may actually be files in the zip, but we don't care)
+	if zt.File == nil {
+		return
+	}
+
+	if z.Comment != zt.Comment {
+		t.Errorf("%s: comment=%q, want %q", zt.Name, z.Comment, zt.Comment)
+	}
+	if len(z.File) != len(zt.File) {
+		t.Errorf("%s: file count=%d, want %d", zt.Name, len(z.File), len(zt.File))
+	}
+
+	// test read of each file
+	for i, ft := range zt.File {
+		readTestFile(t, ft, z.File[i])
+	}
+
+	// test simultaneous reads
+	n := 0
+	done := make(chan bool)
+	for i := 0; i < 5; i++ {
+		for j, ft := range zt.File {
+			go func() {
+				readTestFile(t, ft, z.File[j])
+				done <- true
+			}()
+			n++
+		}
+	}
+	for ; n > 0; n-- {
+		<-done
+	}
+
+	// test invalid checksum
+	if !z.File[0].hasDataDescriptor() { // skip test when crc32 in dd
+		z.File[0].CRC32++ // invalidate
+		r, err := z.File[0].Open()
+		if err != nil {
+			t.Error(err)
+			return
+		}
+		var b bytes.Buffer
+		_, err = io.Copy(&b, r)
+		if err != ChecksumError {
+			t.Errorf("%s: copy error=%v, want %v", z.File[0].Name, err, ChecksumError)
+		}
+	}
+}
+
+func readTestFile(t *testing.T, ft ZipTestFile, f *File) {
+	if f.Name != ft.Name {
+		t.Errorf("name=%q, want %q", f.Name, ft.Name)
+	}
+
+	mtime, err := time.Parse("01-02-06 15:04:05", ft.Mtime)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	if got, want := f.Mtime_ns()/1e9, mtime.Seconds(); got != want {
+		t.Errorf("%s: mtime=%s (%d); want %s (%d)", f.Name, time.SecondsToUTC(got), got, mtime, want)
+	}
+
+	size0 := f.UncompressedSize
+
+	var b bytes.Buffer
+	r, err := f.Open()
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	if size1 := f.UncompressedSize; size0 != size1 {
+		t.Errorf("file %q changed f.UncompressedSize from %d to %d", f.Name, size0, size1)
+	}
+
+	_, err = io.Copy(&b, r)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	r.Close()
+
+	var c []byte
+	if len(ft.Content) != 0 {
+		c = ft.Content
+	} else if c, err = ioutil.ReadFile("testdata/" + ft.File); err != nil {
+		t.Error(err)
+		return
+	}
+
+	if b.Len() != len(c) {
+		t.Errorf("%s: len=%d, want %d", f.Name, b.Len(), len(c))
+		return
+	}
+
+	for i, b := range b.Bytes() {
+		if b != c[i] {
+			t.Errorf("%s: content[%d]=%q want %q", f.Name, i, b, c[i])
+			return
+		}
+	}
+}
+
+func TestInvalidFiles(t *testing.T) {
+	const size = 1024 * 70 // 70kb
+	b := make([]byte, size)
+
+	// zeroes
+	_, err := NewReader(sliceReaderAt(b), size)
+	if err != FormatError {
+		t.Errorf("zeroes: error=%v, want %v", err, FormatError)
+	}
+
+	// repeated directoryEndSignatures
+	sig := make([]byte, 4)
+	binary.LittleEndian.PutUint32(sig, directoryEndSignature)
+	for i := 0; i < size-4; i += 4 {
+		copy(b[i:i+4], sig)
+	}
+	_, err = NewReader(sliceReaderAt(b), size)
+	if err != FormatError {
+		t.Errorf("sigs: error=%v, want %v", err, FormatError)
+	}
+}
+
+type sliceReaderAt []byte
+
+func (r sliceReaderAt) ReadAt(b []byte, off int64) (int, os.Error) {
+	copy(b, r[int(off):int(off)+len(b)])
+	return len(b), nil
+}
diff --git a/src/pkg/archive/zip/struct.go b/src/pkg/archive/zip/struct.go
new file mode 100644
index 000000000..1d6e70f10
--- /dev/null
+++ b/src/pkg/archive/zip/struct.go
@@ -0,0 +1,91 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Package zip provides support for reading and writing ZIP archives.
+
+See: http://www.pkware.com/documents/casestudies/APPNOTE.TXT
+
+This package does not support ZIP64 or disk spanning.
+*/
+package zip
+
+import "os"
+import "time"
+
+// Compression methods.
+const (
+	Store   uint16 = 0
+	Deflate uint16 = 8
+)
+
+const (
+	fileHeaderSignature      = 0x04034b50
+	directoryHeaderSignature = 0x02014b50
+	directoryEndSignature    = 0x06054b50
+	fileHeaderLen            = 30 // + filename + extra
+	directoryHeaderLen       = 46 // + filename + extra + comment
+	directoryEndLen          = 22 // + comment
+	dataDescriptorLen        = 12
+)
+
+type FileHeader struct {
+	Name             string
+	CreatorVersion   uint16
+	ReaderVersion    uint16
+	Flags            uint16
+	Method           uint16
+	ModifiedTime     uint16 // MS-DOS time
+	ModifiedDate     uint16 // MS-DOS date
+	CRC32            uint32
+	CompressedSize   uint32
+	UncompressedSize uint32
+	Extra            []byte
+	Comment          string
+}
+
+type directoryEnd struct {
+	diskNbr            uint16 // unused
+	dirDiskNbr         uint16 // unused
+	dirRecordsThisDisk uint16 // unused
+	directoryRecords   uint16
+	directorySize      uint32
+	directoryOffset    uint32 // relative to file
+	commentLen         uint16
+	comment            string
+}
+
+func recoverError(err *os.Error) {
+	if e := recover(); e != nil {
+		if osErr, ok := e.(os.Error); ok {
+			*err = osErr
+			return
+		}
+		panic(e)
+	}
+}
+
+// msDosTimeToTime converts an MS-DOS date and time into a time.Time.
+// The resolution is 2s.
+// See: http://msdn.microsoft.com/en-us/library/ms724247(v=VS.85).aspx
+func msDosTimeToTime(dosDate, dosTime uint16) time.Time {
+	return time.Time{
+		// date bits 0-4: day of month; 5-8: month; 9-15: years since 1980
+		Year:  int64(dosDate>>9 + 1980),
+		Month: int(dosDate >> 5 & 0xf),
+		Day:   int(dosDate & 0x1f),
+
+		// time bits 0-4: second/2; 5-10: minute; 11-15: hour
+		Hour:   int(dosTime >> 11),
+		Minute: int(dosTime >> 5 & 0x3f),
+		Second: int(dosTime & 0x1f * 2),
+	}
+}
+
+// Mtime_ns returns the modified time in ns since epoch.
+// The resolution is 2s.
+func (h *FileHeader) Mtime_ns() int64 {
+	t := msDosTimeToTime(h.ModifiedDate, h.ModifiedTime)
+	return t.Seconds() * 1e9
+}
diff --git a/src/pkg/archive/zip/testdata/dd.zip b/src/pkg/archive/zip/testdata/dd.zip
new file mode 100644
index 000000000..e53378b0b
--- /dev/null
+++ b/src/pkg/archive/zip/testdata/dd.zip
diff --git a/src/pkg/archive/zip/testdata/gophercolor16x16.png b/src/pkg/archive/zip/testdata/gophercolor16x16.png
new file mode 100644
index 000000000..48854ff3b
--- /dev/null
+++ b/src/pkg/archive/zip/testdata/gophercolor16x16.png
diff --git a/src/pkg/archive/zip/testdata/r.zip b/src/pkg/archive/zip/testdata/r.zip
new file mode 100644
index 000000000..ea0fa2ffc
--- /dev/null
+++ b/src/pkg/archive/zip/testdata/r.zip
diff --git a/src/pkg/archive/zip/testdata/readme.notzip b/src/pkg/archive/zip/testdata/readme.notzip
new file mode 100644
index 000000000..06668c4c1
--- /dev/null
+++ b/src/pkg/archive/zip/testdata/readme.notzip
diff --git a/src/pkg/archive/zip/testdata/readme.zip b/src/pkg/archive/zip/testdata/readme.zip
new file mode 100644
index 000000000..db3bb900e
--- /dev/null
+++ b/src/pkg/archive/zip/testdata/readme.zip
diff --git a/src/pkg/archive/zip/testdata/test.zip b/src/pkg/archive/zip/testdata/test.zip
new file mode 100644
index 000000000..03890c05d
--- /dev/null
+++ b/src/pkg/archive/zip/testdata/test.zip
diff --git a/src/pkg/archive/zip/writer.go b/src/pkg/archive/zip/writer.go
new file mode 100644
index 000000000..2065b06da
--- /dev/null
+++ b/src/pkg/archive/zip/writer.go
@@ -0,0 +1,244 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package zip
+
+import (
+	"bufio"
+	"compress/flate"
+	"encoding/binary"
+	"hash"
+	"hash/crc32"
+	"io"
+	"os"
+)
+
+// TODO(adg): support zip file comments
+// TODO(adg): support specifying deflate level
+
+// Writer implements a zip file writer.
+type Writer struct {
+	*countWriter
+	dir    []*header
+	last   *fileWriter
+	closed bool
+}
+
+type header struct {
+	*FileHeader
+	offset uint32
+}
+
+// NewWriter returns a new Writer writing a zip file to w.
+func NewWriter(w io.Writer) *Writer {
+	return &Writer{countWriter: &countWriter{w: bufio.NewWriter(w)}}
+}
+
+// Close finishes writing the zip file by writing the central directory.
+// It does not (and can not) close the underlying writer.
+func (w *Writer) Close() (err os.Error) {
+	if w.last != nil && !w.last.closed {
+		if err = w.last.close(); err != nil {
+			return
+		}
+		w.last = nil
+	}
+	if w.closed {
+		return os.NewError("zip: writer closed twice")
+	}
+	w.closed = true
+
+	defer recoverError(&err)
+
+	// write central directory
+	start := w.count
+	for _, h := range w.dir {
+		write(w, uint32(directoryHeaderSignature))
+		write(w, h.CreatorVersion)
+		write(w, h.ReaderVersion)
+		write(w, h.Flags)
+		write(w, h.Method)
+		write(w, h.ModifiedTime)
+		write(w, h.ModifiedDate)
+		write(w, h.CRC32)
+		write(w, h.CompressedSize)
+		write(w, h.UncompressedSize)
+		write(w, uint16(len(h.Name)))
+		write(w, uint16(len(h.Extra)))
+		write(w, uint16(len(h.Comment)))
+		write(w, uint16(0)) // disk number start
+		write(w, uint16(0)) // internal file attributes
+		write(w, uint32(0)) // external file attributes
+		write(w, h.offset)
+		writeBytes(w, []byte(h.Name))
+		writeBytes(w, h.Extra)
+		writeBytes(w, []byte(h.Comment))
+	}
+	end := w.count
+
+	// write end record
+	write(w, uint32(directoryEndSignature))
+	write(w, uint16(0))          // disk number
+	write(w, uint16(0))          // disk number where directory starts
+	write(w, uint16(len(w.dir))) // number of entries this disk
+	write(w, uint16(len(w.dir))) // number of entries total
+	write(w, uint32(end-start))  // size of directory
+	write(w, uint32(start))      // start of directory
+	write(w, uint16(0))          // size of comment
+
+	return w.w.(*bufio.Writer).Flush()
+}
+
+// Create adds a file to the zip file using the provided name.
+// It returns a Writer to which the file contents should be written.
+// The file's contents must be written to the io.Writer before the next
+// call to Create, CreateHeader, or Close.
+func (w *Writer) Create(name string) (io.Writer, os.Error) {
+	header := &FileHeader{
+		Name:   name,
+		Method: Deflate,
+	}
+	return w.CreateHeader(header)
+}
+
+// CreateHeader adds a file to the zip file using the provided FileHeader
+// for the file metadata. 
+// It returns a Writer to which the file contents should be written.
+// The file's contents must be written to the io.Writer before the next
+// call to Create, CreateHeader, or Close.
+func (w *Writer) CreateHeader(fh *FileHeader) (io.Writer, os.Error) {
+	if w.last != nil && !w.last.closed {
+		if err := w.last.close(); err != nil {
+			return nil, err
+		}
+	}
+
+	fh.Flags |= 0x8 // we will write a data descriptor
+	fh.CreatorVersion = 0x14
+	fh.ReaderVersion = 0x14
+
+	fw := &fileWriter{
+		zipw:      w,
+		compCount: &countWriter{w: w},
+		crc32:     crc32.NewIEEE(),
+	}
+	switch fh.Method {
+	case Store:
+		fw.comp = nopCloser{fw.compCount}
+	case Deflate:
+		fw.comp = flate.NewWriter(fw.compCount, 5)
+	default:
+		return nil, UnsupportedMethod
+	}
+	fw.rawCount = &countWriter{w: fw.comp}
+
+	h := &header{
+		FileHeader: fh,
+		offset:     uint32(w.count),
+	}
+	w.dir = append(w.dir, h)
+	fw.header = h
+
+	if err := writeHeader(w, fh); err != nil {
+		return nil, err
+	}
+
+	w.last = fw
+	return fw, nil
+}
+
+func writeHeader(w io.Writer, h *FileHeader) (err os.Error) {
+	defer recoverError(&err)
+	write(w, uint32(fileHeaderSignature))
+	write(w, h.ReaderVersion)
+	write(w, h.Flags)
+	write(w, h.Method)
+	write(w, h.ModifiedTime)
+	write(w, h.ModifiedDate)
+	write(w, h.CRC32)
+	write(w, h.CompressedSize)
+	write(w, h.UncompressedSize)
+	write(w, uint16(len(h.Name)))
+	write(w, uint16(len(h.Extra)))
+	writeBytes(w, []byte(h.Name))
+	writeBytes(w, h.Extra)
+	return nil
+}
+
+type fileWriter struct {
+	*header
+	zipw      io.Writer
+	rawCount  *countWriter
+	comp      io.WriteCloser
+	compCount *countWriter
+	crc32     hash.Hash32
+	closed    bool
+}
+
+func (w *fileWriter) Write(p []byte) (int, os.Error) {
+	if w.closed {
+		return 0, os.NewError("zip: write to closed file")
+	}
+	w.crc32.Write(p)
+	return w.rawCount.Write(p)
+}
+
+func (w *fileWriter) close() (err os.Error) {
+	if w.closed {
+		return os.NewError("zip: file closed twice")
+	}
+	w.closed = true
+	if err = w.comp.Close(); err != nil {
+		return
+	}
+
+	// update FileHeader
+	fh := w.header.FileHeader
+	fh.CRC32 = w.crc32.Sum32()
+	fh.CompressedSize = uint32(w.compCount.count)
+	fh.UncompressedSize = uint32(w.rawCount.count)
+
+	// write data descriptor
+	defer recoverError(&err)
+	write(w.zipw, fh.CRC32)
+	write(w.zipw, fh.CompressedSize)
+	write(w.zipw, fh.UncompressedSize)
+
+	return nil
+}
+
+type countWriter struct {
+	w     io.Writer
+	count int64
+}
+
+func (w *countWriter) Write(p []byte) (int, os.Error) {
+	n, err := w.w.Write(p)
+	w.count += int64(n)
+	return n, err
+}
+
+type nopCloser struct {
+	io.Writer
+}
+
+func (w nopCloser) Close() os.Error {
+	return nil
+}
+
+func write(w io.Writer, data interface{}) {
+	if err := binary.Write(w, binary.LittleEndian, data); err != nil {
+		panic(err)
+	}
+}
+
+func writeBytes(w io.Writer, b []byte) {
+	n, err := w.Write(b)
+	if err != nil {
+		panic(err)
+	}
+	if n != len(b) {
+		panic(io.ErrShortWrite)
+	}
+}
diff --git a/src/pkg/archive/zip/writer_test.go b/src/pkg/archive/zip/writer_test.go
new file mode 100644
index 000000000..eb2a80c3f
--- /dev/null
+++ b/src/pkg/archive/zip/writer_test.go
@@ -0,0 +1,73 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package zip
+
+import (
+	"bytes"
+	"io/ioutil"
+	"rand"
+	"testing"
+)
+
+// TODO(adg): a more sophisticated test suite
+
+const testString = "Rabbits, guinea pigs, gophers, marsupial rats, and quolls."
+
+func TestWriter(t *testing.T) {
+	largeData := make([]byte, 1<<17)
+	for i := range largeData {
+		largeData[i] = byte(rand.Int())
+	}
+
+	// write a zip file
+	buf := new(bytes.Buffer)
+	w := NewWriter(buf)
+	testCreate(t, w, "foo", []byte(testString), Store)
+	testCreate(t, w, "bar", largeData, Deflate)
+	if err := w.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	// read it back
+	r, err := NewReader(sliceReaderAt(buf.Bytes()), int64(buf.Len()))
+	if err != nil {
+		t.Fatal(err)
+	}
+	testReadFile(t, r.File[0], []byte(testString))
+	testReadFile(t, r.File[1], largeData)
+}
+
+func testCreate(t *testing.T, w *Writer, name string, data []byte, method uint16) {
+	header := &FileHeader{
+		Name:   name,
+		Method: method,
+	}
+	f, err := w.CreateHeader(header)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = f.Write(data)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func testReadFile(t *testing.T, f *File, data []byte) {
+	rc, err := f.Open()
+	if err != nil {
+		t.Fatal("opening:", err)
+	}
+	b, err := ioutil.ReadAll(rc)
+	if err != nil {
+		t.Fatal("reading:", err)
+	}
+	err = rc.Close()
+	if err != nil {
+		t.Fatal("closing:", err)
+	}
+	if !bytes.Equal(b, data) {
+		t.Errorf("File contents %q, want %q", b, data)
+	}
+}
diff --git a/src/pkg/archive/zip/zip_test.go b/src/pkg/archive/zip/zip_test.go
new file mode 100644
index 000000000..0f71fdfac
--- /dev/null
+++ b/src/pkg/archive/zip/zip_test.go
@@ -0,0 +1,57 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Tests that involve both reading and writing.
+
+package zip
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"testing"
+)
+
+type stringReaderAt string
+
+func (s stringReaderAt) ReadAt(p []byte, off int64) (n int, err os.Error) {
+	if off >= int64(len(s)) {
+		return 0, os.EOF
+	}
+	n = copy(p, s[off:])
+	return
+}
+
+func TestOver65kFiles(t *testing.T) {
+	if testing.Short() {
+		t.Logf("slow test; skipping")
+		return
+	}
+	buf := new(bytes.Buffer)
+	w := NewWriter(buf)
+	const nFiles = (1 << 16) + 42
+	for i := 0; i < nFiles; i++ {
+		_, err := w.Create(fmt.Sprintf("%d.dat", i))
+		if err != nil {
+			t.Fatalf("creating file %d: %v", i, err)
+		}
+	}
+	if err := w.Close(); err != nil {
+		t.Fatalf("Writer.Close: %v", err)
+	}
+	rat := stringReaderAt(buf.String())
+	zr, err := NewReader(rat, int64(len(rat)))
+	if err != nil {
+		t.Fatalf("NewReader: %v", err)
+	}
+	if got := len(zr.File); got != nFiles {
+		t.Fatalf("File contains %d files, want %d", got, nFiles)
+	}
+	for i := 0; i < nFiles; i++ {
+		want := fmt.Sprintf("%d.dat", i)
+		if zr.File[i].Name != want {
+			t.Fatalf("File(%d) = %q, want %q", i, zr.File[i].Name, want)
+		}
+	}
+}