Source file src/pkg/compress/zlib/reader.go
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, err := 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 }