161 lines
3.1 KiB
Go
161 lines
3.1 KiB
Go
package handler
|
|
|
|
import (
|
|
"bufio"
|
|
"io"
|
|
)
|
|
|
|
type (
|
|
s3UnsignedChunkReader struct {
|
|
reader *bufio.Reader
|
|
|
|
trailers map[string]string
|
|
buffer []byte
|
|
offset int
|
|
err error
|
|
}
|
|
)
|
|
|
|
func (c *s3UnsignedChunkReader) Close() (err error) {
|
|
return nil
|
|
}
|
|
|
|
func (c *s3UnsignedChunkReader) Read(buf []byte) (num int, err error) {
|
|
if c.offset > 0 {
|
|
num = copy(buf, c.buffer[c.offset:])
|
|
if num == len(buf) {
|
|
c.offset += num
|
|
return num, nil
|
|
}
|
|
c.offset = 0
|
|
buf = buf[num:]
|
|
}
|
|
|
|
var size int
|
|
var b byte
|
|
for {
|
|
b, err = c.reader.ReadByte()
|
|
if err == io.EOF {
|
|
err = io.ErrUnexpectedEOF
|
|
}
|
|
if err != nil {
|
|
c.err = err
|
|
return num, c.err
|
|
}
|
|
if b == '\r' {
|
|
break
|
|
}
|
|
|
|
// Manually deserialize the size since AWS specified
|
|
// the chunk size to be of variable width. In particular,
|
|
// a size of 16 is encoded as `10` while a size of 64 KB
|
|
// is `10000`.
|
|
switch {
|
|
case b >= '0' && b <= '9':
|
|
size = size<<4 | int(b-'0')
|
|
case b >= 'a' && b <= 'f':
|
|
size = size<<4 | int(b-('a'-10))
|
|
case b >= 'A' && b <= 'F':
|
|
size = size<<4 | int(b-('A'-10))
|
|
default:
|
|
c.err = errMalformedChunkedEncoding
|
|
return num, c.err
|
|
}
|
|
if size > maxChunkSize {
|
|
c.err = errGiantChunk
|
|
return num, c.err
|
|
}
|
|
}
|
|
|
|
if b != '\r' {
|
|
c.err = errMalformedChunkedEncoding
|
|
return num, c.err
|
|
}
|
|
b, err = c.reader.ReadByte()
|
|
if err == io.EOF {
|
|
err = io.ErrUnexpectedEOF
|
|
}
|
|
if err != nil {
|
|
c.err = err
|
|
return num, c.err
|
|
}
|
|
if b != '\n' {
|
|
c.err = errMalformedChunkedEncoding
|
|
return num, c.err
|
|
}
|
|
|
|
if cap(c.buffer) < size {
|
|
c.buffer = make([]byte, size)
|
|
} else {
|
|
c.buffer = c.buffer[:size]
|
|
}
|
|
|
|
// Now, we read the payload and compute its SHA-256 hash.
|
|
_, err = io.ReadFull(c.reader, c.buffer)
|
|
if err == io.EOF && size != 0 {
|
|
err = io.ErrUnexpectedEOF
|
|
}
|
|
if err != nil && err != io.EOF {
|
|
c.err = err
|
|
return num, c.err
|
|
}
|
|
|
|
// If the chunk size is zero we return io.EOF. As specified by AWS,
|
|
// only the last chunk is zero-sized.
|
|
if size == 0 {
|
|
var k, v string
|
|
for err == nil {
|
|
k, err = c.reader.ReadString(':')
|
|
if err != nil {
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
c.err = errMalformedTrailerHeaders
|
|
return num, c.err
|
|
}
|
|
v, err = c.reader.ReadString('\n')
|
|
if err != nil {
|
|
c.err = errMalformedTrailerHeaders
|
|
return num, c.err
|
|
}
|
|
c.trailers[k[:len(k)-1]] = v[:len(v)-1]
|
|
}
|
|
|
|
c.err = io.EOF
|
|
return num, c.err
|
|
}
|
|
|
|
b, err = c.reader.ReadByte()
|
|
if b != '\r' || err != nil {
|
|
c.err = errMalformedChunkedEncoding
|
|
return num, c.err
|
|
}
|
|
b, err = c.reader.ReadByte()
|
|
if err == io.EOF {
|
|
err = io.ErrUnexpectedEOF
|
|
}
|
|
if err != nil {
|
|
c.err = err
|
|
return num, c.err
|
|
}
|
|
if b != '\n' {
|
|
c.err = errMalformedChunkedEncoding
|
|
return num, c.err
|
|
}
|
|
|
|
c.offset = copy(buf, c.buffer)
|
|
num += c.offset
|
|
return num, err
|
|
}
|
|
|
|
func (c *s3UnsignedChunkReader) TrailerHeaders() map[string]string {
|
|
return c.trailers
|
|
}
|
|
|
|
func newUnsignedChunkedReader(body io.Reader) (*s3UnsignedChunkReader, error) {
|
|
return &s3UnsignedChunkReader{
|
|
reader: bufio.NewReader(body),
|
|
trailers: map[string]string{},
|
|
buffer: make([]byte, 64*1024),
|
|
}, nil
|
|
}
|