Bugfix rpc handshake

client/direct.go

 		return nil, nil, errors.Annotate(err, "Cannot parse obfuscated frame")
 	}
 	connOpts.ConnectionProto = mtproto.ConnectionProtocolAny
-	connOpts.ClientAddr = conn.RemoteAddr().(*net.TCPAddr)
 
-	socket := wrappers.NewTimeoutRWC(conn)
+	socket := wrappers.NewTimeoutRWC(conn, conf.PublicIPv4, conf.PublicIPv6)
 	socket = wrappers.NewStreamCipherRWC(socket, obfs2.Encryptor, obfs2.Decryptor)
 
 	return connOpts, socket, nil

config/config.go

 	return getAddr(c.BindIP, c.BindPort)
 }
 
-// IPv4Addr returns connection string to ipv6 for mtproto proxy.
-func (c *Config) IPv4Addr() string {
-	return getAddr(c.PublicIPv4, c.PublicIPv4Port)
-}
-
-// IPv6Addr returns connection string to ipv6 for mtproto proxy.
-func (c *Config) IPv6Addr() string {
-	return getAddr(c.PublicIPv6, c.PublicIPv6Port)
-}
-
 // StatAddr returns connection string to the stats API.
 func (c *Config) StatAddr() string {
 	return getAddr(c.StatsIP, c.StatsPort)
 
 // GetURLs returns configured IPURLs instance with links to this server.
 func (c *Config) GetURLs() IPURLs {
-	return IPURLs{
-		IPv4: getURLs(c.PublicIPv4, c.PublicIPv4Port, c.Secret),
-		IPv6: getURLs(c.PublicIPv6, c.PublicIPv6Port, c.Secret),
+	urls := IPURLs{}
+	if c.PublicIPv4 != nil {
+		urls.IPv4 = getURLs(c.PublicIPv4, c.PublicIPv4Port, c.Secret)
 	}
+	if c.PublicIPv6 != nil {
+		urls.IPv6 = getURLs(c.PublicIPv6, c.PublicIPv6Port, c.Secret)
+	}
+
+	return urls
 }
 
 func getAddr(host fmt.Stringer, port uint16) string {
 	if publicIPv4 == nil {
 		publicIPv4, err = getGlobalIPv4()
 		if err != nil {
-			return nil, errors.Errorf("Cannot get public IP")
+			publicIPv4 = nil
+		} else if publicIPv4.To4() == nil {
+			return nil, errors.Errorf("IP %s is not IPv4", publicIPv4.String())
 		}
 	}
-	if publicIPv4.To4() == nil {
-		return nil, errors.Errorf("IP %s is not IPv4", publicIPv4.String())
-	}
 	if PublicIPv4Port == 0 {
 		PublicIPv4Port = bindPort
 	}
 	if publicIPv6 == nil {
 		publicIPv6, err = getGlobalIPv6()
 		if err != nil {
-			publicIPv6 = publicIPv4
+			publicIPv6 = nil
+		} else if publicIPv6.To4() != nil {
+			return nil, errors.Errorf("IP %s is not IPv6", publicIPv6.String())
 		}
 	}
-	if publicIPv6.To16() == nil {
-		return nil, errors.Errorf("IP %s is not IPv6", publicIPv6.String())
-	}
 	if publicIPv6Port == 0 {
 		publicIPv6Port = bindPort
 	}

main.go

 
 import (
 	"encoding/json"
+	"fmt"
 	"io"
 	"math/rand"
 	"os"
 	kingpin "gopkg.in/alecthomas/kingpin.v2"
 
 	"github.com/9seconds/mtg/config"
-	"github.com/9seconds/mtg/proxy"
+	"github.com/9seconds/mtg/mtproto"
+	"github.com/9seconds/mtg/telegram"
 	"github.com/juju/errors"
 )
 
 		atom,
 	)).Sugar()
 
-	stat := proxy.NewStats(conf)
-	go stat.Serve()
-
-	srv := proxy.NewServer(conf, logger, stat)
-	printURLs(conf.GetURLs())
+	tg := telegram.NewMiddleTelegram(conf, logger)
+	connOpts := &mtproto.ConnectionOpts{
+		DC:              int16(1),
+		ConnectionType:  mtproto.ConnectionTypeAbridged,
+		ConnectionProto: mtproto.ConnectionProtocolIPv4,
+	}
 
-	if err := srv.Serve(); err != nil {
-		logger.Fatal(err.Error())
+	sock, err := tg.Dial(connOpts)
+	if err != nil {
+		panic(err)
 	}
+	_, err = tg.Init(connOpts, sock)
+	fmt.Println(err)
+
+	// stat := proxy.NewStats(conf)
+	// go stat.Serve()
+
+	// srv := proxy.NewServer(conf, logger, stat)
+	// printURLs(conf.GetURLs())
+
+	// if err := srv.Serve(); err != nil {
+	// 	logger.Fatal(err.Error())
+	// }
 }
 
 func setRLimit() (err error) {

mtproto/connection_options.go

 
 import (
 	"bytes"
-	"net"
 
 	"github.com/juju/errors"
 )
 	DC              int16
 	ConnectionType  ConnectionType
 	ConnectionProto ConnectionProtocol
-	ClientAddr      *net.TCPAddr
+	QuickAck        bool
+	SimpleAck       bool
 }
 
 // Different connection types which user requests from Telegram.

mtproto/rpc/rpc_handshake_request.go

 package rpc
 
-import "bytes"
+import (
+	"bytes"
+)
 
 const (
 	rpcHandshakeTagLength       = 4

mtproto/wrappers/crypt.go

 
 var emptyIP = [4]byte{0x00, 0x00, 0x00, 0x00}
 
-func NewMiddleProxyCipherRWC(conn wrappers.ReadWriteCloserWithAddr, req *rpc.RPCNonceRequest,
-	resp *rpc.RPCNonceResponse, client *net.TCPAddr, secret []byte) wrappers.ReadWriteCloserWithAddr {
-	remote := conn.Addr()
-	encKey, encIV := makeKeys(CipherPurposeClient, req, resp, client, remote, secret)
-	decKey, decIV := makeKeys(CipherPurposeServer, req, resp, client, remote, secret)
+func NewMiddleProxyCipherRWC(conn wrappers.ReadWriteCloserWithAddr, req *rpc.RPCNonceRequest, resp *rpc.RPCNonceResponse, secret []byte) wrappers.ReadWriteCloserWithAddr {
+	localAddr := conn.LocalAddr()
+	remoteAddr := conn.RemoteAddr()
+
+	encKey, encIV := makeKeys(CipherPurposeClient, req, resp, localAddr, remoteAddr, secret)
+	decKey, decIV := makeKeys(CipherPurposeServer, req, resp, localAddr, remoteAddr, secret)
 
 	enc, _ := makeEncrypterDecrypter(encKey, encIV)
 	_, dec := makeEncrypterDecrypter(decKey, decIV)

mtproto/wrappers/frame.go

 	return f.conn.Close()
 }
 
-func (f *FrameRWC) Addr() *net.TCPAddr {
-	return f.conn.Addr()
+func (f *FrameRWC) LocalAddr() *net.TCPAddr {
+	return f.conn.LocalAddr()
+}
+
+func (f *FrameRWC) RemoteAddr() *net.TCPAddr {
+	return f.conn.RemoteAddr()
 }
 
 func NewFrameRWC(conn wrappers.ReadWriteCloserWithAddr, seqNo int32) wrappers.ReadWriteCloserWithAddr {

telegram/dialer.go

 
 type tgDialer struct {
 	net.Dialer
+
+	conf *config.Config
 }
 
 func (t *tgDialer) dial(addr string) (net.Conn, error) {
 		return nil, err
 	}
 
-	return wrappers.NewTimeoutRWC(conn), nil
+	return wrappers.NewTimeoutRWC(conn, t.conf.PublicIPv4, t.conf.PublicIPv6), nil
 }

telegram/direct.go

 // to Telegram bypassing middleproxies.
 func NewDirectTelegram(conf *config.Config) Telegram {
 	return &directTelegram{baseTelegram{
-		dialer:      tgDialer{net.Dialer{Timeout: telegramDialTimeout}},
+		dialer: tgDialer{
+			Dialer: net.Dialer{Timeout: telegramDialTimeout},
+			conf:   conf,
+		},
 		v4Addresses: directV4Addresses,
 		v6Addresses: directV6Addresses,
 	}}

telegram/middle.go

 package telegram
 
 import (
+	"fmt"
 	"io"
 	"net"
 	"net/http"
 	tg := &middleTelegram{
 		middleTelegramCaller: middleTelegramCaller{
 			baseTelegram: baseTelegram{
-				dialer: tgDialer{net.Dialer{Timeout: telegramDialTimeout}},
+				dialer: tgDialer{
+					Dialer: net.Dialer{Timeout: telegramDialTimeout},
+					conf:   conf,
+				},
 			},
 			logger: logger,
 			httpClient: &http.Client{
 		return nil, err
 	}
 
-	secureConn := mtwrappers.NewMiddleProxyCipherRWC(conn, rpcNonceReq,
-		rpcNonceResp, connOpts.ClientAddr, t.proxySecret)
+	secureConn := mtwrappers.NewMiddleProxyCipherRWC(conn, rpcNonceReq, rpcNonceResp, t.proxySecret)
 	secureConn = mtwrappers.NewFrameRWC(secureConn, rpc.RPCHandshakeSeqNo)
 
 	rpcHandshakeReq, err := t.sendRPCHandshakeRequest(secureConn)
 	if err = rpcHandshakeResp.Valid(req); err != nil {
 		return nil, errors.Annotate(err, "Invalid RPC handshake response")
 	}
+	fmt.Println("VICTORY")
 
 	return rpcHandshakeResp, nil
 }

wrappers/blockcipherrwc.go

 				return errors.Annotate(err, "Cannot read from socket")
 			}
 			c.Buffer.Write(p[:n])
+			bufferLength = c.Buffer.Len()
 		}
 		c.decryptor.CryptBlocks(c.Buffer.Bytes(), c.Buffer.Bytes())
 
 	return c.conn.Close()
 }
 
-func (c *BlockCipherReadWriteCloserWithAddr) Addr() *net.TCPAddr {
-	return c.conn.Addr()
+func (c *BlockCipherReadWriteCloserWithAddr) LocalAddr() *net.TCPAddr {
+	return c.conn.LocalAddr()
+}
+
+func (c *BlockCipherReadWriteCloserWithAddr) RemoteAddr() *net.TCPAddr {
+	return c.conn.RemoteAddr()
 }
 
 func NewBlockCipherRWC(conn ReadWriteCloserWithAddr, encryptor, decryptor cipher.BlockMode) ReadWriteCloserWithAddr {

wrappers/ctxrwc.go

 	return c.conn.Close()
 }
 
-func (c *CtxReadWriteCloserWithAddr) Addr() *net.TCPAddr {
-	return c.conn.Addr()
+func (c *CtxReadWriteCloserWithAddr) LocalAddr() *net.TCPAddr {
+	return c.conn.LocalAddr()
+}
+
+func (c *CtxReadWriteCloserWithAddr) RemoteAddr() *net.TCPAddr {
+	return c.conn.RemoteAddr()
 }
 
 // NewCtxRWC returns ReadWriteCloser which respects given context,

wrappers/logrwc.go

 	return err
 }
 
-func (l *LogReadWriteCloserWithAddr) Addr() *net.TCPAddr {
-	return l.conn.Addr()
+func (l *LogReadWriteCloserWithAddr) LocalAddr() *net.TCPAddr {
+	return l.conn.LocalAddr()
+}
+
+func (l *LogReadWriteCloserWithAddr) RemoteAddr() *net.TCPAddr {
+	return l.conn.RemoteAddr()
 }
 
 // NewLogRWC wraps ReadWriteCloser with logger calls.

wrappers/rwcaddr.go

 type ReadWriteCloserWithAddr interface {
 	io.ReadWriteCloser
 
-	Addr() *net.TCPAddr
+	LocalAddr() *net.TCPAddr
+	RemoteAddr() *net.TCPAddr
 }

wrappers/streamcipherrwc.go

 	return c.conn.Close()
 }
 
-func (c *StreamCipherReadWriteCloserWithAddr) Addr() *net.TCPAddr {
-	return c.conn.Addr()
+func (c *StreamCipherReadWriteCloserWithAddr) LocalAddr() *net.TCPAddr {
+	return c.conn.LocalAddr()
+}
+
+func (c *StreamCipherReadWriteCloserWithAddr) RemoteAddr() *net.TCPAddr {
+	return c.conn.RemoteAddr()
 }
 
 // NewStreamCipherRWC returns wrapper which transparently

wrappers/timeoutrwc.go

 )
 
 type TimeoutReadWriteCloserWithAddr struct {
-	conn net.Conn
+	conn       net.Conn
+	publicIPv4 net.IP
+	publicIPv6 net.IP
 }
 
 func (t *TimeoutReadWriteCloserWithAddr) Read(p []byte) (int, error) {
 	return t.conn.Close()
 }
 
-func (t *TimeoutReadWriteCloserWithAddr) Addr() *net.TCPAddr {
+func (t *TimeoutReadWriteCloserWithAddr) RemoteAddr() *net.TCPAddr {
 	return t.conn.RemoteAddr().(*net.TCPAddr)
 }
 
-func NewTimeoutRWC(conn net.Conn) ReadWriteCloserWithAddr {
-	return &TimeoutReadWriteCloserWithAddr{conn}
+func (t *TimeoutReadWriteCloserWithAddr) LocalAddr() *net.TCPAddr {
+	addr := t.conn.LocalAddr().(*net.TCPAddr)
+	newAddr := *addr
+
+	if t.RemoteAddr().IP.To4() != nil {
+		if t.publicIPv4 != nil {
+			newAddr.IP = t.publicIPv4
+		}
+	} else if t.publicIPv6 != nil {
+		newAddr.IP = t.publicIPv6
+	}
+
+	return &newAddr
+}
+
+func NewTimeoutRWC(conn net.Conn, ipv4, ipv6 net.IP) ReadWriteCloserWithAddr {
+	return &TimeoutReadWriteCloserWithAddr{
+		conn:       conn,
+		publicIPv4: ipv4,
+		publicIPv6: ipv6,
+	}
 }

wrappers/trafficrwc.go

 	return t.conn.Close()
 }
 
-func (t *TrafficReadWriteCloserWithAddr) Addr() *net.TCPAddr {
-	return t.conn.Addr()
+func (t *TrafficReadWriteCloserWithAddr) LocalAddr() *net.TCPAddr {
+	return t.conn.LocalAddr()
+}
+
+func (t *TrafficReadWriteCloserWithAddr) RemoteAddr() *net.TCPAddr {
+	return t.conn.RemoteAddr()
 }
 
 // NewTrafficRWC wraps ReadWriteCloser to have read/write callbacks.