Preliminary debug state

client/client.go

 )
 
 // Init has to initialize client connection based on given config.
-type Init func(net.Conn, *config.Config) (wrappers.ReadWriteCloserWithAddr, *mtproto.ConnectionOpts, error)
+type Init func(net.Conn, string, *config.Config) (wrappers.ReadWriteCloserWithAddr, *mtproto.ConnectionOpts, error)

client/direct.go

 const handshakeTimeout = 10 * time.Second
 
 // DirectInit initializes client to access Telegram bypassing middleproxies.
-func DirectInit(conn net.Conn, conf *config.Config) (wrappers.ReadWriteCloserWithAddr, *mtproto.ConnectionOpts, error) {
+func DirectInit(conn net.Conn, socketID string, conf *config.Config) (wrappers.ReadWriteCloserWithAddr, *mtproto.ConnectionOpts, error) {
 	if err := config.SetSocketOptions(conn); err != nil {
 		return nil, nil, errors.Annotate(err, "Cannot set socket options")
 	}
 	connOpts.ConnectionProto = mtproto.ConnectionProtocolAny
 	connOpts.ClientAddr = conn.RemoteAddr().(*net.TCPAddr)
 
-	socket := wrappers.NewTimeoutRWC(conn, conf.PublicIPv4, conf.PublicIPv6)
+	socket := wrappers.NewTimeoutRWC(conn, socketID, conf.PublicIPv4, conf.PublicIPv6)
 	socket = wrappers.NewStreamCipherRWC(socket, obfs2.Encryptor, obfs2.Decryptor)
 
 	return socket, connOpts, nil

client/middle.go

 	"github.com/9seconds/mtg/wrappers"
 )
 
-func MiddleInit(conn net.Conn, conf *config.Config) (wrappers.ReadWriteCloserWithAddr, *mtproto.ConnectionOpts, error) {
-	newConn, opts, err := DirectInit(conn, conf)
+func MiddleInit(conn net.Conn, socketID string, conf *config.Config) (wrappers.ReadWriteCloserWithAddr, *mtproto.ConnectionOpts, error) {
+	newConn, opts, err := DirectInit(conn, socketID, conf)
 	if err != nil {
 		return nil, nil, err
 	}

mtproto/wrappers/abridged.go

 		buf := &bytes.Buffer{}
 		buf.Grow(3)
 
+		q := make([]byte, 1)
+
 		if _, err := io.CopyN(buf, a.conn, 1); err != nil {
 			return errors.Annotate(err, "Cannot read message length")
 		}
 		msgLength := uint8(buf.Bytes()[0])
+		q[0] = msgLength
 		buf.Reset()
 
 		if msgLength >= abridgedQuickAckLength {
 			a.opts.ReadHacks.QuickAck = true
-			msgLength -= 0x80
+			msgLength -= abridgedQuickAckLength
 		}
 
 		msgLength32 := uint32(msgLength)
 			}
 			number := uint24{}
 			copy(number[:], buf.Bytes())
+			q = append(q, buf.Bytes()...)
 			msgLength32 = fromUint24(number)
 		}
 		msgLength32 *= 4
 		if _, err := io.CopyN(buf, a.conn, int64(msgLength32)); err != nil {
 			return errors.Annotate(err, "Cannot read message")
 		}
+		q = append(q, buf.Bytes()...)
 		a.Buffer.Write(buf.Bytes())
 
 		return nil
 		buf.Write(length24[:])
 		buf.Write(p)
 		return a.conn.Write(buf.Bytes())
-
-	default:
-		return 0, errors.Errorf("Packet is too big %d", len(p))
 	}
+
+	return 0, errors.Errorf("Packet is too big %d", len(p))
 }
 
 func (a *AbridgedReadWriteCloserWithAddr) Close() error {
 	return a.conn.RemoteAddr()
 }
 
+func (a *AbridgedReadWriteCloserWithAddr) SocketID() string {
+	return a.conn.SocketID()
+}
+
 func toUint24(number uint32) uint24 {
 	return uint24{byte(number), byte(number >> 8), byte(number >> 16)}
 }

mtproto/wrappers/frame.go

 	return f.conn.RemoteAddr()
 }
 
+func (f *FrameRWC) SocketID() string {
+	return f.conn.SocketID()
+}
+
 func NewFrameRWC(conn wrappers.ReadWriteCloserWithAddr, seqNo int32) wrappers.ReadWriteCloserWithAddr {
 	return &FrameRWC{
 		BufferedReader: wrappers.NewBufferedReader(),

mtproto/wrappers/intermediate.go

 	return i.conn.RemoteAddr()
 }
 
+func (i *IntermediateReadWriteCloserWithAddr) SocketID() string {
+	return i.conn.SocketID()
+}
+
 func NewIntermediateRWC(conn wrappers.ReadWriteCloserWithAddr, connOpts *mtproto.ConnectionOpts) wrappers.ReadWriteCloserWithAddr {
 	return &IntermediateReadWriteCloserWithAddr{
 		BufferedReader: wrappers.NewBufferedReader(),

mtproto/wrappers/proxy_request.go

 
 	"github.com/9seconds/mtg/mtproto"
 	"github.com/9seconds/mtg/mtproto/rpc"
+	"github.com/9seconds/mtg/utils"
 	"github.com/9seconds/mtg/wrappers"
 )
 
 
 		switch {
 		case bytes.Equal(ans, rpc.TagProxyAns):
-			return p.readProxyAns(buf)
+			return p.readProxyAns()
 		case bytes.Equal(ans, rpc.TagSimpleAck):
 			return p.readSimpleAck()
 		case bytes.Equal(ans, rpc.TagCloseExt):
 	return errors.New("Connection has been closed remotely")
 }
 
-func (p *ProxyRequestReadWriteCloserWithAddr) readProxyAns(buf []byte) (err error) {
+func (p *ProxyRequestReadWriteCloserWithAddr) readProxyAns() (err error) {
 	if _, err = io.CopyN(ioutil.Discard, p.conn, 8+4); err != nil {
 		return errors.Annotate(err, "Cannot skip flags and connid")
 	}
 
-	n := len(buf)
-	preBuffer := &bytes.Buffer{}
-	for n == len(buf) {
-		n, err = p.conn.Read(buf)
-		if err != nil {
-			return errors.Annotate(err, "Cannot read proxy answer")
-		}
-		preBuffer.Write(buf[:n])
+	buf, err := utils.ReadCurrentData(p.conn)
+	if err != nil {
+		return errors.Annotate(err, "Cannot read proxy answer")
 	}
-	p.Buffer.Write(preBuffer.Bytes())
+	p.Buffer.Write(buf)
 
 	return nil
 }
 	return p.conn.RemoteAddr()
 }
 
+func (p *ProxyRequestReadWriteCloserWithAddr) SocketID() string {
+	return p.conn.SocketID()
+}
+
 func NewProxyRequestRWC(conn wrappers.ReadWriteCloserWithAddr, connOpts *mtproto.ConnectionOpts, adTag []byte) (wrappers.ReadWriteCloserWithAddr, error) {
 	req, err := rpc.NewProxyRequest(connOpts.ClientAddr, conn.LocalAddr(), connOpts, adTag)
 	if err != nil {

proxy/server.go

 	"github.com/9seconds/mtg/config"
 	"github.com/9seconds/mtg/mtproto"
 	"github.com/9seconds/mtg/telegram"
+	"github.com/9seconds/mtg/utils"
 	"github.com/9seconds/mtg/wrappers"
 )
 
 }
 
 func (s *Server) getClientStream(ctx context.Context, cancel context.CancelFunc, conn net.Conn, socketID string) (*mtproto.ConnectionOpts, io.ReadWriteCloser, error) {
-	socket, connOpts, err := s.clientInit(conn, s.conf)
+	socket, connOpts, err := s.clientInit(conn, socketID, s.conf)
 	if err != nil {
 		return nil, nil, errors.Annotate(err, "Cannot init client connection")
 	}
 }
 
 func (s *Server) getTelegramStream(ctx context.Context, cancel context.CancelFunc, connOpts *mtproto.ConnectionOpts, socketID string) (io.ReadWriteCloser, error) {
-	conn, err := s.tg.Dial(connOpts)
+	conn, err := s.tg.Dial(socketID, connOpts)
 	if err != nil {
 		return nil, errors.Annotate(err, "Cannot connect to Telegram")
 	}
 	return conn, nil
 }
 
-func (s *Server) pump(src io.Reader, dst io.Writer, socketID, name string) (err error) {
-	copyBuf := make([]byte, 1024*1024*2)
-
-	n := config.BufferSizeCopy
-	for n == config.BufferSizeCopy {
-		n, err = src.Read(copyBuf)
-		if err != nil {
-			break
-		}
-		_, err = dst.Write(copyBuf[:n])
-		if err != nil {
-			break
-		}
+func (s *Server) pump(src io.Reader, dst io.Writer, socketID, name string) error {
+	buf, err := utils.ReadCurrentData(src)
+	if err != nil {
+		return errors.Annotate(err, "Cannot pump the socket")
 	}
 
-	return
+	_, err = dst.Write(buf)
+
+	return err
 }
 
 // NewServer creates new instance of MTPROTO proxy.

telegram/dialer.go

 	return conn, nil
 }
 
-func (t *tgDialer) dialRWC(addr string) (wrappers.ReadWriteCloserWithAddr, error) {
+func (t *tgDialer) dialRWC(addr, sock string) (wrappers.ReadWriteCloserWithAddr, error) {
 	conn, err := t.dial(addr)
 	if err != nil {
 		return nil, err
 	}
 
-	return wrappers.NewTimeoutRWC(conn, t.conf.PublicIPv4, t.conf.PublicIPv6), nil
+	return wrappers.NewTimeoutRWC(conn, sock, t.conf.PublicIPv4, t.conf.PublicIPv6), nil
 }

telegram/direct.go

 	baseTelegram
 }
 
-func (t *directTelegram) Dial(connOpts *mtproto.ConnectionOpts) (wrappers.ReadWriteCloserWithAddr, error) {
+func (t *directTelegram) Dial(sock string, connOpts *mtproto.ConnectionOpts) (wrappers.ReadWriteCloserWithAddr, error) {
 	dc := connOpts.DC
 	if dc < 0 {
 		dc = -dc
 		dc = 1
 	}
 
-	return t.baseTelegram.dial(dc-1, connOpts.ConnectionProto)
+	return t.baseTelegram.dial(dc-1, sock, connOpts.ConnectionProto)
 }
 
 func (t *directTelegram) Init(connOpts *mtproto.ConnectionOpts, conn wrappers.ReadWriteCloserWithAddr) (wrappers.ReadWriteCloserWithAddr, error) {

telegram/middle_caller.go

 	httpClient  *http.Client
 }
 
-func (t *middleTelegramCaller) Dial(connOpts *mtproto.ConnectionOpts) (wrappers.ReadWriteCloserWithAddr, error) {
+func (t *middleTelegramCaller) Dial(sock string, connOpts *mtproto.ConnectionOpts) (wrappers.ReadWriteCloserWithAddr, error) {
 	dc := connOpts.DC
 	if dc == 0 {
 		dc = 1
 	t.dialerMutex.RLock()
 	defer t.dialerMutex.RUnlock()
 
-	return t.baseTelegram.dial(dc, connOpts.ConnectionProto)
+	return t.baseTelegram.dial(dc, sock, connOpts.ConnectionProto)
 }
 
 func (t *middleTelegramCaller) autoUpdate() {

telegram/telegram.go

 // encapsulates logic of working with middleproxies or direct
 // connections.
 type Telegram interface {
-	Dial(*mtproto.ConnectionOpts) (wrappers.ReadWriteCloserWithAddr, error)
+	Dial(string, *mtproto.ConnectionOpts) (wrappers.ReadWriteCloserWithAddr, error)
 	Init(*mtproto.ConnectionOpts, wrappers.ReadWriteCloserWithAddr) (wrappers.ReadWriteCloserWithAddr, error)
 }
 
 	v6Addresses map[int16][]string
 }
 
-func (b *baseTelegram) dial(dcIdx int16, proto mtproto.ConnectionProtocol) (wrappers.ReadWriteCloserWithAddr, error) {
+func (b *baseTelegram) dial(dcIdx int16, sock string, proto mtproto.ConnectionProtocol) (wrappers.ReadWriteCloserWithAddr, error) {
 	addrs := make([]string, 2)
 
 	if proto&mtproto.ConnectionProtocolIPv6 != 0 {
 	}
 
 	for _, addr := range addrs {
-		if conn, err := b.dialer.dialRWC(addr); err == nil {
+		if conn, err := b.dialer.dialRWC(addr, sock); err == nil {
 			return conn, err
 		}
 	}

utils/read_current_data.go

+package utils
+
+import "io"
+
+const readCurrentDataBufferSize = 1024 + 1
+
+func ReadCurrentData(src io.Reader) (rv []byte, err error) {
+	buf := make([]byte, readCurrentDataBufferSize)
+	n := readCurrentDataBufferSize
+
+	for n == len(buf) {
+		n, err = src.Read(buf)
+		if err != nil {
+			return nil, err
+		}
+		rv = append(rv, buf[:n]...)
+	}
+
+	return rv, nil
+}

wrappers/blockcipherrwc.go

 package wrappers
 
 import (
-	"bytes"
 	"crypto/aes"
 	"crypto/cipher"
+	"fmt"
 	"net"
 
 	"github.com/juju/errors"
+
+	"github.com/9seconds/mtg/utils"
 )
 
 type BlockCipherReadWriteCloserWithAddr struct {
 
 func (c *BlockCipherReadWriteCloserWithAddr) Read(p []byte) (int, error) {
 	return c.BufferedRead(p, func() error {
-		buf := &bytes.Buffer{}
-		for buf.Len()%aes.BlockSize != 0 || buf.Len() == 0 {
-			n, err := c.conn.Read(p)
+		var buf []byte
+
+		for len(buf) == 0 || len(buf)%aes.BlockSize != 0 {
+			rv, err := utils.ReadCurrentData(c.conn)
 			if err != nil {
 				return errors.Annotate(err, "Cannot read from socket")
 			}
-			buf.Write(p[:n])
+			buf = append(buf, rv...)
 		}
-		c.decryptor.CryptBlocks(buf.Bytes(), buf.Bytes())
-		c.Buffer.Write(buf.Bytes())
+
+		c.decryptor.CryptBlocks(buf, buf)
+		c.Buffer.Write(buf)
 
 		return nil
 	})
 }
 
 func (c *BlockCipherReadWriteCloserWithAddr) Close() error {
+	fmt.Println("BlockCipherReadWriteCloserWithAddr closes", "sockid", c.SocketID(), "bufsize", c.Buffer.Len())
 	return c.conn.Close()
 }
 
 	return c.conn.RemoteAddr()
 }
 
+func (c *BlockCipherReadWriteCloserWithAddr) SocketID() string {
+	return c.conn.SocketID()
+}
+
 func NewBlockCipherRWC(conn ReadWriteCloserWithAddr, encryptor, decryptor cipher.BlockMode) ReadWriteCloserWithAddr {
 	return &BlockCipherReadWriteCloserWithAddr{
 		BufferedReader: NewBufferedReader(),

wrappers/buffered_reader.go

 package wrappers
 
-import "bytes"
+import (
+	"bytes"
+
+	"github.com/juju/errors"
+)
 
 type BufferedReader struct {
 	Buffer *bytes.Buffer
 }
 
+var (
+	BufferedReaderContinue = errors.New("Please continue reading")
+)
+
 func (b *BufferedReader) BufferedRead(p []byte, callback func() error) (int, error) {
 	if b.Buffer.Len() > 0 {
 		return b.flush(p)
 }
 
 func (b *BufferedReader) flush(p []byte) (int, error) {
-	if b.Buffer.Len() < len(p) {
+	if b.Buffer.Len() <= len(p) {
 		sizeToReturn := b.Buffer.Len()
 		copy(p, b.Buffer.Bytes())
 		b.Buffer.Reset()

wrappers/ctxrwc.go

 	return c.conn.RemoteAddr()
 }
 
+func (c *CtxReadWriteCloserWithAddr) SocketID() string {
+	return c.conn.SocketID()
+}
+
 // NewCtxRWC returns ReadWriteCloser which respects given context,
 // cancellation etc.
 func NewCtxRWC(ctx context.Context, cancel context.CancelFunc, conn ReadWriteCloserWithAddr) ReadWriteCloserWithAddr {

wrappers/logrwc.go

 // Read reads from connection
 func (l *LogReadWriteCloserWithAddr) Read(p []byte) (n int, err error) {
 	n, err = l.conn.Read(p)
-	l.logger.Debugw("Finish reading", "name", l.name, "socketid", l.sockid, "nbytes", n, "error", err)
+	l.logger.Debugw("Finish reading", "name", l.name, "socketid", l.sockid, "nbytes", n, "error", err, "localAddr", l.LocalAddr())
 	return
 }
 
 // Write writes into connection.
 func (l *LogReadWriteCloserWithAddr) Write(p []byte) (n int, err error) {
 	n, err = l.conn.Write(p)
-	l.logger.Debugw("Finish writing", "name", l.name, "socketid", l.sockid, "nbytes", n, "error", err)
+	l.logger.Debugw("Finish writing", "name", l.name, "socketid", l.sockid, "nbytes", n, "error", err, "localAddr", l.LocalAddr())
 	return
 }
 
 	return l.conn.RemoteAddr()
 }
 
+func (l *LogReadWriteCloserWithAddr) SocketID() string {
+	return l.sockid
+}
+
 // NewLogRWC wraps ReadWriteCloser with logger calls.
 func NewLogRWC(conn ReadWriteCloserWithAddr, logger *zap.SugaredLogger, sockid string, name string) ReadWriteCloserWithAddr {
 	return &LogReadWriteCloserWithAddr{

wrappers/rwcaddr.go

 
 	LocalAddr() *net.TCPAddr
 	RemoteAddr() *net.TCPAddr
+	SocketID() string
 }

wrappers/streamcipherrwc.go

 	return c.conn.RemoteAddr()
 }
 
+func (c *StreamCipherReadWriteCloserWithAddr) SocketID() string {
+	return c.conn.SocketID()
+}
+
 // NewStreamCipherRWC returns wrapper which transparently
 // encrypts/decrypts traffic with obfuscated2 protocol.
 func NewStreamCipherRWC(conn ReadWriteCloserWithAddr, encryptor, decryptor cipher.Stream) ReadWriteCloserWithAddr {

wrappers/timeoutrwc.go

 
 type TimeoutReadWriteCloserWithAddr struct {
 	conn       net.Conn
+	sock       string
 	publicIPv4 net.IP
 	publicIPv6 net.IP
 }
 	return &newAddr
 }
 
-func NewTimeoutRWC(conn net.Conn, ipv4, ipv6 net.IP) ReadWriteCloserWithAddr {
+func (t *TimeoutReadWriteCloserWithAddr) SocketID() string {
+	return t.sock
+}
+
+func NewTimeoutRWC(conn net.Conn, sock string, ipv4, ipv6 net.IP) ReadWriteCloserWithAddr {
 	return &TimeoutReadWriteCloserWithAddr{
 		conn:       conn,
 		publicIPv4: ipv4,
 		publicIPv6: ipv6,
+		sock:       sock,
 	}
 }

wrappers/trafficrwc.go

 	return t.conn.RemoteAddr()
 }
 
+func (t *TrafficReadWriteCloserWithAddr) SocketID() string {
+	return t.conn.SocketID()
+}
+
 // NewTrafficRWC wraps ReadWriteCloser to have read/write callbacks.
 func NewTrafficRWC(conn ReadWriteCloserWithAddr, readCallback, writeCallback func(int)) ReadWriteCloserWithAddr {
 	return &TrafficReadWriteCloserWithAddr{