pool: return specified size of buffer

This commit is contained in:
nadoo committed 2020-04-19 23:20:15 +08:00
1 parent 5326c0a901
commit a0542a028e
16 files changed
+158 -139

No files matched your search

+37 -51
View File
@@ -1,104 +1,90 @@
package vmess
import (
"bytes"
"encoding/binary"
"io"
"github.com/nadoo/glider/common/pool"
)
const (
lenSize = 2
maxChunkSize = 1 << 14 // 16384
defaultChunkSize = 1 << 13 // 8192
lenSize = 2
chunkSize = 1 << 14 // 16384
)
type chunkedWriter struct {
io.Writer
buf []byte
}
// ChunkedWriter returns a chunked writer
func ChunkedWriter(w io.Writer) io.Writer {
return &chunkedWriter{
Writer: w,
buf: make([]byte, lenSize+maxChunkSize),
}
return &chunkedWriter{Writer: w}
}
func (w *chunkedWriter) Write(b []byte) (int, error) {
n, err := w.ReadFrom(bytes.NewBuffer(b))
return int(n), err
}
func (w *chunkedWriter) Write(b []byte) (n int, err error) {
buf := pool.GetBuffer(lenSize + chunkSize)
defer pool.PutBuffer(buf)
func (w *chunkedWriter) ReadFrom(r io.Reader) (n int64, err error) {
for {
buf := w.buf
payloadBuf := buf[lenSize : lenSize+defaultChunkSize]
nr, er := r.Read(payloadBuf)
if nr > 0 {
n += int64(nr)
buf = buf[:lenSize+nr]
payloadBuf = payloadBuf[:nr]
binary.BigEndian.PutUint16(buf[:lenSize], uint16(nr))
_, ew := w.Writer.Write(buf)
if ew != nil {
err = ew
break
}
left := len(b)
for left != 0 {
writeLen := left
if writeLen > chunkSize {
writeLen = chunkSize
}
if er != nil {
if er != io.EOF { // ignore EOF as per io.ReaderFrom contract
err = er
}
copy(buf[lenSize:], b[n:n+writeLen])
binary.BigEndian.PutUint16(buf[:lenSize], uint16(writeLen))
_, err = w.Writer.Write(buf[:lenSize+writeLen])
if err != nil {
break
}
n += writeLen
left -= writeLen
}
return n, err
return
}
type chunkedReader struct {
io.Reader
buf []byte
leftBytes int
left int
}
// ChunkedReader returns a chunked reader
func ChunkedReader(r io.Reader) io.Reader {
return &chunkedReader{
Reader: r,
buf: make([]byte, lenSize), // NOTE: buf only used to save header bytes now
}
return &chunkedReader{Reader: r}
}
func (r *chunkedReader) Read(b []byte) (int, error) {
if r.leftBytes == 0 {
if r.left == 0 {
// get length
_, err := io.ReadFull(r.Reader, r.buf[:lenSize])
buf := pool.GetBuffer(lenSize)
_, err := io.ReadFull(r.Reader, buf[:lenSize])
if err != nil {
return 0, err
}
r.leftBytes = int(binary.BigEndian.Uint16(r.buf[:lenSize]))
r.left = int(binary.BigEndian.Uint16(buf[:lenSize]))
pool.PutBuffer(buf)
// if length == 0, then this is the end
if r.leftBytes == 0 {
// if left == 0, then this is the end
if r.left == 0 {
return 0, nil
}
}
readLen := len(b)
if readLen > r.leftBytes {
readLen = r.leftBytes
if readLen > r.left {
readLen = r.left
}
m, err := r.Reader.Read(b[:readLen])
n, err := r.Reader.Read(b[:readLen])
if err != nil {
return 0, err
}
r.leftBytes -= m
return m, err
r.left -= n
return n, err
}