Remove mtproto pool

mtproto/bufferpool.go

-package mtproto
-
-import (
-	"bytes"
-	"sync"
-)
-
-const bufferPoolSize = 4 * 1024
-
-var bufferPool sync.Pool
-
-func GetBuffer() *bytes.Buffer {
-	buf := bufferPool.Get().(*bytes.Buffer)
-	buf.Reset()
-
-	return buf
-}
-
-func ReturnBuffer(buf *bytes.Buffer) {
-	bufferPool.Put(buf)
-}
-
-func init() {
-	bufferPool = sync.Pool{
-		New: func() interface{} {
-			buf := &bytes.Buffer{}
-			buf.Grow(bufferPoolSize)
-
-			return buf
-		},
-	}
-}

mtproto/rpc/rpc.go

 package rpc
 
-import "bytes"
-
 const (
 	RPCNonceSeqNo     = -2
 	RPCHandshakeSeqNo = -1
 )
-
-type RPC interface {
-	Bytes() *bytes.Buffer
-}

mtproto/rpc/rpc_handshake_request.go

 type RPCHandshakeRequest struct {
 }
 
-func (r *RPCHandshakeRequest) Bytes() *bytes.Buffer {
+func (r *RPCHandshakeRequest) Bytes() []byte {
 	buf := &bytes.Buffer{}
 	buf.Grow(rpcHandshakeRequestLength)
 
 	buf.Write(rpcHandshakeSenderPID[:])
 	buf.Write(rpcHandshakePeerPID[:])
 
-	return buf
+	return buf.Bytes()
 }
 
 func init() {

mtproto/rpc/rpc_handshake_response.go

 	PeerPID   [rpcHandshakePeerPIDLength]byte
 }
 
-func (r *RPCHandshakeResponse) Bytes() *bytes.Buffer {
+func (r *RPCHandshakeResponse) Bytes() []byte {
 	buf := &bytes.Buffer{}
 	buf.Grow(rpcHandshakeResponseLength)
 
 	buf.Write(r.SenderPID[:])
 	buf.Write(r.PeerPID[:])
 
-	return buf
+	return buf.Bytes()
 }
 
 func (r *RPCHandshakeResponse) Valid(req *RPCHandshakeRequest) error {

mtproto/rpc/rpc_nonce_request.go

 	Nonce       [rpcNonceLength]byte
 }
 
-func (r *RPCNonceRequest) Bytes() *bytes.Buffer {
+func (r *RPCNonceRequest) Bytes() []byte {
 	buf := &bytes.Buffer{}
 	buf.Grow(rpcNonceRequestLength)
 
 	buf.Write(r.CryptoTS[:])
 	buf.Write(r.Nonce[:])
 
-	return buf
+	return buf.Bytes()
 }
 
 func NewRPCNonceRequest(proxySecret []byte) (*RPCNonceRequest, error) {

mtproto/rpc/rpc_nonce_response.go

 	Crypto  [rpcNonceCryptoAESLength]byte
 }
 
-func (r *RPCNonceResponse) Bytes() *bytes.Buffer {
+func (r *RPCNonceResponse) Bytes() []byte {
 	buf := &bytes.Buffer{}
 	buf.Grow(rpcNonceResponseLength)
 
 	buf.Write(r.CryptoTS[:])
 	buf.Write(r.Nonce[:])
 
-	return buf
+	return buf.Bytes()
 }
 
 func (r *RPCNonceResponse) Valid(req *RPCNonceRequest) error {

mtproto/rpc/rpc_proxy_request.go

 	Extras       *mtproto.Extras
 }
 
-func (r *RPCProxyRequest) Bytes() *bytes.Buffer {
-	buf := mtproto.GetBuffer()
+func (r *RPCProxyRequest) Bytes() []byte {
+	buf := &bytes.Buffer{}
 
 	flags := r.Flags
 	if r.Extras.QuickAck {
 		buf.Write(messageBytes)
 	}
 
-	return buf
+	return buf.Bytes()
 }
 
 func NewRPCProxyRequest(connectionType mtproto.ConnectionType, local, remote *net.TCPAddr, adTag []byte, extras *mtproto.Extras) (*RPCProxyRequest, error) {

mtproto/rwc.go

-package mtproto
-
-import (
-	"bytes"
-	"io"
-)
-
-type BytesRWC interface {
-	Write(*bytes.Buffer) (int, error)
-	Read([]byte) (int, error)
-	Close() error
-}
-
-type StartBytesRWC struct {
-	conn BytesRWC
-}
-
-func (s *StartBytesRWC) Write(p []byte) (int, error) {
-	buf := GetBuffer()
-	buf.Write(p)
-	defer ReturnBuffer(buf)
-
-	return s.conn.Write(buf)
-}
-
-func (s *StartBytesRWC) Read(p []byte) (int, error) {
-	return s.conn.Read(p)
-}
-
-func (s *StartBytesRWC) Close() error {
-	return s.conn.Close()
-}
-
-type FinishBytesRWC struct {
-	conn io.ReadWriteCloser
-}
-
-func (f *FinishBytesRWC) Write(buf *bytes.Buffer) (int, error) {
-	return f.conn.Write(buf.Bytes())
-}
-
-func (f *FinishBytesRWC) Read(p []byte) (int, error) {
-	return f.conn.Read(p)
-}
-
-func (f *FinishBytesRWC) Close() error {
-	return f.conn.Close()
-}

mtproto/crypt/crypt.go → mtproto/wrappers/crypt.go

-package crypt
+package wrappers
 
 import (
 	"bytes"

mtproto/wrappers/frame.go

 	"io"
 
 	"github.com/juju/errors"
-
-	"github.com/9seconds/mtg/mtproto"
 )
 
 // Frame: { MessageLength(4) | SequenceNumber(4) | Message(???) | CRC32(4) [| padding(4), ...] }
 var frameRWCPadding = [4]byte{0x04, 0x00, 0x00, 0x00}
 
 type FrameRWC struct {
-	conn mtproto.BytesRWC
+	conn io.ReadWriteCloser
 
 	readSeqNo  int32
 	writeSeqNo int32
 	readBuf    *bytes.Buffer
 }
 
-func (f *FrameRWC) Write(buf *bytes.Buffer) (int, error) {
-	writeBuf := mtproto.GetBuffer()
-	defer mtproto.ReturnBuffer(writeBuf)
+func (f *FrameRWC) Write(buf []byte) (int, error) {
+	writeBuf := &bytes.Buffer{}
 
 	// 4 - len bytes
 	// 4 - seq bytes
 	// . - message
 	// 4 - crc32
-	messageLength := 4 + 4 + buf.Len() + 4
+	messageLength := 4 + 4 + len(buf) + 4
 	paddingLength := (aes.BlockSize - messageLength%aes.BlockSize) % aes.BlockSize
 	writeBuf.Grow(messageLength + paddingLength)
 
 	binary.Write(writeBuf, binary.LittleEndian, uint32(messageLength))
 	binary.Write(writeBuf, binary.LittleEndian, f.writeSeqNo)
-	writeBuf.Write(buf.Bytes())
+	writeBuf.Write(buf)
 	f.writeSeqNo++
 
 	checksum := crc32.ChecksumIEEE(writeBuf.Bytes())
 	binary.Write(writeBuf, binary.LittleEndian, checksum)
 	writeBuf.Write(bytes.Repeat(frameRWCPadding[:], paddingLength/4))
 
-	return f.conn.Write(writeBuf)
+	_, err := f.conn.Write(writeBuf.Bytes())
+	return len(buf), err
 }
 
 func (f *FrameRWC) Read(p []byte) (int, error) {
 		return f.flush(p)
 	}
 
-	buf := mtproto.GetBuffer()
-	defer mtproto.ReturnBuffer(buf)
-
+	buf := &bytes.Buffer{}
 	for {
 		buf.Reset()
 		if _, err := io.CopyN(buf, f.conn, 4); err != nil {
 }
 
 func (f *FrameRWC) Close() error {
-	defer mtproto.ReturnBuffer(f.readBuf)
 	return f.conn.Close()
 }
 
 	if sizeToRead == f.readBuf.Len() {
 		f.readBuf.Reset()
 	} else {
-		newBuf := mtproto.GetBuffer()
-		newBuf.Write(data[sizeToRead:])
-
-		mtproto.ReturnBuffer(f.readBuf)
-		f.readBuf = newBuf
+		f.readBuf = bytes.NewBuffer(data[sizeToRead:])
 	}
 
 	return sizeToRead, nil
 }
 
-func NewFrameRWC(conn mtproto.BytesRWC, seqNo int32) mtproto.BytesRWC {
+func NewFrameRWC(conn io.ReadWriteCloser, seqNo int32) io.ReadWriteCloser {
 	return &FrameRWC{
 		conn:       conn,
 		readSeqNo:  seqNo,
 		writeSeqNo: seqNo,
-		readBuf:    mtproto.GetBuffer(),
+		readBuf:    &bytes.Buffer{},
 	}
 }