github.com/spotify/syslog-redirector-golang@v0.0.0-20140320174030-4859f03d829a/src/pkg/compress/zlib/reader.go (about)

     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  // NewReader creates a new io.ReadCloser that satisfies reads by decompressing data read from r.
    55  // The implementation buffers input and may read more data than necessary from r.
    56  // It is the caller's responsibility to call Close on the ReadCloser when done.
    57  func NewReader(r io.Reader) (io.ReadCloser, error) {
    58  	return NewReaderDict(r, nil)
    59  }
    60  
    61  // NewReaderDict is like NewReader but uses a preset dictionary.
    62  // NewReaderDict ignores the dictionary if the compressed data does not refer to it.
    63  func NewReaderDict(r io.Reader, dict []byte) (io.ReadCloser, error) {
    64  	z := new(reader)
    65  	if fr, ok := r.(flate.Reader); ok {
    66  		z.r = fr
    67  	} else {
    68  		z.r = bufio.NewReader(r)
    69  	}
    70  	_, err := io.ReadFull(z.r, z.scratch[0:2])
    71  	if err != nil {
    72  		return nil, err
    73  	}
    74  	h := uint(z.scratch[0])<<8 | uint(z.scratch[1])
    75  	if (z.scratch[0]&0x0f != zlibDeflate) || (h%31 != 0) {
    76  		return nil, ErrHeader
    77  	}
    78  	if z.scratch[1]&0x20 != 0 {
    79  		_, err = io.ReadFull(z.r, z.scratch[0:4])
    80  		if err != nil {
    81  			return nil, err
    82  		}
    83  		checksum := uint32(z.scratch[0])<<24 | uint32(z.scratch[1])<<16 | uint32(z.scratch[2])<<8 | uint32(z.scratch[3])
    84  		if checksum != adler32.Checksum(dict) {
    85  			return nil, ErrDictionary
    86  		}
    87  		z.decompressor = flate.NewReaderDict(z.r, dict)
    88  	} else {
    89  		z.decompressor = flate.NewReader(z.r)
    90  	}
    91  	z.digest = adler32.New()
    92  	return z, nil
    93  }
    94  
    95  func (z *reader) Read(p []byte) (n int, err error) {
    96  	if z.err != nil {
    97  		return 0, z.err
    98  	}
    99  	if len(p) == 0 {
   100  		return 0, nil
   101  	}
   102  
   103  	n, err = z.decompressor.Read(p)
   104  	z.digest.Write(p[0:n])
   105  	if n != 0 || err != io.EOF {
   106  		z.err = err
   107  		return
   108  	}
   109  
   110  	// Finished file; check checksum.
   111  	if _, err := io.ReadFull(z.r, z.scratch[0:4]); err != nil {
   112  		z.err = err
   113  		return 0, err
   114  	}
   115  	// ZLIB (RFC 1950) is big-endian, unlike GZIP (RFC 1952).
   116  	checksum := uint32(z.scratch[0])<<24 | uint32(z.scratch[1])<<16 | uint32(z.scratch[2])<<8 | uint32(z.scratch[3])
   117  	if checksum != z.digest.Sum32() {
   118  		z.err = ErrChecksum
   119  		return 0, z.err
   120  	}
   121  	return
   122  }
   123  
   124  // Calling Close does not close the wrapped io.Reader originally passed to NewReader.
   125  func (z *reader) Close() error {
   126  	if z.err != nil {
   127  		return z.err
   128  	}
   129  	z.err = z.decompressor.Close()
   130  	return z.err
   131  }