reader.go

Documentation: compress/zlib

		 1  // Copyright 2009 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  /*
		 6  Package zlib implements reading and writing of zlib format compressed data,
		 7  as specified in RFC 1950.
		 8  
		 9  The implementation provides filters that uncompress during reading
		10  and compress during writing.	For example, to write compressed data
		11  to a buffer:
		12  
		13  	var b bytes.Buffer
		14  	w := zlib.NewWriter(&b)
		15  	w.Write([]byte("hello, world\n"))
		16  	w.Close()
		17  
		18  and to read that data back:
		19  
		20  	r, err := zlib.NewReader(&b)
		21  	io.Copy(os.Stdout, r)
		22  	r.Close()
		23  */
		24  package zlib
		25  
		26  import (
		27  	"bufio"
		28  	"compress/flate"
		29  	"errors"
		30  	"hash"
		31  	"hash/adler32"
		32  	"io"
		33  )
		34  
		35  const zlibDeflate = 8
		36  
		37  var (
		38  	// ErrChecksum is returned when reading ZLIB data that has an invalid checksum.
		39  	ErrChecksum = errors.New("zlib: invalid checksum")
		40  	// ErrDictionary is returned when reading ZLIB data that has an invalid dictionary.
		41  	ErrDictionary = errors.New("zlib: invalid dictionary")
		42  	// ErrHeader is returned when reading ZLIB data that has an invalid header.
		43  	ErrHeader = errors.New("zlib: invalid header")
		44  )
		45  
		46  type reader struct {
		47  	r						flate.Reader
		48  	decompressor io.ReadCloser
		49  	digest			 hash.Hash32
		50  	err					error
		51  	scratch			[4]byte
		52  }
		53  
		54  // Resetter resets a ReadCloser returned by NewReader or NewReaderDict
		55  // to switch to a new underlying Reader. This permits reusing a ReadCloser
		56  // instead of allocating a new one.
		57  type Resetter interface {
		58  	// Reset discards any buffered data and resets the Resetter as if it was
		59  	// newly initialized with the given reader.
		60  	Reset(r io.Reader, dict []byte) error
		61  }
		62  
		63  // NewReader creates a new ReadCloser.
		64  // Reads from the returned ReadCloser read and decompress data from r.
		65  // If r does not implement io.ByteReader, the decompressor may read more
		66  // data than necessary from r.
		67  // It is the caller's responsibility to call Close on the ReadCloser when done.
		68  //
		69  // The ReadCloser returned by NewReader also implements Resetter.
		70  func NewReader(r io.Reader) (io.ReadCloser, error) {
		71  	return NewReaderDict(r, nil)
		72  }
		73  
		74  // NewReaderDict is like NewReader but uses a preset dictionary.
		75  // NewReaderDict ignores the dictionary if the compressed data does not refer to it.
		76  // If the compressed data refers to a different dictionary, NewReaderDict returns ErrDictionary.
		77  //
		78  // The ReadCloser returned by NewReaderDict also implements Resetter.
		79  func NewReaderDict(r io.Reader, dict []byte) (io.ReadCloser, error) {
		80  	z := new(reader)
		81  	err := z.Reset(r, dict)
		82  	if err != nil {
		83  		return nil, err
		84  	}
		85  	return z, nil
		86  }
		87  
		88  func (z *reader) Read(p []byte) (int, error) {
		89  	if z.err != nil {
		90  		return 0, z.err
		91  	}
		92  
		93  	var n int
		94  	n, z.err = z.decompressor.Read(p)
		95  	z.digest.Write(p[0:n])
		96  	if z.err != io.EOF {
		97  		// In the normal case we return here.
		98  		return n, z.err
		99  	}
	 100  
	 101  	// Finished file; check checksum.
	 102  	if _, err := io.ReadFull(z.r, z.scratch[0:4]); err != nil {
	 103  		if err == io.EOF {
	 104  			err = io.ErrUnexpectedEOF
	 105  		}
	 106  		z.err = err
	 107  		return n, z.err
	 108  	}
	 109  	// ZLIB (RFC 1950) is big-endian, unlike GZIP (RFC 1952).
	 110  	checksum := uint32(z.scratch[0])<<24 | uint32(z.scratch[1])<<16 | uint32(z.scratch[2])<<8 | uint32(z.scratch[3])
	 111  	if checksum != z.digest.Sum32() {
	 112  		z.err = ErrChecksum
	 113  		return n, z.err
	 114  	}
	 115  	return n, io.EOF
	 116  }
	 117  
	 118  // Calling Close does not close the wrapped io.Reader originally passed to NewReader.
	 119  // In order for the ZLIB checksum to be verified, the reader must be
	 120  // fully consumed until the io.EOF.
	 121  func (z *reader) Close() error {
	 122  	if z.err != nil && z.err != io.EOF {
	 123  		return z.err
	 124  	}
	 125  	z.err = z.decompressor.Close()
	 126  	return z.err
	 127  }
	 128  
	 129  func (z *reader) Reset(r io.Reader, dict []byte) error {
	 130  	*z = reader{decompressor: z.decompressor}
	 131  	if fr, ok := r.(flate.Reader); ok {
	 132  		z.r = fr
	 133  	} else {
	 134  		z.r = bufio.NewReader(r)
	 135  	}
	 136  
	 137  	// Read the header (RFC 1950 section 2.2.).
	 138  	_, z.err = io.ReadFull(z.r, z.scratch[0:2])
	 139  	if z.err != nil {
	 140  		if z.err == io.EOF {
	 141  			z.err = io.ErrUnexpectedEOF
	 142  		}
	 143  		return z.err
	 144  	}
	 145  	h := uint(z.scratch[0])<<8 | uint(z.scratch[1])
	 146  	if (z.scratch[0]&0x0f != zlibDeflate) || (h%31 != 0) {
	 147  		z.err = ErrHeader
	 148  		return z.err
	 149  	}
	 150  	haveDict := z.scratch[1]&0x20 != 0
	 151  	if haveDict {
	 152  		_, z.err = io.ReadFull(z.r, z.scratch[0:4])
	 153  		if z.err != nil {
	 154  			if z.err == io.EOF {
	 155  				z.err = io.ErrUnexpectedEOF
	 156  			}
	 157  			return z.err
	 158  		}
	 159  		checksum := uint32(z.scratch[0])<<24 | uint32(z.scratch[1])<<16 | uint32(z.scratch[2])<<8 | uint32(z.scratch[3])
	 160  		if checksum != adler32.Checksum(dict) {
	 161  			z.err = ErrDictionary
	 162  			return z.err
	 163  		}
	 164  	}
	 165  
	 166  	if z.decompressor == nil {
	 167  		if haveDict {
	 168  			z.decompressor = flate.NewReaderDict(z.r, dict)
	 169  		} else {
	 170  			z.decompressor = flate.NewReader(z.r)
	 171  		}
	 172  	} else {
	 173  		z.decompressor.(flate.Resetter).Reset(z.r, dict)
	 174  	}
	 175  	z.digest = adler32.New()
	 176  	return nil
	 177  }
	 178
View as plain text