Code optimization

2025-09-01 02:46:52 +00:00 · 2019-03-23 22:19:59 +08:00
parent efa341c7e8
commit b189fb1b6e
260 changed files with 50746 additions and 851 deletions
--- a/server/proxy/base.go
+++ b/server/proxy/base.go
@@ -64,17 +64,19 @@ func (s *BaseServer) auth(r *http.Request, c *conn.Conn, u, p string) error {
 	return nil
 }

-func (s *BaseServer) checkFlow() error {
-	if s.task.Client.Flow.FlowLimit > 0 && (s.task.Client.Flow.FlowLimit<<20) < (s.task.Client.Flow.ExportFlow+s.task.Client.Flow.InletFlow) {
+func (s *BaseServer) CheckFlowAndConnNum(client *file.Client) error {
+	if client.Flow.FlowLimit > 0 && (client.Flow.FlowLimit<<20) < (client.Flow.ExportFlow+client.Flow.InletFlow) {
 		return errors.New("Traffic exceeded")
 	}
+	if !client.GetConn() {
+		return errors.New("Connections exceed the current client limit")
+	}
 	return nil
 }

 //与客户端建立通道
-func (s *BaseServer) DealClient(c *conn.Conn, client *file.Client, addr string, rb []byte, tp string) error {
+func (s *BaseServer) DealClient(c *conn.Conn, client *file.Client, addr string, rb []byte, tp string, f func()) error {
 	link := conn.NewLink(tp, addr, client.Cnf.Crypt, client.Cnf.Compress, c.Conn.RemoteAddr().String())
-
 	if target, err := s.bridge.SendLinkInfo(client.Id, link, c.Conn.RemoteAddr().String(), s.task); err != nil {
 		logs.Warn("task id %d get connection from client id %d  error %s", s.task.Id, client.Id, err.Error())
 		c.Close()
@@ -84,9 +86,11 @@ func (s *BaseServer) DealClient(c *conn.Conn, client *file.Client, addr string,
 			//HTTP proxy crypt or compress
 			conn.GetConn(target, link.Crypt, link.Compress, client.Rate, true).Write(rb)
 		}
+		if f != nil {
+			f()
+		}
 		conn.CopyWaitGroup(target, c.Conn, link.Crypt, link.Compress, client.Rate, s.task.Flow, true)
 	}
-
 	client.AddConn()
 	return nil
 }
--- a/server/proxy/http.go
+++ b/server/proxy/http.go
@@ -28,8 +28,9 @@ type httpServer struct {
 	httpsPort     int //https监听端口
 	pemPath       string
 	keyPath       string
-	stop          chan bool
-	httpslistener net.Listener
+	httpServer    *http.Server
+	httpsServer   *http.Server
+	httpsListener net.Listener
 }

 func NewHttp(bridge *bridge.Bridge, c *file.Tunnel) *httpServer {
@@ -47,7 +48,6 @@ func NewHttp(bridge *bridge.Bridge, c *file.Tunnel) *httpServer {
 		httpsPort: httpsPort,
 		pemPath:   pemPath,
 		keyPath:   keyPath,
-		stop:      make(chan bool),
 	}
 }

@@ -58,13 +58,17 @@ func (s *httpServer) processHttps(c net.Conn) {
 		return
 	}
 	var host *file.Host
-	file.GetCsvDb().Lock()
-	for _, v := range file.GetCsvDb().Hosts {
+	file.GetCsvDb().Hosts.Range(func(key, value interface{}) bool {
+		v := value.(*file.Host)
+		if v.Scheme != "https" && v.Scheme != "all" {
+			return true
+		}
 		if bytes.Index(buf[:n], []byte(v.Host)) >= 0 && (host == nil || len(host.Host) < len(v.Host)) {
 			host = v
+			return false
 		}
-	}
-	file.GetCsvDb().Unlock()
+		return true
+	})
 	if host == nil {
 		logs.Error("new https connection can't be parsed!", c.RemoteAddr().String())
 		c.Close()
@@ -76,40 +80,37 @@ func (s *httpServer) processHttps(c net.Conn) {
 	r.URL = new(url.URL)
 	r.URL.Scheme = "https"
 	r.Host = host.Host
-	//read the host form connection
-	if !host.Client.GetConn() { //conn num limit
-		logs.Notice("connections exceed the current client %d limit %d ,now connection num %d", host.Client.Id, host.Client.MaxConn, host.Client.NowConn)
+	if err := s.CheckFlowAndConnNum(host.Client); err != nil {
+		logs.Warn("client id %d, host id %d, error %s, when https connection", host.Client.Id, host.Id, err.Error())
 		c.Close()
 		return
 	}
-	//流量限制
-	if host.Client.Flow.FlowLimit > 0 && (host.Client.Flow.FlowLimit<<20) < (host.Client.Flow.ExportFlow+host.Client.Flow.InletFlow) {
-		logs.Warn("Traffic exceeded client id %s", host.Client.Id)
+	if err = s.auth(r, conn.NewConn(c), host.Client.Cnf.U, host.Client.Cnf.P); err != nil {
+		logs.Warn("auth error", err, r.RemoteAddr)
 		return
 	}
 	if targetAddr, err = host.GetRandomTarget(); err != nil {
 		logs.Warn(err.Error())
 	}
 	logs.Trace("new https connection,clientId %d,host %s,remote address %s", host.Client.Id, r.Host, c.RemoteAddr().String())
-	s.DealClient(conn.NewConn(c), host.Client, targetAddr, buf[:n], common.CONN_TCP)
+	s.DealClient(conn.NewConn(c), host.Client, targetAddr, buf[:n], common.CONN_TCP, nil)
 }

 func (s *httpServer) Start() error {
 	var err error
-	var httpSrv, httpsSrv *http.Server
 	if s.errorContent, err = common.ReadAllFromFile(filepath.Join(common.GetRunPath(), "web", "static", "page", "error.html")); err != nil {
 		s.errorContent = []byte("easyProxy 404")
 	}

 	if s.httpPort > 0 {
-		httpSrv = s.NewServer(s.httpPort, "http")
+		s.httpServer = s.NewServer(s.httpPort, "http")
 		go func() {
 			l, err := connection.GetHttpListener()
 			if err != nil {
 				logs.Error(err)
 				os.Exit(0)
 			}
-			err = httpSrv.Serve(l)
+			err = s.httpServer.Serve(l)
 			if err != nil {
 				logs.Error(err)
 				os.Exit(0)
@@ -117,23 +118,16 @@ func (s *httpServer) Start() error {
 		}()
 	}
 	if s.httpsPort > 0 {
-		if !common.FileExists(s.pemPath) {
-			os.Exit(0)
-		}
-		if !common.FileExists(s.keyPath) {
-			logs.Error("ssl keyFile %s exist", s.keyPath)
-			os.Exit(0)
-		}
-		httpsSrv = s.NewServer(s.httpsPort, "https")
+		s.httpsServer = s.NewServer(s.httpsPort, "https")
 		go func() {
-			l, err := connection.GetHttpsListener()
+			s.httpsListener, err = connection.GetHttpsListener()
 			if err != nil {
 				logs.Error(err)
 				os.Exit(0)
 			}
 			if b, err := beego.AppConfig.Bool("https_just_proxy"); err == nil && b {
 				for {
-					c, err := l.Accept()
+					c, err := s.httpsListener.Accept()
 					if err != nil {
 						logs.Error(err)
 						break
@@ -141,7 +135,15 @@ func (s *httpServer) Start() error {
 					go s.processHttps(c)
 				}
 			} else {
-				err = httpsSrv.ServeTLS(l, s.pemPath, s.keyPath)
+				if !common.FileExists(s.pemPath) {
+					logs.Error("ssl certFile %s exist", s.keyPath)
+					os.Exit(0)
+				}
+				if !common.FileExists(s.keyPath) {
+					logs.Error("ssl keyFile %s exist", s.keyPath)
+					os.Exit(0)
+				}
+				err = s.httpsServer.ServeTLS(s.httpsListener, s.pemPath, s.keyPath)
 				if err != nil {
 					logs.Error(err)
 					os.Exit(0)
@@ -149,20 +151,19 @@ func (s *httpServer) Start() error {
 			}
 		}()
 	}
-	select {
-	case <-s.stop:
-		if httpSrv != nil {
-			httpsSrv.Close()
-		}
-		if httpsSrv != nil {
-			httpsSrv.Close()
-		}
-	}
 	return nil
 }

 func (s *httpServer) Close() error {
-	s.stop <- true
+	if s.httpsListener != nil {
+		s.httpsListener.Close()
+	}
+	if s.httpsServer != nil {
+		s.httpsServer.Close()
+	}
+	if s.httpServer != nil {
+		s.httpServer.Close()
+	}
 	return nil
 }

@@ -196,23 +197,17 @@ func (s *httpServer) process(c *conn.Conn, r *http.Request) {
 	if host, err = file.GetCsvDb().GetInfoByHost(r.Host, r); err != nil {
 		logs.Notice("the url %s %s %s can't be parsed!", r.URL.Scheme, r.Host, r.RequestURI)
 		goto end
-	} else if !host.Client.GetConn() { //conn num limit
-		logs.Notice("connections exceed the current client %d limit %d ,now connection num %d", host.Client.Id, host.Client.MaxConn, host.Client.NowConn)
+	}
+	if err := s.CheckFlowAndConnNum(host.Client); err != nil {
+		logs.Warn("client id %d, host id %d, error %s, when https connection", host.Client.Id, host.Id, err.Error())
 		c.Close()
 		return
-	} else {
-		logs.Trace("new %s connection,clientId %d,host %s,url %s,remote address %s", r.URL.Scheme, host.Client.Id, r.Host, r.URL, r.RemoteAddr)
-		lastHost = host
 	}
+	logs.Trace("new %s connection,clientId %d,host %s,url %s,remote address %s", r.URL.Scheme, host.Client.Id, r.Host, r.URL, r.RemoteAddr)
+	lastHost = host
 	for {
 	start:
 		if isConn {
-			//流量限制
-			if host.Client.Flow.FlowLimit > 0 && (host.Client.Flow.FlowLimit<<20) < (host.Client.Flow.ExportFlow+host.Client.Flow.InletFlow) {
-				logs.Warn("Traffic exceeded client id %s", host.Client.Id)
-				break
-			}
-			//权限控制
 			if err = s.auth(r, c, host.Client.Cnf.U, host.Client.Cnf.P); err != nil {
 				logs.Warn("auth error", err, r.RemoteAddr)
 				break
--- a/server/proxy/p2p.go
+++ b/server/proxy/p2p.go
@@ -3,8 +3,7 @@ package proxy
 import (
 	"github.com/cnlh/nps/lib/common"
 	"github.com/cnlh/nps/lib/conn"
-	"github.com/cnlh/nps/vender/github.com/astaxie/beego/logs"
-	"github.com/cnlh/nps/vender/github.com/xtaci/kcp"
+	"net"
 	"strconv"
 	"time"
 )
@@ -30,21 +29,9 @@ func NewP2PServer(p2pPort int) *P2PServer {
 }

 func (s *P2PServer) Start() error {
-	kcpListener, err := kcp.ListenWithOptions(":"+strconv.Itoa(s.p2pPort), nil, 150, 3)
-	if err != nil {
-		logs.Error(err)
-		return err
-	}
-	for {
-		c, err := kcpListener.AcceptKCP()
-		conn.SetUdpSession(c)
-		if err != nil {
-			logs.Warn(err)
-			continue
-		}
-		go s.p2pProcess(conn.NewConn(c))
-	}
-	return nil
+	return conn.NewKcpListenerAndProcess(":"+strconv.Itoa(s.p2pPort), func(c net.Conn) {
+		s.p2pProcess(conn.NewConn(c))
+	})
 }

 func (s *P2PServer) p2pProcess(c *conn.Conn) {
--- a/server/proxy/socks5.go
+++ b/server/proxy/socks5.go
@@ -11,7 +11,6 @@ import (
 	"io"
 	"net"
 	"strconv"
-	"strings"
 )

 const (
@@ -141,18 +140,9 @@ func (s *Sock5ModeServer) doConnect(c net.Conn, command uint8) {
 	} else {
 		ltype = common.CONN_TCP
 	}
-	//s.DealClient(conn.NewConn(c), addr, nil, ltype)
-	link := conn.NewLink(ltype, addr, s.task.Client.Cnf.Crypt, s.task.Client.Cnf.Compress, c.RemoteAddr().String())
-
-	if target, err := s.bridge.SendLinkInfo(s.task.Client.Id, link, c.RemoteAddr().String(), s.task); err != nil {
-		c.Close()
-		return
-	} else {
+	s.DealClient(conn.NewConn(c), s.task.Client, addr, nil, ltype, func() {
 		s.sendReply(c, succeeded)
-		conn.CopyWaitGroup(target, c, link.Crypt, link.Compress, s.task.Client.Rate, s.task.Flow, true)
-	}
-
-	s.task.Client.AddConn()
+	})
 	return
 }

@@ -261,37 +251,15 @@ func (s *Sock5ModeServer) Auth(c net.Conn) error {

 //start
 func (s *Sock5ModeServer) Start() error {
-	var err error
-	s.listener, err = net.Listen("tcp", ":"+strconv.Itoa(s.task.Port))
-	if err != nil {
-		return err
-	}
-	for {
-		conn, err := s.listener.Accept()
-		if err != nil {
-			if strings.Contains(err.Error(), "use of closed network connection") {
-				break
-			}
-			logs.Warn("accept error: ", err)
+	return conn.NewTcpListenerAndProcess(":"+strconv.Itoa(s.task.Port), func(c net.Conn) {
+		if err := s.CheckFlowAndConnNum(s.task.Client); err != nil {
+			logs.Warn("client id %d, task id %d, error %s, when socks5 connection", s.task.Client.Id, s.task.Id, err.Error())
+			c.Close()
+			return
 		}
-		if err := s.checkFlow(); err != nil {
-			logs.Warn("client id %d  task id %d  error  %s", s.task.Client.Id, s.task.Id, err.Error())
-			conn.Close()
-		}
-		if s.task.Client.GetConn() {
-			logs.Trace("New socks5 connection,client %d,remote address %s", s.task.Client.Id, conn.RemoteAddr())
-			go s.handleConn(conn)
-		} else {
-			logs.Warn("Connections exceed the current client %d limit", s.task.Client.Id)
-			conn.Close()
-		}
-	}
-	return nil
-}
-
-//close
-func (s *Sock5ModeServer) Close() error {
-	return s.listener.Close()
+		logs.Trace("New socks5 connection,client %d,remote address %s", s.task.Client.Id, c.RemoteAddr())
+		s.handleConn(c)
+	}, &s.listener)
 }

 //new
@@ -301,3 +269,8 @@ func NewSock5ModeServer(bridge *bridge.Bridge, task *file.Tunnel) *Sock5ModeServ
 	s.task = task
 	return s
 }
+
+//close
+func (s *Sock5ModeServer) Close() error {
+	return s.listener.Close()
+}
--- a/server/proxy/tcp.go
+++ b/server/proxy/tcp.go
@@ -12,13 +12,13 @@ import (
 	"net"
 	"net/http"
 	"path/filepath"
-	"strings"
+	"strconv"
 )

 type TunnelModeServer struct {
 	BaseServer
 	process  process
-	listener *net.TCPListener
+	listener net.Listener
 }

 //tcp|http|host
@@ -32,33 +32,15 @@ func NewTunnelModeServer(process process, bridge *bridge.Bridge, task *file.Tunn

 //开始
 func (s *TunnelModeServer) Start() error {
-	var err error
-	s.listener, err = net.ListenTCP("tcp", &net.TCPAddr{net.ParseIP("0.0.0.0"), s.task.Port, ""})
-	if err != nil {
-		return err
-	}
-	for {
-		c, err := s.listener.AcceptTCP()
-		if err != nil {
-			if strings.Contains(err.Error(), "use of closed network connection") {
-				break
-			}
-			logs.Info(err)
-			continue
-		}
-		if err := s.checkFlow(); err != nil {
-			logs.Warn("client id %d  task id %d  error  %s", s.task.Client.Id, s.task.Id, err.Error())
+	return conn.NewTcpListenerAndProcess(":"+strconv.Itoa(s.task.Port), func(c net.Conn) {
+		if err := s.CheckFlowAndConnNum(s.task.Client); err != nil {
+			logs.Warn("client id %d, task id %d,error %s, when tcp connection", s.task.Client.Id, s.task.Id, err.Error())
 			c.Close()
+			return
 		}
-		if s.task.Client.GetConn() {
-			logs.Trace("New tcp connection,local port %d,client %d,remote address %s", s.task.Port, s.task.Client.Id, c.RemoteAddr())
-			go s.process(conn.NewConn(c), s)
-		} else {
-			logs.Info("Connections exceed the current client %d limit", s.task.Client.Id)
-			c.Close()
-		}
-	}
-	return nil
+		logs.Trace("new tcp connection,local port %d,client %d,remote address %s", s.task.Port, s.task.Client.Id, c.RemoteAddr())
+		s.process(conn.NewConn(c), s)
+	}, &s.listener)
 }

 //close
@@ -78,10 +60,6 @@ func (s *WebServer) Start() error {
 		stop := make(chan struct{})
 		<-stop
 	}
-	//if !common.TestTcpPort(p) {
-	//	//	logs.Error("Web management port %d is occupied", p)
-	//	//	os.Exit(0)
-	//	//}
 	beego.BConfig.WebConfig.Session.SessionOn = true
 	beego.SetStaticPath("/static", filepath.Join(common.GetRunPath(), "web", "static"))
 	beego.SetViewsPath(filepath.Join(common.GetRunPath(), "web", "views"))
@@ -115,7 +93,7 @@ func ProcessTunnel(c *conn.Conn, s *TunnelModeServer) error {
 		logs.Warn("tcp port %d ,client id %d,task id %d connect error %s", s.task.Port, s.task.Client.Id, s.task.Id, err.Error())
 		return err
 	}
-	return s.DealClient(c, s.task.Client, targetAddr, nil, common.CONN_TCP)
+	return s.DealClient(c, s.task.Client, targetAddr, nil, common.CONN_TCP, nil)
 }

 //http代理模式
@@ -133,5 +111,5 @@ func ProcessHttp(c *conn.Conn, s *TunnelModeServer) error {
 	if err := s.auth(r, c, s.task.Client.Cnf.U, s.task.Client.Cnf.P); err != nil {
 		return err
 	}
-	return s.DealClient(c, s.task.Client, addr, rb, common.CONN_TCP)
+	return s.DealClient(c, s.task.Client, addr, rb, common.CONN_TCP, nil)
 }
--- a/server/proxy/udp.go
+++ b/server/proxy/udp.go
@@ -46,10 +46,12 @@ func (s *UdpModeServer) Start() error {
 }

 func (s *UdpModeServer) process(addr *net.UDPAddr, data []byte) {
-	link := conn.NewLink(common.CONN_UDP, s.task.Target, s.task.Client.Cnf.Crypt, s.task.Client.Cnf.Compress, addr.String())
-	if err := s.checkFlow(); err != nil {
+	if err := s.CheckFlowAndConnNum(s.task.Client); err != nil {
+		logs.Warn("client id %d, task id %d,error %s, when udp connection", s.task.Client.Id, s.task.Id, err.Error())
 		return
 	}
+	defer s.task.Client.AddConn()
+	link := conn.NewLink(common.CONN_UDP, s.task.Target, s.task.Client.Cnf.Crypt, s.task.Client.Cnf.Compress, addr.String())
 	if target, err := s.bridge.SendLinkInfo(s.task.Client.Id, link, addr.String(), s.task); err != nil {
 		return
 	} else {
--- a/server/server.go
+++ b/server/server.go
@@ -16,6 +16,7 @@ import (
 	"math"
 	"os"
 	"strconv"
+	"strings"
 	"time"
 )

@@ -40,11 +41,12 @@ func InitFromCsv() {
 		RunList[c.Id] = nil
 	}
 	//Initialize services in server-side files
-	for _, v := range file.GetCsvDb().Tasks {
-		if v.Status {
-			AddTask(v)
+	file.GetCsvDb().Tasks.Range(func(key, value interface{}) bool {
+		if value.(*file.Tunnel).Status {
+			AddTask(value.(*file.Tunnel))
 		}
-	}
+		return true
+	})
 }

 func DealBridgeTask() {
@@ -66,7 +68,7 @@ func DealBridgeTask() {
 					logs.Info("Connections exceed the current client %d limit", t.Client.Id)
 					s.Conn.Close()
 				} else if t.Status {
-					go proxy.NewBaseServer(Bridge, t).DealClient(s.Conn, t.Client, t.Target, nil, common.CONN_TCP)
+					go proxy.NewBaseServer(Bridge, t).DealClient(s.Conn, t.Client, t.Target, nil, common.CONN_TCP, nil)
 				} else {
 					s.Conn.Close()
 					logs.Trace("This key %s cannot be processed,status is close", s.Password)
@@ -82,10 +84,12 @@ func DealBridgeTask() {
 //start a new server
 func StartNewServer(bridgePort int, cnf *file.Tunnel, bridgeType string) {
 	Bridge = bridge.NewTunnel(bridgePort, bridgeType, common.GetBoolByStr(beego.AppConfig.String("ip_limit")), RunList)
-	if err := Bridge.StartTunnel(); err != nil {
-		logs.Error("start server bridge error", err)
-		os.Exit(0)
-	}
+	go func() {
+		if err := Bridge.StartTunnel(); err != nil {
+			logs.Error("start server bridge error", err)
+			os.Exit(0)
+		}
+	}()
 	if p, err := beego.AppConfig.Int("p2p_port"); err == nil {
 		logs.Info("start p2p server port", p)
 		go proxy.NewP2PServer(p).Start()
@@ -107,7 +111,7 @@ func dealClientFlow() {
 	for {
 		select {
 		case <-ticker.C:
-			dealClientData(file.GetCsvDb().Clients)
+			dealClientData()
 		}
 	}
 }
@@ -148,6 +152,8 @@ func StopServer(id int) error {
 				return err
 			}
 			logs.Info("stop server id %d", id)
+		} else {
+			logs.Warn("stop server id %d error", id)
 		}
 		if t, err := file.GetCsvDb().GetTask(id); err != nil {
 			return err
@@ -214,29 +220,34 @@ func DelTask(id int) error {
 }

 //get task list by page num
-func GetTunnel(start, length int, typeVal string, clientId int) ([]*file.Tunnel, int) {
+func GetTunnel(start, length int, typeVal string, clientId int, search string) ([]*file.Tunnel, int) {
 	list := make([]*file.Tunnel, 0)
 	var cnt int
-	file.GetCsvDb().Lock()
-	defer file.GetCsvDb().Unlock()
-	for _, v := range file.GetCsvDb().Tasks {
-		if (typeVal != "" && v.Mode != typeVal) || (typeVal == "" && clientId != v.Client.Id) {
-			continue
-		}
-		cnt++
-		if _, ok := Bridge.Client[v.Client.Id]; ok {
-			v.Client.IsConnect = true
-		} else {
-			v.Client.IsConnect = false
-		}
-		if start--; start < 0 {
-			if length--; length > 0 {
-				if _, ok := RunList[v.Id]; ok {
-					v.RunStatus = true
-				} else {
-					v.RunStatus = false
+	keys := common.GetMapKeys(file.GetCsvDb().Tasks)
+	for _, key := range keys {
+		if value, ok := file.GetCsvDb().Tasks.Load(key); ok {
+			v := value.(*file.Tunnel)
+			if (typeVal != "" && v.Mode != typeVal) || (typeVal == "" && clientId != v.Client.Id) {
+				continue
+			}
+			if search != "" && !(v.Id == common.GetIntNoErrByStr(search) || v.Port == common.GetIntNoErrByStr(search) || strings.Contains(v.Password, search) || strings.Contains(v.Remark, search)) {
+				continue
+			}
+			cnt++
+			if _, ok := Bridge.Client.Load(v.Client.Id); ok {
+				v.Client.IsConnect = true
+			} else {
+				v.Client.IsConnect = false
+			}
+			if start--; start < 0 {
+				if length--; length > 0 {
+					if _, ok := RunList[v.Id]; ok {
+						v.RunStatus = true
+					} else {
+						v.RunStatus = false
+					}
+					list = append(list, v)
 				}
-				list = append(list, v)
 			}
 		}
 	}
@@ -244,60 +255,64 @@ func GetTunnel(start, length int, typeVal string, clientId int) ([]*file.Tunnel,
 }

 //获取客户端列表
-func GetClientList(start, length int) (list []*file.Client, cnt int) {
-	list, cnt = file.GetCsvDb().GetClientList(start, length)
-	dealClientData(list)
+func GetClientList(start, length int, search string) (list []*file.Client, cnt int) {
+	list, cnt = file.GetCsvDb().GetClientList(start, length, search)
+	dealClientData()
 	return
 }

-func dealClientData(list []*file.Client) {
-	file.GetCsvDb().Lock()
-	defer file.GetCsvDb().Unlock()
-	for _, v := range list {
-		if _, ok := Bridge.Client[v.Id]; ok {
+func dealClientData() {
+	file.GetCsvDb().Clients.Range(func(key, value interface{}) bool {
+		v := value.(*file.Client)
+		if _, ok := Bridge.Client.Load(v.Id); ok {
 			v.IsConnect = true
 		} else {
 			v.IsConnect = false
 		}
 		v.Flow.InletFlow = 0
 		v.Flow.ExportFlow = 0
-		for _, h := range file.GetCsvDb().Hosts {
+		file.GetCsvDb().Hosts.Range(func(key, value interface{}) bool {
+			h := value.(*file.Host)
 			if h.Client.Id == v.Id {
 				v.Flow.InletFlow += h.Flow.InletFlow
 				v.Flow.ExportFlow += h.Flow.ExportFlow
 			}
-		}
-		for _, t := range file.GetCsvDb().Tasks {
+			return true
+		})
+		file.GetCsvDb().Tasks.Range(func(key, value interface{}) bool {
+			t := value.(*file.Tunnel)
 			if t.Client.Id == v.Id {
 				v.Flow.InletFlow += t.Flow.InletFlow
 				v.Flow.ExportFlow += t.Flow.ExportFlow
 			}
-		}
-	}
+			return true
+		})
+		return true
+	})
 	return
 }

 //根据客户端id删除其所属的所有隧道和域名
 func DelTunnelAndHostByClientId(clientId int) {
 	var ids []int
-	file.GetCsvDb().Lock()
-	for _, v := range file.GetCsvDb().Tasks {
+	file.GetCsvDb().Tasks.Range(func(key, value interface{}) bool {
+		v := value.(*file.Tunnel)
 		if v.Client.Id == clientId {
 			ids = append(ids, v.Id)
 		}
-	}
-	file.GetCsvDb().Unlock()
+		return true
+	})
 	for _, id := range ids {
 		DelTask(id)
 	}
 	ids = ids[:0]
-	file.GetCsvDb().Lock()
-	for _, v := range file.GetCsvDb().Hosts {
+	file.GetCsvDb().Hosts.Range(func(key, value interface{}) bool {
+		v := value.(*file.Host)
 		if v.Client.Id == clientId {
 			ids = append(ids, v.Id)
 		}
-	}
-	file.GetCsvDb().Unlock()
+		return true
+	})
 	for _, id := range ids {
 		file.GetCsvDb().DelHost(id)
 	}
@@ -305,32 +320,31 @@ func DelTunnelAndHostByClientId(clientId int) {

 //关闭客户端连接
 func DelClientConnect(clientId int) {
-	Bridge.DelClient(clientId, false)
+	Bridge.DelClient(clientId)
 }

 func GetDashboardData() map[string]interface{} {
 	data := make(map[string]interface{})
-	data["hostCount"] = len(file.GetCsvDb().Hosts)
-	data["clientCount"] = len(file.GetCsvDb().Clients) - 1 //Remove the public key client
-	list := file.GetCsvDb().Clients
-	dealClientData(list)
+	data["hostCount"] = file.GetCsvDb().GetMapLen(file.GetCsvDb().Hosts)
+	data["clientCount"] = file.GetCsvDb().GetMapLen(file.GetCsvDb().Clients) - 1 //Remove the public key client
+	dealClientData()
 	c := 0
 	var in, out int64
-	for _, v := range list {
+	file.GetCsvDb().Clients.Range(func(key, value interface{}) bool {
+		v := value.(*file.Client)
 		if v.IsConnect {
 			c += 1
 		}
 		in += v.Flow.InletFlow
 		out += v.Flow.ExportFlow
-	}
+		return true
+	})
 	data["clientOnlineCount"] = c
 	data["inletFlowCount"] = int(in)
 	data["exportFlowCount"] = int(out)
 	var tcp, udp, secret, socks5, p2p, http int
-	file.GetCsvDb().Lock()
-	defer file.GetCsvDb().Unlock()
-	for _, v := range file.GetCsvDb().Tasks {
-		switch v.Mode {
+	file.GetCsvDb().Tasks.Range(func(key, value interface{}) bool {
+		switch value.(*file.Tunnel).Mode {
 		case "tcp":
 			tcp += 1
 		case "socks5":
@@ -344,7 +358,9 @@ func GetDashboardData() map[string]interface{} {
 		case "secret":
 			secret += 1
 		}
-	}
+		return true
+	})
+
 	data["tcpC"] = tcp
 	data["udpCount"] = udp
 	data["socks5Count"] = socks5
@@ -360,9 +376,11 @@ func GetDashboardData() map[string]interface{} {
 	data["p2pPort"] = beego.AppConfig.String("p2p_port")
 	data["logLevel"] = beego.AppConfig.String("log_level")
 	tcpCount := 0
-	for _, v := range file.GetCsvDb().Clients {
-		tcpCount += v.NowConn
-	}
+
+	file.GetCsvDb().Clients.Range(func(key, value interface{}) bool {
+		tcpCount += value.(*file.Client).NowConn
+		return true
+	})
 	data["tcpCount"] = tcpCount
 	cpuPercet, _ := cpu.Percent(0, true)
 	var cpuAll float64
--- a/server/test/test.go
+++ b/server/test/test.go
@@ -5,19 +5,23 @@ import (
 	"github.com/cnlh/nps/lib/file"
 	"github.com/cnlh/nps/vender/github.com/astaxie/beego"
 	"log"
+	"path/filepath"
 	"strconv"
 )

 func TestServerConfig() {
 	var postTcpArr []int
 	var postUdpArr []int
-	for _, v := range file.GetCsvDb().Tasks {
+	file.GetCsvDb().Tasks.Range(func(key, value interface{}) bool {
+		v := value.(*file.Tunnel)
 		if v.Mode == "udp" {
 			isInArr(&postUdpArr, v.Port, v.Remark, "udp")
-		} else {
+		} else if v.Port != 0 {
+
 			isInArr(&postTcpArr, v.Port, v.Remark, "tcp")
 		}
-	}
+		return true
+	})
 	p, err := beego.AppConfig.Int("web_port")
 	if err != nil {
 		log.Fatalln("Getting web management port error :", err)
@@ -43,16 +47,18 @@ func TestServerConfig() {
 		}
 	}
 	if p := beego.AppConfig.String("https_proxy_port"); p != "" {
-		if port, err := strconv.Atoi(p); err != nil {
-			log.Fatalln("get https port error", err)
-		} else {
-			if !common.FileExists(beego.AppConfig.String("pemPath")) {
-				log.Fatalf("ssl certFile %s is not exist", beego.AppConfig.String("pemPath"))
+		if b, err := beego.AppConfig.Bool("https_just_proxy"); !(err == nil && b) {
+			if port, err := strconv.Atoi(p); err != nil {
+				log.Fatalln("get https port error", err)
+			} else {
+				if !common.FileExists(filepath.Join(beego.AppPath, beego.AppConfig.String("pemPath"))) {
+					log.Fatalf("ssl certFile %s is not exist", beego.AppConfig.String("pemPath"))
+				}
+				if !common.FileExists(filepath.Join(beego.AppPath, beego.AppConfig.String("ketPath"))) {
+					log.Fatalf("ssl keyFile %s is not exist", beego.AppConfig.String("pemPath"))
+				}
+				isInArr(&postTcpArr, port, "http port", "tcp")
 			}
-			if !common.FileExists(beego.AppConfig.String("ketPath")) {
-				log.Fatalf("ssl keyFile %s is not exist", beego.AppConfig.String("pemPath"))
-			}
-			isInArr(&postTcpArr, port, "http port", "tcp")
 		}
 	}
 }
--- a/server/tool/utils.go
+++ b/server/tool/utils.go
@@ -7,7 +7,7 @@ import (

 var ports []int

-func init() {
+func InitAllowPort() {
 	p := beego.AppConfig.String("allow_ports")
 	ports = common.GetPorts(p)
 }