all: modify import path, change version to v0.8.0

src/models/server/config.go

@@ -0,0 +1,370 @@
+// Copyright 2016 fatedier, fatedier@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package server
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"sync"
+
+	ini "github.com/vaughan0/go-ini"
+
+	"github.com/fatedier/frp/src/models/consts"
+	"github.com/fatedier/frp/src/models/metric"
+	"github.com/fatedier/frp/src/utils/log"
+	"github.com/fatedier/frp/src/utils/vhost"
+)
+
+// common config
+var (
+	ConfigFile     string = "./frps.ini"
+	BindAddr       string = "0.0.0.0"
+	BindPort       int64  = 7000
+	VhostHttpPort  int64  = 0 // if VhostHttpPort equals 0, don't listen a public port for http protocol
+	VhostHttpsPort int64  = 0 // if VhostHttpsPort equals 0, don't listen a public port for https protocol
+	DashboardPort  int64  = 0 // if DashboardPort equals 0, dashboard is not available
+	AssetsDir      string = ""
+	LogFile        string = "console"
+	LogWay         string = "console" // console or file
+	LogLevel       string = "info"
+	LogMaxDays     int64  = 3
+	PrivilegeMode  bool   = false
+	PrivilegeToken string = ""
+
+	// if PrivilegeAllowPorts is not nil, tcp proxies which remote port exist in this map can be connected
+	PrivilegeAllowPorts map[int64]struct{}
+	MaxPoolCount        int64 = 100
+	HeartBeatTimeout    int64 = 90
+	UserConnTimeout     int64 = 10
+
+	VhostHttpMuxer    *vhost.HttpMuxer
+	VhostHttpsMuxer   *vhost.HttpsMuxer
+	ProxyServers      map[string]*ProxyServer = make(map[string]*ProxyServer) // all proxy servers info and resources
+	ProxyServersMutex sync.RWMutex
+)
+
+func LoadConf(confFile string) (err error) {
+	err = loadCommonConf(confFile)
+	if err != nil {
+		return err
+	}
+
+	// load all proxy server's configure and initialize
+	// and set ProxyServers map
+	newProxyServers, err := loadProxyConf(confFile)
+	if err != nil {
+		return err
+	}
+	for _, proxyServer := range newProxyServers {
+		proxyServer.Init()
+	}
+	ProxyServersMutex.Lock()
+	ProxyServers = newProxyServers
+	ProxyServersMutex.Unlock()
+	return nil
+}
+
+func loadCommonConf(confFile string) error {
+	var tmpStr string
+	var ok bool
+	conf, err := ini.LoadFile(confFile)
+	if err != nil {
+		return err
+	}
+	// common
+	tmpStr, ok = conf.Get("common", "bind_addr")
+	if ok {
+		BindAddr = tmpStr
+	}
+
+	tmpStr, ok = conf.Get("common", "bind_port")
+	if ok {
+		v, err := strconv.ParseInt(tmpStr, 10, 64)
+		if err == nil {
+			BindPort = v
+		}
+	}
+
+	tmpStr, ok = conf.Get("common", "vhost_http_port")
+	if ok {
+		VhostHttpPort, _ = strconv.ParseInt(tmpStr, 10, 64)
+	} else {
+		VhostHttpPort = 0
+	}
+
+	tmpStr, ok = conf.Get("common", "vhost_https_port")
+	if ok {
+		VhostHttpsPort, _ = strconv.ParseInt(tmpStr, 10, 64)
+	} else {
+		VhostHttpsPort = 0
+	}
+
+	tmpStr, ok = conf.Get("common", "dashboard_port")
+	if ok {
+		DashboardPort, _ = strconv.ParseInt(tmpStr, 10, 64)
+	} else {
+		DashboardPort = 0
+	}
+
+	tmpStr, ok = conf.Get("common", "assets_dir")
+	if ok {
+		AssetsDir = tmpStr
+	}
+
+	tmpStr, ok = conf.Get("common", "log_file")
+	if ok {
+		LogFile = tmpStr
+		if LogFile == "console" {
+			LogWay = "console"
+		} else {
+			LogWay = "file"
+		}
+	}
+
+	tmpStr, ok = conf.Get("common", "log_level")
+	if ok {
+		LogLevel = tmpStr
+	}
+
+	tmpStr, ok = conf.Get("common", "log_max_days")
+	if ok {
+		v, err := strconv.ParseInt(tmpStr, 10, 64)
+		if err == nil {
+			LogMaxDays = v
+		}
+	}
+
+	tmpStr, ok = conf.Get("common", "privilege_mode")
+	if ok {
+		if tmpStr == "true" {
+			PrivilegeMode = true
+		}
+	}
+
+	if PrivilegeMode == true {
+		tmpStr, ok = conf.Get("common", "privilege_token")
+		if ok {
+			if tmpStr == "" {
+				return fmt.Errorf("Parse conf error: privilege_token can not be null")
+			}
+			PrivilegeToken = tmpStr
+		} else {
+			return fmt.Errorf("Parse conf error: privilege_token must be set if privilege_mode is enabled")
+		}
+
+		PrivilegeAllowPorts = make(map[int64]struct{})
+		tmpStr, ok = conf.Get("common", "privilege_allow_ports")
+		if ok {
+			// for example: 1000-2000,2001,2002,3000-4000
+			portRanges := strings.Split(tmpStr, ",")
+			for _, portRangeStr := range portRanges {
+				// 1000-2000 or 2001
+				portArray := strings.Split(portRangeStr, "-")
+				// lenght: only 1 or 2 is correct
+				rangeType := len(portArray)
+				if rangeType == 1 {
+					singlePort, err := strconv.ParseInt(portArray[0], 10, 64)
+					if err != nil {
+						return fmt.Errorf("Parse conf error: privilege_allow_ports is incorrect, %v", err)
+					}
+					PrivilegeAllowPorts[singlePort] = struct{}{}
+				} else if rangeType == 2 {
+					min, err := strconv.ParseInt(portArray[0], 10, 64)
+					if err != nil {
+						return fmt.Errorf("Parse conf error: privilege_allow_ports is incorrect, %v", err)
+					}
+					max, err := strconv.ParseInt(portArray[1], 10, 64)
+					if err != nil {
+						return fmt.Errorf("Parse conf error: privilege_allow_ports is incorrect, %v", err)
+					}
+					if max < min {
+						return fmt.Errorf("Parse conf error: privilege_allow_ports range incorrect")
+					}
+					for i := min; i <= max; i++ {
+						PrivilegeAllowPorts[i] = struct{}{}
+					}
+				} else {
+					return fmt.Errorf("Parse conf error: privilege_allow_ports is incorrect")
+				}
+			}
+		}
+	}
+
+	tmpStr, ok = conf.Get("common", "max_pool_count")
+	if ok {
+		v, err := strconv.ParseInt(tmpStr, 10, 64)
+		if err == nil && v >= 0 {
+			MaxPoolCount = v
+		}
+	}
+	return nil
+}
+
+func loadProxyConf(confFile string) (proxyServers map[string]*ProxyServer, err error) {
+	var ok bool
+	proxyServers = make(map[string]*ProxyServer)
+	conf, err := ini.LoadFile(confFile)
+	if err != nil {
+		return proxyServers, err
+	}
+	// servers
+	for name, section := range conf {
+		if name != "common" {
+			proxyServer := NewProxyServer()
+			proxyServer.Name = name
+
+			proxyServer.Type, ok = section["type"]
+			if ok {
+				if proxyServer.Type != "tcp" && proxyServer.Type != "http" && proxyServer.Type != "https" {
+					return proxyServers, fmt.Errorf("Parse conf error: proxy [%s] type error", proxyServer.Name)
+				}
+			} else {
+				proxyServer.Type = "tcp"
+			}
+
+			proxyServer.AuthToken, ok = section["auth_token"]
+			if !ok {
+				return proxyServers, fmt.Errorf("Parse conf error: proxy [%s] no auth_token found", proxyServer.Name)
+			}
+
+			// for tcp
+			if proxyServer.Type == "tcp" {
+				proxyServer.BindAddr, ok = section["bind_addr"]
+				if !ok {
+					proxyServer.BindAddr = "0.0.0.0"
+				}
+
+				portStr, ok := section["listen_port"]
+				if ok {
+					proxyServer.ListenPort, err = strconv.ParseInt(portStr, 10, 64)
+					if err != nil {
+						return proxyServers, fmt.Errorf("Parse conf error: proxy [%s] listen_port error", proxyServer.Name)
+					}
+				} else {
+					return proxyServers, fmt.Errorf("Parse conf error: proxy [%s] listen_port not found", proxyServer.Name)
+				}
+			} else if proxyServer.Type == "http" {
+				// for http
+				proxyServer.ListenPort = VhostHttpPort
+
+				domainStr, ok := section["custom_domains"]
+				if ok {
+					proxyServer.CustomDomains = strings.Split(domainStr, ",")
+					if len(proxyServer.CustomDomains) == 0 {
+						return proxyServers, fmt.Errorf("Parse conf error: proxy [%s] custom_domains must be set when type equals http", proxyServer.Name)
+					}
+					for i, domain := range proxyServer.CustomDomains {
+						proxyServer.CustomDomains[i] = strings.ToLower(strings.TrimSpace(domain))
+					}
+				} else {
+					return proxyServers, fmt.Errorf("Parse conf error: proxy [%s] custom_domains must be set when type equals http", proxyServer.Name)
+				}
+			} else if proxyServer.Type == "https" {
+				// for https
+				proxyServer.ListenPort = VhostHttpsPort
+
+				domainStr, ok := section["custom_domains"]
+				if ok {
+					proxyServer.CustomDomains = strings.Split(domainStr, ",")
+					if len(proxyServer.CustomDomains) == 0 {
+						return proxyServers, fmt.Errorf("Parse conf error: proxy [%s] custom_domains must be set when type equals https", proxyServer.Name)
+					}
+					for i, domain := range proxyServer.CustomDomains {
+						proxyServer.CustomDomains[i] = strings.ToLower(strings.TrimSpace(domain))
+					}
+				} else {
+					return proxyServers, fmt.Errorf("Parse conf error: proxy [%s] custom_domains must be set when type equals https", proxyServer.Name)
+				}
+			}
+			proxyServers[proxyServer.Name] = proxyServer
+		}
+	}
+
+	// set metric statistics of all proxies
+	for name, p := range proxyServers {
+		metric.SetProxyInfo(name, p.Type, p.BindAddr, p.UseEncryption, p.UseGzip,
+			p.PrivilegeMode, p.CustomDomains, p.ListenPort)
+	}
+	return proxyServers, nil
+}
+
+// the function can only reload proxy configures
+// common section won't be changed
+func ReloadConf(confFile string) (err error) {
+	loadProxyServers, err := loadProxyConf(confFile)
+	if err != nil {
+		return err
+	}
+
+	ProxyServersMutex.Lock()
+	for name, proxyServer := range loadProxyServers {
+		oldProxyServer, ok := ProxyServers[name]
+		if ok {
+			if !oldProxyServer.Compare(proxyServer) {
+				oldProxyServer.Close()
+				proxyServer.Init()
+				ProxyServers[name] = proxyServer
+				log.Info("ProxyName [%s] configure change, restart", name)
+			}
+		} else {
+			proxyServer.Init()
+			ProxyServers[name] = proxyServer
+			log.Info("ProxyName [%s] is new, init it", name)
+		}
+	}
+
+	// proxies created by PrivilegeMode won't be deleted
+	for name, oldProxyServer := range ProxyServers {
+		_, ok := loadProxyServers[name]
+		if !ok {
+			if !oldProxyServer.PrivilegeMode {
+				oldProxyServer.Close()
+				delete(ProxyServers, name)
+				log.Info("ProxyName [%s] deleted, close it", name)
+			} else {
+				log.Info("ProxyName [%s] created by PrivilegeMode, won't be closed", name)
+			}
+		}
+	}
+	ProxyServersMutex.Unlock()
+	return nil
+}
+
+func CreateProxy(s *ProxyServer) error {
+	ProxyServersMutex.Lock()
+	defer ProxyServersMutex.Unlock()
+	oldServer, ok := ProxyServers[s.Name]
+	if ok {
+		if oldServer.Status == consts.Working {
+			return fmt.Errorf("this proxy is already working now")
+		}
+		oldServer.Close()
+		if oldServer.PrivilegeMode {
+			delete(ProxyServers, s.Name)
+		}
+	}
+	ProxyServers[s.Name] = s
+	metric.SetProxyInfo(s.Name, s.Type, s.BindAddr, s.UseEncryption, s.UseGzip,
+		s.PrivilegeMode, s.CustomDomains, s.ListenPort)
+	s.Init()
+	return nil
+}
+
+func DeleteProxy(proxyName string) {
+	ProxyServersMutex.Lock()
+	defer ProxyServersMutex.Unlock()
+	delete(ProxyServers, proxyName)
+}

src/models/server/dashboard.go

@@ -0,0 +1,57 @@
+// Copyright 2016 fatedier, fatedier@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package server
+
+import (
+	"fmt"
+	"net"
+	"net/http"
+	"time"
+)
+
+var (
+	httpServerReadTimeout  = 10 * time.Second
+	httpServerWriteTimeout = 10 * time.Second
+)
+
+func RunDashboardServer(addr string, port int64) (err error) {
+	// url router
+	mux := http.NewServeMux()
+	// api, see dashboard_api.go
+	mux.HandleFunc("/api/reload", apiReload)
+	mux.HandleFunc("/api/proxies", apiProxies)
+
+	// view see dashboard_view.go
+	mux.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("./assets"))))
+	mux.HandleFunc("/", viewDashboard)
+
+	address := fmt.Sprintf("%s:%d", addr, port)
+	server := &http.Server{
+		Addr:         address,
+		Handler:      mux,
+		ReadTimeout:  httpServerReadTimeout,
+		WriteTimeout: httpServerWriteTimeout,
+	}
+	if address == "" {
+		address = ":http"
+	}
+	ln, err := net.Listen("tcp", address)
+	if err != nil {
+		return err
+	}
+
+	go server.Serve(ln)
+	return
+}

src/models/server/dashboard_api.go

@@ -0,0 +1,67 @@
+// Copyright 2016 fatedier, fatedier@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package server
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/fatedier/frp/src/models/metric"
+	"github.com/fatedier/frp/src/utils/log"
+)
+
+type GeneralResponse struct {
+	Code int64  `json:"code"`
+	Msg  string `json:"msg"`
+}
+
+func apiReload(w http.ResponseWriter, r *http.Request) {
+	var buf []byte
+	res := &GeneralResponse{}
+	defer func() {
+		log.Info("Http response [/api/reload]: %s", string(buf))
+	}()
+
+	log.Info("Http request: [/api/reload]")
+	err := ReloadConf(ConfigFile)
+	if err != nil {
+		res.Code = 2
+		res.Msg = fmt.Sprintf("%v", err)
+		log.Error("frps reload error: %v", err)
+	}
+
+	buf, _ = json.Marshal(res)
+	w.Write(buf)
+}
+
+type ProxiesResponse struct {
+	Code    int64                  `json:"code"`
+	Msg     string                 `json:"msg"`
+	Proxies []*metric.ServerMetric `json:"proxies"`
+}
+
+func apiProxies(w http.ResponseWriter, r *http.Request) {
+	var buf []byte
+	res := &ProxiesResponse{}
+	defer func() {
+		log.Info("Http response [/api/proxies]: code [%d]", res.Code)
+	}()
+
+	log.Info("Http request: [/api/proxies]")
+	res.Proxies = metric.GetAllProxyMetrics()
+	buf, _ = json.Marshal(res)
+	w.Write(buf)
+}

src/models/server/dashboard_view.go

@@ -0,0 +1,35 @@
+// Copyright 2016 fatedier, fatedier@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package server
+
+import (
+	"html/template"
+	"net/http"
+	"path"
+
+	"github.com/fatedier/frp/src/models/metric"
+	"github.com/fatedier/frp/src/utils/log"
+)
+
+func viewDashboard(w http.ResponseWriter, r *http.Request) {
+	metrics := metric.GetAllProxyMetrics()
+	t := template.Must(template.New("index.html").Delims("<<<", ">>>").ParseFiles(path.Join(AssetsDir, "index.html")))
+
+	err := t.Execute(w, metrics)
+	if err != nil {
+		log.Warn("parse template file [index.html] error: %v", err)
+		http.Error(w, "parse template file error", http.StatusInternalServerError)
+	}
+}

src/models/server/server.go

@@ -0,0 +1,308 @@
+// Copyright 2016 fatedier, fatedier@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package server
+
+import (
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/fatedier/frp/src/models/config"
+	"github.com/fatedier/frp/src/models/consts"
+	"github.com/fatedier/frp/src/models/metric"
+	"github.com/fatedier/frp/src/models/msg"
+	"github.com/fatedier/frp/src/utils/conn"
+	"github.com/fatedier/frp/src/utils/log"
+)
+
+type Listener interface {
+	Accept() (*conn.Conn, error)
+	Close() error
+}
+
+type ProxyServer struct {
+	config.BaseConf
+	BindAddr      string
+	ListenPort    int64
+	CustomDomains []string
+
+	Status       int64
+	CtlConn      *conn.Conn      // control connection with frpc
+	listeners    []Listener      // accept new connection from remote users
+	ctlMsgChan   chan int64      // every time accept a new user conn, put "1" to the channel
+	workConnChan chan *conn.Conn // get new work conns from control goroutine
+	mutex        sync.RWMutex
+	closeChan    chan struct{} // for notify other goroutines that the proxy is closed by close this channel
+}
+
+func NewProxyServer() (p *ProxyServer) {
+	p = &ProxyServer{
+		CustomDomains: make([]string, 0),
+	}
+	return p
+}
+
+func NewProxyServerFromCtlMsg(req *msg.ControlReq) (p *ProxyServer) {
+	p = &ProxyServer{}
+	p.Name = req.ProxyName
+	p.Type = req.ProxyType
+	p.UseEncryption = req.UseEncryption
+	p.UseGzip = req.UseGzip
+	p.PrivilegeMode = req.PrivilegeMode
+	p.PrivilegeToken = PrivilegeToken
+	p.BindAddr = BindAddr
+	if p.Type == "tcp" {
+		p.ListenPort = req.RemotePort
+	} else if p.Type == "http" {
+		p.ListenPort = VhostHttpPort
+	} else if p.Type == "https" {
+		p.ListenPort = VhostHttpsPort
+	}
+	p.CustomDomains = req.CustomDomains
+	p.HostHeaderRewrite = req.HostHeaderRewrite
+	return
+}
+
+func (p *ProxyServer) Init() {
+	p.Lock()
+	p.Status = consts.Idle
+	metric.SetStatus(p.Name, p.Status)
+	p.workConnChan = make(chan *conn.Conn, p.PoolCount+10)
+	p.ctlMsgChan = make(chan int64, p.PoolCount+10)
+	p.listeners = make([]Listener, 0)
+	p.closeChan = make(chan struct{})
+	p.Unlock()
+}
+
+func (p *ProxyServer) Compare(p2 *ProxyServer) bool {
+	if p.Name != p2.Name || p.AuthToken != p2.AuthToken || p.Type != p2.Type ||
+		p.BindAddr != p2.BindAddr || p.ListenPort != p2.ListenPort || p.HostHeaderRewrite != p2.HostHeaderRewrite {
+		return false
+	}
+	if len(p.CustomDomains) != len(p2.CustomDomains) {
+		return false
+	}
+	for i, _ := range p.CustomDomains {
+		if p.CustomDomains[i] != p2.CustomDomains[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func (p *ProxyServer) Lock() {
+	p.mutex.Lock()
+}
+
+func (p *ProxyServer) Unlock() {
+	p.mutex.Unlock()
+}
+
+// start listening for user conns
+func (p *ProxyServer) Start(c *conn.Conn) (err error) {
+	p.CtlConn = c
+	p.Init()
+	if p.Type == "tcp" {
+		l, err := conn.Listen(p.BindAddr, p.ListenPort)
+		if err != nil {
+			return err
+		}
+		p.listeners = append(p.listeners, l)
+	} else if p.Type == "http" {
+		for _, domain := range p.CustomDomains {
+			l, err := VhostHttpMuxer.Listen(domain, p.HostHeaderRewrite)
+			if err != nil {
+				return err
+			}
+			p.listeners = append(p.listeners, l)
+		}
+	} else if p.Type == "https" {
+		for _, domain := range p.CustomDomains {
+			l, err := VhostHttpsMuxer.Listen(domain, p.HostHeaderRewrite)
+			if err != nil {
+				return err
+			}
+			p.listeners = append(p.listeners, l)
+		}
+	}
+
+	p.Lock()
+	p.Status = consts.Working
+	p.Unlock()
+	metric.SetStatus(p.Name, p.Status)
+
+	// create connection pool if needed
+	if p.PoolCount > 0 {
+		go p.connectionPoolManager(p.closeChan)
+	}
+
+	// start a goroutine for every listener to accept user connection
+	for _, listener := range p.listeners {
+		go func(l Listener) {
+			for {
+				// block
+				// if listener is closed, err returned
+				c, err := l.Accept()
+				if err != nil {
+					log.Info("ProxyName [%s], listener is closed", p.Name)
+					return
+				}
+				log.Debug("ProxyName [%s], get one new user conn [%s]", p.Name, c.GetRemoteAddr())
+
+				if p.Status != consts.Working {
+					log.Debug("ProxyName [%s] is not working, new user conn close", p.Name)
+					c.Close()
+					return
+				}
+
+				go func(userConn *conn.Conn) {
+					workConn, err := p.getWorkConn()
+					if err != nil {
+						return
+					}
+
+					// message will be transferred to another without modifying
+					// l means local, r means remote
+					log.Debug("Join two connections, (l[%s] r[%s]) (l[%s] r[%s])", workConn.GetLocalAddr(), workConn.GetRemoteAddr(),
+						userConn.GetLocalAddr(), userConn.GetRemoteAddr())
+
+					metric.OpenConnection(p.Name)
+					needRecord := true
+					go msg.JoinMore(userConn, workConn, p.BaseConf, needRecord)
+					metric.OpenConnection(p.Name)
+				}(c)
+			}
+		}(listener)
+	}
+	return nil
+}
+
+func (p *ProxyServer) Close() {
+	p.Lock()
+	if p.Status != consts.Closed {
+		p.Status = consts.Closed
+		for _, l := range p.listeners {
+			if l != nil {
+				l.Close()
+			}
+		}
+		close(p.ctlMsgChan)
+		close(p.workConnChan)
+		close(p.closeChan)
+		if p.CtlConn != nil {
+			p.CtlConn.Close()
+		}
+	}
+	metric.SetStatus(p.Name, p.Status)
+	// if the proxy created by PrivilegeMode, delete it when closed
+	if p.PrivilegeMode {
+		DeleteProxy(p.Name)
+	}
+	p.Unlock()
+}
+
+func (p *ProxyServer) WaitUserConn() (closeFlag bool) {
+	closeFlag = false
+
+	_, ok := <-p.ctlMsgChan
+	if !ok {
+		closeFlag = true
+	}
+	return
+}
+
+func (p *ProxyServer) RegisterNewWorkConn(c *conn.Conn) {
+	select {
+	case p.workConnChan <- c:
+	default:
+		log.Debug("ProxyName [%s], workConnChan is full, so close this work connection", p.Name)
+	}
+}
+
+// When frps get one user connection, we get one work connection from the pool and return it.
+// If no workConn available in the pool, send message to frpc to get one or more
+// and wait until it is available.
+// return an error if wait timeout
+func (p *ProxyServer) getWorkConn() (workConn *conn.Conn, err error) {
+	var ok bool
+	// get a work connection from the pool
+	for {
+		select {
+		case workConn, ok = <-p.workConnChan:
+			if !ok {
+				err = fmt.Errorf("ProxyName [%s], no work connections available, control is closing", p.Name)
+				return
+			}
+		default:
+			// no work connections available in the poll, send message to frpc to get more
+			p.ctlMsgChan <- 1
+
+			select {
+			case workConn, ok = <-p.workConnChan:
+				if !ok {
+					err = fmt.Errorf("ProxyName [%s], no work connections available, control is closing", p.Name)
+					return
+				}
+
+			case <-time.After(time.Duration(UserConnTimeout) * time.Second):
+				log.Warn("ProxyName [%s], timeout trying to get work connection", p.Name)
+				err = fmt.Errorf("ProxyName [%s], timeout trying to get work connection", p.Name)
+				return
+			}
+		}
+
+		// if connection pool is not used, we don't check the status
+		// function CheckClosed will consume at least 1 millisecond if the connection isn't closed
+		if p.PoolCount == 0 || !workConn.CheckClosed() {
+			break
+		} else {
+			log.Warn("ProxyName [%s], connection got from pool, but it's already closed", p.Name)
+		}
+	}
+	return
+}
+
+func (p *ProxyServer) connectionPoolManager(closeCh <-chan struct{}) {
+	for {
+		// check if we need more work connections and send messages to frpc to get more
+		time.Sleep(time.Duration(2) * time.Second)
+		select {
+		// if the channel closed, it means the proxy is closed, so just return
+		case <-closeCh:
+			log.Info("ProxyName [%s], connectionPoolManager exit", p.Name)
+			return
+		default:
+			curWorkConnNum := int64(len(p.workConnChan))
+			diff := p.PoolCount - curWorkConnNum
+			if diff > 0 {
+				if diff < p.PoolCount/5 {
+					diff = p.PoolCount*4/5 + 1
+				} else if diff < p.PoolCount/2 {
+					diff = p.PoolCount/4 + 1
+				} else if diff < p.PoolCount*4/5 {
+					diff = p.PoolCount/5 + 1
+				} else {
+					diff = p.PoolCount/10 + 1
+				}
+				if diff+curWorkConnNum > p.PoolCount {
+					diff = p.PoolCount - curWorkConnNum
+				}
+				for i := 0; i < int(diff); i++ {
+					p.ctlMsgChan <- 1
+				}
+			}
+		}
+	}
+}