2016-12-09 07:17:34 -05:00
|
|
|
package buf
|
|
|
|
|
2017-04-17 16:35:20 -04:00
|
|
|
import (
|
|
|
|
"io"
|
|
|
|
|
2018-04-08 17:22:55 -04:00
|
|
|
"v2ray.com/core/common"
|
2017-04-17 16:35:20 -04:00
|
|
|
"v2ray.com/core/common/errors"
|
|
|
|
)
|
2016-12-09 07:17:34 -05:00
|
|
|
|
2018-07-31 06:37:59 -04:00
|
|
|
func readOne(r io.Reader) (*Buffer, error) {
|
|
|
|
b := New()
|
|
|
|
for i := 0; i < 64; i++ {
|
|
|
|
err := b.Reset(ReadFrom(r))
|
|
|
|
if !b.IsEmpty() {
|
|
|
|
return b, nil
|
|
|
|
}
|
|
|
|
if err != nil {
|
|
|
|
b.Release()
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil, newError("Reader returns too many empty payloads.")
|
|
|
|
}
|
|
|
|
|
2016-12-09 07:17:34 -05:00
|
|
|
// BytesToBufferReader is a Reader that adjusts its reading speed automatically.
|
|
|
|
type BytesToBufferReader struct {
|
2017-11-09 16:33:15 -05:00
|
|
|
io.Reader
|
2017-04-19 17:30:18 -04:00
|
|
|
buffer []byte
|
2016-12-09 07:17:34 -05:00
|
|
|
}
|
|
|
|
|
2018-02-13 05:15:04 -05:00
|
|
|
// NewBytesToBufferReader returns a new BytesToBufferReader.
|
2017-11-08 16:23:21 -05:00
|
|
|
func NewBytesToBufferReader(reader io.Reader) Reader {
|
|
|
|
return &BytesToBufferReader{
|
2017-11-09 16:33:15 -05:00
|
|
|
Reader: reader,
|
2017-11-08 16:23:21 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (r *BytesToBufferReader) readSmall() (MultiBuffer, error) {
|
2018-07-31 06:37:59 -04:00
|
|
|
b, err := readOne(r.Reader)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2018-07-31 07:04:55 -04:00
|
|
|
if b.IsFull() && largeSize > Size {
|
|
|
|
r.buffer = newBytes(Size + 1)
|
|
|
|
}
|
2018-07-31 06:37:59 -04:00
|
|
|
return NewMultiBufferValue(b), nil
|
2018-03-29 12:15:50 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
func (r *BytesToBufferReader) freeBuffer() {
|
|
|
|
freeBytes(r.buffer)
|
|
|
|
r.buffer = nil
|
2017-11-08 16:23:21 -05:00
|
|
|
}
|
|
|
|
|
2017-11-09 16:33:15 -05:00
|
|
|
// ReadMultiBuffer implements Reader.
|
|
|
|
func (r *BytesToBufferReader) ReadMultiBuffer() (MultiBuffer, error) {
|
2018-04-06 15:13:29 -04:00
|
|
|
if r.buffer == nil || largeSize == Size {
|
2017-11-08 16:23:21 -05:00
|
|
|
return r.readSmall()
|
|
|
|
}
|
|
|
|
|
2018-03-29 12:15:50 -04:00
|
|
|
nBytes, err := r.Reader.Read(r.buffer)
|
|
|
|
if nBytes > 0 {
|
2018-04-02 14:00:50 -04:00
|
|
|
mb := NewMultiBufferCap(int32(nBytes/Size) + 1)
|
2018-04-08 17:22:55 -04:00
|
|
|
common.Must2(mb.Write(r.buffer[:nBytes]))
|
2018-04-01 06:20:32 -04:00
|
|
|
if nBytes == len(r.buffer) && nBytes < int(largeSize) {
|
2018-03-16 11:32:03 -04:00
|
|
|
freeBytes(r.buffer)
|
2018-04-02 16:01:55 -04:00
|
|
|
r.buffer = newBytes(int32(nBytes) + 1)
|
2018-03-29 12:15:50 -04:00
|
|
|
} else if nBytes < Size {
|
|
|
|
r.freeBuffer()
|
2017-12-08 07:23:15 -05:00
|
|
|
}
|
2018-03-29 12:15:50 -04:00
|
|
|
return mb, nil
|
2016-12-09 07:17:34 -05:00
|
|
|
}
|
2018-03-29 12:15:50 -04:00
|
|
|
|
|
|
|
r.freeBuffer()
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Read() returns empty payload and nil err. We don't expect this to happen, but just in case.
|
|
|
|
return r.readSmall()
|
2016-12-09 07:17:34 -05:00
|
|
|
}
|
|
|
|
|
2018-02-13 05:15:04 -05:00
|
|
|
// BufferedReader is a Reader that keeps its internal buffer.
|
2017-11-09 16:33:15 -05:00
|
|
|
type BufferedReader struct {
|
2018-04-20 18:54:53 -04:00
|
|
|
// Reader is the underlying reader to be read from
|
|
|
|
Reader Reader
|
|
|
|
// Buffer is the internal buffer to be read from first
|
|
|
|
Buffer MultiBuffer
|
|
|
|
// Direct indicates whether or not to use the internal buffer
|
|
|
|
Direct bool
|
2016-12-09 07:17:34 -05:00
|
|
|
}
|
|
|
|
|
2018-04-01 17:31:53 -04:00
|
|
|
// BufferedBytes returns the number of bytes that is cached in this reader.
|
|
|
|
func (r *BufferedReader) BufferedBytes() int32 {
|
2018-04-20 18:54:53 -04:00
|
|
|
return r.Buffer.Len()
|
2018-04-01 17:31:53 -04:00
|
|
|
}
|
|
|
|
|
2018-02-13 05:15:04 -05:00
|
|
|
// ReadByte implements io.ByteReader.
|
2017-11-24 17:16:01 -05:00
|
|
|
func (r *BufferedReader) ReadByte() (byte, error) {
|
|
|
|
var b [1]byte
|
|
|
|
_, err := r.Read(b[:])
|
|
|
|
return b[0], err
|
|
|
|
}
|
|
|
|
|
2018-02-13 05:15:04 -05:00
|
|
|
// Read implements io.Reader. It reads from internal buffer first (if available) and then reads from the underlying reader.
|
2017-11-09 16:33:15 -05:00
|
|
|
func (r *BufferedReader) Read(b []byte) (int, error) {
|
2018-07-29 07:19:03 -04:00
|
|
|
if !r.Buffer.IsEmpty() {
|
|
|
|
nBytes, err := r.Buffer.Read(b)
|
|
|
|
common.Must(err)
|
2018-04-20 18:54:53 -04:00
|
|
|
if r.Buffer.IsEmpty() {
|
|
|
|
r.Buffer.Release()
|
|
|
|
r.Buffer = nil
|
2017-04-19 05:52:27 -04:00
|
|
|
}
|
2017-04-19 15:27:21 -04:00
|
|
|
return nBytes, nil
|
2016-12-09 07:17:34 -05:00
|
|
|
}
|
|
|
|
|
2018-04-20 18:54:53 -04:00
|
|
|
if r.Direct {
|
|
|
|
if reader, ok := r.Reader.(io.Reader); ok {
|
2017-11-25 15:58:47 -05:00
|
|
|
return reader.Read(b)
|
|
|
|
}
|
2017-11-09 16:33:15 -05:00
|
|
|
}
|
|
|
|
|
2018-04-20 18:54:53 -04:00
|
|
|
mb, err := r.Reader.ReadMultiBuffer()
|
2018-07-29 07:19:03 -04:00
|
|
|
if err != nil {
|
|
|
|
return 0, err
|
|
|
|
}
|
|
|
|
|
|
|
|
nBytes, err := mb.Read(b)
|
|
|
|
common.Must(err)
|
|
|
|
if !mb.IsEmpty() {
|
|
|
|
r.Buffer = mb
|
2016-12-09 07:17:34 -05:00
|
|
|
}
|
2018-07-29 07:19:03 -04:00
|
|
|
return nBytes, err
|
2016-12-09 07:17:34 -05:00
|
|
|
}
|
2017-04-15 16:22:29 -04:00
|
|
|
|
2018-02-13 05:15:04 -05:00
|
|
|
// ReadMultiBuffer implements Reader.
|
2017-11-09 16:33:15 -05:00
|
|
|
func (r *BufferedReader) ReadMultiBuffer() (MultiBuffer, error) {
|
2018-07-29 07:19:03 -04:00
|
|
|
if !r.Buffer.IsEmpty() {
|
2018-04-20 18:54:53 -04:00
|
|
|
mb := r.Buffer
|
|
|
|
r.Buffer = nil
|
2017-04-19 05:52:27 -04:00
|
|
|
return mb, nil
|
2017-04-15 16:22:29 -04:00
|
|
|
}
|
2017-04-19 05:52:27 -04:00
|
|
|
|
2018-04-20 18:54:53 -04:00
|
|
|
return r.Reader.ReadMultiBuffer()
|
2017-04-15 16:22:29 -04:00
|
|
|
}
|
2017-04-17 16:35:20 -04:00
|
|
|
|
2017-11-24 19:05:30 -05:00
|
|
|
// ReadAtMost returns a MultiBuffer with at most size.
|
2018-04-02 14:00:50 -04:00
|
|
|
func (r *BufferedReader) ReadAtMost(size int32) (MultiBuffer, error) {
|
2018-07-29 07:19:03 -04:00
|
|
|
if r.Buffer.IsEmpty() {
|
2018-04-20 18:54:53 -04:00
|
|
|
mb, err := r.Reader.ReadMultiBuffer()
|
2017-11-26 09:08:37 -05:00
|
|
|
if mb.IsEmpty() && err != nil {
|
|
|
|
return nil, err
|
2017-11-24 19:05:30 -05:00
|
|
|
}
|
2018-04-20 18:54:53 -04:00
|
|
|
r.Buffer = mb
|
2017-11-26 09:08:37 -05:00
|
|
|
}
|
|
|
|
|
2018-04-20 18:54:53 -04:00
|
|
|
mb := r.Buffer.SliceBySize(size)
|
|
|
|
if r.Buffer.IsEmpty() {
|
|
|
|
r.Buffer = nil
|
2017-11-24 19:05:30 -05:00
|
|
|
}
|
2017-11-26 09:08:37 -05:00
|
|
|
return mb, nil
|
2017-11-24 19:05:30 -05:00
|
|
|
}
|
|
|
|
|
2017-11-09 16:33:15 -05:00
|
|
|
func (r *BufferedReader) writeToInternal(writer io.Writer) (int64, error) {
|
2017-04-17 16:35:20 -04:00
|
|
|
mbWriter := NewWriter(writer)
|
|
|
|
totalBytes := int64(0)
|
2018-04-20 18:54:53 -04:00
|
|
|
if r.Buffer != nil {
|
|
|
|
totalBytes += int64(r.Buffer.Len())
|
|
|
|
if err := mbWriter.WriteMultiBuffer(r.Buffer); err != nil {
|
2017-04-19 10:29:36 -04:00
|
|
|
return 0, err
|
|
|
|
}
|
2018-04-20 18:54:53 -04:00
|
|
|
r.Buffer = nil
|
2017-04-19 05:52:27 -04:00
|
|
|
}
|
|
|
|
|
2017-04-17 16:35:20 -04:00
|
|
|
for {
|
2018-04-20 18:54:53 -04:00
|
|
|
mb, err := r.Reader.ReadMultiBuffer()
|
2017-11-24 17:16:01 -05:00
|
|
|
if mb != nil {
|
|
|
|
totalBytes += int64(mb.Len())
|
|
|
|
if werr := mbWriter.WriteMultiBuffer(mb); werr != nil {
|
|
|
|
return totalBytes, err
|
|
|
|
}
|
2017-04-17 16:35:20 -04:00
|
|
|
}
|
2017-11-24 17:16:01 -05:00
|
|
|
if err != nil {
|
2017-04-17 16:35:20 -04:00
|
|
|
return totalBytes, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-13 05:15:04 -05:00
|
|
|
// WriteTo implements io.WriterTo.
|
2017-11-09 16:33:15 -05:00
|
|
|
func (r *BufferedReader) WriteTo(writer io.Writer) (int64, error) {
|
2017-04-17 16:35:20 -04:00
|
|
|
nBytes, err := r.writeToInternal(writer)
|
|
|
|
if errors.Cause(err) == io.EOF {
|
|
|
|
return nBytes, nil
|
|
|
|
}
|
|
|
|
return nBytes, err
|
|
|
|
}
|
2018-04-16 08:57:13 -04:00
|
|
|
|
|
|
|
// Close implements io.Closer.
|
|
|
|
func (r *BufferedReader) Close() error {
|
2018-04-20 18:54:53 -04:00
|
|
|
if !r.Buffer.IsEmpty() {
|
|
|
|
r.Buffer.Release()
|
2018-04-16 08:57:13 -04:00
|
|
|
}
|
2018-04-20 18:54:53 -04:00
|
|
|
return common.Close(r.Reader)
|
2018-04-16 08:57:13 -04:00
|
|
|
}
|
2018-07-31 06:37:59 -04:00
|
|
|
|
|
|
|
type SingleReader struct {
|
|
|
|
io.Reader
|
|
|
|
}
|
|
|
|
|
|
|
|
func (r *SingleReader) ReadMultiBuffer() (MultiBuffer, error) {
|
|
|
|
b, err := readOne(r.Reader)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return NewMultiBufferValue(b), nil
|
|
|
|
}
|