cubefs

1
// Copyright 2011 The Snappy-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
package snapref
6

7
import (
8
	"encoding/binary"
9
	"errors"
10
	"io"
11
)
12

13
var (
14
	// ErrCorrupt reports that the input is invalid.
15
	ErrCorrupt = errors.New("snappy: corrupt input")
16
	// ErrTooLarge reports that the uncompressed length is too large.
17
	ErrTooLarge = errors.New("snappy: decoded block is too large")
18
	// ErrUnsupported reports that the input isn't supported.
19
	ErrUnsupported = errors.New("snappy: unsupported input")
20

21
	errUnsupportedLiteralLength = errors.New("snappy: unsupported literal length")
22
)
23

24
// DecodedLen returns the length of the decoded block.
25
func DecodedLen(src []byte) (int, error) {
26
	v, _, err := decodedLen(src)
27
	return v, err
28
}
29

30
// decodedLen returns the length of the decoded block and the number of bytes
31
// that the length header occupied.
32
func decodedLen(src []byte) (blockLen, headerLen int, err error) {
33
	v, n := binary.Uvarint(src)
34
	if n <= 0 || v > 0xffffffff {
35
		return 0, 0, ErrCorrupt
36
	}
37

38
	const wordSize = 32 << (^uint(0) >> 32 & 1)
39
	if wordSize == 32 && v > 0x7fffffff {
40
		return 0, 0, ErrTooLarge
41
	}
42
	return int(v), n, nil
43
}
44

45
const (
46
	decodeErrCodeCorrupt                  = 1
47
	decodeErrCodeUnsupportedLiteralLength = 2
48
)
49

50
// Decode returns the decoded form of src. The returned slice may be a sub-
51
// slice of dst if dst was large enough to hold the entire decoded block.
52
// Otherwise, a newly allocated slice will be returned.
53
//
54
// The dst and src must not overlap. It is valid to pass a nil dst.
55
//
56
// Decode handles the Snappy block format, not the Snappy stream format.
57
func Decode(dst, src []byte) ([]byte, error) {
58
	dLen, s, err := decodedLen(src)
59
	if err != nil {
60
		return nil, err
61
	}
62
	if dLen <= len(dst) {
63
		dst = dst[:dLen]
64
	} else {
65
		dst = make([]byte, dLen)
66
	}
67
	switch decode(dst, src[s:]) {
68
	case 0:
69
		return dst, nil
70
	case decodeErrCodeUnsupportedLiteralLength:
71
		return nil, errUnsupportedLiteralLength
72
	}
73
	return nil, ErrCorrupt
74
}
75

76
// NewReader returns a new Reader that decompresses from r, using the framing
77
// format described at
78
// https://github.com/google/snappy/blob/master/framing_format.txt
79
func NewReader(r io.Reader) *Reader {
80
	return &Reader{
81
		r:       r,
82
		decoded: make([]byte, maxBlockSize),
83
		buf:     make([]byte, maxEncodedLenOfMaxBlockSize+checksumSize),
84
	}
85
}
86

87
// Reader is an io.Reader that can read Snappy-compressed bytes.
88
//
89
// Reader handles the Snappy stream format, not the Snappy block format.
90
type Reader struct {
91
	r       io.Reader
92
	err     error
93
	decoded []byte
94
	buf     []byte
95
	// decoded[i:j] contains decoded bytes that have not yet been passed on.
96
	i, j       int
97
	readHeader bool
98
}
99

100
// Reset discards any buffered data, resets all state, and switches the Snappy
101
// reader to read from r. This permits reusing a Reader rather than allocating
102
// a new one.
103
func (r *Reader) Reset(reader io.Reader) {
104
	r.r = reader
105
	r.err = nil
106
	r.i = 0
107
	r.j = 0
108
	r.readHeader = false
109
}
110

111
func (r *Reader) readFull(p []byte, allowEOF bool) (ok bool) {
112
	if _, r.err = io.ReadFull(r.r, p); r.err != nil {
113
		if r.err == io.ErrUnexpectedEOF || (r.err == io.EOF && !allowEOF) {
114
			r.err = ErrCorrupt
115
		}
116
		return false
117
	}
118
	return true
119
}
120

121
func (r *Reader) fill() error {
122
	for r.i >= r.j {
123
		if !r.readFull(r.buf[:4], true) {
124
			return r.err
125
		}
126
		chunkType := r.buf[0]
127
		if !r.readHeader {
128
			if chunkType != chunkTypeStreamIdentifier {
129
				r.err = ErrCorrupt
130
				return r.err
131
			}
132
			r.readHeader = true
133
		}
134
		chunkLen := int(r.buf[1]) | int(r.buf[2])<<8 | int(r.buf[3])<<16
135
		if chunkLen > len(r.buf) {
136
			r.err = ErrUnsupported
137
			return r.err
138
		}
139

140
		// The chunk types are specified at
141
		// https://github.com/google/snappy/blob/master/framing_format.txt
142
		switch chunkType {
143
		case chunkTypeCompressedData:
144
			// Section 4.2. Compressed data (chunk type 0x00).
145
			if chunkLen < checksumSize {
146
				r.err = ErrCorrupt
147
				return r.err
148
			}
149
			buf := r.buf[:chunkLen]
150
			if !r.readFull(buf, false) {
151
				return r.err
152
			}
153
			checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
154
			buf = buf[checksumSize:]
155

156
			n, err := DecodedLen(buf)
157
			if err != nil {
158
				r.err = err
159
				return r.err
160
			}
161
			if n > len(r.decoded) {
162
				r.err = ErrCorrupt
163
				return r.err
164
			}
165
			if _, err := Decode(r.decoded, buf); err != nil {
166
				r.err = err
167
				return r.err
168
			}
169
			if crc(r.decoded[:n]) != checksum {
170
				r.err = ErrCorrupt
171
				return r.err
172
			}
173
			r.i, r.j = 0, n
174
			continue
175

176
		case chunkTypeUncompressedData:
177
			// Section 4.3. Uncompressed data (chunk type 0x01).
178
			if chunkLen < checksumSize {
179
				r.err = ErrCorrupt
180
				return r.err
181
			}
182
			buf := r.buf[:checksumSize]
183
			if !r.readFull(buf, false) {
184
				return r.err
185
			}
186
			checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
187
			// Read directly into r.decoded instead of via r.buf.
188
			n := chunkLen - checksumSize
189
			if n > len(r.decoded) {
190
				r.err = ErrCorrupt
191
				return r.err
192
			}
193
			if !r.readFull(r.decoded[:n], false) {
194
				return r.err
195
			}
196
			if crc(r.decoded[:n]) != checksum {
197
				r.err = ErrCorrupt
198
				return r.err
199
			}
200
			r.i, r.j = 0, n
201
			continue
202

203
		case chunkTypeStreamIdentifier:
204
			// Section 4.1. Stream identifier (chunk type 0xff).
205
			if chunkLen != len(magicBody) {
206
				r.err = ErrCorrupt
207
				return r.err
208
			}
209
			if !r.readFull(r.buf[:len(magicBody)], false) {
210
				return r.err
211
			}
212
			for i := 0; i < len(magicBody); i++ {
213
				if r.buf[i] != magicBody[i] {
214
					r.err = ErrCorrupt
215
					return r.err
216
				}
217
			}
218
			continue
219
		}
220

221
		if chunkType <= 0x7f {
222
			// Section 4.5. Reserved unskippable chunks (chunk types 0x02-0x7f).
223
			r.err = ErrUnsupported
224
			return r.err
225
		}
226
		// Section 4.4 Padding (chunk type 0xfe).
227
		// Section 4.6. Reserved skippable chunks (chunk types 0x80-0xfd).
228
		if !r.readFull(r.buf[:chunkLen], false) {
229
			return r.err
230
		}
231
	}
232

233
	return nil
234
}
235

236
// Read satisfies the io.Reader interface.
237
func (r *Reader) Read(p []byte) (int, error) {
238
	if r.err != nil {
239
		return 0, r.err
240
	}
241

242
	if err := r.fill(); err != nil {
243
		return 0, err
244
	}
245

246
	n := copy(p, r.decoded[r.i:r.j])
247
	r.i += n
248
	return n, nil
249
}
250

251
// ReadByte satisfies the io.ByteReader interface.
252
func (r *Reader) ReadByte() (byte, error) {
253
	if r.err != nil {
254
		return 0, r.err
255
	}
256

257
	if err := r.fill(); err != nil {
258
		return 0, err
259
	}
260

261
	c := r.decoded[r.i]
262
	r.i++
263
	return c, nil
264
}
265