Simplify internals

cli/proxy.go

 	"github.com/9seconds/mtg/obfuscated2"
 	"github.com/9seconds/mtg/proxy"
 	"github.com/9seconds/mtg/stats"
-	"github.com/9seconds/mtg/telegram"
 	"github.com/9seconds/mtg/utils"
 )
 
 	app := &proxy.Proxy{
 		Logger:  zap.S().Named("proxy"),
 		Context: ctx,
+		ClientProtocolMaker: obfuscated2.MakeClientProtocol,
+		TelegramProtocolMaker: obfuscated2.MakeTelegramProtocol,
 	}
-	if len(config.C.AdTag) == 0 {
-		app.TelegramProtocolMaker = obfuscated2.MakeTelegramProtocol
-		app.TelegramDialer = telegram.NewDirectTelegram()
-	}
-	if config.C.SecretMode != config.SecretModeTLS {
-		app.ClientProtocolMaker = obfuscated2.MakeClientProtocol
-	}
+	// if len(config.C.AdTag) == 0 {
+	// 	app.TelegramProtocolMaker = obfuscated2.MakeTelegramProtocol
+	// }
+	// if config.C.SecretMode != config.SecretModeTLS {
+	// 	app.ClientProtocolMaker = obfuscated2.MakeClientProtocol
+	// }
 
 	app.Serve(proxyListener)
 

obfuscated2/client_protocol.go

 const clientProtocolHandshakeTimeout = 10 * time.Second
 
 type ClientProtocol struct {
-	protocol.BaseProtocol
+	connectionType     conntypes.ConnectionType
+	connectionProtocol conntypes.ConnectionProtocol
+	dc                 conntypes.DC
+}
+
+func (c *ClientProtocol) ConnectionType() conntypes.ConnectionType {
+	return c.connectionType
+}
+
+func (c *ClientProtocol) ConnectionProtocol() conntypes.ConnectionProtocol {
+	return c.connectionProtocol
+}
+
+func (c *ClientProtocol) DC() conntypes.DC {
+	return c.dc
 }
 
 func (c *ClientProtocol) Handshake(socket wrappers.StreamReadWriteCloser) (wrappers.StreamReadWriteCloser, error) {
 	magic := decryptedFrame.Magic()
 	switch {
 	case bytes.Equal(magic, conntypes.ConnectionTagAbridged):
-		c.ConnectionType = conntypes.ConnectionTypeAbridged
+		c.connectionType = conntypes.ConnectionTypeAbridged
 	case bytes.Equal(magic, conntypes.ConnectionTagIntermediate):
-		c.ConnectionType = conntypes.ConnectionTypeIntermediate
+		c.connectionType = conntypes.ConnectionTypeIntermediate
 	case bytes.Equal(magic, conntypes.ConnectionTagSecure):
-		c.ConnectionType = conntypes.ConnectionTypeSecure
+		c.connectionType = conntypes.ConnectionTypeSecure
 	default:
 		return nil, errors.New("Unknown connection type")
 	}
 
-	c.ConnectionProtocol = conntypes.ConnectionProtocolIPv4
+	c.connectionProtocol = conntypes.ConnectionProtocolIPv4
 	if socket.LocalAddr().IP.To4() == nil {
-		c.ConnectionProtocol = conntypes.ConnectionProtocolIPv6
+		c.connectionProtocol = conntypes.ConnectionProtocolIPv6
 	}
 
 	buf := bytes.NewReader(decryptedFrame.DC())
-	if err := binary.Read(buf, binary.LittleEndian, &c.DC); err != nil {
-		c.DC = conntypes.DCDefaultIdx
+	if err := binary.Read(buf, binary.LittleEndian, &c.dc); err != nil {
+		c.dc = conntypes.DCDefaultIdx
 	}
 
 	antiReplayKey := decryptedFrame.Unique()

obfuscated2/telegram_protocol.go

 	"github.com/9seconds/mtg/wrappers"
 )
 
-type TelegramProtocol struct {
-	protocol.BaseProtocol
-
-	dialer telegram.Telegram
-}
+type TelegramProtocol struct{}
 
 func (t *TelegramProtocol) Handshake(req *protocol.TelegramRequest) (wrappers.Wrap, error) {
-	socket, err := t.dialer.Dial(req.Ctx,
+	socket, err := telegram.Direct.Dial(req.Ctx,
 		req.Cancel,
-		req.ClientProtocol.GetDC(),
-		req.ClientProtocol.GetConnectionProtocol())
+		req.ClientProtocol.DC(),
+		req.ClientProtocol.ConnectionProtocol())
 	if err != nil {
 		return nil, fmt.Errorf("cannot dial to telegram: %w", err)
 	}
 	return wrappers.NewObfuscated2(socket, encryptor, decryptor), nil
 }
 
-func MakeTelegramProtocol(dialer telegram.Telegram) protocol.TelegramProtocol {
-	return &TelegramProtocol{
-		dialer: dialer,
-	}
+func MakeTelegramProtocol() protocol.TelegramProtocol {
+	return &TelegramProtocol{}
 }
 
 func generateFrame(cp protocol.ClientProtocol) (fm Frame) {
 			continue
 		}
 
-		copy(fm.Magic(), cp.GetConnectionType().Tag())
+		copy(fm.Magic(), cp.ConnectionType().Tag())
 
 		return
 	}

protocol/base_protocol.go

-package protocol
-
-import "github.com/9seconds/mtg/conntypes"
-
-type BaseProtocol struct {
-	ConnectionType     conntypes.ConnectionType
-	ConnectionProtocol conntypes.ConnectionProtocol
-	DC                 conntypes.DC
-}
-
-func (b *BaseProtocol) GetConnectionType() conntypes.ConnectionType {
-	return b.ConnectionType
-}
-
-func (b *BaseProtocol) GetConnectionProtocol() conntypes.ConnectionProtocol {
-	return b.ConnectionProtocol
-}
-
-func (b *BaseProtocol) GetDC() conntypes.DC {
-	return b.DC
-}

protocol/interfaces.go

 
 import (
 	"github.com/9seconds/mtg/conntypes"
-	"github.com/9seconds/mtg/telegram"
 	"github.com/9seconds/mtg/wrappers"
 )
 
 type ClientProtocol interface {
 	Handshake(wrappers.StreamReadWriteCloser) (wrappers.StreamReadWriteCloser, error)
-	GetConnectionType() conntypes.ConnectionType
-	GetConnectionProtocol() conntypes.ConnectionProtocol
-	GetDC() conntypes.DC
+	ConnectionType() conntypes.ConnectionType
+	ConnectionProtocol() conntypes.ConnectionProtocol
+	DC() conntypes.DC
 }
 
-type ClientProtocolMaker func() ClientProtocol
-
 type TelegramProtocol interface {
 	Handshake(*TelegramRequest) (wrappers.Wrap, error)
 }
 
-type TelegramProtocolMaker func(telegram.Telegram) TelegramProtocol
+type ClientProtocolMaker func() ClientProtocol
+type TelegramProtocolMaker func() TelegramProtocol

proxy/proxy.go

 	"github.com/9seconds/mtg/conntypes"
 	"github.com/9seconds/mtg/protocol"
 	"github.com/9seconds/mtg/stats"
-	"github.com/9seconds/mtg/telegram"
 	"github.com/9seconds/mtg/utils"
 	"github.com/9seconds/mtg/wrappers"
 )
 	Context               context.Context
 	ClientProtocolMaker   protocol.ClientProtocolMaker
 	TelegramProtocolMaker protocol.TelegramProtocolMaker
-	TelegramDialer        telegram.Telegram
 }
 
 func (p *Proxy) Serve(listener net.Listener) {
 	}
 	defer wrappedConn.Close()
 
-	stats.S.ClientConnected(clientProtocol.GetConnectionType(), wrappedConn.RemoteAddr())
-	defer stats.S.ClientDisconnected(clientProtocol.GetConnectionType(), wrappedConn.RemoteAddr())
+	stats.S.ClientConnected(clientProtocol.ConnectionType(), wrappedConn.RemoteAddr())
+	defer stats.S.ClientDisconnected(clientProtocol.ConnectionType(), wrappedConn.RemoteAddr())
 	logger.Infow("Client connected", "addr", conn.RemoteAddr())
 
 	req := &protocol.TelegramRequest{
 }
 
 func (p *Proxy) acceptDirectConnection(request *protocol.TelegramRequest) error {
-	telegramProtocol := p.TelegramProtocolMaker(p.TelegramDialer)
+	telegramProtocol := p.TelegramProtocolMaker()
 	telegramConnRaw, err := telegramProtocol.Handshake(request)
 	if err != nil {
 		return err

telegram/direct.go

 	"github.com/9seconds/mtg/wrappers"
 )
 
+var Direct = newDirectTelegram()
+
 const (
 	directV4DefaultIdx conntypes.DC = 1
 	directV6DefaultIdx conntypes.DC = 1
 	return d.baseTelegram.dial(ctx, cancel, dc-1, protocol)
 }
 
-func NewDirectTelegram() Telegram {
+func newDirectTelegram() Telegram {
 	return &directTelegram{
 		baseTelegram: baseTelegram{
 			dialer:      net.Dialer{Timeout: telegramDialTimeout},

telegram/middle.go

 
 const middleTelegramBackgroundUpdateEvery = time.Hour
 
+var Middle = NewMiddleTelegram()
+
 type middleTelegram struct {
 	baseTelegram