github.com/mtsmfm/go/src@v0.0.0-20221020090648-44bdcb9f8fde/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 ( 36 zlibDeflate = 8 37 zlibMaxWindow = 7 38 ) 39 40 var ( 41 // ErrChecksum is returned when reading ZLIB data that has an invalid checksum. 42 ErrChecksum = errors.New("zlib: invalid checksum") 43 // ErrDictionary is returned when reading ZLIB data that has an invalid dictionary. 44 ErrDictionary = errors.New("zlib: invalid dictionary") 45 // ErrHeader is returned when reading ZLIB data that has an invalid header. 46 ErrHeader = errors.New("zlib: invalid header") 47 ) 48 49 type reader struct { 50 r flate.Reader 51 decompressor io.ReadCloser 52 digest hash.Hash32 53 err error 54 scratch [4]byte 55 } 56 57 // Resetter resets a ReadCloser returned by NewReader or NewReaderDict 58 // to switch to a new underlying Reader. This permits reusing a ReadCloser 59 // instead of allocating a new one. 60 type Resetter interface { 61 // Reset discards any buffered data and resets the Resetter as if it was 62 // newly initialized with the given reader. 63 Reset(r io.Reader, dict []byte) error 64 } 65 66 // NewReader creates a new ReadCloser. 67 // Reads from the returned ReadCloser read and decompress data from r. 68 // If r does not implement io.ByteReader, the decompressor may read more 69 // data than necessary from r. 70 // It is the caller's responsibility to call Close on the ReadCloser when done. 71 // 72 // The ReadCloser returned by NewReader also implements Resetter. 73 func NewReader(r io.Reader) (io.ReadCloser, error) { 74 return NewReaderDict(r, nil) 75 } 76 77 // NewReaderDict is like NewReader but uses a preset dictionary. 78 // NewReaderDict ignores the dictionary if the compressed data does not refer to it. 79 // If the compressed data refers to a different dictionary, NewReaderDict returns ErrDictionary. 80 // 81 // The ReadCloser returned by NewReaderDict also implements Resetter. 82 func NewReaderDict(r io.Reader, dict []byte) (io.ReadCloser, error) { 83 z := new(reader) 84 err := z.Reset(r, dict) 85 if err != nil { 86 return nil, err 87 } 88 return z, nil 89 } 90 91 func (z *reader) Read(p []byte) (int, error) { 92 if z.err != nil { 93 return 0, z.err 94 } 95 96 var n int 97 n, z.err = z.decompressor.Read(p) 98 z.digest.Write(p[0:n]) 99 if z.err != io.EOF { 100 // In the normal case we return here. 101 return n, z.err 102 } 103 104 // Finished file; check checksum. 105 if _, err := io.ReadFull(z.r, z.scratch[0:4]); err != nil { 106 if err == io.EOF { 107 err = io.ErrUnexpectedEOF 108 } 109 z.err = err 110 return n, z.err 111 } 112 // ZLIB (RFC 1950) is big-endian, unlike GZIP (RFC 1952). 113 checksum := uint32(z.scratch[0])<<24 | uint32(z.scratch[1])<<16 | uint32(z.scratch[2])<<8 | uint32(z.scratch[3]) 114 if checksum != z.digest.Sum32() { 115 z.err = ErrChecksum 116 return n, z.err 117 } 118 return n, io.EOF 119 } 120 121 // Calling Close does not close the wrapped io.Reader originally passed to NewReader. 122 // In order for the ZLIB checksum to be verified, the reader must be 123 // fully consumed until the io.EOF. 124 func (z *reader) Close() error { 125 if z.err != nil && z.err != io.EOF { 126 return z.err 127 } 128 z.err = z.decompressor.Close() 129 return z.err 130 } 131 132 func (z *reader) Reset(r io.Reader, dict []byte) error { 133 *z = reader{decompressor: z.decompressor} 134 if fr, ok := r.(flate.Reader); ok { 135 z.r = fr 136 } else { 137 z.r = bufio.NewReader(r) 138 } 139 140 // Read the header (RFC 1950 section 2.2.). 141 _, z.err = io.ReadFull(z.r, z.scratch[0:2]) 142 if z.err != nil { 143 if z.err == io.EOF { 144 z.err = io.ErrUnexpectedEOF 145 } 146 return z.err 147 } 148 h := uint(z.scratch[0])<<8 | uint(z.scratch[1]) 149 if (z.scratch[0]&0x0f != zlibDeflate) || (z.scratch[0]>>4 > zlibMaxWindow) || (h%31 != 0) { 150 z.err = ErrHeader 151 return z.err 152 } 153 haveDict := z.scratch[1]&0x20 != 0 154 if haveDict { 155 _, z.err = io.ReadFull(z.r, z.scratch[0:4]) 156 if z.err != nil { 157 if z.err == io.EOF { 158 z.err = io.ErrUnexpectedEOF 159 } 160 return z.err 161 } 162 checksum := uint32(z.scratch[0])<<24 | uint32(z.scratch[1])<<16 | uint32(z.scratch[2])<<8 | uint32(z.scratch[3]) 163 if checksum != adler32.Checksum(dict) { 164 z.err = ErrDictionary 165 return z.err 166 } 167 } 168 169 if z.decompressor == nil { 170 if haveDict { 171 z.decompressor = flate.NewReaderDict(z.r, dict) 172 } else { 173 z.decompressor = flate.NewReader(z.r) 174 } 175 } else { 176 z.decompressor.(flate.Resetter).Reset(z.r, dict) 177 } 178 z.digest = adler32.New() 179 return nil 180 }