https 、客户端与服务端连接优化

client/client.go

@@ -5,87 +5,129 @@ import (
 	"log"
 	"net"
 	"sync"
-	"sync/atomic"
 	"time"
 )
 
 type TRPClient struct {
-	svrAddr      string
-	tcpNum       int
-	connPoolSize int
-	tunnelNum    int64
-	tunnel       chan bool
-	serverStatus bool
+	svrAddr string
+	linkMap map[int]*utils.Link
+	stop    chan bool
+	tunnel  *utils.Conn
 	sync.Mutex
 	vKey string
 }
 
 //new client
-func NewRPClient(svraddr string, tcpNum int, vKey string) *TRPClient {
-	c := new(TRPClient)
-	c.svrAddr = svraddr
-	c.tcpNum = tcpNum
-	c.vKey = vKey
-	c.tunnel = make(chan bool)
-	c.connPoolSize = 5
-	return c
+func NewRPClient(svraddr string, vKey string) *TRPClient {
+	return &TRPClient{
+		svrAddr: svraddr,
+		linkMap: make(map[int]*utils.Link),
+		stop:    make(chan bool),
+		tunnel:  nil,
+		Mutex:   sync.Mutex{},
+		vKey:    vKey,
+	}
 }
 
 //start
 func (s *TRPClient) Start() error {
-	for i := 0; i < s.tcpNum; i++ {
-		go s.NewConn()
-	}
-	for i := 0; i < 5; i++ {
-		go s.dealChan()
-	}
-	go s.session()
+	s.NewConn()
 	return nil
 }
 
 //新建
-func (s *TRPClient) NewConn() error {
-	s.Lock()
-	s.serverStatus = false
+func (s *TRPClient) NewConn() {
+retry:
 	conn, err := net.Dial("tcp", s.svrAddr)
 	if err != nil {
 		log.Println("连接服务端失败,五秒后将重连")
 		time.Sleep(time.Second * 5)
-		s.Unlock()
-		go s.NewConn()
-		return err
+		goto retry
+		return
 	}
-	s.Unlock()
-	return s.processor(utils.NewConn(conn))
+	s.processor(utils.NewConn(conn))
 }
+
 //处理
-func (s *TRPClient) processor(c *utils.Conn) error {
-	s.serverStatus = true
+func (s *TRPClient) processor(c *utils.Conn) {
 	c.SetAlive()
 	if _, err := c.Write([]byte(utils.Getverifyval(s.vKey))); err != nil {
-		return err
+		return
 	}
 	c.WriteMain()
+
+	go s.dealChan()
+
 	for {
 		flags, err := c.ReadFlag()
 		if err != nil {
-			log.Println("服务端断开,五秒后将重连", err)
-			go s.NewConn()
+			log.Println("服务端断开,正在重新连接")
 			break
 		}
 		switch flags {
 		case utils.VERIFY_EER:
-			log.Fatalln("vkey:", s.vKey, "不正确,服务端拒绝连接,请检查")
-		case utils.WORK_CHAN: //隧道模式，每次开启10个，加快连接速度
+			log.Fatalf("vKey:%s不正确,服务端拒绝连接,请检查", s.vKey)
+		case utils.NEW_CONN:
+			if link, err := c.GetLinkInfo(); err != nil {
+				break
+			} else {
+				log.Println(link)
+				s.Lock()
+				s.linkMap[link.Id] = link
+				s.Unlock()
+				go s.linkProcess(link, c)
+			}
 		case utils.RES_CLOSE:
 			log.Fatal("该vkey被另一客户连接")
 		case utils.RES_MSG:
-			log.Println("服务端返回错误。")
+			log.Println("服务端返回错误，重新连接")
+			break
 		default:
-			log.Println("无法解析该错误。", flags)
+			log.Println("无法解析该错误，重新连接")
+			break
 		}
 	}
-	return nil
+	s.stop <- true
+	s.linkMap = make(map[int]*utils.Link)
+	go s.NewConn()
+}
+func (s *TRPClient) linkProcess(link *utils.Link, c *utils.Conn) {
+	//与目标建立连接
+	server, err := net.DialTimeout(link.ConnType, link.Host, time.Second*3)
+
+	if err != nil {
+		c.WriteFail(link.Id)
+		log.Println("connect to ", link.Host, "error:", err)
+		return
+	}
+
+	c.WriteSuccess(link.Id)
+
+	link.Conn = utils.NewConn(server)
+
+	for {
+		buf := utils.BufPoolCopy.Get().([]byte)
+		if n, err := server.Read(buf); err != nil {
+			utils.PutBufPoolCopy(buf)
+			s.tunnel.SendMsg([]byte(utils.IO_EOF), link)
+			break
+		} else {
+			if _, err := s.tunnel.SendMsg(buf[:n], link); err != nil {
+				utils.PutBufPoolCopy(buf)
+				c.Close()
+				break
+			}
+			utils.PutBufPoolCopy(buf)
+			if link.ConnType == utils.CONN_UDP {
+				c.Close()
+				break
+			}
+		}
+	}
+
+	s.Lock()
+	delete(s.linkMap, link.Id)
+	s.Unlock()
 }
 
 //隧道模式处理
@@ -103,50 +145,37 @@ func (s *TRPClient) dealChan() {
 		return
 	}
 	//默认长连接保持
-	c := utils.NewConn(conn)
-	c.SetAlive()
+	s.tunnel = utils.NewConn(conn)
+	s.tunnel.SetAlive()
 	//写标志
-	c.WriteChan()
-re:
-	atomic.AddInt64(&s.tunnelNum, 1)
-	//获取连接的host type(tcp or udp)
-	typeStr, host, en, de, crypt, mux, err := c.GetHostFromConn()
-	s.tunnel <- true
-	atomic.AddInt64(&s.tunnelNum, -1)
-	if err != nil {
-		c.Close()
-		return
-	}
-	s.ConnectAndCopy(c, typeStr, host, en, de, crypt, mux)
-	if mux {
-		utils.FlushConn(conn)
-		goto re
-	} else {
-		c.Close()
-	}
-}
+	s.tunnel.WriteChan()
 
-func (s *TRPClient) session() {
-	t := time.NewTicker(time.Millisecond * 1000)
-	for {
-		select {
-		case <-s.tunnel:
-		case <-t.C:
-		}
-		if s.serverStatus && s.tunnelNum < 5 {
-			go s.dealChan()
+	go func() {
+		for {
+			if id, err := s.tunnel.GetLen(); err != nil {
+				log.Println("get msg id error")
+				break
+			} else {
+				s.Lock()
+				if v, ok := s.linkMap[id]; ok {
+					s.Unlock()
+					if content, err := s.tunnel.GetMsgContent(v); err != nil {
+						log.Println("get msg content error:", err, id)
+						break
+					} else {
+						if len(content) == len(utils.IO_EOF) && string(content) == utils.IO_EOF {
+							v.Conn.Close()
+						} else if v.Conn != nil {
+							v.Conn.Write(content)
+						}
+					}
+				} else {
+					s.Unlock()
+				}
+			}
 		}
+	}()
+	select {
+	case <-s.stop:
 	}
 }
-
-func (s *TRPClient) ConnectAndCopy(c *utils.Conn, typeStr, host string, en, de int, crypt, mux bool) {
-	//与目标建立连接,超时时间为3
-	server, err := net.DialTimeout(typeStr, host, time.Second*3)
-	if err != nil {
-		log.Println("connect to ", host, "error:", err, mux)
-		c.WriteFail()
-		return
-	}
-	c.WriteSuccess()
-	utils.ReplayWaitGroup(c.Conn, server, en, de, crypt, mux, nil)
-}