[Update] 移动结构

pkg/coco/task.go

@@ -59,7 +59,7 @@ func keepHeartbeat(interval int) {
 			tasks := service.TerminalHeartBeat(data)
 			if len(tasks) != 0 {
 				for _, task := range tasks {
-					proxy.HandlerSessionTask(task)
+					proxy.HandleSessionTask(task)
 				}
 			}
 		}

pkg/handler/session.go

@@ -511,7 +511,7 @@ func selectHighestPrioritySystemUsers(systemUsers []model.SystemUser) []model.Sy
 //	Home := userhome.NewUserSessionHome(sshConn)
 //	logger.Info("session Home ID: ", Home.SessionID())
 //
-//	err = proxy.Manager.Session(i.sess.Context(), Home, memChan)
+//	err = proxy.Manager.session(i.sess.Context(), Home, memChan)
 //	if err != nil {
 //		logger.Error(err)
 //	}

pkg/httpd/handler.go

@@ -38,7 +38,7 @@ func AuthDecorator(handler http.HandlerFunc) http.HandlerFunc {
 
 func OnConnectHandler(s socketio.Conn) error {
 	// 首次连接 1.获取当前用户的信息
-	logger.Debug("OnConnectHandler")
+	logger.Debug("On connect trigger")
 	cookies := strings.Split(s.RemoteHeader().Get("Cookie"), ";")
 	var csrfToken, sessionID, remoteIP string
 	for _, line := range cookies {
@@ -51,7 +51,9 @@ func OnConnectHandler(s socketio.Conn) error {
 	}
 	user, err := service.CheckUserCookie(sessionID, csrfToken)
 	if err != nil {
-		return errors.New("user is not authenticated")
+		msg := "User is not authenticated"
+		logger.Error(msg)
+		return errors.New(strings.ToLower(msg))
 	}
 	remoteAddr := s.RemoteHeader().Get("X-Forwarded-For")
 	if remoteAddr == "" {
@@ -65,7 +67,6 @@ func OnConnectHandler(s socketio.Conn) error {
 	s.SetContext(ctx)
 	conns.AddWebConn(s.ID(), conn)
 	logger.Info("On Connect handler end")
-	s.Emit("3")
 	return nil
 }
 
@@ -191,7 +192,6 @@ func OnResizeHandler(s socketio.Conn, message ResizeMsg) {
 
 func OnLogoutHandler(s socketio.Conn, message string) {
 	logger.Debug("OnLogout trigger")
-	logger.Debugf("Msg: %s\n", message)
 	webConn := conns.GetWebConn(s.ID())
 	if webConn == nil {
 		logger.Error("No conn found")

pkg/httpd/server.go

 package httpd
 
 import (
-	"cocogo/pkg/config"
-	"cocogo/pkg/logger"
-	"github.com/googollee/go-engine.io"
-	"github.com/googollee/go-socket.io"
-	"github.com/satori/go.uuid"
 	"net/http"
 	"strconv"
-	"strings"
 	"sync"
+
+	"github.com/googollee/go-socket.io"
+
+	"cocogo/pkg/config"
+	"cocogo/pkg/logger"
 )
 
 var (
@@ -17,17 +16,9 @@ var (
 	conns      = &connections{container: make(map[string]*WebConn), mu: new(sync.RWMutex)}
 )
 
-type UUIDSessionIDGenerator struct {
-}
-
-func (u *UUIDSessionIDGenerator) NewID() string {
-	return strings.Split(uuid.NewV4().String(), "-")[4]
-}
-
 func StartHTTPServer() {
 	conf := config.GetConf()
-	option := engineio.Options{}
-	server, err := socketio.NewServer(&option)
+	server, err := socketio.NewServer(nil)
 	if err != nil {
 		logger.Fatal(err)
 	}
@@ -35,7 +26,7 @@ func StartHTTPServer() {
 	server.OnDisconnect("/ssh", OnDisconnect)
 	server.OnError("/ssh", OnErrorHandler)
 	server.OnEvent("/ssh", "host", OnHostHandler)
-	//server.OnEvent("/ssh", "token", OnTokenHandler)
+	server.OnEvent("/ssh", "token", OnTokenHandler)
 	server.OnEvent("/ssh", "data", OnDataHandler)
 	server.OnEvent("/ssh", "resize", OnResizeHandler)
 	server.OnEvent("/ssh", "logout", OnLogoutHandler)

pkg/proxy/proxy.go

 package proxy
 
 import (
+	"cocogo/pkg/srvconn"
 	"cocogo/pkg/utils"
 	"fmt"
 	"regexp"
@@ -34,7 +35,7 @@ func (p *ProxyServer) getSystemUserAuthOrManualSet() {
 		if err != nil {
 			logger.Errorf("Get password from user err %s", err.Error())
 		}
-		logger.Info("Get password from user input: ", line)
+		logger.Debug("Get password from user input: ", line)
 		p.SystemUser.Password = line
 	}
 }
@@ -72,50 +73,57 @@ func (p *ProxyServer) validatePermission() bool {
 	return true
 }
 
-func (p *ProxyServer) getSSHConn() (srvConn *ServerSSHConnection, err error) {
-	srvConn = &ServerSSHConnection{
-		name:       p.Asset.Hostname,
-		host:       p.Asset.Ip,
-		port:       strconv.Itoa(p.Asset.Port),
-		user:       p.SystemUser.Username,
-		password:   p.SystemUser.Password,
-		privateKey: p.SystemUser.PrivateKey,
-		timeout:    config.GetConf().SSHTimeout,
+func (p *ProxyServer) getSSHConn() (srvConn *srvconn.ServerSSHConnection, err error) {
+	proxyConfig := &srvconn.SSHClientConfig{}
+	sshConfig := srvconn.SSHClientConfig{
+		Host:       p.Asset.Ip,
+		Port:       strconv.Itoa(p.Asset.Port),
+		User:       p.SystemUser.Username,
+		Password:   p.SystemUser.Password,
+		PrivateKey: p.SystemUser.PrivateKey,
+		Overtime:   config.GetConf().SSHTimeout,
+		Proxy:      proxyConfig,
+	}
+	srvConn = &srvconn.ServerSSHConnection{
+		Name:            p.Asset.Hostname,
+		Creator:         p.User.Username,
+		SSHClientConfig: sshConfig,
 	}
 	pty := p.UserConn.Pty()
-	done := make(chan struct{})
-	go p.sendConnectingMsg(done, srvConn.timeout)
 	err = srvConn.Connect(pty.Window.Height, pty.Window.Width, pty.Term)
-	utils.IgnoreErrWriteString(p.UserConn, "\r\n")
-	close(done)
+	fmt.Println("Error: ", err)
 	return
 }
 
-func (p *ProxyServer) getTelnetConn() (srvConn *ServerTelnetConnection, err error) {
+func (p *ProxyServer) getTelnetConn() (srvConn *srvconn.ServerTelnetConnection, err error) {
 	conf := config.GetConf()
 	cusString := conf.TelnetRegex
 	pattern, _ := regexp.Compile(cusString)
-	srvConn = &ServerTelnetConnection{
-		name:                 p.Asset.Hostname,
-		host:                 p.Asset.Ip,
-		port:                 strconv.Itoa(p.Asset.Port),
-		user:                 p.SystemUser.Username,
-		password:             p.SystemUser.Password,
-		customString:         cusString,
-		customSuccessPattern: pattern,
-		timeout:              conf.SSHTimeout,
+	srvConn = &srvconn.ServerTelnetConnection{
+		Name:                 p.Asset.Hostname,
+		Creator:              p.User.ID,
+		Host:                 p.Asset.Ip,
+		Port:                 strconv.Itoa(p.Asset.Port),
+		User:                 p.SystemUser.Username,
+		Password:             p.SystemUser.Password,
+		CustomString:         cusString,
+		CustomSuccessPattern: pattern,
+		Overtime:             conf.SSHTimeout,
 	}
-	done := make(chan struct{})
-	go p.sendConnectingMsg(done, srvConn.timeout)
 	err = srvConn.Connect(0, 0, "")
 	utils.IgnoreErrWriteString(p.UserConn, "\r\n")
-	close(done)
 	return
 }
 
-func (p *ProxyServer) getServerConn() (srvConn ServerConnection, err error) {
+func (p *ProxyServer) getServerConn() (srvConn srvconn.ServerConnection, err error) {
 	p.getSystemUserUsernameIfNeed()
 	p.getSystemUserAuthOrManualSet()
+	done := make(chan struct{})
+	defer func() {
+		utils.IgnoreErrWriteString(p.UserConn, "\r\n")
+		close(done)
+	}()
+	go p.sendConnectingMsg(done, config.GetConf().SSHTimeout)
 	if p.Asset.Protocol == "telnet" {
 		return p.getTelnetConn()
 	} else {
@@ -204,7 +212,7 @@ func (p *ProxyServer) finishSession(s *SwitchSession) {
 	data := s.MapData()
 	service.FinishSession(data)
 	service.FinishReply(s.Id)
-	logger.Debugf("finish Session: %s", s.Id)
+	logger.Debugf("finish session: %s", s.Id)
 }
 
 func (p *ProxyServer) GetFilterRules() []model.SystemUserFilterRule {

pkg/proxy/recorder.go

@@ -66,7 +66,7 @@ func (c *CommandRecorder) record() {
 			}
 		case p, ok := <-c.queue:
 			if !ok {
-				logger.Debug("Session command recorder close: ", c.sessionID)
+				logger.Debug("session command recorder close: ", c.sessionID)
 				return
 			}
 			cmdList = append(cmdList, p)

pkg/proxy/sessiontask.go

@@ -9,7 +9,7 @@ import (
 var sessionMap = make(map[string]*SwitchSession)
 var lock = new(sync.RWMutex)
 
-func HandlerSessionTask(task model.TerminalTask) {
+func HandleSessionTask(task model.TerminalTask) {
 	switch task.Name {
 	case "kill_session":
 		KillSession(task.Args)

pkg/proxy/switch.go

 package proxy
 
 import (
+	"cocogo/pkg/srvconn"
 	"context"
 	"fmt"
 	"strings"
@@ -117,13 +118,13 @@ func (s *SwitchSession) SetFilterRules(cmdRules []model.SystemUserFilterRule) {
 	s.parser.SetCMDFilterRules(cmdRules)
 }
 
-func (s *SwitchSession) Bridge(userConn UserConnection, srvConn ServerConnection) (err error) {
+func (s *SwitchSession) Bridge(userConn UserConnection, srvConn srvconn.ServerConnection) (err error) {
 	winCh := userConn.WinCh()
 	s.srvTran = NewDirectTransport(s.Id, srvConn)
 	s.userTran = NewDirectTransport(s.Id, userConn)
 
 	defer func() {
-		logger.Info("Session bridge done: ", s.Id)
+		logger.Info("session bridge done: ", s.Id)
 	}()
 
 	go s.parser.Parse()

pkg/srvconn/connmanager.go

+package srvconn
+
+import (
+	"fmt"
+	"strconv"
+	"sync"
+
+	gossh "golang.org/x/crypto/ssh"
+
+	"cocogo/pkg/config"
+	"cocogo/pkg/logger"
+	"cocogo/pkg/model"
+)
+
+var (
+	sshClients        = make(map[string]*gossh.Client)
+	clientsRefCounter = make(map[*gossh.Client]int)
+	clientLock        = new(sync.RWMutex)
+)
+
+func newClient(user *model.User, asset *model.Asset,
+	systemUser *model.SystemUser) (client *gossh.Client, err error) {
+	cfg := SSHClientConfig{
+		Host:       asset.Ip,
+		Port:       strconv.Itoa(asset.Port),
+		User:       systemUser.Username,
+		Password:   systemUser.Password,
+		PrivateKey: systemUser.PrivateKey,
+		Overtime:   config.GetConf().SSHTimeout,
+	}
+	client, err = cfg.Dial()
+	return
+}
+
+func NewClient(user *model.User, asset *model.Asset, systemUser *model.SystemUser) (client *gossh.Client, err error) {
+	key := fmt.Sprintf("%s_%s_%s", user.ID, asset.Id, systemUser.Id)
+	clientLock.RLock()
+	client, ok := sshClients[key]
+	clientLock.RUnlock()
+
+	var u = user.Username
+	var ip = asset.Ip
+	var sysName = systemUser.Username
+
+	if ok {
+		clientLock.Lock()
+		clientsRefCounter[client]++
+
+		var counter = clientsRefCounter[client]
+		logger.Infof("Reuse connection: %s->%s@%s\n ref: %d", u, sysName, ip, counter)
+		clientLock.Unlock()
+		return client, nil
+	}
+
+	client, err = newClient(user, asset, systemUser)
+	if err == nil {
+		clientLock.Lock()
+		sshClients[key] = client
+		clientsRefCounter[client] = 1
+		clientLock.Unlock()
+	}
+	return
+}
+
+func RecycleClient(client *gossh.Client) {
+	clientLock.Lock()
+	defer clientLock.Unlock()
+
+	if counter, ok := clientsRefCounter[client]; ok {
+		if counter == 1 {
+			logger.Debug("Recycle client: close it")
+			_ = client.Close()
+			delete(clientsRefCounter, client)
+			var key string
+			for k, v := range sshClients {
+				if v == client {
+					key = k
+					break
+				}
+			}
+			if key != "" {
+				delete(sshClients, key)
+			}
+		} else {
+			logger.Debug("Recycle client: ref -1")
+			clientsRefCounter[client]--
+		}
+	}
+}

pkg/proxy/srvconn_test.go → pkg/srvconn/connmanager_test.go

-package proxy
+package srvconn
 
 import (
 	"fmt"
 	"testing"
 )
 
-var testConnection = ServerSSHConnection{
-	host:     "127.0.0.1",
-	port:     "22",
-	user:     "root",
-	password: "redhat",
-	Proxy:    &ServerSSHConnection{host: "192.168.244.185", port: "22", user: "root", password: "redhat"},
+var testConnection = SSHClientConfig{
+	Host:     "127.0.0.1",
+	Port:     "22",
+	User:     "root",
+	Password: "redhat",
+	Proxy:    &SSHClientConfig{Host: "192.168.244.185", Port: "22", User: "root", Password: "redhat"},
 }
 
 func TestSSHConnection_Config(t *testing.T) {
@@ -22,7 +22,7 @@ func TestSSHConnection_Config(t *testing.T) {
 }
 
 func TestSSHConnection_Connect(t *testing.T) {
-	err := testConnection.Connect(24, 80, "xterm")
+	_, err := testConnection.Dial()
 	if err != nil {
 		t.Errorf("Connect error %s", err)
 	}

pkg/proxy/srvconn.go → pkg/srvconn/srvconn.go

-package proxy
+package srvconn
 
 import (
 	"fmt"
+	"github.com/pkg/errors"
 	"io"
 	"net"
 	"time"
@@ -11,86 +12,54 @@ import (
 
 type ServerConnection interface {
 	io.ReadWriteCloser
-	Name() string
-	Host() string
-	Port() string
-	User() string
 	Timeout() time.Duration
 	Protocol() string
-	Connect(h, w int, term string) error
 	SetWinSize(w, h int) error
 }
 
-type ServerSSHConnection struct {
-	name           string
-	host           string
-	port           string
-	user           string
-	password       string
-	privateKey     string
-	privateKeyPath string
-	timeout        int
-	Proxy          *ServerSSHConnection
-
-	client    *gossh.Client
-	Session   *gossh.Session
-	proxyConn gossh.Conn
-	stdin     io.WriteCloser
-	stdout    io.Reader
-	closed    bool
-}
-
-func (sc *ServerSSHConnection) Protocol() string {
-	return "ssh"
-}
-
-func (sc *ServerSSHConnection) User() string {
-	return sc.user
-}
-
-func (sc *ServerSSHConnection) Host() string {
-	return sc.host
-}
-
-func (sc *ServerSSHConnection) Name() string {
-	return sc.name
-}
-
-func (sc *ServerSSHConnection) Port() string {
-	return sc.port
-}
+type SSHClientConfig struct {
+	Host           string
+	Port           string
+	User           string
+	Password       string
+	PrivateKey     string
+	PrivateKeyPath string
+	Overtime       int
+	Proxy          *SSHClientConfig
 
-func (sc *ServerSSHConnection) Timeout() time.Duration {
-	return time.Duration(sc.timeout) * time.Second
+	proxyConn gossh.Conn
 }
 
-func (sc *ServerSSHConnection) String() string {
-	return fmt.Sprintf("%s@%s:%s", sc.user, sc.host, sc.port)
+func (sc *SSHClientConfig) Timeout() time.Duration {
+	if sc.Overtime == 0 {
+		sc.Overtime = 30
+	}
+	return time.Duration(sc.Overtime) * time.Second
 }
 
-func (sc *ServerSSHConnection) Config() (config *gossh.ClientConfig, err error) {
+func (sc *SSHClientConfig) Config() (config *gossh.ClientConfig, err error) {
 	authMethods := make([]gossh.AuthMethod, 0)
-	if sc.password != "" {
-		authMethods = append(authMethods, gossh.Password(sc.password))
+	if sc.Password != "" {
+		authMethods = append(authMethods, gossh.Password(sc.Password))
 	}
-	if sc.privateKeyPath != "" {
-		if pubkey, err := GetPubKeyFromFile(sc.privateKeyPath); err != nil {
-			err = fmt.Errorf("parse private key from file error: %sc", err)
+	if sc.PrivateKeyPath != "" {
+		if pubkey, err := GetPubKeyFromFile(sc.PrivateKeyPath); err != nil {
+			err = fmt.Errorf("parse private key from file error: %s", err)
 			return config, err
 		} else {
 			authMethods = append(authMethods, gossh.PublicKeys(pubkey))
 		}
 	}
-	if sc.privateKey != "" {
-		if signer, err := gossh.ParsePrivateKey([]byte(sc.privateKey)); err != nil {
-			err = fmt.Errorf("parse private key error: %sc", err)
+	if sc.PrivateKey != "" {
+		if signer, err := gossh.ParsePrivateKey([]byte(sc.PrivateKey)); err != nil {
+			err = fmt.Errorf("parse private key error: %s", err)
 			return config, err
 		} else {
 			authMethods = append(authMethods, gossh.PublicKeys(signer))
 		}
 	}
 	config = &gossh.ClientConfig{
-		User:            sc.user,
+		User:            sc.User,
 		Auth:            authMethods,
 		HostKeyCallback: gossh.InsecureIgnoreHostKey(),
 		Timeout:         sc.Timeout(),
@@ -98,42 +67,68 @@ func (sc *ServerSSHConnection) Config() (config *gossh.ClientConfig, err error)
 	return config, nil
 }
 
-func (sc *ServerSSHConnection) connect() (client *gossh.Client, err error) {
-	config, err := sc.Config()
+func (sc *SSHClientConfig) Dial() (client *gossh.Client, err error) {
+	cfg, err := sc.Config()
 	if err != nil {
 		return
 	}
-	if sc.Proxy != nil {
-		proxyClient, err := sc.Proxy.connect()
+	if sc.Proxy != nil && sc.Proxy.Host != "" {
+		proxyClient, err := sc.Proxy.Dial()
 		if err != nil {
+			err = errors.New("connect proxy Host error1: " + err.Error())
 			return client, err
 		}
-		proxySock, err := proxyClient.Dial("tcp", net.JoinHostPort(sc.host, sc.port))
+		proxySock, err := proxyClient.Dial("tcp", net.JoinHostPort(sc.Host, sc.Port))
 		if err != nil {
+			err = errors.New("connect proxy Host error2: " + err.Error())
 			return client, err
 		}
-		proxyConn, chans, reqs, err := gossh.NewClientConn(proxySock, net.JoinHostPort(sc.host, sc.port), config)
+		proxyConn, chans, reqs, err := gossh.NewClientConn(proxySock, net.JoinHostPort(sc.Host, sc.Port), cfg)
 		if err != nil {
 			return client, err
 		}
 		sc.proxyConn = proxyConn
 		client = gossh.NewClient(proxyConn, chans, reqs)
 	} else {
-		client, err = gossh.Dial("tcp", net.JoinHostPort(sc.host, sc.port), config)
+		client, err = gossh.Dial("tcp", net.JoinHostPort(sc.Host, sc.Port), cfg)
 		if err != nil {
 			return
 		}
 	}
-	sc.client = client
 	return client, nil
 }
 
+func (sc *SSHClientConfig) String() string {
+	return fmt.Sprintf("%s@%s:%s", sc.User, sc.Host, sc.Port)
+}
+
+type ServerSSHConnection struct {
+	SSHClientConfig
+	Name    string
+	Creator string
+
+	client   *gossh.Client
+	session  *gossh.Session
+	stdin    io.WriteCloser
+	stdout   io.Reader
+	closed   bool
+	refCount int
+}
+
+func (sc *ServerSSHConnection) Protocol() string {
+	return "ssh"
+}
+
+func (sc *ServerSSHConnection) String() string {
+	return fmt.Sprintf("%s@%s:%s", sc.User, sc.Host, sc.Port)
+}
+
 func (sc *ServerSSHConnection) invokeShell(h, w int, term string) (err error) {
 	sess, err := sc.client.NewSession()
 	if err != nil {
 		return
 	}
-	sc.Session = sess
+	sc.session = sess
 	modes := gossh.TerminalModes{
 		gossh.ECHO:          1,     // enable echoing
 		gossh.TTY_OP_ISPEED: 14400, // input speed = 14.4 kbaud
@@ -156,7 +151,7 @@ func (sc *ServerSSHConnection) invokeShell(h, w int, term string) (err error) {
 }
 
 func (sc *ServerSSHConnection) Connect(h, w int, term string) (err error) {
-	_, err = sc.connect()
+	sc.client, err = sc.Dial()
 	if err != nil {
 		return
 	}
@@ -168,7 +163,7 @@ func (sc *ServerSSHConnection) Connect(h, w int, term string) (err error) {
 }
 
 func (sc *ServerSSHConnection) SetWinSize(h, w int) error {
-	return sc.Session.WindowChange(h, w)
+	return sc.session.WindowChange(h, w)
 }
 
 func (sc *ServerSSHConnection) Read(p []byte) (n int, err error) {
@@ -183,7 +178,7 @@ func (sc *ServerSSHConnection) Close() (err error) {
 	if sc.closed {
 		return
 	}
-	err = sc.Session.Close()
+	err = sc.session.Close()
 	err = sc.client.Close()
 	if sc.proxyConn != nil {
 		err = sc.proxyConn.Close()

pkg/srvconn/srvconn_test.go

+package srvconn

pkg/proxy/telnetconn.go → pkg/srvconn/telnetconn.go

-package proxy
+package srvconn
 
 import (
 	"bytes"
@@ -45,38 +45,25 @@ const (
 )
 
 type ServerTelnetConnection struct {
-	name                 string
-	host                 string
-	port                 string
-	user                 string
-	password             string
-	timeout              int
-	customString         string
-	customSuccessPattern *regexp.Regexp
-
-	conn net.Conn
-
+	Name                 string
+	Creator              string
+	Host                 string
+	Port                 string
+	User                 string
+	Password             string
+	Overtime             int
+	CustomString         string
+	CustomSuccessPattern *regexp.Regexp
+
+	conn   net.Conn
 	closed bool
 }
 
-func (tc *ServerTelnetConnection) Name() string {
-	return tc.name
-}
-
-func (tc *ServerTelnetConnection) Host() string {
-	return tc.host
-}
-
-func (tc *ServerTelnetConnection) Port() string {
-	return tc.port
-}
-
-func (tc *ServerTelnetConnection) User() string {
-	return tc.user
-}
-
 func (tc *ServerTelnetConnection) Timeout() time.Duration {
-	return time.Duration(tc.timeout) * time.Second
+	if tc.Overtime == 0 {
+		tc.Overtime = 30
+	}
+	return time.Duration(tc.Overtime) * time.Second
 }
 
 func (tc *ServerTelnetConnection) Protocol() string {
@@ -133,18 +120,18 @@ func (tc *ServerTelnetConnection) login(data []byte) AuthStatus {
 	if incorrectPattern.Match(data) {
 		return AuthFailed
 	} else if usernamePattern.Match(data) {
-		_, _ = tc.conn.Write([]byte(tc.user + "\r\n"))
-		logger.Debug("usernamePattern ", tc.user)
+		_, _ = tc.conn.Write([]byte(tc.User + "\r\n"))
+		logger.Debug("usernamePattern ", tc.User)
 		return AuthPartial
 	} else if passwordPattern.Match(data) {
-		_, _ = tc.conn.Write([]byte(tc.password + "\r\n"))
-		logger.Debug("passwordPattern ", tc.password)
+		_, _ = tc.conn.Write([]byte(tc.Password + "\r\n"))
+		logger.Debug("passwordPattern ", tc.Password)
 		return AuthPartial
 	} else if successPattern.Match(data) {
 		return AuthSuccess
 	}
-	if tc.customString != "" {
-		if tc.customSuccessPattern.Match(data) {
+	if tc.CustomString != "" {
+		if tc.CustomSuccessPattern.Match(data) {
 			return AuthSuccess
 		}
 	}
@@ -152,7 +139,7 @@ func (tc *ServerTelnetConnection) login(data []byte) AuthStatus {
 }
 
 func (tc *ServerTelnetConnection) Connect(h, w int, term string) (err error) {
-	conn, err := net.DialTimeout("tcp", net.JoinHostPort(tc.host, tc.port), tc.Timeout())
+	conn, err := net.DialTimeout("tcp", net.JoinHostPort(tc.Host, tc.Port), tc.Timeout())
 	if err != nil {
 		return
 	}

pkg/proxy/utils.go → pkg/srvconn/utils.go

-package proxy
+package srvconn
 
 import (
 	"golang.org/x/crypto/ssh"