File mode|pubVkey optimization

client/client.go

@@ -17,6 +17,8 @@ type TRPClient struct {
 	stop           chan bool
 	proxyUrl       string
 	vKey           string
+	tunnel         *mux.Mux
+	signal         *conn.Conn
 }
 
 //new client
@@ -39,16 +41,19 @@ retry:
 		time.Sleep(time.Second * 5)
 		goto retry
 	}
+
 	logs.Info("Successful connection with server %s", s.svrAddr)
+	go s.ping()
 	s.processor(c)
 }
 
 func (s *TRPClient) Close() {
-	s.stop <- true
+	s.signal.Close()
 }
 
 //处理
 func (s *TRPClient) processor(c *conn.Conn) {
+	s.signal = c
 	go s.dealChan()
 	for {
 		flags, err := c.ReadFlag()
@@ -176,9 +181,9 @@ func (s *TRPClient) dealChan() {
 		return
 	}
 	go func() {
-		l := mux.NewMux(tunnel.Conn)
+		s.tunnel = mux.NewMux(tunnel.Conn)
 		for {
-			src, err := l.Accept()
+			src, err := s.tunnel.Accept()
 			if err != nil {
 				logs.Warn(err)
 				break
@@ -196,6 +201,7 @@ func (s *TRPClient) srcProcess(src net.Conn) {
 		logs.Error("get connection info from server error ", err)
 		return
 	}
+	//host for target processing
 	lk.Host = common.FormatAddress(lk.Host)
 	//connect to target
 	if targetConn, err := net.Dial(lk.ConnType, lk.Host); err != nil {
@@ -206,3 +212,18 @@ func (s *TRPClient) srcProcess(src net.Conn) {
 		conn.CopyWaitGroup(src, targetConn, lk.Crypt, lk.Compress, nil, nil)
 	}
 }
+
+func (s *TRPClient) ping() {
+	ticker := time.NewTicker(time.Second * 5)
+loop:
+	for {
+		select {
+		case <-ticker.C:
+			if s.tunnel.IsClose {
+				s.Close()
+				ticker.Stop()
+				break loop
+			}
+		}
+	}
+}

client/control.go

@@ -1,6 +1,7 @@
 package client
 
 import (
+	"encoding/binary"
 	"errors"
 	"github.com/cnlh/nps/lib/common"
 	"github.com/cnlh/nps/lib/config"
@@ -41,7 +42,8 @@ func GetTaskStatus(path string) {
 	} else if _, err := c.Write([]byte(crypt.Md5(string(f)))); err != nil {
 		log.Fatalln(err)
 	}
-
+	var isPub bool
+	binary.Read(c, binary.LittleEndian, &isPub)
 	if l, err := c.GetLen(); err != nil {
 		log.Fatalln(err)
 	} else if b, err := c.GetShortContent(l); err != nil {
@@ -104,25 +106,30 @@ 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
-	}
-	if !c.GetAddStatus() {
-		logs.Error(errAdd)
-		goto re
-	}
+	var isPub bool
+	binary.Read(c, binary.LittleEndian, &isPub)
 
 	// get tmp password
 	var b []byte
-	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)
+	vkey := cnf.CommonConfig.VKey
+	if isPub {
+		// send global configuration to server and get status of config setting
+		if _, err := c.SendConfigInfo(cnf.CommonConfig); err != nil {
+			logs.Error(err)
+			goto re
+		}
+		if !c.GetAddStatus() {
+			logs.Error(errAdd)
+			goto re
+		}
+
+		if b, err = c.GetShortContent(16); err != nil {
+			logs.Error(err)
+			goto re
+		}
+		vkey = string(b)
 	}
+	ioutil.WriteFile(filepath.Join(common.GetTmpPath(), "npc_vkey.txt"), []byte(vkey), 0600)
 
 	//send hosts to server
 	for _, v := range cnf.Hosts {
@@ -146,6 +153,10 @@ re:
 			logs.Error(errAdd, v.Ports)
 			goto re
 		}
+		if v.Mode == "file" {
+			//start local file server
+			go startLocalFileServer(cnf.CommonConfig, v, vkey)
+		}
 	}
 
 	//create local server secret or p2p
@@ -154,7 +165,7 @@ re:
 	}
 
 	c.Close()
-	NewRPClient(cnf.CommonConfig.Server, string(b), cnf.CommonConfig.Tp, cnf.CommonConfig.ProxyUrl).Start()
+	NewRPClient(cnf.CommonConfig.Server, vkey, cnf.CommonConfig.Tp, cnf.CommonConfig.ProxyUrl).Start()
 	CloseLocalServer()
 	goto re
 }

client/local.go

@@ -5,31 +5,52 @@ import (
 	"github.com/cnlh/nps/lib/config"
 	"github.com/cnlh/nps/lib/conn"
 	"github.com/cnlh/nps/lib/crypt"
+	"github.com/cnlh/nps/lib/file"
 	"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"
+	"net/http"
 	"strings"
 )
 
 var LocalServer []*net.TCPListener
 var udpConn net.Conn
 var muxSession *mux.Mux
+var fileServer []*http.Server
 
 func CloseLocalServer() {
 	for _, v := range LocalServer {
 		v.Close()
 	}
+	for _, v := range fileServer {
+		v.Close()
+	}
+}
+
+func startLocalFileServer(config *config.CommonConfig, t *file.Tunnel, vkey string) {
+	remoteConn, err := NewConn(config.Tp, vkey, config.Server, common.WORK_FILE, config.ProxyUrl)
+	if err != nil {
+		logs.Error("Local connection server failed ", err.Error())
+		return
+	}
+	srv := &http.Server{
+		Handler: http.StripPrefix(t.StripPre, http.FileServer(http.Dir(t.LocalPath))),
+	}
+	logs.Info("start local file system, local path %s, strip prefix %s ,remote port %s ", t.LocalPath, t.StripPre, t.Ports)
+	fileServer = append(fileServer, srv)
+	listener := mux.NewMux(remoteConn.Conn)
+	logs.Warn(srv.Serve(listener))
 }
 
 func StartLocalServer(l *config.LocalServer, config *config.CommonConfig) error {
 	listener, err := net.ListenTCP("tcp", &net.TCPAddr{net.ParseIP("0.0.0.0"), l.Port, ""})
 	if err != nil {
-		logs.Error("Local listener startup failed port %d, error %s", l.Port, err.Error())
+		logs.Error("local listener startup failed port %d, error %s", l.Port, err.Error())
 		return err
 	}
 	LocalServer = append(LocalServer, listener)
-	logs.Info("Successful start-up of local monitoring, port", l.Port)
+	logs.Info("successful start-up of local monitoring, port", l.Port)
 	for {
 		c, err := listener.AcceptTCP()
 		if err != nil {
@@ -52,9 +73,11 @@ func processSecret(localTcpConn net.Conn, config *config.CommonConfig, l *config
 	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())
+		return
 	}
 	if _, err := remoteConn.Write([]byte(crypt.Md5(l.Password))); err != nil {
 		logs.Error("Local connection server failed ", err.Error())
+		return
 	}
 	conn.CopyWaitGroup(remoteConn, localTcpConn, false, false, nil, nil)
 }
@@ -62,6 +85,9 @@ func processSecret(localTcpConn net.Conn, config *config.CommonConfig, l *config
 func processP2P(localTcpConn net.Conn, config *config.CommonConfig, l *config.LocalServer) {
 	if udpConn == nil {
 		newUdpConn(config, l)
+		if udpConn == nil {
+			return
+		}
 		muxSession = mux.NewMux(udpConn)
 	}
 	nowConn, err := muxSession.NewConn()
@@ -110,6 +136,7 @@ func newUdpConn(config *config.CommonConfig, l *config.LocalServer) {
 	conn.SetUdpSession(localKcpConn)
 	if err != nil {
 		logs.Error(err)
+		return
 	}
 	//写入密钥、provider身份
 	if _, err := localKcpConn.Write([]byte(crypt.Md5(l.Password))); err != nil {