remove closure on ReadFullFrom

common/buf/buffer.go

@@ -167,6 +167,23 @@ func (b *Buffer) Read(data []byte) (int, error) {
 	return nBytes, nil
 }
 
+// ReadFrom implements io.ReaderFrom.
+func (b *Buffer) ReadFrom(reader io.Reader) (int64, error) {
+	n, err := reader.Read(b.v[b.end:])
+	b.end += int32(n)
+	return int64(n), err
+}
+
+func (b *Buffer) ReadFullFrom(reader io.Reader, size int32) (int64, error) {
+	end := b.end + size
+	if end > int32(len(b.v)) {
+		return 0, newError("out of bound: ", end)
+	}
+	n, err := io.ReadFull(reader, b.v[b.end:end])
+	b.end += int32(n)
+	return int64(n), err
+}
+
 // String returns the string form of this Buffer.
 func (b *Buffer) String() string {
 	return string(b.Bytes())

common/buf/buffer_test.go

@@ -1,12 +1,13 @@
 package buf_test
 
 import (
+	"bytes"
+	"crypto/rand"
 	"testing"
 
 	"v2ray.com/core/common"
-	"v2ray.com/core/common/compare"
-
 	. "v2ray.com/core/common/buf"
+	"v2ray.com/core/common/compare"
 	"v2ray.com/core/common/serial"
 	. "v2ray.com/ext/assert"
 )
@@ -73,6 +74,23 @@ func TestBufferSlice(t *testing.T) {
 	}
 }
 
+func TestBufferReadFullFrom(t *testing.T) {
+	payload := make([]byte, 1024)
+	common.Must2(rand.Read(payload))
+
+	reader := bytes.NewReader(payload)
+	b := New()
+	n, err := b.ReadFullFrom(reader, 1024)
+	common.Must(err)
+	if n != 1024 {
+		t.Error("expect reading 1024 bytes, but actually ", n)
+	}
+
+	if err := compare.BytesEqualWithDetail(payload, b.Bytes()); err != nil {
+		t.Error(err)
+	}
+}
+
 func BenchmarkNewBuffer(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		buffer := New()

common/buf/io.go

@@ -26,20 +26,6 @@ type Writer interface {
 	WriteMultiBuffer(MultiBuffer) error
 }
 
-// ReadFrom creates a Supplier to read from a given io.Reader.
-func ReadFrom(reader io.Reader) Supplier {
-	return func(b []byte) (int, error) {
-		return reader.Read(b)
-	}
-}
-
-// ReadFullFrom creates a Supplier to read full buffer from a given io.Reader.
-func ReadFullFrom(reader io.Reader, size int32) Supplier {
-	return func(b []byte) (int, error) {
-		return io.ReadFull(reader, b[:size])
-	}
-}
-
 // WriteAllBytes ensures all bytes are written into the given writer.
 func WriteAllBytes(writer io.Writer, payload []byte) error {
 	for len(payload) > 0 {

common/buf/multi_buffer.go

@@ -79,7 +79,7 @@ func (mb *MultiBuffer) ReadFrom(reader io.Reader) (int64, error) {
 
 	for {
 		b := New()
-		err := b.Reset(ReadFullFrom(reader, Size))
+		_, err := b.ReadFullFrom(reader, Size)
 		if b.IsEmpty() {
 			b.Release()
 		} else {
@@ -220,7 +220,7 @@ func (mb *MultiBuffer) SliceBySize(size int32) MultiBuffer {
 	*mb = (*mb)[endIndex:]
 	if endIndex == 0 && len(*mb) > 0 {
 		b := New()
-		common.Must(b.Reset(ReadFullFrom((*mb)[0], size)))
+		common.Must2(b.ReadFullFrom((*mb)[0], size))
 		return NewMultiBufferValue(b)
 	}
 	return slice

common/buf/reader.go

@@ -10,7 +10,7 @@ import (
 func readOne(r io.Reader) (*Buffer, error) {
 	b := New()
 	for i := 0; i < 64; i++ {
-		err := b.Reset(ReadFrom(r))
+		_, err := b.ReadFrom(r)
 		if !b.IsEmpty() {
 			return b, nil
 		}

common/buf/writer.go

@@ -140,7 +140,7 @@ func (w *BufferedWriter) WriteMultiBuffer(b MultiBuffer) error {
 		if w.buffer == nil {
 			w.buffer = New()
 		}
-		if err := w.buffer.AppendSupplier(ReadFrom(&b)); err != nil {
+		if _, err := w.buffer.ReadFrom(&b); err != nil {
 			return err
 		}
 		if w.buffer.IsFull() {
@@ -248,7 +248,8 @@ func (noOpWriter) ReadFrom(reader io.Reader) (int64, error) {
 
 	totalBytes := int64(0)
 	for {
-		err := b.Reset(ReadFrom(reader))
+		b.Clear()
+		_, err := b.ReadFrom(reader)
 		totalBytes += int64(b.Len())
 		if err != nil {
 			if errors.Cause(err) == io.EOF {

common/buf/writer_test.go

@@ -17,7 +17,7 @@ func TestWriter(t *testing.T) {
 	assert := With(t)
 
 	lb := New()
-	assert(lb.AppendSupplier(ReadFrom(rand.Reader)), IsNil)
+	common.Must2(lb.ReadFrom(rand.Reader))
 
 	expectedBytes := append([]byte(nil), lb.Bytes()...)
 
@@ -54,7 +54,7 @@ func TestDiscardBytes(t *testing.T) {
 	assert := With(t)
 
 	b := New()
-	common.Must(b.Reset(ReadFullFrom(rand.Reader, Size)))
+	common.Must2(b.ReadFullFrom(rand.Reader, Size))
 
 	nBytes, err := io.Copy(DiscardBytes, b)
 	assert(nBytes, Equals, int64(Size))

common/crypto/auth.go

@@ -132,7 +132,7 @@ var errSoft = newError("waiting for more data")
 
 func (r *AuthenticationReader) readBuffer(size int32, padding int32) (*buf.Buffer, error) {
 	b := buf.New()
-	if err := b.Reset(buf.ReadFullFrom(r.reader, size)); err != nil {
+	if _, err := b.ReadFullFrom(r.reader, size); err != nil {
 		b.Release()
 		return nil, err
 	}
@@ -270,7 +270,7 @@ func (w *AuthenticationWriter) seal(b *buf.Buffer) (*buf.Buffer, error) {
 	}
 	if paddingSize > 0 {
 		// With size of the chunk and padding length encrypted, the content of padding doesn't matter much.
-		common.Must(eb.AppendSupplier(buf.ReadFullFrom(w.randReader, int32(paddingSize))))
+		common.Must2(eb.ReadFullFrom(w.randReader, int32(paddingSize)))
 	}
 
 	return eb, nil
@@ -289,9 +289,7 @@ func (w *AuthenticationWriter) writeStream(mb buf.MultiBuffer) error {
 
 	for {
 		b := buf.New()
-		common.Must(b.Reset(func(bb []byte) (int, error) {
-			return mb.Read(bb[:payloadSize])
-		}))
+		common.Must2(b.ReadFrom(io.LimitReader(&mb, int64(payloadSize))))
 		eb, err := w.seal(b)
 		b.Release()
 

common/mux/frame.go

@@ -1,6 +1,7 @@
 package mux
 
 import (
+	"encoding/binary"
 	"io"
 
 	"v2ray.com/core/common"
@@ -9,6 +10,7 @@ import (
 	"v2ray.com/core/common/net"
 	"v2ray.com/core/common/protocol"
 	"v2ray.com/core/common/serial"
+	"v2ray.com/core/common/vio"
 )
 
 type SessionStatus byte
@@ -60,11 +62,11 @@ type FrameMetadata struct {
 }
 
 func (f FrameMetadata) WriteTo(b *buf.Buffer) error {
-	lenBytes := b.Bytes()
 	common.Must2(b.WriteBytes(0x00, 0x00))
+	lenBytes := b.Bytes()
 
 	len0 := b.Len()
-	if err := b.AppendSupplier(serial.WriteUint16(f.SessionID)); err != nil {
+	if _, err := vio.WriteUint16(b, f.SessionID); err != nil {
 		return err
 	}
 
@@ -84,7 +86,7 @@ func (f FrameMetadata) WriteTo(b *buf.Buffer) error {
 	}
 
 	len1 := b.Len()
-	serial.Uint16ToBytes(uint16(len1-len0), lenBytes)
+	binary.BigEndian.PutUint16(lenBytes, uint16(len1-len0))
 	return nil
 }
 
@@ -101,7 +103,7 @@ func (f *FrameMetadata) Unmarshal(reader io.Reader) error {
 	b := buf.New()
 	defer b.Release()
 
-	if err := b.Reset(buf.ReadFullFrom(reader, int32(metaLen))); err != nil {
+	if _, err := b.ReadFullFrom(reader, int32(metaLen)); err != nil {
 		return err
 	}
 	return f.UnmarshalFromBuffer(b)

common/mux/reader.go

@@ -38,7 +38,7 @@ func (r *PacketReader) ReadMultiBuffer() (buf.MultiBuffer, error) {
 	}
 
 	b := buf.New()
-	if err := b.Reset(buf.ReadFullFrom(r.reader, int32(size))); err != nil {
+	if _, err := b.ReadFullFrom(r.reader, int32(size)); err != nil {
 		b.Release()
 		return nil, err
 	}

common/mux/writer.go

@@ -5,7 +5,7 @@ import (
 	"v2ray.com/core/common/buf"
 	"v2ray.com/core/common/net"
 	"v2ray.com/core/common/protocol"
-	"v2ray.com/core/common/serial"
+	"v2ray.com/core/common/vio"
 )
 
 type Writer struct {
@@ -66,7 +66,7 @@ func writeMetaWithFrame(writer buf.Writer, meta FrameMetadata, data buf.MultiBuf
 	if err := meta.WriteTo(frame); err != nil {
 		return err
 	}
-	if err := frame.AppendSupplier(serial.WriteUint16(uint16(data.Len()))); err != nil {
+	if _, err := vio.WriteUint16(frame, uint16(data.Len())); err != nil {
 		return err
 	}
 

common/protocol/address.go

@@ -53,7 +53,7 @@ func NewAddressParser(options ...AddressOption) *AddressParser {
 }
 
 func (p *AddressParser) readPort(b *buf.Buffer, reader io.Reader) (net.Port, error) {
-	if err := b.AppendSupplier(buf.ReadFullFrom(reader, 2)); err != nil {
+	if _, err := b.ReadFullFrom(reader, 2); err != nil {
 		return 0, err
 	}
 	return net.PortFromBytes(b.BytesFrom(-2)), nil
@@ -73,7 +73,7 @@ func isValidDomain(d string) bool {
 }
 
 func (p *AddressParser) readAddress(b *buf.Buffer, reader io.Reader) (net.Address, error) {
-	if err := b.AppendSupplier(buf.ReadFullFrom(reader, 1)); err != nil {
+	if _, err := b.ReadFullFrom(reader, 1); err != nil {
 		return nil, err
 	}
 
@@ -89,21 +89,21 @@ func (p *AddressParser) readAddress(b *buf.Buffer, reader io.Reader) (net.Addres
 
 	switch addrFamily {
 	case net.AddressFamilyIPv4:
-		if err := b.AppendSupplier(buf.ReadFullFrom(reader, 4)); err != nil {
+		if _, err := b.ReadFullFrom(reader, 4); err != nil {
 			return nil, err
 		}
 		return net.IPAddress(b.BytesFrom(-4)), nil
 	case net.AddressFamilyIPv6:
-		if err := b.AppendSupplier(buf.ReadFullFrom(reader, 16)); err != nil {
+		if _, err := b.ReadFullFrom(reader, 16); err != nil {
 			return nil, err
 		}
 		return net.IPAddress(b.BytesFrom(-16)), nil
 	case net.AddressFamilyDomain:
-		if err := b.AppendSupplier(buf.ReadFullFrom(reader, 1)); err != nil {
+		if _, err := b.ReadFullFrom(reader, 1); err != nil {
 			return nil, err
 		}
 		domainLength := int32(b.Byte(b.Len() - 1))
-		if err := b.AppendSupplier(buf.ReadFullFrom(reader, domainLength)); err != nil {
+		if _, err := b.ReadFullFrom(reader, domainLength); err != nil {
 			return nil, err
 		}
 		domain := string(b.BytesFrom(-domainLength))

common/serial/numbers.go

@@ -20,13 +20,6 @@ func ReadUint16(reader io.Reader) (uint16, error) {
 	return BytesToUint16(b[:]), nil
 }
 
-func WriteUint16(value uint16) func([]byte) (int, error) {
-	return func(b []byte) (int, error) {
-		Uint16ToBytes(value, b[:0])
-		return 2, nil
-	}
-}
-
 func Uint32ToBytes(value uint32, b []byte) []byte {
 	return append(b, byte(value>>24), byte(value>>16), byte(value>>8), byte(value))
 }

common/vio/serial.go

@@ -0,0 +1,18 @@
+package vio
+
+import (
+	"encoding/binary"
+	"io"
+)
+
+func WriteUint32(writer io.Writer, value uint32) (int, error) {
+	var b [4]byte
+	binary.BigEndian.PutUint32(b[:], value)
+	return writer.Write(b[:])
+}
+
+func WriteUint16(writer io.Writer, value uint16) (int, error) {
+	var b [2]byte
+	binary.BigEndian.PutUint16(b[:], value)
+	return writer.Write(b[:])
+}

common/vio/serial_test.go

@@ -0,0 +1,24 @@
+package vio_test
+
+import (
+	"testing"
+
+	"v2ray.com/core/common"
+	"v2ray.com/core/common/buf"
+	"v2ray.com/core/common/compare"
+	"v2ray.com/core/common/vio"
+)
+
+func TestUint32Serial(t *testing.T) {
+	b := buf.New()
+	defer b.Release()
+
+	n, err := vio.WriteUint32(b, 10)
+	common.Must(err)
+	if n != 4 {
+		t.Error("expect 4 bytes writtng, but actually ", n)
+	}
+	if err := compare.BytesEqualWithDetail(b.Bytes(), []byte{0, 0, 0, 10}); err != nil {
+		t.Error(err)
+	}
+}