redo web UI |web close| client log |system info |p2p |max、ump optimization

client/client.go

@@ -3,33 +3,26 @@ package client
 import (
 	"github.com/cnlh/nps/lib/common"
 	"github.com/cnlh/nps/lib/conn"
-	"github.com/cnlh/nps/lib/pool"
+	"github.com/cnlh/nps/lib/mux"
 	"github.com/cnlh/nps/vender/github.com/astaxie/beego/logs"
 	"github.com/cnlh/nps/vender/github.com/xtaci/kcp"
 	"net"
 	"os"
-	"sync"
 	"time"
 )
 
 type TRPClient struct {
 	svrAddr        string
-	linkMap        map[int]*conn.Link
-	tunnel         *conn.Conn
-	msgTunnel      *conn.Conn
 	bridgeConnType string
 	stop           chan bool
 	proxyUrl       string
-	sync.Mutex
-	vKey string
+	vKey           string
 }
 
 //new client
 func NewRPClient(svraddr string, vKey string, bridgeConnType string, proxyUrl string) *TRPClient {
 	return &TRPClient{
 		svrAddr:        svraddr,
-		linkMap:        make(map[int]*conn.Link),
-		Mutex:          sync.Mutex{},
 		vKey:           vKey,
 		bridgeConnType: bridgeConnType,
 		stop:           make(chan bool),
@@ -51,19 +44,12 @@ retry:
 }
 
 func (s *TRPClient) Close() {
-	s.tunnel.Close()
 	s.stop <- true
-	for _, v := range s.linkMap {
-		if v.Conn != nil {
-			v.Conn.Close()
-		}
-	}
 }
 
 //处理
 func (s *TRPClient) processor(c *conn.Conn) {
 	go s.dealChan()
-	go s.getMsgStatus()
 	for {
 		flags, err := c.ReadFlag()
 		if err != nil {
@@ -74,17 +60,6 @@ func (s *TRPClient) processor(c *conn.Conn) {
 		case common.VERIFY_EER:
 			logs.Error("VKey:%s is incorrect, the server refuses to connect, please check", s.vKey)
 			os.Exit(0)
-		case common.NEW_CONN:
-			if link, err := c.GetLinkInfo(); err != nil {
-				break
-			} else {
-				s.Lock()
-				s.linkMap[link.Id] = link
-				s.Unlock()
-				link.MsgConn = s.msgTunnel
-				go linkProcess(link, c, s.tunnel)
-				link.RunWrite()
-			}
 		case common.RES_CLOSE:
 			logs.Error("The authentication key is connected by another client or the server closes the client.")
 			os.Exit(0)
@@ -93,10 +68,10 @@ func (s *TRPClient) processor(c *conn.Conn) {
 			break
 		case common.NEW_UDP_CONN:
 			//读取服务端地址、密钥 继续做处理
-			if lAddr, err := c.GetLenContent(); err != nil {
+			if lAddr, err := c.GetShortLenContent(); err != nil {
+				logs.Warn(err)
 				return
-			} else if pwd, err := c.GetLenContent(); err == nil {
-				logs.Warn(string(lAddr), string(pwd))
+			} else if pwd, err := c.GetShortLenContent(); err == nil {
 				go s.newUdpConn(string(lAddr), string(pwd))
 			}
 		default:
@@ -109,181 +84,125 @@ func (s *TRPClient) processor(c *conn.Conn) {
 }
 
 func (s *TRPClient) newUdpConn(rAddr string, md5Password string) {
-	tmpConn, err := net.Dial("udp", "114.114.114.114:53")
+	tmpConn, err := common.GetLocalUdpAddr()
 	if err != nil {
-		logs.Warn(err)
+		logs.Error(err)
 		return
 	}
-	tmpConn.Close()
-	//与服务端建立udp连接
 	localAddr, _ := net.ResolveUDPAddr("udp", tmpConn.LocalAddr().String())
 	localConn, err := net.ListenUDP("udp", localAddr)
 	if err != nil {
-		logs.Warn(err)
+		logs.Error(err)
 		return
 	}
 	localKcpConn, err := kcp.NewConn(rAddr, nil, 150, 3, localConn)
-	logs.Warn(localConn.RemoteAddr(), rAddr)
-	conn.SetUdpSession(localKcpConn)
 	if err != nil {
-		logs.Warn(err)
+		logs.Error(err)
 		return
 	}
+	conn.SetUdpSession(localKcpConn)
 	localToolConn := conn.NewConn(localKcpConn)
 	//写入密钥、provider身份
 	if _, err := localToolConn.Write([]byte(md5Password)); err != nil {
-		logs.Warn(err)
+		logs.Error(err)
 		return
 	}
 	if _, err := localToolConn.Write([]byte(common.WORK_P2P_PROVIDER)); err != nil {
-		logs.Warn(err)
+		logs.Error(err)
 		return
 	}
 	//接收服务端传的visitor地址
-	if b, err := localToolConn.GetLenContent(); err != nil {
-		logs.Warn(err)
+	var b []byte
+	if b, err = localToolConn.GetShortLenContent(); err != nil {
+		logs.Error(err)
 		return
-	} else {
-		logs.Warn("收到服务端回传地址", string(b))
-		//向visitor地址发送测试消息
-		visitorAddr, err := net.ResolveUDPAddr("udp", string(b))
+	}
+	//向visitor地址发送测试消息
+	visitorAddr, err := net.ResolveUDPAddr("udp", string(b))
+	if err != nil {
+		logs.Error(err)
+		return
+	}
+	//向目标IP发送探测包
+	if _, err := localConn.WriteTo([]byte("test"), visitorAddr); err != nil {
+		logs.Error(err)
+		return
+	}
+	//给服务端发反馈
+	if _, err := localToolConn.Write([]byte(common.VERIFY_SUCCESS)); err != nil {
+		logs.Error(err)
+		return
+	}
+	//关闭与服务端的连接
+	localConn.Close()
+	//关闭与服务端udp conn，建立新的监听
+	if localConn, err = net.ListenUDP("udp", localAddr); err != nil {
+		logs.Error(err)
+		return
+	}
+	l, err := kcp.ServeConn(nil, 150, 3, localConn)
+	if err != nil {
+		logs.Error(err)
+		return
+	}
+	//接收新的监听，得到conn，
+	for {
+		udpTunnel, err := l.AcceptKCP()
 		if err != nil {
-			logs.Warn(err)
-		}
-		logs.Warn(visitorAddr.String())
-		if n, err := localConn.WriteTo([]byte("test"), visitorAddr); err != nil {
-			logs.Warn(err)
-		} else {
-			logs.Warn("write", n)
-		}
-		//给服务端发反馈
-		if _, err := localToolConn.Write([]byte(common.VERIFY_SUCCESS)); err != nil {
-			logs.Warn(err)
-		}
-		//关闭与服务端的连接
-		localConn.Close()
-		//关闭与服务端udp conn，建立新的监听
-		localConn, err = net.ListenUDP("udp", localAddr)
-
-		if err != nil {
-			logs.Warn(err)
-		}
-		l, err := kcp.ServeConn(nil, 150, 3, localConn)
-		if err != nil {
-			logs.Warn(err)
+			logs.Error(err)
+			l.Close()
 			return
 		}
+		if udpTunnel.RemoteAddr().String() == string(b) {
+			conn.SetUdpSession(udpTunnel)
+			//读取link,设置msgCh 设置msgConn消息回传响应机制
+			l := mux.NewMux(udpTunnel)
+			for {
+				connMux, err := l.Accept()
+				if err != nil {
+					continue
+				}
+				go s.srcProcess(connMux)
+			}
+		}
+	}
+}
+
+//mux tunnel
+func (s *TRPClient) dealChan() {
+	tunnel, err := NewConn(s.bridgeConnType, s.vKey, s.svrAddr, common.WORK_CHAN, s.proxyUrl)
+	if err != nil {
+		logs.Error("connect to ", s.svrAddr, "error:", err)
+		return
+	}
+	go func() {
+		l := mux.NewMux(tunnel.Conn)
 		for {
-			//接收新的监听，得到conn，
-			udpTunnel, err := l.AcceptKCP()
-			logs.Warn(udpTunnel.RemoteAddr(), udpTunnel.LocalAddr())
+			src, err := l.Accept()
 			if err != nil {
 				logs.Warn(err)
-				l.Close()
-				return
-			}
-			conn.SetUdpSession(udpTunnel)
-			if udpTunnel.RemoteAddr().String() == string(b) {
-				//读取link,设置msgCh 设置msgConn消息回传响应机制
-				c, e := net.Dial("tcp", "123.206.77.88:22")
-				if e != nil {
-					logs.Warn(e)
-					return
-				}
-
-				go common.CopyBuffer(c, udpTunnel)
-				common.CopyBuffer(udpTunnel, c)
-				//读取flag ping/new/msg/msgConn//分别对于不同的做法
 				break
 			}
-		}
-
-	}
-}
-
-func linkProcess(link *conn.Link, statusConn, msgConn *conn.Conn) {
-	link.Host = common.FormatAddress(link.Host)
-	//与目标建立连接
-	server, err := net.DialTimeout(link.ConnType, link.Host, time.Second*3)
-
-	if err != nil {
-		statusConn.WriteFail(link.Id)
-		logs.Warn("connect to ", link.Host, "error:", err)
-		return
-	}
-	statusConn.WriteSuccess(link.Id)
-	link.Conn = conn.NewConn(server)
-	link.RunRead(msgConn)
-}
-
-func (s *TRPClient) getMsgStatus() {
-	var err error
-	s.msgTunnel, err = NewConn(s.bridgeConnType, s.vKey, s.svrAddr, common.WORK_SEND_STATUS, s.proxyUrl)
-	if err != nil {
-		logs.Error("connect to ", s.svrAddr, "error:", err)
-		return
-	}
-	go func() {
-		for {
-			if id, err := s.msgTunnel.GetLen(); err != nil {
-				break
-			} else {
-				s.Lock()
-				if v, ok := s.linkMap[id]; ok {
-					s.Unlock()
-					v.StatusCh <- true
-				} else {
-					s.Unlock()
-				}
-			}
+			go s.srcProcess(src)
 		}
 	}()
 	<-s.stop
 }
 
-//隧道模式处理
-func (s *TRPClient) dealChan() {
-	var err error
-	s.tunnel, err = NewConn(s.bridgeConnType, s.vKey, s.svrAddr, common.WORK_CHAN, s.proxyUrl)
+func (s *TRPClient) srcProcess(src net.Conn) {
+	lk, err := conn.NewConn(src).GetLinkInfo()
 	if err != nil {
-		logs.Error("connect to ", s.svrAddr, "error:", err)
+		src.Close()
+		logs.Error("get connection info from server error ", err)
 		return
 	}
-	go func() {
-		for {
-			if id, err := s.tunnel.GetLen(); err != nil {
-				break
-			} else {
-				s.Lock()
-				if v, ok := s.linkMap[id]; ok {
-					s.Unlock()
-					if content, err := s.tunnel.GetMsgContent(v); err != nil {
-						pool.PutBufPoolCopy(content)
-						break
-					} else {
-						v.MsgCh <- content
-					}
-				} else {
-					s.Unlock()
-				}
-			}
-		}
-	}()
-	<-s.stop
-}
-
-func (s *TRPClient) linkCleanSession() {
-	ticker := time.NewTicker(time.Minute * 5)
-	for {
-		select {
-		case <-ticker.C:
-			s.Lock()
-			for _, v := range s.linkMap {
-				if v.FinishUse {
-					delete(s.linkMap, v.Id)
-				}
-			}
-			s.Unlock()
-		}
+	lk.Host = common.FormatAddress(lk.Host)
+	//connect to target
+	if targetConn, err := net.Dial(lk.ConnType, lk.Host); err != nil {
+		logs.Warn("connect to %s error %s", lk.Host, err.Error())
+		src.Close()
+	} else {
+		logs.Trace("new %s connection with the goal of %s, remote address:%s", lk.ConnType, lk.Host, lk.RemoteAddr)
+		conn.CopyWaitGroup(src, targetConn, lk.Crypt, lk.Compress, nil, nil)
 	}
 }