fix by golint (#1822)

2026-01-11 22:23:12 +00:00 · 2020-05-24 17:48:37 +08:00
parent 2170c481ce
commit 8b75b8b837
80 changed files with 1315 additions and 1324 deletions
--- a/server/control.go
+++ b/server/control.go
@@ -43,42 +43,42 @@ import (

 type ControlManager struct {
 	// controls indexed by run id
-	ctlsByRunId map[string]*Control
+	ctlsByRunID map[string]*Control

 	mu sync.RWMutex
 }

 func NewControlManager() *ControlManager {
 	return &ControlManager{
-		ctlsByRunId: make(map[string]*Control),
+		ctlsByRunID: make(map[string]*Control),
 	}
 }

-func (cm *ControlManager) Add(runId string, ctl *Control) (oldCtl *Control) {
+func (cm *ControlManager) Add(runID string, ctl *Control) (oldCtl *Control) {
 	cm.mu.Lock()
 	defer cm.mu.Unlock()

-	oldCtl, ok := cm.ctlsByRunId[runId]
+	oldCtl, ok := cm.ctlsByRunID[runID]
 	if ok {
 		oldCtl.Replaced(ctl)
 	}
-	cm.ctlsByRunId[runId] = ctl
+	cm.ctlsByRunID[runID] = ctl
 	return
 }

 // we should make sure if it's the same control to prevent delete a new one
-func (cm *ControlManager) Del(runId string, ctl *Control) {
+func (cm *ControlManager) Del(runID string, ctl *Control) {
 	cm.mu.Lock()
 	defer cm.mu.Unlock()
-	if c, ok := cm.ctlsByRunId[runId]; ok && c == ctl {
-		delete(cm.ctlsByRunId, runId)
+	if c, ok := cm.ctlsByRunID[runID]; ok && c == ctl {
+		delete(cm.ctlsByRunID, runID)
 	}
 }

-func (cm *ControlManager) GetById(runId string) (ctl *Control, ok bool) {
+func (cm *ControlManager) GetByID(runID string) (ctl *Control, ok bool) {
 	cm.mu.RLock()
 	defer cm.mu.RUnlock()
-	ctl, ok = cm.ctlsByRunId[runId]
+	ctl, ok = cm.ctlsByRunID[runID]
 	return
 }

@@ -87,7 +87,7 @@ type Control struct {
 	rc *controller.ResourceController

 	// proxy manager
-	pxyManager *proxy.ProxyManager
+	pxyManager *proxy.Manager

 	// plugin manager
 	pluginManager *plugin.Manager
@@ -125,7 +125,7 @@ type Control struct {
 	// A new run id will be generated when a new client login.
 	// If run id got from login message has same run id, it means it's the same client, so we can
 	// replace old controller instantly.
-	runId string
+	runID string

 	// control status
 	status string
@@ -147,7 +147,7 @@ type Control struct {
 func NewControl(
 	ctx context.Context,
 	rc *controller.ResourceController,
-	pxyManager *proxy.ProxyManager,
+	pxyManager *proxy.Manager,
 	pluginManager *plugin.Manager,
 	authVerifier auth.Verifier,
 	ctlConn net.Conn,
@@ -173,7 +173,7 @@ func NewControl(
 		poolCount:       poolCount,
 		portsUsedNum:    0,
 		lastPing:        time.Now(),
-		runId:           loginMsg.RunId,
+		runID:           loginMsg.RunID,
 		status:          consts.Working,
 		readerShutdown:  shutdown.New(),
 		writerShutdown:  shutdown.New(),
@@ -189,8 +189,8 @@ func NewControl(
 func (ctl *Control) Start() {
 	loginRespMsg := &msg.LoginResp{
 		Version:       version.Full(),
-		RunId:         ctl.runId,
-		ServerUdpPort: ctl.serverCfg.BindUdpPort,
+		RunID:         ctl.runID,
+		ServerUDPPort: ctl.serverCfg.BindUDPPort,
 		Error:         "",
 	}
 	msg.WriteMsg(ctl.conn, loginRespMsg)
@@ -280,8 +280,8 @@ func (ctl *Control) GetWorkConn() (workConn net.Conn, err error) {

 func (ctl *Control) Replaced(newCtl *Control) {
 	xl := ctl.xl
-	xl.Info("Replaced by client [%s]", newCtl.runId)
-	ctl.runId = ""
+	xl.Info("Replaced by client [%s]", newCtl.runID)
+	ctl.runID = ""
 	ctl.allShutdown.Start()
 }

@@ -304,14 +304,15 @@ func (ctl *Control) writer() {
 		return
 	}
 	for {
-		if m, ok := <-ctl.sendCh; !ok {
+		m, ok := <-ctl.sendCh
+		if !ok {
 			xl.Info("control writer is closing")
 			return
-		} else {
-			if err := msg.WriteMsg(encWriter, m); err != nil {
-				xl.Warn("write message to control connection error: %v", err)
-				return
-			}
+		}
+
+		if err := msg.WriteMsg(encWriter, m); err != nil {
+			xl.Warn("write message to control connection error: %v", err)
+			return
 		}
 	}
 }
@@ -330,18 +331,18 @@ func (ctl *Control) reader() {

 	encReader := crypto.NewReader(ctl.conn, []byte(ctl.serverCfg.Token))
 	for {
-		if m, err := msg.ReadMsg(encReader); err != nil {
+		m, err := msg.ReadMsg(encReader)
+		if err != nil {
 			if err == io.EOF {
 				xl.Debug("control connection closed")
 				return
-			} else {
-				xl.Warn("read error: %v", err)
-				ctl.conn.Close()
-				return
 			}
-		} else {
-			ctl.readCh <- m
+			xl.Warn("read error: %v", err)
+			ctl.conn.Close()
+			return
 		}
+
+		ctl.readCh <- m
 	}
 }

@@ -422,7 +423,7 @@ func (ctl *Control) manager() {
 					User: plugin.UserInfo{
 						User:  ctl.loginMsg.User,
 						Metas: ctl.loginMsg.Metas,
-						RunId: ctl.loginMsg.RunId,
+						RunID: ctl.loginMsg.RunID,
 					},
 					NewProxy: *m,
 				}
@@ -454,7 +455,7 @@ func (ctl *Control) manager() {
 					User: plugin.UserInfo{
 						User:  ctl.loginMsg.User,
 						Metas: ctl.loginMsg.Metas,
-						RunId: ctl.loginMsg.RunId,
+						RunID: ctl.loginMsg.RunID,
 					},
 					Ping: *m,
 				}
@@ -490,7 +491,7 @@ func (ctl *Control) RegisterProxy(pxyMsg *msg.NewProxy) (remoteAddr string, err
 	userInfo := plugin.UserInfo{
 		User:  ctl.loginMsg.User,
 		Metas: ctl.loginMsg.Metas,
-		RunId: ctl.runId,
+		RunID: ctl.runID,
 	}

 	// NewProxy will return a interface Proxy.
--- a/server/controller/resource.go
+++ b/server/controller/resource.go
@@ -27,34 +27,34 @@ import (
 // All resource managers and controllers
 type ResourceController struct {
 	// Manage all visitor listeners
-	VisitorManager *visitor.VisitorManager
+	VisitorManager *visitor.Manager

-	// Tcp Group Controller
-	TcpGroupCtl *group.TcpGroupCtl
+	// TCP Group Controller
+	TCPGroupCtl *group.TCPGroupCtl

 	// HTTP Group Controller
 	HTTPGroupCtl *group.HTTPGroupController

 	// TCP Mux Group Controller
-	TcpMuxGroupCtl *group.TcpMuxGroupCtl
+	TCPMuxGroupCtl *group.TCPMuxGroupCtl

-	// Manage all tcp ports
-	TcpPortManager *ports.PortManager
+	// Manage all TCP ports
+	TCPPortManager *ports.Manager

-	// Manage all udp ports
-	UdpPortManager *ports.PortManager
+	// Manage all UDP ports
+	UDPPortManager *ports.Manager

-	// For http proxies, forwarding http requests
-	HttpReverseProxy *vhost.HttpReverseProxy
+	// For HTTP proxies, forwarding HTTP requests
+	HTTPReverseProxy *vhost.HTTPReverseProxy

-	// For https proxies, route requests to different clients by hostname and other information
-	VhostHttpsMuxer *vhost.HttpsMuxer
+	// For HTTPS proxies, route requests to different clients by hostname and other information
+	VhostHTTPSMuxer *vhost.HTTPSMuxer

 	// Controller for nat hole connections
-	NatHoleController *nathole.NatHoleController
+	NatHoleController *nathole.Controller

-	// TcpMux HTTP CONNECT multiplexer
-	TcpMuxHttpConnectMuxer *tcpmux.HttpConnectTcpMuxer
+	// TCPMux HTTP CONNECT multiplexer
+	TCPMuxHTTPConnectMuxer *tcpmux.HTTPConnectTCPMuxer

 	// All server manager plugin
 	PluginManager *plugin.Manager
--- a/server/dashboard.go
+++ b/server/dashboard.go
@@ -37,7 +37,7 @@ func (svr *Service) RunDashboardServer(addr string, port int) (err error) {
 	router := mux.NewRouter()

 	user, passwd := svr.cfg.DashboardUser, svr.cfg.DashboardPwd
-	router.Use(frpNet.NewHttpAuthMiddleware(user, passwd).Middleware)
+	router.Use(frpNet.NewHTTPAuthMiddleware(user, passwd).Middleware)

 	// metrics
 	if svr.cfg.EnablePrometheus {
@@ -45,14 +45,14 @@ func (svr *Service) RunDashboardServer(addr string, port int) (err error) {
 	}

 	// api, see dashboard_api.go
-	router.HandleFunc("/api/serverinfo", svr.ApiServerInfo).Methods("GET")
-	router.HandleFunc("/api/proxy/{type}", svr.ApiProxyByType).Methods("GET")
-	router.HandleFunc("/api/proxy/{type}/{name}", svr.ApiProxyByTypeAndName).Methods("GET")
-	router.HandleFunc("/api/traffic/{name}", svr.ApiProxyTraffic).Methods("GET")
+	router.HandleFunc("/api/serverinfo", svr.APIServerInfo).Methods("GET")
+	router.HandleFunc("/api/proxy/{type}", svr.APIProxyByType).Methods("GET")
+	router.HandleFunc("/api/proxy/{type}/{name}", svr.APIProxyByTypeAndName).Methods("GET")
+	router.HandleFunc("/api/traffic/{name}", svr.APIProxyTraffic).Methods("GET")

 	// view
 	router.Handle("/favicon.ico", http.FileServer(assets.FileSystem)).Methods("GET")
-	router.PathPrefix("/static/").Handler(frpNet.MakeHttpGzipHandler(http.StripPrefix("/static/", http.FileServer(assets.FileSystem)))).Methods("GET")
+	router.PathPrefix("/static/").Handler(frpNet.MakeHTTPGzipHandler(http.StripPrefix("/static/", http.FileServer(assets.FileSystem)))).Methods("GET")

 	router.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		http.Redirect(w, r, "/static/", http.StatusMovedPermanently)
--- a/server/dashboard_api.go
+++ b/server/dashboard_api.go
@@ -32,13 +32,13 @@ type GeneralResponse struct {
 	Msg  string
 }

-type ServerInfoResp struct {
+type serverInfoResp struct {
 	Version           string `json:"version"`
 	BindPort          int    `json:"bind_port"`
-	BindUdpPort       int    `json:"bind_udp_port"`
-	VhostHttpPort     int    `json:"vhost_http_port"`
-	VhostHttpsPort    int    `json:"vhost_https_port"`
-	KcpBindPort       int    `json:"kcp_bind_port"`
+	BindUDPPort       int    `json:"bind_udp_port"`
+	VhostHTTPPort     int    `json:"vhost_http_port"`
+	VhostHTTPSPort    int    `json:"vhost_https_port"`
+	KCPBindPort       int    `json:"kcp_bind_port"`
 	SubdomainHost     string `json:"subdomain_host"`
 	MaxPoolCount      int64  `json:"max_pool_count"`
 	MaxPortsPerClient int64  `json:"max_ports_per_client"`
@@ -52,7 +52,7 @@ type ServerInfoResp struct {
 }

 // api/serverinfo
-func (svr *Service) ApiServerInfo(w http.ResponseWriter, r *http.Request) {
+func (svr *Service) APIServerInfo(w http.ResponseWriter, r *http.Request) {
 	res := GeneralResponse{Code: 200}
 	defer func() {
 		log.Info("Http response [%s]: code [%d]", r.URL.Path, res.Code)
@@ -64,13 +64,13 @@ func (svr *Service) ApiServerInfo(w http.ResponseWriter, r *http.Request) {

 	log.Info("Http request: [%s]", r.URL.Path)
 	serverStats := mem.StatsCollector.GetServer()
-	svrResp := ServerInfoResp{
+	svrResp := serverInfoResp{
 		Version:           version.Full(),
 		BindPort:          svr.cfg.BindPort,
-		BindUdpPort:       svr.cfg.BindUdpPort,
-		VhostHttpPort:     svr.cfg.VhostHttpPort,
-		VhostHttpsPort:    svr.cfg.VhostHttpsPort,
-		KcpBindPort:       svr.cfg.KcpBindPort,
+		BindUDPPort:       svr.cfg.BindUDPPort,
+		VhostHTTPPort:     svr.cfg.VhostHTTPPort,
+		VhostHTTPSPort:    svr.cfg.VhostHTTPSPort,
+		KCPBindPort:       svr.cfg.KCPBindPort,
 		SubdomainHost:     svr.cfg.SubDomainHost,
 		MaxPoolCount:      svr.cfg.MaxPoolCount,
 		MaxPortsPerClient: svr.cfg.MaxPortsPerClient,
@@ -91,58 +91,58 @@ type BaseOutConf struct {
 	config.BaseProxyConf
 }

-type TcpOutConf struct {
+type TCPOutConf struct {
 	BaseOutConf
 	RemotePort int `json:"remote_port"`
 }

-type TcpMuxOutConf struct {
+type TCPMuxOutConf struct {
 	BaseOutConf
 	config.DomainConf
 	Multiplexer string `json:"multiplexer"`
 }

-type UdpOutConf struct {
+type UDPOutConf struct {
 	BaseOutConf
 	RemotePort int `json:"remote_port"`
 }

-type HttpOutConf struct {
+type HTTPOutConf struct {
 	BaseOutConf
 	config.DomainConf
 	Locations         []string `json:"locations"`
 	HostHeaderRewrite string   `json:"host_header_rewrite"`
 }

-type HttpsOutConf struct {
+type HTTPSOutConf struct {
 	BaseOutConf
 	config.DomainConf
 }

-type StcpOutConf struct {
+type STCPOutConf struct {
 	BaseOutConf
 }

-type XtcpOutConf struct {
+type XTCPOutConf struct {
 	BaseOutConf
 }

 func getConfByType(proxyType string) interface{} {
 	switch proxyType {
-	case consts.TcpProxy:
-		return &TcpOutConf{}
-	case consts.TcpMuxProxy:
-		return &TcpMuxOutConf{}
-	case consts.UdpProxy:
-		return &UdpOutConf{}
-	case consts.HttpProxy:
-		return &HttpOutConf{}
-	case consts.HttpsProxy:
-		return &HttpsOutConf{}
-	case consts.StcpProxy:
-		return &StcpOutConf{}
-	case consts.XtcpProxy:
-		return &XtcpOutConf{}
+	case consts.TCPProxy:
+		return &TCPOutConf{}
+	case consts.TCPMuxProxy:
+		return &TCPMuxOutConf{}
+	case consts.UDPProxy:
+		return &UDPOutConf{}
+	case consts.HTTPProxy:
+		return &HTTPOutConf{}
+	case consts.HTTPSProxy:
+		return &HTTPSOutConf{}
+	case consts.STCPProxy:
+		return &STCPOutConf{}
+	case consts.XTCPProxy:
+		return &XTCPOutConf{}
 	default:
 		return nil
 	}
@@ -165,7 +165,7 @@ type GetProxyInfoResp struct {
 }

 // api/proxy/:type
-func (svr *Service) ApiProxyByType(w http.ResponseWriter, r *http.Request) {
+func (svr *Service) APIProxyByType(w http.ResponseWriter, r *http.Request) {
 	res := GeneralResponse{Code: 200}
 	params := mux.Vars(r)
 	proxyType := params["type"]
@@ -230,7 +230,7 @@ type GetProxyStatsResp struct {
 }

 // api/proxy/:type/:name
-func (svr *Service) ApiProxyByTypeAndName(w http.ResponseWriter, r *http.Request) {
+func (svr *Service) APIProxyByTypeAndName(w http.ResponseWriter, r *http.Request) {
 	res := GeneralResponse{Code: 200}
 	params := mux.Vars(r)
 	proxyType := params["type"]
@@ -299,7 +299,7 @@ type GetProxyTrafficResp struct {
 	TrafficOut []int64 `json:"traffic_out"`
 }

-func (svr *Service) ApiProxyTraffic(w http.ResponseWriter, r *http.Request) {
+func (svr *Service) APIProxyTraffic(w http.ResponseWriter, r *http.Request) {
 	res := GeneralResponse{Code: 200}
 	params := mux.Vars(r)
 	name := params["name"]
@@ -321,10 +321,9 @@ func (svr *Service) ApiProxyTraffic(w http.ResponseWriter, r *http.Request) {
 		res.Code = 404
 		res.Msg = "no proxy info found"
 		return
-	} else {
-		trafficResp.TrafficIn = proxyTrafficInfo.TrafficIn
-		trafficResp.TrafficOut = proxyTrafficInfo.TrafficOut
 	}
+	trafficResp.TrafficIn = proxyTrafficInfo.TrafficIn
+	trafficResp.TrafficOut = proxyTrafficInfo.TrafficOut

 	buf, _ := json.Marshal(&trafficResp)
 	res.Msg = string(buf)
--- a/server/group/http.go
+++ b/server/group/http.go
@@ -12,12 +12,12 @@ import (
 type HTTPGroupController struct {
 	groups map[string]*HTTPGroup

-	vhostRouter *vhost.VhostRouters
+	vhostRouter *vhost.Routers

 	mu sync.Mutex
 }

-func NewHTTPGroupController(vhostRouter *vhost.VhostRouters) *HTTPGroupController {
+func NewHTTPGroupController(vhostRouter *vhost.Routers) *HTTPGroupController {
 	return &HTTPGroupController{
 		groups:      make(map[string]*HTTPGroup),
 		vhostRouter: vhostRouter,
@@ -25,7 +25,7 @@ func NewHTTPGroupController(vhostRouter *vhost.VhostRouters) *HTTPGroupControlle
 }

 func (ctl *HTTPGroupController) Register(proxyName, group, groupKey string,
-	routeConfig vhost.VhostRouteConfig) (err error) {
+	routeConfig vhost.RouteConfig) (err error) {

 	indexKey := httpGroupIndex(group, routeConfig.Domain, routeConfig.Location)
 	ctl.mu.Lock()
@@ -76,7 +76,7 @@ func NewHTTPGroup(ctl *HTTPGroupController) *HTTPGroup {
 }

 func (g *HTTPGroup) Register(proxyName, group, groupKey string,
-	routeConfig vhost.VhostRouteConfig) (err error) {
+	routeConfig vhost.RouteConfig) (err error) {

 	g.mu.Lock()
 	defer g.mu.Unlock()
--- a/server/group/tcp.go
+++ b/server/group/tcp.go
@@ -24,32 +24,32 @@ import (
 	gerr "github.com/fatedier/golib/errors"
 )

-// TcpGroupCtl manage all TcpGroups
-type TcpGroupCtl struct {
-	groups map[string]*TcpGroup
+// TCPGroupCtl manage all TCPGroups
+type TCPGroupCtl struct {
+	groups map[string]*TCPGroup

 	// portManager is used to manage port
-	portManager *ports.PortManager
+	portManager *ports.Manager
 	mu          sync.Mutex
 }

-// NewTcpGroupCtl return a new TcpGroupCtl
-func NewTcpGroupCtl(portManager *ports.PortManager) *TcpGroupCtl {
-	return &TcpGroupCtl{
-		groups:      make(map[string]*TcpGroup),
+// NewTCPGroupCtl return a new TcpGroupCtl
+func NewTCPGroupCtl(portManager *ports.Manager) *TCPGroupCtl {
+	return &TCPGroupCtl{
+		groups:      make(map[string]*TCPGroup),
 		portManager: portManager,
 	}
 }

-// Listen is the wrapper for TcpGroup's Listen
+// Listen is the wrapper for TCPGroup's Listen
 // If there are no group, we will create one here
-func (tgc *TcpGroupCtl) Listen(proxyName string, group string, groupKey string,
+func (tgc *TCPGroupCtl) Listen(proxyName string, group string, groupKey string,
 	addr string, port int) (l net.Listener, realPort int, err error) {

 	tgc.mu.Lock()
 	tcpGroup, ok := tgc.groups[group]
 	if !ok {
-		tcpGroup = NewTcpGroup(tgc)
+		tcpGroup = NewTCPGroup(tgc)
 		tgc.groups[group] = tcpGroup
 	}
 	tgc.mu.Unlock()
@@ -57,15 +57,15 @@ func (tgc *TcpGroupCtl) Listen(proxyName string, group string, groupKey string,
 	return tcpGroup.Listen(proxyName, group, groupKey, addr, port)
 }

-// RemoveGroup remove TcpGroup from controller
-func (tgc *TcpGroupCtl) RemoveGroup(group string) {
+// RemoveGroup remove TCPGroup from controller
+func (tgc *TCPGroupCtl) RemoveGroup(group string) {
 	tgc.mu.Lock()
 	defer tgc.mu.Unlock()
 	delete(tgc.groups, group)
 }

-// TcpGroup route connections to different proxies
-type TcpGroup struct {
+// TCPGroup route connections to different proxies
+type TCPGroup struct {
 	group    string
 	groupKey string
 	addr     string
@@ -75,24 +75,24 @@ type TcpGroup struct {
 	acceptCh chan net.Conn
 	index    uint64
 	tcpLn    net.Listener
-	lns      []*TcpGroupListener
-	ctl      *TcpGroupCtl
+	lns      []*TCPGroupListener
+	ctl      *TCPGroupCtl
 	mu       sync.Mutex
 }

-// NewTcpGroup return a new TcpGroup
-func NewTcpGroup(ctl *TcpGroupCtl) *TcpGroup {
-	return &TcpGroup{
-		lns:      make([]*TcpGroupListener, 0),
+// NewTCPGroup return a new TCPGroup
+func NewTCPGroup(ctl *TCPGroupCtl) *TCPGroup {
+	return &TCPGroup{
+		lns:      make([]*TCPGroupListener, 0),
 		ctl:      ctl,
 		acceptCh: make(chan net.Conn),
 	}
 }

-// Listen will return a new TcpGroupListener
-// if TcpGroup already has a listener, just add a new TcpGroupListener to the queues
+// Listen will return a new TCPGroupListener
+// if TCPGroup already has a listener, just add a new TCPGroupListener to the queues
 // otherwise, listen on the real address
-func (tg *TcpGroup) Listen(proxyName string, group string, groupKey string, addr string, port int) (ln *TcpGroupListener, realPort int, err error) {
+func (tg *TCPGroup) Listen(proxyName string, group string, groupKey string, addr string, port int) (ln *TCPGroupListener, realPort int, err error) {
 	tg.mu.Lock()
 	defer tg.mu.Unlock()
 	if len(tg.lns) == 0 {
@@ -106,7 +106,7 @@ func (tg *TcpGroup) Listen(proxyName string, group string, groupKey string, addr
 			err = errRet
 			return
 		}
-		ln = newTcpGroupListener(group, tg, tcpLn.Addr())
+		ln = newTCPGroupListener(group, tg, tcpLn.Addr())

 		tg.group = group
 		tg.groupKey = groupKey
@@ -133,7 +133,7 @@ func (tg *TcpGroup) Listen(proxyName string, group string, groupKey string, addr
 			err = ErrGroupAuthFailed
 			return
 		}
-		ln = newTcpGroupListener(group, tg, tg.lns[0].Addr())
+		ln = newTCPGroupListener(group, tg, tg.lns[0].Addr())
 		realPort = tg.realPort
 		tg.lns = append(tg.lns, ln)
 	}
@@ -141,7 +141,7 @@ func (tg *TcpGroup) Listen(proxyName string, group string, groupKey string, addr
 }

 // worker is called when the real tcp listener has been created
-func (tg *TcpGroup) worker() {
+func (tg *TCPGroup) worker() {
 	for {
 		c, err := tg.tcpLn.Accept()
 		if err != nil {
@@ -156,12 +156,12 @@ func (tg *TcpGroup) worker() {
 	}
 }

-func (tg *TcpGroup) Accept() <-chan net.Conn {
+func (tg *TCPGroup) Accept() <-chan net.Conn {
 	return tg.acceptCh
 }

-// CloseListener remove the TcpGroupListener from the TcpGroup
-func (tg *TcpGroup) CloseListener(ln *TcpGroupListener) {
+// CloseListener remove the TCPGroupListener from the TCPGroup
+func (tg *TCPGroup) CloseListener(ln *TCPGroupListener) {
 	tg.mu.Lock()
 	defer tg.mu.Unlock()
 	for i, tmpLn := range tg.lns {
@@ -178,17 +178,17 @@ func (tg *TcpGroup) CloseListener(ln *TcpGroupListener) {
 	}
 }

-// TcpGroupListener
-type TcpGroupListener struct {
+// TCPGroupListener
+type TCPGroupListener struct {
 	groupName string
-	group     *TcpGroup
+	group     *TCPGroup

 	addr    net.Addr
 	closeCh chan struct{}
 }

-func newTcpGroupListener(name string, group *TcpGroup, addr net.Addr) *TcpGroupListener {
-	return &TcpGroupListener{
+func newTCPGroupListener(name string, group *TCPGroup, addr net.Addr) *TCPGroupListener {
+	return &TCPGroupListener{
 		groupName: name,
 		group:     group,
 		addr:      addr,
@@ -196,8 +196,8 @@ func newTcpGroupListener(name string, group *TcpGroup, addr net.Addr) *TcpGroupL
 	}
 }

-// Accept will accept connections from TcpGroup
-func (ln *TcpGroupListener) Accept() (c net.Conn, err error) {
+// Accept will accept connections from TCPGroup
+func (ln *TCPGroupListener) Accept() (c net.Conn, err error) {
 	var ok bool
 	select {
 	case <-ln.closeCh:
@@ -210,12 +210,12 @@ func (ln *TcpGroupListener) Accept() (c net.Conn, err error) {
 	}
 }

-func (ln *TcpGroupListener) Addr() net.Addr {
+func (ln *TCPGroupListener) Addr() net.Addr {
 	return ln.addr
 }

 // Close close the listener
-func (ln *TcpGroupListener) Close() (err error) {
+func (ln *TCPGroupListener) Close() (err error) {
 	close(ln.closeCh)

 	// remove self from TcpGroup
--- a/server/group/tcpmux.go
+++ b/server/group/tcpmux.go
@@ -27,53 +27,54 @@ import (
 	gerr "github.com/fatedier/golib/errors"
 )

-// TcpMuxGroupCtl manage all TcpMuxGroups
-type TcpMuxGroupCtl struct {
-	groups map[string]*TcpMuxGroup
+// TCPMuxGroupCtl manage all TCPMuxGroups
+type TCPMuxGroupCtl struct {
+	groups map[string]*TCPMuxGroup

 	// portManager is used to manage port
-	tcpMuxHttpConnectMuxer *tcpmux.HttpConnectTcpMuxer
+	tcpMuxHTTPConnectMuxer *tcpmux.HTTPConnectTCPMuxer
 	mu                     sync.Mutex
 }

-// NewTcpMuxGroupCtl return a new TcpMuxGroupCtl
-func NewTcpMuxGroupCtl(tcpMuxHttpConnectMuxer *tcpmux.HttpConnectTcpMuxer) *TcpMuxGroupCtl {
-	return &TcpMuxGroupCtl{
-		groups:                 make(map[string]*TcpMuxGroup),
-		tcpMuxHttpConnectMuxer: tcpMuxHttpConnectMuxer,
+// NewTCPMuxGroupCtl return a new TCPMuxGroupCtl
+func NewTCPMuxGroupCtl(tcpMuxHTTPConnectMuxer *tcpmux.HTTPConnectTCPMuxer) *TCPMuxGroupCtl {
+	return &TCPMuxGroupCtl{
+		groups:                 make(map[string]*TCPMuxGroup),
+		tcpMuxHTTPConnectMuxer: tcpMuxHTTPConnectMuxer,
 	}
 }

-// Listen is the wrapper for TcpMuxGroup's Listen
+// Listen is the wrapper for TCPMuxGroup's Listen
 // If there are no group, we will create one here
-func (tmgc *TcpMuxGroupCtl) Listen(multiplexer string, group string, groupKey string,
-	domain string, ctx context.Context) (l net.Listener, err error) {
+func (tmgc *TCPMuxGroupCtl) Listen(ctx context.Context, multiplexer string, group string, groupKey string,
+	domain string) (l net.Listener, err error) {
+
 	tmgc.mu.Lock()
 	tcpMuxGroup, ok := tmgc.groups[group]
 	if !ok {
-		tcpMuxGroup = NewTcpMuxGroup(tmgc)
+		tcpMuxGroup = NewTCPMuxGroup(tmgc)
 		tmgc.groups[group] = tcpMuxGroup
 	}
 	tmgc.mu.Unlock()

 	switch multiplexer {
-	case consts.HttpConnectTcpMultiplexer:
-		return tcpMuxGroup.HttpConnectListen(group, groupKey, domain, ctx)
+	case consts.HTTPConnectTCPMultiplexer:
+		return tcpMuxGroup.HTTPConnectListen(ctx, group, groupKey, domain)
 	default:
 		err = fmt.Errorf("unknown multiplexer [%s]", multiplexer)
 		return
 	}
 }

-// RemoveGroup remove TcpMuxGroup from controller
-func (tmgc *TcpMuxGroupCtl) RemoveGroup(group string) {
+// RemoveGroup remove TCPMuxGroup from controller
+func (tmgc *TCPMuxGroupCtl) RemoveGroup(group string) {
 	tmgc.mu.Lock()
 	defer tmgc.mu.Unlock()
 	delete(tmgc.groups, group)
 }

-// TcpMuxGroup route connections to different proxies
-type TcpMuxGroup struct {
+// TCPMuxGroup route connections to different proxies
+type TCPMuxGroup struct {
 	group    string
 	groupKey string
 	domain   string
@@ -81,36 +82,36 @@ type TcpMuxGroup struct {
 	acceptCh chan net.Conn
 	index    uint64
 	tcpMuxLn net.Listener
-	lns      []*TcpMuxGroupListener
-	ctl      *TcpMuxGroupCtl
+	lns      []*TCPMuxGroupListener
+	ctl      *TCPMuxGroupCtl
 	mu       sync.Mutex
 }

-// NewTcpMuxGroup return a new TcpMuxGroup
-func NewTcpMuxGroup(ctl *TcpMuxGroupCtl) *TcpMuxGroup {
-	return &TcpMuxGroup{
-		lns:      make([]*TcpMuxGroupListener, 0),
+// NewTCPMuxGroup return a new TCPMuxGroup
+func NewTCPMuxGroup(ctl *TCPMuxGroupCtl) *TCPMuxGroup {
+	return &TCPMuxGroup{
+		lns:      make([]*TCPMuxGroupListener, 0),
 		ctl:      ctl,
 		acceptCh: make(chan net.Conn),
 	}
 }

-// Listen will return a new TcpMuxGroupListener
-// if TcpMuxGroup already has a listener, just add a new TcpMuxGroupListener to the queues
+// Listen will return a new TCPMuxGroupListener
+// if TCPMuxGroup already has a listener, just add a new TCPMuxGroupListener to the queues
 // otherwise, listen on the real address
-func (tmg *TcpMuxGroup) HttpConnectListen(group string, groupKey string, domain string, context context.Context) (ln *TcpMuxGroupListener, err error) {
+func (tmg *TCPMuxGroup) HTTPConnectListen(ctx context.Context, group string, groupKey string, domain string) (ln *TCPMuxGroupListener, err error) {
 	tmg.mu.Lock()
 	defer tmg.mu.Unlock()
 	if len(tmg.lns) == 0 {
 		// the first listener, listen on the real address
-		routeConfig := &vhost.VhostRouteConfig{
+		routeConfig := &vhost.RouteConfig{
 			Domain: domain,
 		}
-		tcpMuxLn, errRet := tmg.ctl.tcpMuxHttpConnectMuxer.Listen(context, routeConfig)
+		tcpMuxLn, errRet := tmg.ctl.tcpMuxHTTPConnectMuxer.Listen(ctx, routeConfig)
 		if errRet != nil {
 			return nil, errRet
 		}
-		ln = newTcpMuxGroupListener(group, tmg, tcpMuxLn.Addr())
+		ln = newTCPMuxGroupListener(group, tmg, tcpMuxLn.Addr())

 		tmg.group = group
 		tmg.groupKey = groupKey
@@ -129,14 +130,14 @@ func (tmg *TcpMuxGroup) HttpConnectListen(group string, groupKey string, domain
 		if tmg.groupKey != groupKey {
 			return nil, ErrGroupAuthFailed
 		}
-		ln = newTcpMuxGroupListener(group, tmg, tmg.lns[0].Addr())
+		ln = newTCPMuxGroupListener(group, tmg, tmg.lns[0].Addr())
 		tmg.lns = append(tmg.lns, ln)
 	}
 	return
 }

-// worker is called when the real tcp listener has been created
-func (tmg *TcpMuxGroup) worker() {
+// worker is called when the real TCP listener has been created
+func (tmg *TCPMuxGroup) worker() {
 	for {
 		c, err := tmg.tcpMuxLn.Accept()
 		if err != nil {
@@ -151,12 +152,12 @@ func (tmg *TcpMuxGroup) worker() {
 	}
 }

-func (tmg *TcpMuxGroup) Accept() <-chan net.Conn {
+func (tmg *TCPMuxGroup) Accept() <-chan net.Conn {
 	return tmg.acceptCh
 }

-// CloseListener remove the TcpMuxGroupListener from the TcpMuxGroup
-func (tmg *TcpMuxGroup) CloseListener(ln *TcpMuxGroupListener) {
+// CloseListener remove the TCPMuxGroupListener from the TCPMuxGroup
+func (tmg *TCPMuxGroup) CloseListener(ln *TCPMuxGroupListener) {
 	tmg.mu.Lock()
 	defer tmg.mu.Unlock()
 	for i, tmpLn := range tmg.lns {
@@ -172,17 +173,17 @@ func (tmg *TcpMuxGroup) CloseListener(ln *TcpMuxGroupListener) {
 	}
 }

-// TcpMuxGroupListener
-type TcpMuxGroupListener struct {
+// TCPMuxGroupListener
+type TCPMuxGroupListener struct {
 	groupName string
-	group     *TcpMuxGroup
+	group     *TCPMuxGroup

 	addr    net.Addr
 	closeCh chan struct{}
 }

-func newTcpMuxGroupListener(name string, group *TcpMuxGroup, addr net.Addr) *TcpMuxGroupListener {
-	return &TcpMuxGroupListener{
+func newTCPMuxGroupListener(name string, group *TCPMuxGroup, addr net.Addr) *TCPMuxGroupListener {
+	return &TCPMuxGroupListener{
 		groupName: name,
 		group:     group,
 		addr:      addr,
@@ -190,8 +191,8 @@ func newTcpMuxGroupListener(name string, group *TcpMuxGroup, addr net.Addr) *Tcp
 	}
 }

-// Accept will accept connections from TcpMuxGroup
-func (ln *TcpMuxGroupListener) Accept() (c net.Conn, err error) {
+// Accept will accept connections from TCPMuxGroup
+func (ln *TCPMuxGroupListener) Accept() (c net.Conn, err error) {
 	var ok bool
 	select {
 	case <-ln.closeCh:
@@ -204,12 +205,12 @@ func (ln *TcpMuxGroupListener) Accept() (c net.Conn, err error) {
 	}
 }

-func (ln *TcpMuxGroupListener) Addr() net.Addr {
+func (ln *TCPMuxGroupListener) Addr() net.Addr {
 	return ln.addr
 }

 // Close close the listener
-func (ln *TcpMuxGroupListener) Close() (err error) {
+func (ln *TCPMuxGroupListener) Close() (err error) {
 	close(ln.closeCh)

 	// remove self from TcpMuxGroup
--- a/server/ports/ports.go
+++ b/server/ports/ports.go
@@ -29,7 +29,7 @@ type PortCtx struct {
 	UpdateTime time.Time
 }

-type PortManager struct {
+type Manager struct {
 	reservedPorts map[string]*PortCtx
 	usedPorts     map[int]*PortCtx
 	freePorts     map[int]struct{}
@@ -39,8 +39,8 @@ type PortManager struct {
 	mu       sync.Mutex
 }

-func NewPortManager(netType string, bindAddr string, allowPorts map[int]struct{}) *PortManager {
-	pm := &PortManager{
+func NewManager(netType string, bindAddr string, allowPorts map[int]struct{}) *Manager {
+	pm := &Manager{
 		reservedPorts: make(map[string]*PortCtx),
 		usedPorts:     make(map[int]*PortCtx),
 		freePorts:     make(map[int]struct{}),
@@ -48,7 +48,7 @@ func NewPortManager(netType string, bindAddr string, allowPorts map[int]struct{}
 		netType:       netType,
 	}
 	if len(allowPorts) > 0 {
-		for port, _ := range allowPorts {
+		for port := range allowPorts {
 			pm.freePorts[port] = struct{}{}
 		}
 	} else {
@@ -60,7 +60,7 @@ func NewPortManager(netType string, bindAddr string, allowPorts map[int]struct{}
 	return pm
 }

-func (pm *PortManager) Acquire(name string, port int) (realPort int, err error) {
+func (pm *Manager) Acquire(name string, port int) (realPort int, err error) {
 	portCtx := &PortCtx{
 		ProxyName:  name,
 		Closed:     false,
@@ -94,7 +94,7 @@ func (pm *PortManager) Acquire(name string, port int) (realPort int, err error)
 		// get random port
 		count := 0
 		maxTryTimes := 5
-		for k, _ := range pm.freePorts {
+		for k := range pm.freePorts {
 			count++
 			if count > maxTryTimes {
 				break
@@ -132,7 +132,7 @@ func (pm *PortManager) Acquire(name string, port int) (realPort int, err error)
 	return
 }

-func (pm *PortManager) isPortAvailable(port int) bool {
+func (pm *Manager) isPortAvailable(port int) bool {
 	if pm.netType == "udp" {
 		addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", pm.bindAddr, port))
 		if err != nil {
@@ -144,17 +144,17 @@ func (pm *PortManager) isPortAvailable(port int) bool {
 		}
 		l.Close()
 		return true
-	} else {
-		l, err := net.Listen(pm.netType, fmt.Sprintf("%s:%d", pm.bindAddr, port))
-		if err != nil {
-			return false
-		}
-		l.Close()
-		return true
 	}
+
+	l, err := net.Listen(pm.netType, fmt.Sprintf("%s:%d", pm.bindAddr, port))
+	if err != nil {
+		return false
+	}
+	l.Close()
+	return true
 }

-func (pm *PortManager) Release(port int) {
+func (pm *Manager) Release(port int) {
 	pm.mu.Lock()
 	defer pm.mu.Unlock()
 	if ctx, ok := pm.usedPorts[port]; ok {
@@ -166,7 +166,7 @@ func (pm *PortManager) Release(port int) {
 }

 // Release reserved port if it isn't used in last 24 hours.
-func (pm *PortManager) cleanReservedPortsWorker() {
+func (pm *Manager) cleanReservedPortsWorker() {
 	for {
 		time.Sleep(CleanReservedPortsInterval)
 		pm.mu.Lock()
--- a/server/proxy/http.go
+++ b/server/proxy/http.go
@@ -28,20 +28,20 @@ import (
 	frpIo "github.com/fatedier/golib/io"
 )

-type HttpProxy struct {
+type HTTPProxy struct {
 	*BaseProxy
-	cfg *config.HttpProxyConf
+	cfg *config.HTTPProxyConf

 	closeFuncs []func()
 }

-func (pxy *HttpProxy) Run() (remoteAddr string, err error) {
+func (pxy *HTTPProxy) Run() (remoteAddr string, err error) {
 	xl := pxy.xl
-	routeConfig := vhost.VhostRouteConfig{
+	routeConfig := vhost.RouteConfig{
 		RewriteHost:  pxy.cfg.HostHeaderRewrite,
 		Headers:      pxy.cfg.Headers,
-		Username:     pxy.cfg.HttpUser,
-		Password:     pxy.cfg.HttpPwd,
+		Username:     pxy.cfg.HTTPUser,
+		Password:     pxy.cfg.HTTPPwd,
 		CreateConnFn: pxy.GetRealConn,
 	}

@@ -80,15 +80,15 @@ func (pxy *HttpProxy) Run() (remoteAddr string, err error) {
 				})
 			} else {
 				// no group
-				err = pxy.rc.HttpReverseProxy.Register(routeConfig)
+				err = pxy.rc.HTTPReverseProxy.Register(routeConfig)
 				if err != nil {
 					return
 				}
 				pxy.closeFuncs = append(pxy.closeFuncs, func() {
-					pxy.rc.HttpReverseProxy.UnRegister(tmpDomain, tmpLocation)
+					pxy.rc.HTTPReverseProxy.UnRegister(tmpDomain, tmpLocation)
 				})
 			}
-			addrs = append(addrs, util.CanonicalAddr(routeConfig.Domain, int(pxy.serverCfg.VhostHttpPort)))
+			addrs = append(addrs, util.CanonicalAddr(routeConfig.Domain, int(pxy.serverCfg.VhostHTTPPort)))
 			xl.Info("http proxy listen for host [%s] location [%s] group [%s]", routeConfig.Domain, routeConfig.Location, pxy.cfg.Group)
 		}
 	}
@@ -111,15 +111,15 @@ func (pxy *HttpProxy) Run() (remoteAddr string, err error) {
 					pxy.rc.HTTPGroupCtl.UnRegister(pxy.name, pxy.cfg.Group, tmpDomain, tmpLocation)
 				})
 			} else {
-				err = pxy.rc.HttpReverseProxy.Register(routeConfig)
+				err = pxy.rc.HTTPReverseProxy.Register(routeConfig)
 				if err != nil {
 					return
 				}
 				pxy.closeFuncs = append(pxy.closeFuncs, func() {
-					pxy.rc.HttpReverseProxy.UnRegister(tmpDomain, tmpLocation)
+					pxy.rc.HTTPReverseProxy.UnRegister(tmpDomain, tmpLocation)
 				})
 			}
-			addrs = append(addrs, util.CanonicalAddr(tmpDomain, pxy.serverCfg.VhostHttpPort))
+			addrs = append(addrs, util.CanonicalAddr(tmpDomain, pxy.serverCfg.VhostHTTPPort))

 			xl.Info("http proxy listen for host [%s] location [%s] group [%s]", routeConfig.Domain, routeConfig.Location, pxy.cfg.Group)
 		}
@@ -128,11 +128,11 @@ func (pxy *HttpProxy) Run() (remoteAddr string, err error) {
 	return
 }

-func (pxy *HttpProxy) GetConf() config.ProxyConf {
+func (pxy *HTTPProxy) GetConf() config.ProxyConf {
 	return pxy.cfg
 }

-func (pxy *HttpProxy) GetRealConn(remoteAddr string) (workConn net.Conn, err error) {
+func (pxy *HTTPProxy) GetRealConn(remoteAddr string) (workConn net.Conn, err error) {
 	xl := pxy.xl
 	rAddr, errRet := net.ResolveTCPAddr("tcp", remoteAddr)
 	if errRet != nil {
@@ -163,7 +163,7 @@ func (pxy *HttpProxy) GetRealConn(remoteAddr string) (workConn net.Conn, err err
 	return
 }

-func (pxy *HttpProxy) updateStatsAfterClosedConn(totalRead, totalWrite int64) {
+func (pxy *HTTPProxy) updateStatsAfterClosedConn(totalRead, totalWrite int64) {
 	name := pxy.GetName()
 	proxyType := pxy.GetConf().GetBaseInfo().ProxyType
 	metrics.Server.CloseConnection(name, proxyType)
@@ -171,7 +171,7 @@ func (pxy *HttpProxy) updateStatsAfterClosedConn(totalRead, totalWrite int64) {
 	metrics.Server.AddTrafficOut(name, proxyType, totalRead)
 }

-func (pxy *HttpProxy) Close() {
+func (pxy *HTTPProxy) Close() {
 	pxy.BaseProxy.Close()
 	for _, closeFn := range pxy.closeFuncs {
 		closeFn()
--- a/server/proxy/https.go
+++ b/server/proxy/https.go
@@ -22,14 +22,14 @@ import (
 	"github.com/fatedier/frp/utils/vhost"
 )

-type HttpsProxy struct {
+type HTTPSProxy struct {
 	*BaseProxy
-	cfg *config.HttpsProxyConf
+	cfg *config.HTTPSProxyConf
 }

-func (pxy *HttpsProxy) Run() (remoteAddr string, err error) {
+func (pxy *HTTPSProxy) Run() (remoteAddr string, err error) {
 	xl := pxy.xl
-	routeConfig := &vhost.VhostRouteConfig{}
+	routeConfig := &vhost.RouteConfig{}

 	defer func() {
 		if err != nil {
@@ -43,37 +43,37 @@ func (pxy *HttpsProxy) Run() (remoteAddr string, err error) {
 		}

 		routeConfig.Domain = domain
-		l, errRet := pxy.rc.VhostHttpsMuxer.Listen(pxy.ctx, routeConfig)
+		l, errRet := pxy.rc.VhostHTTPSMuxer.Listen(pxy.ctx, routeConfig)
 		if errRet != nil {
 			err = errRet
 			return
 		}
 		xl.Info("https proxy listen for host [%s]", routeConfig.Domain)
 		pxy.listeners = append(pxy.listeners, l)
-		addrs = append(addrs, util.CanonicalAddr(routeConfig.Domain, pxy.serverCfg.VhostHttpsPort))
+		addrs = append(addrs, util.CanonicalAddr(routeConfig.Domain, pxy.serverCfg.VhostHTTPSPort))
 	}

 	if pxy.cfg.SubDomain != "" {
 		routeConfig.Domain = pxy.cfg.SubDomain + "." + pxy.serverCfg.SubDomainHost
-		l, errRet := pxy.rc.VhostHttpsMuxer.Listen(pxy.ctx, routeConfig)
+		l, errRet := pxy.rc.VhostHTTPSMuxer.Listen(pxy.ctx, routeConfig)
 		if errRet != nil {
 			err = errRet
 			return
 		}
 		xl.Info("https proxy listen for host [%s]", routeConfig.Domain)
 		pxy.listeners = append(pxy.listeners, l)
-		addrs = append(addrs, util.CanonicalAddr(routeConfig.Domain, int(pxy.serverCfg.VhostHttpsPort)))
+		addrs = append(addrs, util.CanonicalAddr(routeConfig.Domain, int(pxy.serverCfg.VhostHTTPSPort)))
 	}

-	pxy.startListenHandler(pxy, HandleUserTcpConnection)
+	pxy.startListenHandler(pxy, HandleUserTCPConnection)
 	remoteAddr = strings.Join(addrs, ",")
 	return
 }

-func (pxy *HttpsProxy) GetConf() config.ProxyConf {
+func (pxy *HTTPSProxy) GetConf() config.ProxyConf {
 	return pxy.cfg
 }

-func (pxy *HttpsProxy) Close() {
+func (pxy *HTTPSProxy) Close() {
 	pxy.BaseProxy.Close()
 }
--- a/server/proxy/proxy.go
+++ b/server/proxy/proxy.go
@@ -102,7 +102,7 @@ func (pxy *BaseProxy) GetWorkConnFromPool(src, dst net.Addr) (workConn net.Conn,
 		}
 		xl.Info("get a new work connection: [%s]", workConn.RemoteAddr().String())
 		xl.Spawn().AppendPrefix(pxy.GetName())
-		workConn = frpNet.NewContextConn(workConn, pxy.ctx)
+		workConn = frpNet.NewContextConn(pxy.ctx, workConn)

 		var (
 			srcAddr    string
@@ -182,45 +182,45 @@ func NewProxy(ctx context.Context, userInfo plugin.UserInfo, rc *controller.Reso
 		userInfo:      userInfo,
 	}
 	switch cfg := pxyConf.(type) {
-	case *config.TcpProxyConf:
+	case *config.TCPProxyConf:
 		basePxy.usedPortsNum = 1
-		pxy = &TcpProxy{
+		pxy = &TCPProxy{
 			BaseProxy: &basePxy,
 			cfg:       cfg,
 		}
-	case *config.TcpMuxProxyConf:
-		pxy = &TcpMuxProxy{
+	case *config.TCPMuxProxyConf:
+		pxy = &TCPMuxProxy{
 			BaseProxy: &basePxy,
 			cfg:       cfg,
 		}
-	case *config.HttpProxyConf:
-		pxy = &HttpProxy{
+	case *config.HTTPProxyConf:
+		pxy = &HTTPProxy{
 			BaseProxy: &basePxy,
 			cfg:       cfg,
 		}
-	case *config.HttpsProxyConf:
-		pxy = &HttpsProxy{
+	case *config.HTTPSProxyConf:
+		pxy = &HTTPSProxy{
 			BaseProxy: &basePxy,
 			cfg:       cfg,
 		}
-	case *config.UdpProxyConf:
+	case *config.UDPProxyConf:
 		basePxy.usedPortsNum = 1
-		pxy = &UdpProxy{
+		pxy = &UDPProxy{
 			BaseProxy: &basePxy,
 			cfg:       cfg,
 		}
-	case *config.StcpProxyConf:
-		pxy = &StcpProxy{
+	case *config.STCPProxyConf:
+		pxy = &STCPProxy{
 			BaseProxy: &basePxy,
 			cfg:       cfg,
 		}
-	case *config.XtcpProxyConf:
-		pxy = &XtcpProxy{
+	case *config.XTCPProxyConf:
+		pxy = &XTCPProxy{
 			BaseProxy: &basePxy,
 			cfg:       cfg,
 		}
-	case *config.SudpProxyConf:
-		pxy = &SudpProxy{
+	case *config.SUDPProxyConf:
+		pxy = &SUDPProxy{
 			BaseProxy: &basePxy,
 			cfg:       cfg,
 		}
@@ -230,9 +230,9 @@ func NewProxy(ctx context.Context, userInfo plugin.UserInfo, rc *controller.Reso
 	return
 }

-// HandleUserTcpConnection is used for incoming tcp user connections.
+// HandleUserTCPConnection is used for incoming user TCP connections.
 // It can be used for tcp, http, https type.
-func HandleUserTcpConnection(pxy Proxy, userConn net.Conn, serverCfg config.ServerCommonConf) {
+func HandleUserTCPConnection(pxy Proxy, userConn net.Conn, serverCfg config.ServerCommonConf) {
 	xl := xlog.FromContextSafe(pxy.Context())
 	defer userConn.Close()

@@ -283,20 +283,20 @@ func HandleUserTcpConnection(pxy Proxy, userConn net.Conn, serverCfg config.Serv
 	xl.Debug("join connections closed")
 }

-type ProxyManager struct {
+type Manager struct {
 	// proxies indexed by proxy name
 	pxys map[string]Proxy

 	mu sync.RWMutex
 }

-func NewProxyManager() *ProxyManager {
-	return &ProxyManager{
+func NewManager() *Manager {
+	return &Manager{
 		pxys: make(map[string]Proxy),
 	}
 }

-func (pm *ProxyManager) Add(name string, pxy Proxy) error {
+func (pm *Manager) Add(name string, pxy Proxy) error {
 	pm.mu.Lock()
 	defer pm.mu.Unlock()
 	if _, ok := pm.pxys[name]; ok {
@@ -307,13 +307,13 @@ func (pm *ProxyManager) Add(name string, pxy Proxy) error {
 	return nil
 }

-func (pm *ProxyManager) Del(name string) {
+func (pm *Manager) Del(name string) {
 	pm.mu.Lock()
 	defer pm.mu.Unlock()
 	delete(pm.pxys, name)
 }

-func (pm *ProxyManager) GetByName(name string) (pxy Proxy, ok bool) {
+func (pm *Manager) GetByName(name string) (pxy Proxy, ok bool) {
 	pm.mu.RLock()
 	defer pm.mu.RUnlock()
 	pxy, ok = pm.pxys[name]
--- a/server/proxy/stcp.go
+++ b/server/proxy/stcp.go
@@ -18,12 +18,12 @@ import (
 	"github.com/fatedier/frp/models/config"
 )

-type StcpProxy struct {
+type STCPProxy struct {
 	*BaseProxy
-	cfg *config.StcpProxyConf
+	cfg *config.STCPProxyConf
 }

-func (pxy *StcpProxy) Run() (remoteAddr string, err error) {
+func (pxy *STCPProxy) Run() (remoteAddr string, err error) {
 	xl := pxy.xl
 	listener, errRet := pxy.rc.VisitorManager.Listen(pxy.GetName(), pxy.cfg.Sk)
 	if errRet != nil {
@@ -33,15 +33,15 @@ func (pxy *StcpProxy) Run() (remoteAddr string, err error) {
 	pxy.listeners = append(pxy.listeners, listener)
 	xl.Info("stcp proxy custom listen success")

-	pxy.startListenHandler(pxy, HandleUserTcpConnection)
+	pxy.startListenHandler(pxy, HandleUserTCPConnection)
 	return
 }

-func (pxy *StcpProxy) GetConf() config.ProxyConf {
+func (pxy *STCPProxy) GetConf() config.ProxyConf {
 	return pxy.cfg
 }

-func (pxy *StcpProxy) Close() {
+func (pxy *STCPProxy) Close() {
 	pxy.BaseProxy.Close()
 	pxy.rc.VisitorManager.CloseListener(pxy.GetName())
 }
--- a/server/proxy/sudp.go
+++ b/server/proxy/sudp.go
@@ -18,12 +18,12 @@ import (
 	"github.com/fatedier/frp/models/config"
 )

-type SudpProxy struct {
+type SUDPProxy struct {
 	*BaseProxy
-	cfg *config.SudpProxyConf
+	cfg *config.SUDPProxyConf
 }

-func (pxy *SudpProxy) Run() (remoteAddr string, err error) {
+func (pxy *SUDPProxy) Run() (remoteAddr string, err error) {
 	xl := pxy.xl

 	listener, errRet := pxy.rc.VisitorManager.Listen(pxy.GetName(), pxy.cfg.Sk)
@@ -34,15 +34,15 @@ func (pxy *SudpProxy) Run() (remoteAddr string, err error) {
 	pxy.listeners = append(pxy.listeners, listener)
 	xl.Info("sudp proxy custom listen success")

-	pxy.startListenHandler(pxy, HandleUserTcpConnection)
+	pxy.startListenHandler(pxy, HandleUserTCPConnection)
 	return
 }

-func (pxy *SudpProxy) GetConf() config.ProxyConf {
+func (pxy *SUDPProxy) GetConf() config.ProxyConf {
 	return pxy.cfg
 }

-func (pxy *SudpProxy) Close() {
+func (pxy *SUDPProxy) Close() {
 	pxy.BaseProxy.Close()
 	pxy.rc.VisitorManager.CloseListener(pxy.GetName())
 }
--- a/server/proxy/tcp.go
+++ b/server/proxy/tcp.go
@@ -21,17 +21,17 @@ import (
 	"github.com/fatedier/frp/models/config"
 )

-type TcpProxy struct {
+type TCPProxy struct {
 	*BaseProxy
-	cfg *config.TcpProxyConf
+	cfg *config.TCPProxyConf

 	realPort int
 }

-func (pxy *TcpProxy) Run() (remoteAddr string, err error) {
+func (pxy *TCPProxy) Run() (remoteAddr string, err error) {
 	xl := pxy.xl
 	if pxy.cfg.Group != "" {
-		l, realPort, errRet := pxy.rc.TcpGroupCtl.Listen(pxy.name, pxy.cfg.Group, pxy.cfg.GroupKey, pxy.serverCfg.ProxyBindAddr, pxy.cfg.RemotePort)
+		l, realPort, errRet := pxy.rc.TCPGroupCtl.Listen(pxy.name, pxy.cfg.Group, pxy.cfg.GroupKey, pxy.serverCfg.ProxyBindAddr, pxy.cfg.RemotePort)
 		if errRet != nil {
 			err = errRet
 			return
@@ -45,13 +45,13 @@ func (pxy *TcpProxy) Run() (remoteAddr string, err error) {
 		pxy.listeners = append(pxy.listeners, l)
 		xl.Info("tcp proxy listen port [%d] in group [%s]", pxy.cfg.RemotePort, pxy.cfg.Group)
 	} else {
-		pxy.realPort, err = pxy.rc.TcpPortManager.Acquire(pxy.name, pxy.cfg.RemotePort)
+		pxy.realPort, err = pxy.rc.TCPPortManager.Acquire(pxy.name, pxy.cfg.RemotePort)
 		if err != nil {
 			return
 		}
 		defer func() {
 			if err != nil {
-				pxy.rc.TcpPortManager.Release(pxy.realPort)
+				pxy.rc.TCPPortManager.Release(pxy.realPort)
 			}
 		}()
 		listener, errRet := net.Listen("tcp", fmt.Sprintf("%s:%d", pxy.serverCfg.ProxyBindAddr, pxy.realPort))
@@ -65,17 +65,17 @@ func (pxy *TcpProxy) Run() (remoteAddr string, err error) {

 	pxy.cfg.RemotePort = pxy.realPort
 	remoteAddr = fmt.Sprintf(":%d", pxy.realPort)
-	pxy.startListenHandler(pxy, HandleUserTcpConnection)
+	pxy.startListenHandler(pxy, HandleUserTCPConnection)
 	return
 }

-func (pxy *TcpProxy) GetConf() config.ProxyConf {
+func (pxy *TCPProxy) GetConf() config.ProxyConf {
 	return pxy.cfg
 }

-func (pxy *TcpProxy) Close() {
+func (pxy *TCPProxy) Close() {
 	pxy.BaseProxy.Close()
 	if pxy.cfg.Group == "" {
-		pxy.rc.TcpPortManager.Release(pxy.realPort)
+		pxy.rc.TCPPortManager.Release(pxy.realPort)
 	}
 }
--- a/server/proxy/tcpmux.go
+++ b/server/proxy/tcpmux.go
@@ -25,30 +25,30 @@ import (
 	"github.com/fatedier/frp/utils/vhost"
 )

-type TcpMuxProxy struct {
+type TCPMuxProxy struct {
 	*BaseProxy
-	cfg *config.TcpMuxProxyConf
+	cfg *config.TCPMuxProxyConf
 }

-func (pxy *TcpMuxProxy) httpConnectListen(domain string, addrs []string) (_ []string, err error) {
+func (pxy *TCPMuxProxy) httpConnectListen(domain string, addrs []string) (_ []string, err error) {
 	var l net.Listener
 	if pxy.cfg.Group != "" {
-		l, err = pxy.rc.TcpMuxGroupCtl.Listen(pxy.cfg.Multiplexer, pxy.cfg.Group, pxy.cfg.GroupKey, domain, pxy.ctx)
+		l, err = pxy.rc.TCPMuxGroupCtl.Listen(pxy.ctx, pxy.cfg.Multiplexer, pxy.cfg.Group, pxy.cfg.GroupKey, domain)
 	} else {
-		routeConfig := &vhost.VhostRouteConfig{
+		routeConfig := &vhost.RouteConfig{
 			Domain: domain,
 		}
-		l, err = pxy.rc.TcpMuxHttpConnectMuxer.Listen(pxy.ctx, routeConfig)
+		l, err = pxy.rc.TCPMuxHTTPConnectMuxer.Listen(pxy.ctx, routeConfig)
 	}
 	if err != nil {
 		return nil, err
 	}
 	pxy.xl.Info("tcpmux httpconnect multiplexer listens for host [%s]", domain)
 	pxy.listeners = append(pxy.listeners, l)
-	return append(addrs, util.CanonicalAddr(domain, pxy.serverCfg.TcpMuxHttpConnectPort)), nil
+	return append(addrs, util.CanonicalAddr(domain, pxy.serverCfg.TCPMuxHTTPConnectPort)), nil
 }

-func (pxy *TcpMuxProxy) httpConnectRun() (remoteAddr string, err error) {
+func (pxy *TCPMuxProxy) httpConnectRun() (remoteAddr string, err error) {
 	addrs := make([]string, 0)
 	for _, domain := range pxy.cfg.CustomDomains {
 		if domain == "" {
@@ -68,14 +68,14 @@ func (pxy *TcpMuxProxy) httpConnectRun() (remoteAddr string, err error) {
 		}
 	}

-	pxy.startListenHandler(pxy, HandleUserTcpConnection)
+	pxy.startListenHandler(pxy, HandleUserTCPConnection)
 	remoteAddr = strings.Join(addrs, ",")
 	return remoteAddr, err
 }

-func (pxy *TcpMuxProxy) Run() (remoteAddr string, err error) {
+func (pxy *TCPMuxProxy) Run() (remoteAddr string, err error) {
 	switch pxy.cfg.Multiplexer {
-	case consts.HttpConnectTcpMultiplexer:
+	case consts.HTTPConnectTCPMultiplexer:
 		remoteAddr, err = pxy.httpConnectRun()
 	default:
 		err = fmt.Errorf("unknown multiplexer [%s]", pxy.cfg.Multiplexer)
@@ -87,10 +87,10 @@ func (pxy *TcpMuxProxy) Run() (remoteAddr string, err error) {
 	return remoteAddr, err
 }

-func (pxy *TcpMuxProxy) GetConf() config.ProxyConf {
+func (pxy *TCPMuxProxy) GetConf() config.ProxyConf {
 	return pxy.cfg
 }

-func (pxy *TcpMuxProxy) Close() {
+func (pxy *TCPMuxProxy) Close() {
 	pxy.BaseProxy.Close()
 }
--- a/server/proxy/udp.go
+++ b/server/proxy/udp.go
@@ -28,9 +28,9 @@ import (
 	"github.com/fatedier/golib/errors"
 )

-type UdpProxy struct {
+type UDPProxy struct {
 	*BaseProxy
-	cfg *config.UdpProxyConf
+	cfg *config.UDPProxyConf

 	realPort int

@@ -42,10 +42,10 @@ type UdpProxy struct {
 	workConn net.Conn

 	// sendCh is used for sending packages to workConn
-	sendCh chan *msg.UdpPacket
+	sendCh chan *msg.UDPPacket

 	// readCh is used for reading packages from workConn
-	readCh chan *msg.UdpPacket
+	readCh chan *msg.UDPPacket

 	// checkCloseCh is used for watching if workConn is closed
 	checkCloseCh chan int
@@ -53,15 +53,15 @@ type UdpProxy struct {
 	isClosed bool
 }

-func (pxy *UdpProxy) Run() (remoteAddr string, err error) {
+func (pxy *UDPProxy) Run() (remoteAddr string, err error) {
 	xl := pxy.xl
-	pxy.realPort, err = pxy.rc.UdpPortManager.Acquire(pxy.name, pxy.cfg.RemotePort)
+	pxy.realPort, err = pxy.rc.UDPPortManager.Acquire(pxy.name, pxy.cfg.RemotePort)
 	if err != nil {
 		return
 	}
 	defer func() {
 		if err != nil {
-			pxy.rc.UdpPortManager.Release(pxy.realPort)
+			pxy.rc.UDPPortManager.Release(pxy.realPort)
 		}
 	}()

@@ -81,8 +81,8 @@ func (pxy *UdpProxy) Run() (remoteAddr string, err error) {
 	xl.Info("udp proxy listen port [%d]", pxy.cfg.RemotePort)

 	pxy.udpConn = udpConn
-	pxy.sendCh = make(chan *msg.UdpPacket, 1024)
-	pxy.readCh = make(chan *msg.UdpPacket, 1024)
+	pxy.sendCh = make(chan *msg.UDPPacket, 1024)
+	pxy.readCh = make(chan *msg.UDPPacket, 1024)
 	pxy.checkCloseCh = make(chan int)

 	// read message from workConn, if it returns any error, notify proxy to start a new workConn
@@ -110,7 +110,7 @@ func (pxy *UdpProxy) Run() (remoteAddr string, err error) {
 			case *msg.Ping:
 				xl.Trace("udp work conn get ping message")
 				continue
-			case *msg.UdpPacket:
+			case *msg.UDPPacket:
 				if errRet := errors.PanicToError(func() {
 					xl.Trace("get udp message from workConn: %s", m.Content)
 					pxy.readCh <- m
@@ -142,15 +142,14 @@ func (pxy *UdpProxy) Run() (remoteAddr string, err error) {
 					xl.Info("sender goroutine for udp work connection closed: %v", errRet)
 					conn.Close()
 					return
-				} else {
-					xl.Trace("send message to udp workConn: %s", udpMsg.Content)
-					metrics.Server.AddTrafficIn(
-						pxy.GetName(),
-						pxy.GetConf().GetBaseInfo().ProxyType,
-						int64(len(udpMsg.Content)),
-					)
-					continue
 				}
+				xl.Trace("send message to udp workConn: %s", udpMsg.Content)
+				metrics.Server.AddTrafficIn(
+					pxy.GetName(),
+					pxy.GetConf().GetBaseInfo().ProxyType,
+					int64(len(udpMsg.Content)),
+				)
+				continue
 			case <-ctx.Done():
 				xl.Info("sender goroutine for udp work connection closed")
 				return
@@ -196,17 +195,17 @@ func (pxy *UdpProxy) Run() (remoteAddr string, err error) {
 	// Response will be wrapped to be forwarded by work connection to server.
 	// Close readCh and sendCh at the end.
 	go func() {
-		udp.ForwardUserConn(udpConn, pxy.readCh, pxy.sendCh, int(pxy.serverCfg.UdpPacketSize))
+		udp.ForwardUserConn(udpConn, pxy.readCh, pxy.sendCh, int(pxy.serverCfg.UDPPacketSize))
 		pxy.Close()
 	}()
 	return remoteAddr, nil
 }

-func (pxy *UdpProxy) GetConf() config.ProxyConf {
+func (pxy *UDPProxy) GetConf() config.ProxyConf {
 	return pxy.cfg
 }

-func (pxy *UdpProxy) Close() {
+func (pxy *UDPProxy) Close() {
 	pxy.mu.Lock()
 	defer pxy.mu.Unlock()
 	if !pxy.isClosed {
@@ -223,5 +222,5 @@ func (pxy *UdpProxy) Close() {
 		close(pxy.readCh)
 		close(pxy.sendCh)
 	}
-	pxy.rc.UdpPortManager.Release(pxy.realPort)
+	pxy.rc.UDPPortManager.Release(pxy.realPort)
 }
--- a/server/proxy/xtcp.go
+++ b/server/proxy/xtcp.go
@@ -23,14 +23,14 @@ import (
 	"github.com/fatedier/golib/errors"
 )

-type XtcpProxy struct {
+type XTCPProxy struct {
 	*BaseProxy
-	cfg *config.XtcpProxyConf
+	cfg *config.XTCPProxyConf

 	closeCh chan struct{}
 }

-func (pxy *XtcpProxy) Run() (remoteAddr string, err error) {
+func (pxy *XTCPProxy) Run() (remoteAddr string, err error) {
 	xl := pxy.xl

 	if pxy.rc.NatHoleController == nil {
@@ -84,11 +84,11 @@ func (pxy *XtcpProxy) Run() (remoteAddr string, err error) {
 	return
 }

-func (pxy *XtcpProxy) GetConf() config.ProxyConf {
+func (pxy *XTCPProxy) GetConf() config.ProxyConf {
 	return pxy.cfg
 }

-func (pxy *XtcpProxy) Close() {
+func (pxy *XTCPProxy) Close() {
 	pxy.BaseProxy.Close()
 	pxy.rc.NatHoleController.CloseClient(pxy.GetName())
 	errors.PanicToError(func() {
--- a/server/service.go
+++ b/server/service.go
@@ -80,13 +80,13 @@ type Service struct {
 	ctlManager *ControlManager

 	// Manage all proxies
-	pxyManager *proxy.ProxyManager
+	pxyManager *proxy.Manager

 	// Manage all plugins
 	pluginManager *plugin.Manager

 	// HTTP vhost router
-	httpVhostRouter *vhost.VhostRouters
+	httpVhostRouter *vhost.Routers

 	// All resource managers and controllers
 	rc *controller.ResourceController
@@ -102,34 +102,34 @@ type Service struct {
 func NewService(cfg config.ServerCommonConf) (svr *Service, err error) {
 	svr = &Service{
 		ctlManager:    NewControlManager(),
-		pxyManager:    proxy.NewProxyManager(),
+		pxyManager:    proxy.NewManager(),
 		pluginManager: plugin.NewManager(),
 		rc: &controller.ResourceController{
-			VisitorManager: visitor.NewVisitorManager(),
-			TcpPortManager: ports.NewPortManager("tcp", cfg.ProxyBindAddr, cfg.AllowPorts),
-			UdpPortManager: ports.NewPortManager("udp", cfg.ProxyBindAddr, cfg.AllowPorts),
+			VisitorManager: visitor.NewManager(),
+			TCPPortManager: ports.NewManager("tcp", cfg.ProxyBindAddr, cfg.AllowPorts),
+			UDPPortManager: ports.NewManager("udp", cfg.ProxyBindAddr, cfg.AllowPorts),
 		},
-		httpVhostRouter: vhost.NewVhostRouters(),
-		authVerifier:    auth.NewAuthVerifier(cfg.AuthServerConfig),
+		httpVhostRouter: vhost.NewRouters(),
+		authVerifier:    auth.NewAuthVerifier(cfg.ServerConfig),
 		tlsConfig:       generateTLSConfig(),
 		cfg:             cfg,
 	}

 	// Create tcpmux httpconnect multiplexer.
-	if cfg.TcpMuxHttpConnectPort > 0 {
+	if cfg.TCPMuxHTTPConnectPort > 0 {
 		var l net.Listener
-		l, err = net.Listen("tcp", fmt.Sprintf("%s:%d", cfg.ProxyBindAddr, cfg.TcpMuxHttpConnectPort))
+		l, err = net.Listen("tcp", fmt.Sprintf("%s:%d", cfg.ProxyBindAddr, cfg.TCPMuxHTTPConnectPort))
 		if err != nil {
 			err = fmt.Errorf("Create server listener error, %v", err)
 			return
 		}

-		svr.rc.TcpMuxHttpConnectMuxer, err = tcpmux.NewHttpConnectTcpMuxer(l, vhostReadWriteTimeout)
+		svr.rc.TCPMuxHTTPConnectMuxer, err = tcpmux.NewHTTPConnectTCPMuxer(l, vhostReadWriteTimeout)
 		if err != nil {
 			err = fmt.Errorf("Create vhost tcpMuxer error, %v", err)
 			return
 		}
-		log.Info("tcpmux httpconnect multiplexer listen on %s:%d", cfg.ProxyBindAddr, cfg.TcpMuxHttpConnectPort)
+		log.Info("tcpmux httpconnect multiplexer listen on %s:%d", cfg.ProxyBindAddr, cfg.TCPMuxHTTPConnectPort)
 	}

 	// Init all plugins
@@ -140,13 +140,13 @@ func NewService(cfg config.ServerCommonConf) (svr *Service, err error) {
 	svr.rc.PluginManager = svr.pluginManager

 	// Init group controller
-	svr.rc.TcpGroupCtl = group.NewTcpGroupCtl(svr.rc.TcpPortManager)
+	svr.rc.TCPGroupCtl = group.NewTCPGroupCtl(svr.rc.TCPPortManager)

 	// Init HTTP group controller
 	svr.rc.HTTPGroupCtl = group.NewHTTPGroupController(svr.httpVhostRouter)

 	// Init TCP mux group controller
-	svr.rc.TcpMuxGroupCtl = group.NewTcpMuxGroupCtl(svr.rc.TcpMuxHttpConnectMuxer)
+	svr.rc.TCPMuxGroupCtl = group.NewTCPMuxGroupCtl(svr.rc.TCPMuxHTTPConnectMuxer)

 	// Init 404 not found page
 	vhost.NotFoundPagePath = cfg.Custom404Page
@@ -156,10 +156,10 @@ func NewService(cfg config.ServerCommonConf) (svr *Service, err error) {
 		httpsMuxOn bool
 	)
 	if cfg.BindAddr == cfg.ProxyBindAddr {
-		if cfg.BindPort == cfg.VhostHttpPort {
+		if cfg.BindPort == cfg.VhostHTTPPort {
 			httpMuxOn = true
 		}
-		if cfg.BindPort == cfg.VhostHttpsPort {
+		if cfg.BindPort == cfg.VhostHTTPSPort {
 			httpsMuxOn = true
 		}
 	}
@@ -179,13 +179,13 @@ func NewService(cfg config.ServerCommonConf) (svr *Service, err error) {
 	log.Info("frps tcp listen on %s:%d", cfg.BindAddr, cfg.BindPort)

 	// Listen for accepting connections from client using kcp protocol.
-	if cfg.KcpBindPort > 0 {
-		svr.kcpListener, err = frpNet.ListenKcp(cfg.BindAddr, cfg.KcpBindPort)
+	if cfg.KCPBindPort > 0 {
+		svr.kcpListener, err = frpNet.ListenKcp(cfg.BindAddr, cfg.KCPBindPort)
 		if err != nil {
-			err = fmt.Errorf("Listen on kcp address udp [%s:%d] error: %v", cfg.BindAddr, cfg.KcpBindPort, err)
+			err = fmt.Errorf("Listen on kcp address udp [%s:%d] error: %v", cfg.BindAddr, cfg.KCPBindPort, err)
 			return
 		}
-		log.Info("frps kcp listen on udp %s:%d", cfg.BindAddr, cfg.KcpBindPort)
+		log.Info("frps kcp listen on udp %s:%d", cfg.BindAddr, cfg.KCPBindPort)
 	}

 	// Listen for accepting connections from client using websocket protocol.
@@ -196,13 +196,13 @@ func NewService(cfg config.ServerCommonConf) (svr *Service, err error) {
 	svr.websocketListener = frpNet.NewWebsocketListener(websocketLn)

 	// Create http vhost muxer.
-	if cfg.VhostHttpPort > 0 {
-		rp := vhost.NewHttpReverseProxy(vhost.HttpReverseProxyOptions{
-			ResponseHeaderTimeoutS: cfg.VhostHttpTimeout,
+	if cfg.VhostHTTPPort > 0 {
+		rp := vhost.NewHTTPReverseProxy(vhost.HTTPReverseProxyOptions{
+			ResponseHeaderTimeoutS: cfg.VhostHTTPTimeout,
 		}, svr.httpVhostRouter)
-		svr.rc.HttpReverseProxy = rp
+		svr.rc.HTTPReverseProxy = rp

-		address := fmt.Sprintf("%s:%d", cfg.ProxyBindAddr, cfg.VhostHttpPort)
+		address := fmt.Sprintf("%s:%d", cfg.ProxyBindAddr, cfg.VhostHTTPPort)
 		server := &http.Server{
 			Addr:    address,
 			Handler: rp,
@@ -218,46 +218,46 @@ func NewService(cfg config.ServerCommonConf) (svr *Service, err error) {
 			}
 		}
 		go server.Serve(l)
-		log.Info("http service listen on %s:%d", cfg.ProxyBindAddr, cfg.VhostHttpPort)
+		log.Info("http service listen on %s:%d", cfg.ProxyBindAddr, cfg.VhostHTTPPort)
 	}

 	// Create https vhost muxer.
-	if cfg.VhostHttpsPort > 0 {
+	if cfg.VhostHTTPSPort > 0 {
 		var l net.Listener
 		if httpsMuxOn {
 			l = svr.muxer.ListenHttps(1)
 		} else {
-			l, err = net.Listen("tcp", fmt.Sprintf("%s:%d", cfg.ProxyBindAddr, cfg.VhostHttpsPort))
+			l, err = net.Listen("tcp", fmt.Sprintf("%s:%d", cfg.ProxyBindAddr, cfg.VhostHTTPSPort))
 			if err != nil {
 				err = fmt.Errorf("Create server listener error, %v", err)
 				return
 			}
 		}

-		svr.rc.VhostHttpsMuxer, err = vhost.NewHttpsMuxer(l, vhostReadWriteTimeout)
+		svr.rc.VhostHTTPSMuxer, err = vhost.NewHTTPSMuxer(l, vhostReadWriteTimeout)
 		if err != nil {
 			err = fmt.Errorf("Create vhost httpsMuxer error, %v", err)
 			return
 		}
-		log.Info("https service listen on %s:%d", cfg.ProxyBindAddr, cfg.VhostHttpsPort)
+		log.Info("https service listen on %s:%d", cfg.ProxyBindAddr, cfg.VhostHTTPSPort)
 	}

 	// frp tls listener
 	svr.tlsListener = svr.muxer.Listen(1, 1, func(data []byte) bool {
-		return int(data[0]) == frpNet.FRP_TLS_HEAD_BYTE
+		return int(data[0]) == frpNet.FRPTLSHeadByte
 	})

 	// Create nat hole controller.
-	if cfg.BindUdpPort > 0 {
-		var nc *nathole.NatHoleController
-		addr := fmt.Sprintf("%s:%d", cfg.BindAddr, cfg.BindUdpPort)
-		nc, err = nathole.NewNatHoleController(addr)
+	if cfg.BindUDPPort > 0 {
+		var nc *nathole.Controller
+		addr := fmt.Sprintf("%s:%d", cfg.BindAddr, cfg.BindUDPPort)
+		nc, err = nathole.NewController(addr)
 		if err != nil {
 			err = fmt.Errorf("Create nat hole controller error, %v", err)
 			return
 		}
 		svr.rc.NatHoleController = nc
-		log.Info("nat hole udp service listen on %s:%d", cfg.BindAddr, cfg.BindUdpPort)
+		log.Info("nat hole udp service listen on %s:%d", cfg.BindAddr, cfg.BindUDPPort)
 	}

 	var statsEnable bool
@@ -291,7 +291,7 @@ func (svr *Service) Run() {
 	if svr.rc.NatHoleController != nil {
 		go svr.rc.NatHoleController.Run()
 	}
-	if svr.cfg.KcpBindPort > 0 {
+	if svr.cfg.KCPBindPort > 0 {
 		go svr.HandleListener(svr.kcpListener)
 	}

@@ -375,11 +375,11 @@ func (svr *Service) HandleListener(l net.Listener) {
 		xl := xlog.New()
 		ctx := context.Background()

-		c = frpNet.NewContextConn(c, xlog.NewContext(ctx, xl))
+		c = frpNet.NewContextConn(xlog.NewContext(ctx, xl), c)

 		log.Trace("start check TLS connection...")
 		originConn := c
-		c, err = frpNet.CheckAndEnableTLSServerConnWithTimeout(c, svr.tlsConfig, svr.cfg.TlsOnly, connReadTimeout)
+		c, err = frpNet.CheckAndEnableTLSServerConnWithTimeout(c, svr.tlsConfig, svr.cfg.TLSOnly, connReadTimeout)
 		if err != nil {
 			log.Warn("CheckAndEnableTLSServerConnWithTimeout error: %v", err)
 			originConn.Close()
@@ -389,7 +389,7 @@ func (svr *Service) HandleListener(l net.Listener) {

 		// Start a new goroutine for dealing connections.
 		go func(ctx context.Context, frpConn net.Conn) {
-			if svr.cfg.TcpMux {
+			if svr.cfg.TCPMux {
 				fmuxCfg := fmux.DefaultConfig()
 				fmuxCfg.KeepAliveInterval = 20 * time.Second
 				fmuxCfg.LogOutput = ioutil.Discard
@@ -417,10 +417,10 @@ func (svr *Service) HandleListener(l net.Listener) {
 }

 func (svr *Service) RegisterControl(ctlConn net.Conn, loginMsg *msg.Login) (err error) {
-	// If client's RunId is empty, it's a new client, we just create a new controller.
+	// If client's RunID is empty, it's a new client, we just create a new controller.
 	// Otherwise, we check if there is one controller has the same run id. If so, we release previous controller and start new one.
-	if loginMsg.RunId == "" {
-		loginMsg.RunId, err = util.RandId()
+	if loginMsg.RunID == "" {
+		loginMsg.RunID, err = util.RandID()
 		if err != nil {
 			return
 		}
@@ -428,7 +428,7 @@ func (svr *Service) RegisterControl(ctlConn net.Conn, loginMsg *msg.Login) (err

 	ctx := frpNet.NewContextFromConn(ctlConn)
 	xl := xlog.FromContextSafe(ctx)
-	xl.AppendPrefix(loginMsg.RunId)
+	xl.AppendPrefix(loginMsg.RunID)
 	ctx = xlog.NewContext(ctx, xl)
 	xl.Info("client login info: ip [%s] version [%s] hostname [%s] os [%s] arch [%s]",
 		ctlConn.RemoteAddr().String(), loginMsg.Version, loginMsg.Hostname, loginMsg.Os, loginMsg.Arch)
@@ -445,7 +445,7 @@ func (svr *Service) RegisterControl(ctlConn net.Conn, loginMsg *msg.Login) (err
 	}

 	ctl := NewControl(ctx, svr.rc, svr.pxyManager, svr.pluginManager, svr.authVerifier, ctlConn, loginMsg, svr.cfg)
-	if oldCtl := svr.ctlManager.Add(loginMsg.RunId, ctl); oldCtl != nil {
+	if oldCtl := svr.ctlManager.Add(loginMsg.RunID, ctl); oldCtl != nil {
 		oldCtl.allShutdown.WaitDone()
 	}

@@ -457,7 +457,7 @@ func (svr *Service) RegisterControl(ctlConn net.Conn, loginMsg *msg.Login) (err
 	go func() {
 		// block until control closed
 		ctl.WaitClosed()
-		svr.ctlManager.Del(loginMsg.RunId, ctl)
+		svr.ctlManager.Del(loginMsg.RunID, ctl)
 	}()
 	return
 }
@@ -465,17 +465,17 @@ func (svr *Service) RegisterControl(ctlConn net.Conn, loginMsg *msg.Login) (err
 // RegisterWorkConn register a new work connection to control and proxies need it.
 func (svr *Service) RegisterWorkConn(workConn net.Conn, newMsg *msg.NewWorkConn) error {
 	xl := frpNet.NewLogFromConn(workConn)
-	ctl, exist := svr.ctlManager.GetById(newMsg.RunId)
+	ctl, exist := svr.ctlManager.GetByID(newMsg.RunID)
 	if !exist {
-		xl.Warn("No client control found for run id [%s]", newMsg.RunId)
-		return fmt.Errorf("no client control found for run id [%s]", newMsg.RunId)
+		xl.Warn("No client control found for run id [%s]", newMsg.RunID)
+		return fmt.Errorf("no client control found for run id [%s]", newMsg.RunID)
 	}
 	// server plugin hook
 	content := &plugin.NewWorkConnContent{
 		User: plugin.UserInfo{
 			User:  ctl.loginMsg.User,
 			Metas: ctl.loginMsg.Metas,
-			RunId: ctl.loginMsg.RunId,
+			RunID: ctl.loginMsg.RunID,
 		},
 		NewWorkConn: *newMsg,
 	}
@@ -486,11 +486,11 @@ func (svr *Service) RegisterWorkConn(workConn net.Conn, newMsg *msg.NewWorkConn)
 		err = svr.authVerifier.VerifyNewWorkConn(newMsg)
 	}
 	if err != nil {
-		xl.Warn("invalid NewWorkConn with run id [%s]", newMsg.RunId)
+		xl.Warn("invalid NewWorkConn with run id [%s]", newMsg.RunID)
 		msg.WriteMsg(workConn, &msg.StartWorkConn{
 			Error: util.GenerateResponseErrorString("invalid NewWorkConn", err, ctl.serverCfg.DetailedErrorsToClient),
 		})
-		return fmt.Errorf("invalid NewWorkConn with run id [%s]", newMsg.RunId)
+		return fmt.Errorf("invalid NewWorkConn with run id [%s]", newMsg.RunID)
 	}
 	return ctl.RegisterWorkConn(workConn)
 }
--- a/server/visitor/visitor.go
+++ b/server/visitor/visitor.go
@@ -27,21 +27,21 @@ import (
 )

 // Manager for visitor listeners.
-type VisitorManager struct {
+type Manager struct {
 	visitorListeners map[string]*frpNet.CustomListener
 	skMap            map[string]string

 	mu sync.RWMutex
 }

-func NewVisitorManager() *VisitorManager {
-	return &VisitorManager{
+func NewManager() *Manager {
+	return &Manager{
 		visitorListeners: make(map[string]*frpNet.CustomListener),
 		skMap:            make(map[string]string),
 	}
 }

-func (vm *VisitorManager) Listen(name string, sk string) (l *frpNet.CustomListener, err error) {
+func (vm *Manager) Listen(name string, sk string) (l *frpNet.CustomListener, err error) {
 	vm.mu.Lock()
 	defer vm.mu.Unlock()

@@ -56,7 +56,7 @@ func (vm *VisitorManager) Listen(name string, sk string) (l *frpNet.CustomListen
 	return
 }

-func (vm *VisitorManager) NewConn(name string, conn net.Conn, timestamp int64, signKey string,
+func (vm *Manager) NewConn(name string, conn net.Conn, timestamp int64, signKey string,
 	useEncryption bool, useCompression bool) (err error) {

 	vm.mu.RLock()
@@ -87,7 +87,7 @@ func (vm *VisitorManager) NewConn(name string, conn net.Conn, timestamp int64, s
 	return
 }

-func (vm *VisitorManager) CloseListener(name string) {
+func (vm *Manager) CloseListener(name string) {
 	vm.mu.Lock()
 	defer vm.mu.Unlock()