github.com/insionng/yougam@v0.0.0-20170714101924-2bc18d833463/libraries/klauspost/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  	"errors"
    29  	"hash"
    30  	"hash/adler32"
    31  	"io"
    32  
    33  	"github.com/insionng/yougam/libraries/klauspost/compress/flate"
    34  )
    35  
    36  const zlibDeflate = 8
    37  
    38  var (
    39  	// ErrChecksum is returned when reading ZLIB data that has an invalid checksum.
    40  	ErrChecksum = errors.New("zlib: invalid checksum")
    41  	// ErrDictionary is returned when reading ZLIB data that has an invalid dictionary.
    42  	ErrDictionary = errors.New("zlib: invalid dictionary")
    43  	// ErrHeader is returned when reading ZLIB data that has an invalid header.
    44  	ErrHeader = errors.New("zlib: invalid header")
    45  )
    46  
    47  type reader struct {
    48  	r            flate.Reader
    49  	decompressor io.ReadCloser
    50  	digest       hash.Hash32
    51  	err          error
    52  	scratch      [4]byte
    53  }
    54  
    55  // Resetter resets a ReadCloser returned by NewReader or NewReaderDict to
    56  // to switch to a new underlying Reader. This permits reusing a ReadCloser
    57  // instead of allocating a new one.
    58  type Resetter interface {
    59  	// Reset discards any buffered data and resets the Resetter as if it was
    60  	// newly initialized with the given reader.
    61  	Reset(r io.Reader, dict []byte) error
    62  }
    63  
    64  // NewReader creates a new ReadCloser.
    65  // Reads from the returned ReadCloser read and decompress data from r.
    66  // The implementation buffers input and may read more 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) (n int, err error) {
    89  	if z.err != nil {
    90  		return 0, z.err
    91  	}
    92  	if len(p) == 0 {
    93  		return 0, nil
    94  	}
    95  
    96  	n, err = z.decompressor.Read(p)
    97  	z.digest.Write(p[0:n])
    98  	if n != 0 || err != io.EOF {
    99  		z.err = err
   100  		return
   101  	}
   102  
   103  	// Finished file; check checksum.
   104  	if _, err := io.ReadFull(z.r, z.scratch[0:4]); err != nil {
   105  		z.err = err
   106  		return 0, err
   107  	}
   108  	// ZLIB (RFC 1950) is big-endian, unlike GZIP (RFC 1952).
   109  	checksum := uint32(z.scratch[0])<<24 | uint32(z.scratch[1])<<16 | uint32(z.scratch[2])<<8 | uint32(z.scratch[3])
   110  	if checksum != z.digest.Sum32() {
   111  		z.err = ErrChecksum
   112  		return 0, z.err
   113  	}
   114  	return
   115  }
   116  
   117  // Calling Close does not close the wrapped io.Reader originally passed to NewReader.
   118  func (z *reader) Close() error {
   119  	if z.err != nil {
   120  		return z.err
   121  	}
   122  	z.err = z.decompressor.Close()
   123  	return z.err
   124  }
   125  
   126  func (z *reader) Reset(r io.Reader, dict []byte) error {
   127  	if fr, ok := r.(flate.Reader); ok {
   128  		z.r = fr
   129  	} else {
   130  		z.r = bufio.NewReader(r)
   131  	}
   132  	_, err := io.ReadFull(z.r, z.scratch[0:2])
   133  	if err != nil {
   134  		return err
   135  	}
   136  	h := uint(z.scratch[0])<<8 | uint(z.scratch[1])
   137  	if (z.scratch[0]&0x0f != zlibDeflate) || (h%31 != 0) {
   138  		return ErrHeader
   139  	}
   140  	haveDict := z.scratch[1]&0x20 != 0
   141  	if haveDict {
   142  		_, err = io.ReadFull(z.r, z.scratch[0:4])
   143  		if err != nil {
   144  			return err
   145  		}
   146  		checksum := uint32(z.scratch[0])<<24 | uint32(z.scratch[1])<<16 | uint32(z.scratch[2])<<8 | uint32(z.scratch[3])
   147  		if checksum != adler32.Checksum(dict) {
   148  			return ErrDictionary
   149  		}
   150  	}
   151  	if z.decompressor == nil {
   152  		if haveDict {
   153  			z.decompressor = flate.NewReaderDict(z.r, dict)
   154  		} else {
   155  			z.decompressor = flate.NewReader(z.r)
   156  		}
   157  	} else {
   158  		z.decompressor.(flate.Resetter).Reset(z.r, dict)
   159  	}
   160  	z.digest = adler32.New()
   161  	return nil
   162  }