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)
 	}
 }

client/client_test.go

@@ -43,7 +43,7 @@ func TestConfig(t *testing.T) {
 	}
 	tunnel := &file.Tunnel{
 		Port:   9001,
-		Mode:   "tcpServer",
+		Mode:   "tcp",
 		Target: "127.0.0.1:8082",
 		Remark: "333",
 	}

client/control.go

@@ -30,17 +30,21 @@ func GetTaskStatus(path string) {
 	if err != nil {
 		log.Fatalln(err)
 	}
+
 	if _, err := c.Write([]byte(common.WORK_STATUS)); err != nil {
 		log.Fatalln(err)
 	}
+
+	//read now vKey and write to server
 	if f, err := common.ReadAllFromFile(filepath.Join(common.GetTmpPath(), "npc_vkey.txt")); err != nil {
 		log.Fatalln(err)
-	} else if _, err := c.Write([]byte(string(f))); err != nil {
+	} else if _, err := c.Write([]byte(crypt.Md5(string(f)))); err != nil {
 		log.Fatalln(err)
 	}
+
 	if l, err := c.GetLen(); err != nil {
 		log.Fatalln(err)
-	} else if b, err := c.ReadLen(l); err != nil {
+	} else if b, err := c.GetShortContent(l); err != nil {
 		log.Fatalln(err)
 	} else {
 		arr := strings.Split(string(b), common.CONN_DATA_SEQ)
@@ -53,7 +57,7 @@ func GetTaskStatus(path string) {
 		}
 		for _, v := range cnf.Tasks {
 			ports := common.GetPorts(v.Ports)
-			if v.Mode == "secretServer" {
+			if v.Mode == "secret" {
 				ports = append(ports, 0)
 			}
 			for _, vv := range ports {
@@ -83,8 +87,8 @@ func StartFromFile(path string) {
 		logs.Error("Config file %s loading error", path)
 		os.Exit(0)
 	}
-
 	logs.Info("Loading configuration file %s successfully", path)
+
 re:
 	if first || cnf.CommonConfig.AutoReconnection {
 		if !first {
@@ -100,6 +104,8 @@ re:
 		logs.Error(err)
 		goto re
 	}
+
+	// send global configuration to server and get status of config setting
 	if _, err := c.SendConfigInfo(cnf.CommonConfig); err != nil {
 		logs.Error(err)
 		goto re
@@ -108,13 +114,17 @@ re:
 		logs.Error(errAdd)
 		goto re
 	}
+
+	// get tmp password
 	var b []byte
-	if b, err = c.ReadLen(16); err != nil {
+	if b, err = c.GetShortContent(16); err != nil {
 		logs.Error(err)
 		goto re
 	} else {
 		ioutil.WriteFile(filepath.Join(common.GetTmpPath(), "npc_vkey.txt"), []byte(string(b)), 0600)
 	}
+
+	//send hosts to server
 	for _, v := range cnf.Hosts {
 		if _, err := c.SendHostInfo(v); err != nil {
 			logs.Error(err)
@@ -125,6 +135,8 @@ re:
 			goto re
 		}
 	}
+
+	//send  task to server
 	for _, v := range cnf.Tasks {
 		if _, err := c.SendTaskInfo(v); err != nil {
 			logs.Error(err)
@@ -135,16 +147,19 @@ re:
 			goto re
 		}
 	}
+
+	//create local server secret or p2p
 	for _, v := range cnf.LocalServer {
 		go StartLocalServer(v, cnf.CommonConfig)
 	}
+
 	c.Close()
 	NewRPClient(cnf.CommonConfig.Server, string(b), cnf.CommonConfig.Tp, cnf.CommonConfig.ProxyUrl).Start()
 	CloseLocalServer()
 	goto re
 }
 
-//Create a new connection with the server and verify it
+// Create a new connection with the server and verify it
 func NewConn(tp string, vkey string, server string, connType string, proxyUrl string) (*conn.Conn, error) {
 	var err error
 	var connection net.Conn
@@ -176,7 +191,7 @@ func NewConn(tp string, vkey string, server string, connType string, proxyUrl st
 		logs.Error(err)
 		os.Exit(0)
 	}
-	if b, err := c.ReadLen(32); err != nil || crypt.Md5(version.GetVersion()) != string(b) {
+	if b, err := c.GetShortContent(32); err != nil || crypt.Md5(version.GetVersion()) != string(b) {
 		logs.Error("The client does not match the server version. The current version of the client is", version.GetVersion())
 		os.Exit(0)
 	}

client/local.go

@@ -5,6 +5,7 @@ import (
 	"github.com/cnlh/nps/lib/config"
 	"github.com/cnlh/nps/lib/conn"
 	"github.com/cnlh/nps/lib/crypt"
+	"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"
@@ -12,6 +13,8 @@ import (
 )
 
 var LocalServer []*net.TCPListener
+var udpConn net.Conn
+var muxSession *mux.Mux
 
 func CloseLocalServer() {
 	for _, v := range LocalServer {
@@ -36,86 +39,102 @@ func StartLocalServer(l *config.LocalServer, config *config.CommonConfig) error
 			logs.Info(err)
 			continue
 		}
-		go process(c, config, l)
+		if l.Type == "secret" {
+			go processSecret(c, config, l)
+		} else {
+			go processP2P(c, config, l)
+		}
 	}
 	return nil
 }
 
-func process(localTcpConn net.Conn, config *config.CommonConfig, l *config.LocalServer) {
-	var workType string
-	if l.Type == "secret" {
-		workType = common.WORK_SECRET
-	} else {
-		workType = common.WORK_P2P
-	}
-	remoteConn, err := NewConn(config.Tp, config.VKey, config.Server, workType, config.ProxyUrl)
+func processSecret(localTcpConn net.Conn, config *config.CommonConfig, l *config.LocalServer) {
+	remoteConn, err := NewConn(config.Tp, config.VKey, config.Server, common.WORK_SECRET, config.ProxyUrl)
 	if err != nil {
 		logs.Error("Local connection server failed ", err.Error())
 	}
 	if _, err := remoteConn.Write([]byte(crypt.Md5(l.Password))); err != nil {
 		logs.Error("Local connection server failed ", err.Error())
 	}
-	if l.Type == "secret" {
-		go common.CopyBuffer(remoteConn, localTcpConn)
-		common.CopyBuffer(localTcpConn, remoteConn)
-		remoteConn.Close()
-		localTcpConn.Close()
+	conn.CopyWaitGroup(remoteConn, localTcpConn, false, false, nil, nil)
+}
+
+func processP2P(localTcpConn net.Conn, config *config.CommonConfig, l *config.LocalServer) {
+	if udpConn == nil {
+		newUdpConn(config, l)
+		muxSession = mux.NewMux(udpConn)
+	}
+	nowConn, err := muxSession.NewConn()
+	if err != nil {
+		logs.Error(err)
+		return
+	}
+	link := conn.NewLink(common.CONN_TCP, l.Target, config.Cnf.Crypt, config.Cnf.Compress, localTcpConn.LocalAddr().String())
+	if _, err := conn.NewConn(nowConn).SendLinkInfo(link); err != nil {
+		logs.Error(err)
+		return
+	}
+	conn.CopyWaitGroup(nowConn, localTcpConn, config.Cnf.Crypt, config.Cnf.Compress, nil, nil)
+}
+
+func newUdpConn(config *config.CommonConfig, l *config.LocalServer) {
+	remoteConn, err := NewConn(config.Tp, config.VKey, config.Server, common.WORK_P2P, config.ProxyUrl)
+	if err != nil {
+		logs.Error("Local connection server failed ", err.Error())
+		return
+	}
+	if _, err := remoteConn.Write([]byte(crypt.Md5(l.Password))); err != nil {
+		logs.Error("Local connection server failed ", err.Error())
+		return
+	}
+	var rAddr []byte
+	//读取服务端地址、密钥 继续做处理
+	if rAddr, err = remoteConn.GetShortLenContent(); err != nil {
+		logs.Error(err)
+		return
+	}
+	//与服务端udp建立连接
+	tmpConn, err := common.GetLocalUdpAddr()
+	if err != nil {
+		logs.Warn(err)
+		return
+	}
+	//与服务端建立udp连接
+	localAddr, _ := net.ResolveUDPAddr("udp", tmpConn.LocalAddr().String())
+	localConn, err := net.ListenUDP("udp", localAddr)
+	if err != nil {
+		logs.Error(err)
+		return
+	}
+	localKcpConn, err := kcp.NewConn(string(rAddr), nil, 150, 3, localConn)
+	conn.SetUdpSession(localKcpConn)
+	if err != nil {
+		logs.Error(err)
+	}
+	//写入密钥、provider身份
+	if _, err := localKcpConn.Write([]byte(crypt.Md5(l.Password))); err != nil {
+		logs.Error(err)
+		return
+	}
+	if _, err := localKcpConn.Write([]byte(common.WORK_P2P_VISITOR)); err != nil {
+		logs.Error(err)
+		return
+	}
+	//接收服务端传的visitor地址
+	if b, err := conn.NewConn(localKcpConn).GetShortLenContent(); err != nil {
+		logs.Error(err)
+		return
 	} else {
-		//读取服务端地址、密钥 继续做处理
-		logs.Warn(111)
-		if rAddr, err := remoteConn.GetLenContent(); err != nil {
+		//关闭与服务端连接
+		localConn.Close()
+		//建立新的连接
+		localConn, err = net.ListenUDP("udp", localAddr)
+		udpTunnel, err := kcp.NewConn(string(b), nil, 150, 3, localConn)
+		if err != nil || udpTunnel == nil {
+			logs.Warn(err)
 			return
-		} else {
-			logs.Warn(222)
-			//与服务端udp建立连接
-			tmpConn, err := net.Dial("udp", "114.114.114.114:53")
-			if err != nil {
-				logs.Warn(err)
-			}
-			tmpConn.Close()
-			//与服务端建立udp连接
-			localAddr, _ := net.ResolveUDPAddr("udp", tmpConn.LocalAddr().String())
-			localConn, err := net.ListenUDP("udp", localAddr)
-			if err != nil {
-				return
-			}
-			logs.Warn(333)
-			localKcpConn, err := kcp.NewConn(string(rAddr), nil, 150, 3, localConn)
-			conn.SetUdpSession(localKcpConn)
-			if err != nil {
-				logs.Warn(err)
-			}
-			localToolConn := conn.NewConn(localKcpConn)
-			//写入密钥、provider身份
-			if _, err := localToolConn.Write([]byte(crypt.Md5(l.Password))); err != nil {
-				return
-			}
-			if _, err := localToolConn.Write([]byte(common.WORK_P2P_VISITOR)); err != nil {
-				return
-			}
-			logs.Warn(444)
-			//接收服务端传的visitor地址
-			if b, err := localToolConn.GetLenContent(); err != nil {
-				logs.Warn(err)
-				return
-			} else {
-				logs.Warn("收到服务回传地址", string(b))
-				//关闭与服务端连接
-				localConn.Close()
-				//建立新的连接
-				localConn, err = net.ListenUDP("udp", localAddr)
-				udpTunnel, err := kcp.NewConn(string(b), nil, 150, 3, localConn)
-				if err != nil || udpTunnel == nil {
-					logs.Warn(err)
-					return
-				}
-				conn.SetUdpSession(udpTunnel)
-				logs.Warn(udpTunnel.RemoteAddr(), string(b), udpTunnel.LocalAddr())
-
-				go common.CopyBuffer(udpTunnel, localTcpConn)
-				common.CopyBuffer(localTcpConn, udpTunnel)
-			}
 		}
-
+		conn.SetUdpSession(udpTunnel)
+		udpConn = udpTunnel
 	}
 }