fix by golint (#1822)

client/admin.go

@@ -36,7 +36,7 @@ func (svr *Service) RunAdminServer(addr string, port int) (err error) {
 	router := mux.NewRouter()
 
 	user, passwd := svr.cfg.AdminUser, svr.cfg.AdminPwd
-	router.Use(frpNet.NewHttpAuthMiddleware(user, passwd).Middleware)
+	router.Use(frpNet.NewHTTPAuthMiddleware(user, passwd).Middleware)
 
 	// api, see dashboard_api.go
 	router.HandleFunc("/api/reload", svr.apiReload).Methods("GET")
@@ -46,7 +46,7 @@ func (svr *Service) RunAdminServer(addr string, port int) (err error) {
 
 	// 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)
 	})

client/admin_api.go

@@ -82,13 +82,13 @@ func (svr *Service) apiReload(w http.ResponseWriter, r *http.Request) {
 }
 
 type StatusResp struct {
-	Tcp   []ProxyStatusResp `json:"tcp"`
-	Udp   []ProxyStatusResp `json:"udp"`
-	Http  []ProxyStatusResp `json:"http"`
-	Https []ProxyStatusResp `json:"https"`
-	Stcp  []ProxyStatusResp `json:"stcp"`
-	Xtcp  []ProxyStatusResp `json:"xtcp"`
-	Sudp  []ProxyStatusResp `json:"sudp"`
+	TCP   []ProxyStatusResp `json:"tcp"`
+	UDP   []ProxyStatusResp `json:"udp"`
+	HTTP  []ProxyStatusResp `json:"http"`
+	HTTPS []ProxyStatusResp `json:"https"`
+	STCP  []ProxyStatusResp `json:"stcp"`
+	XTCP  []ProxyStatusResp `json:"xtcp"`
+	SUDP  []ProxyStatusResp `json:"sudp"`
 }
 
 type ProxyStatusResp struct {
@@ -107,17 +107,17 @@ func (a ByProxyStatusResp) Len() int           { return len(a) }
 func (a ByProxyStatusResp) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
 func (a ByProxyStatusResp) Less(i, j int) bool { return strings.Compare(a[i].Name, a[j].Name) < 0 }
 
-func NewProxyStatusResp(status *proxy.ProxyStatus, serverAddr string) ProxyStatusResp {
+func NewProxyStatusResp(status *proxy.WorkingStatus, serverAddr string) ProxyStatusResp {
 	psr := ProxyStatusResp{
 		Name:   status.Name,
 		Type:   status.Type,
-		Status: status.Status,
+		Status: status.Phase,
 		Err:    status.Err,
 	}
 	switch cfg := status.Cfg.(type) {
-	case *config.TcpProxyConf:
+	case *config.TCPProxyConf:
 		if cfg.LocalPort != 0 {
-			psr.LocalAddr = fmt.Sprintf("%s:%d", cfg.LocalIp, cfg.LocalPort)
+			psr.LocalAddr = fmt.Sprintf("%s:%d", cfg.LocalIP, cfg.LocalPort)
 		}
 		psr.Plugin = cfg.Plugin
 		if status.Err != "" {
@@ -125,40 +125,40 @@ func NewProxyStatusResp(status *proxy.ProxyStatus, serverAddr string) ProxyStatu
 		} else {
 			psr.RemoteAddr = serverAddr + status.RemoteAddr
 		}
-	case *config.UdpProxyConf:
+	case *config.UDPProxyConf:
 		if cfg.LocalPort != 0 {
-			psr.LocalAddr = fmt.Sprintf("%s:%d", cfg.LocalIp, cfg.LocalPort)
+			psr.LocalAddr = fmt.Sprintf("%s:%d", cfg.LocalIP, cfg.LocalPort)
 		}
 		if status.Err != "" {
 			psr.RemoteAddr = fmt.Sprintf("%s:%d", serverAddr, cfg.RemotePort)
 		} else {
 			psr.RemoteAddr = serverAddr + status.RemoteAddr
 		}
-	case *config.HttpProxyConf:
+	case *config.HTTPProxyConf:
 		if cfg.LocalPort != 0 {
-			psr.LocalAddr = fmt.Sprintf("%s:%d", cfg.LocalIp, cfg.LocalPort)
+			psr.LocalAddr = fmt.Sprintf("%s:%d", cfg.LocalIP, cfg.LocalPort)
 		}
 		psr.Plugin = cfg.Plugin
 		psr.RemoteAddr = status.RemoteAddr
-	case *config.HttpsProxyConf:
+	case *config.HTTPSProxyConf:
 		if cfg.LocalPort != 0 {
-			psr.LocalAddr = fmt.Sprintf("%s:%d", cfg.LocalIp, cfg.LocalPort)
+			psr.LocalAddr = fmt.Sprintf("%s:%d", cfg.LocalIP, cfg.LocalPort)
 		}
 		psr.Plugin = cfg.Plugin
 		psr.RemoteAddr = status.RemoteAddr
-	case *config.StcpProxyConf:
+	case *config.STCPProxyConf:
 		if cfg.LocalPort != 0 {
-			psr.LocalAddr = fmt.Sprintf("%s:%d", cfg.LocalIp, cfg.LocalPort)
+			psr.LocalAddr = fmt.Sprintf("%s:%d", cfg.LocalIP, cfg.LocalPort)
 		}
 		psr.Plugin = cfg.Plugin
-	case *config.XtcpProxyConf:
+	case *config.XTCPProxyConf:
 		if cfg.LocalPort != 0 {
-			psr.LocalAddr = fmt.Sprintf("%s:%d", cfg.LocalIp, cfg.LocalPort)
+			psr.LocalAddr = fmt.Sprintf("%s:%d", cfg.LocalIP, cfg.LocalPort)
 		}
 		psr.Plugin = cfg.Plugin
-	case *config.SudpProxyConf:
+	case *config.SUDPProxyConf:
 		if cfg.LocalPort != 0 {
-			psr.LocalAddr = fmt.Sprintf("%s:%d", cfg.LocalIp, cfg.LocalPort)
+			psr.LocalAddr = fmt.Sprintf("%s:%d", cfg.LocalIP, cfg.LocalPort)
 		}
 		psr.Plugin = cfg.Plugin
 	}
@@ -171,13 +171,13 @@ func (svr *Service) apiStatus(w http.ResponseWriter, r *http.Request) {
 		buf []byte
 		res StatusResp
 	)
-	res.Tcp = make([]ProxyStatusResp, 0)
-	res.Udp = make([]ProxyStatusResp, 0)
-	res.Http = make([]ProxyStatusResp, 0)
-	res.Https = make([]ProxyStatusResp, 0)
-	res.Stcp = make([]ProxyStatusResp, 0)
-	res.Xtcp = make([]ProxyStatusResp, 0)
-	res.Sudp = make([]ProxyStatusResp, 0)
+	res.TCP = make([]ProxyStatusResp, 0)
+	res.UDP = make([]ProxyStatusResp, 0)
+	res.HTTP = make([]ProxyStatusResp, 0)
+	res.HTTPS = make([]ProxyStatusResp, 0)
+	res.STCP = make([]ProxyStatusResp, 0)
+	res.XTCP = make([]ProxyStatusResp, 0)
+	res.SUDP = make([]ProxyStatusResp, 0)
 
 	log.Info("Http request [/api/status]")
 	defer func() {
@@ -190,28 +190,28 @@ func (svr *Service) apiStatus(w http.ResponseWriter, r *http.Request) {
 	for _, status := range ps {
 		switch status.Type {
 		case "tcp":
-			res.Tcp = append(res.Tcp, NewProxyStatusResp(status, svr.cfg.ServerAddr))
+			res.TCP = append(res.TCP, NewProxyStatusResp(status, svr.cfg.ServerAddr))
 		case "udp":
-			res.Udp = append(res.Udp, NewProxyStatusResp(status, svr.cfg.ServerAddr))
+			res.UDP = append(res.UDP, NewProxyStatusResp(status, svr.cfg.ServerAddr))
 		case "http":
-			res.Http = append(res.Http, NewProxyStatusResp(status, svr.cfg.ServerAddr))
+			res.HTTP = append(res.HTTP, NewProxyStatusResp(status, svr.cfg.ServerAddr))
 		case "https":
-			res.Https = append(res.Https, NewProxyStatusResp(status, svr.cfg.ServerAddr))
+			res.HTTPS = append(res.HTTPS, NewProxyStatusResp(status, svr.cfg.ServerAddr))
 		case "stcp":
-			res.Stcp = append(res.Stcp, NewProxyStatusResp(status, svr.cfg.ServerAddr))
+			res.STCP = append(res.STCP, NewProxyStatusResp(status, svr.cfg.ServerAddr))
 		case "xtcp":
-			res.Xtcp = append(res.Xtcp, NewProxyStatusResp(status, svr.cfg.ServerAddr))
+			res.XTCP = append(res.XTCP, NewProxyStatusResp(status, svr.cfg.ServerAddr))
 		case "sudp":
-			res.Sudp = append(res.Sudp, NewProxyStatusResp(status, svr.cfg.ServerAddr))
+			res.SUDP = append(res.SUDP, NewProxyStatusResp(status, svr.cfg.ServerAddr))
 		}
 	}
-	sort.Sort(ByProxyStatusResp(res.Tcp))
-	sort.Sort(ByProxyStatusResp(res.Udp))
-	sort.Sort(ByProxyStatusResp(res.Http))
-	sort.Sort(ByProxyStatusResp(res.Https))
-	sort.Sort(ByProxyStatusResp(res.Stcp))
-	sort.Sort(ByProxyStatusResp(res.Xtcp))
-	sort.Sort(ByProxyStatusResp(res.Sudp))
+	sort.Sort(ByProxyStatusResp(res.TCP))
+	sort.Sort(ByProxyStatusResp(res.UDP))
+	sort.Sort(ByProxyStatusResp(res.HTTP))
+	sort.Sort(ByProxyStatusResp(res.HTTPS))
+	sort.Sort(ByProxyStatusResp(res.STCP))
+	sort.Sort(ByProxyStatusResp(res.XTCP))
+	sort.Sort(ByProxyStatusResp(res.SUDP))
 	return
 }
 

client/control.go

@@ -38,11 +38,11 @@ import (
 
 type Control struct {
 	// uniq id got from frps, attach it in loginMsg
-	runId string
+	runID string
 
 	// manage all proxies
 	pxyCfgs map[string]config.ProxyConf
-	pm      *proxy.ProxyManager
+	pm      *proxy.Manager
 
 	// manage all visitors
 	vm *VisitorManager
@@ -88,7 +88,7 @@ type Control struct {
 	authSetter auth.Setter
 }
 
-func NewControl(ctx context.Context, runId string, conn net.Conn, session *fmux.Session,
+func NewControl(ctx context.Context, runID string, conn net.Conn, session *fmux.Session,
 	clientCfg config.ClientCommonConf,
 	pxyCfgs map[string]config.ProxyConf,
 	visitorCfgs map[string]config.VisitorConf,
@@ -97,7 +97,7 @@ func NewControl(ctx context.Context, runId string, conn net.Conn, session *fmux.
 
 	// new xlog instance
 	ctl := &Control{
-		runId:              runId,
+		runID:              runID,
 		conn:               conn,
 		session:            session,
 		pxyCfgs:            pxyCfgs,
@@ -114,7 +114,7 @@ func NewControl(ctx context.Context, runId string, conn net.Conn, session *fmux.
 		ctx:                ctx,
 		authSetter:         authSetter,
 	}
-	ctl.pm = proxy.NewProxyManager(ctl.ctx, ctl.sendCh, clientCfg, serverUDPPort)
+	ctl.pm = proxy.NewManager(ctl.ctx, ctl.sendCh, clientCfg, serverUDPPort)
 
 	ctl.vm = NewVisitorManager(ctl.ctx, ctl)
 	ctl.vm.Reload(visitorCfgs)
@@ -140,7 +140,7 @@ func (ctl *Control) HandleReqWorkConn(inMsg *msg.ReqWorkConn) {
 	}
 
 	m := &msg.NewWorkConn{
-		RunId: ctl.runId,
+		RunID: ctl.runID,
 	}
 	if err = ctl.authSetter.SetNewWorkConn(m); err != nil {
 		xl.Warn("error during NewWorkConn authentication: %v", err)
@@ -198,7 +198,7 @@ func (ctl *Control) ClosedDoneCh() <-chan struct{} {
 // connectServer return a new connection to frps
 func (ctl *Control) connectServer() (conn net.Conn, err error) {
 	xl := ctl.xl
-	if ctl.clientCfg.TcpMux {
+	if ctl.clientCfg.TCPMux {
 		stream, errRet := ctl.session.OpenStream()
 		if errRet != nil {
 			err = errRet
@@ -213,7 +213,7 @@ func (ctl *Control) connectServer() (conn net.Conn, err error) {
 				InsecureSkipVerify: true,
 			}
 		}
-		conn, err = frpNet.ConnectServerByProxyWithTLS(ctl.clientCfg.HttpProxy, ctl.clientCfg.Protocol,
+		conn, err = frpNet.ConnectServerByProxyWithTLS(ctl.clientCfg.HTTPProxy, ctl.clientCfg.Protocol,
 			fmt.Sprintf("%s:%d", ctl.clientCfg.ServerAddr, ctl.clientCfg.ServerPort), tlsConfig)
 		if err != nil {
 			xl.Warn("start new connection to server error: %v", err)
@@ -237,18 +237,17 @@ func (ctl *Control) reader() {
 
 	encReader := crypto.NewReader(ctl.conn, []byte(ctl.clientCfg.Token))
 	for {
-		if m, err := msg.ReadMsg(encReader); err != nil {
+		m, err := msg.ReadMsg(encReader)
+		if err != nil {
 			if err == io.EOF {
 				xl.Debug("read from control connection EOF")
 				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
 	}
 }
 
@@ -263,14 +262,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
 		}
 	}
 }

client/event/event.go

@@ -6,10 +6,10 @@ import (
 	"github.com/fatedier/frp/models/msg"
 )
 
-type EventType int
+type Type int
 
 const (
-	EvStartProxy EventType = iota
+	EvStartProxy Type = iota
 	EvCloseProxy
 )
 
@@ -17,7 +17,7 @@ var (
 	ErrPayloadType = errors.New("error payload type")
 )
 
-type EventHandler func(evType EventType, payload interface{}) error
+type Handler func(evType Type, payload interface{}) error
 
 type StartProxyPayload struct {
 	NewProxyMsg *msg.NewProxy

client/health/health.go

@@ -31,7 +31,7 @@ var (
 	ErrHealthCheckType = errors.New("error health check type")
 )
 
-type HealthCheckMonitor struct {
+type Monitor struct {
 	checkType      string
 	interval       time.Duration
 	timeout        time.Duration
@@ -52,10 +52,10 @@ type HealthCheckMonitor struct {
 	cancel context.CancelFunc
 }
 
-func NewHealthCheckMonitor(ctx context.Context, checkType string,
+func NewMonitor(ctx context.Context, checkType string,
 	intervalS int, timeoutS int, maxFailedTimes int,
 	addr string, url string,
-	statusNormalFn func(), statusFailedFn func()) *HealthCheckMonitor {
+	statusNormalFn func(), statusFailedFn func()) *Monitor {
 
 	if intervalS <= 0 {
 		intervalS = 10
@@ -67,7 +67,7 @@ func NewHealthCheckMonitor(ctx context.Context, checkType string,
 		maxFailedTimes = 1
 	}
 	newctx, cancel := context.WithCancel(ctx)
-	return &HealthCheckMonitor{
+	return &Monitor{
 		checkType:      checkType,
 		interval:       time.Duration(intervalS) * time.Second,
 		timeout:        time.Duration(timeoutS) * time.Second,
@@ -82,15 +82,15 @@ func NewHealthCheckMonitor(ctx context.Context, checkType string,
 	}
 }
 
-func (monitor *HealthCheckMonitor) Start() {
+func (monitor *Monitor) Start() {
 	go monitor.checkWorker()
 }
 
-func (monitor *HealthCheckMonitor) Stop() {
+func (monitor *Monitor) Stop() {
 	monitor.cancel()
 }
 
-func (monitor *HealthCheckMonitor) checkWorker() {
+func (monitor *Monitor) checkWorker() {
 	xl := xlog.FromContextSafe(monitor.ctx)
 	for {
 		doCtx, cancel := context.WithDeadline(monitor.ctx, time.Now().Add(monitor.timeout))
@@ -126,18 +126,18 @@ func (monitor *HealthCheckMonitor) checkWorker() {
 	}
 }
 
-func (monitor *HealthCheckMonitor) doCheck(ctx context.Context) error {
+func (monitor *Monitor) doCheck(ctx context.Context) error {
 	switch monitor.checkType {
 	case "tcp":
-		return monitor.doTcpCheck(ctx)
+		return monitor.doTCPCheck(ctx)
 	case "http":
-		return monitor.doHttpCheck(ctx)
+		return monitor.doHTTPCheck(ctx)
 	default:
 		return ErrHealthCheckType
 	}
 }
 
-func (monitor *HealthCheckMonitor) doTcpCheck(ctx context.Context) error {
+func (monitor *Monitor) doTCPCheck(ctx context.Context) error {
 	// if tcp address is not specified, always return nil
 	if monitor.addr == "" {
 		return nil
@@ -152,7 +152,7 @@ func (monitor *HealthCheckMonitor) doTcpCheck(ctx context.Context) error {
 	return nil
 }
 
-func (monitor *HealthCheckMonitor) doHttpCheck(ctx context.Context) error {
+func (monitor *Monitor) doHTTPCheck(ctx context.Context) error {
 	req, err := http.NewRequest("GET", monitor.url, nil)
 	if err != nil {
 		return err

client/proxy/proxy.go

@@ -67,43 +67,43 @@ func NewProxy(ctx context.Context, pxyConf config.ProxyConf, clientCfg config.Cl
 		ctx:           ctx,
 	}
 	switch cfg := pxyConf.(type) {
-	case *config.TcpProxyConf:
-		pxy = &TcpProxy{
+	case *config.TCPProxyConf:
+		pxy = &TCPProxy{
 			BaseProxy: &baseProxy,
 			cfg:       cfg,
 		}
-	case *config.TcpMuxProxyConf:
-		pxy = &TcpMuxProxy{
+	case *config.TCPMuxProxyConf:
+		pxy = &TCPMuxProxy{
 			BaseProxy: &baseProxy,
 			cfg:       cfg,
 		}
-	case *config.UdpProxyConf:
-		pxy = &UdpProxy{
+	case *config.UDPProxyConf:
+		pxy = &UDPProxy{
 			BaseProxy: &baseProxy,
 			cfg:       cfg,
 		}
-	case *config.HttpProxyConf:
-		pxy = &HttpProxy{
+	case *config.HTTPProxyConf:
+		pxy = &HTTPProxy{
 			BaseProxy: &baseProxy,
 			cfg:       cfg,
 		}
-	case *config.HttpsProxyConf:
-		pxy = &HttpsProxy{
+	case *config.HTTPSProxyConf:
+		pxy = &HTTPSProxy{
 			BaseProxy: &baseProxy,
 			cfg:       cfg,
 		}
-	case *config.StcpProxyConf:
-		pxy = &StcpProxy{
+	case *config.STCPProxyConf:
+		pxy = &STCPProxy{
 			BaseProxy: &baseProxy,
 			cfg:       cfg,
 		}
-	case *config.XtcpProxyConf:
-		pxy = &XtcpProxy{
+	case *config.XTCPProxyConf:
+		pxy = &XTCPProxy{
 			BaseProxy: &baseProxy,
 			cfg:       cfg,
 		}
-	case *config.SudpProxyConf:
-		pxy = &SudpProxy{
+	case *config.SUDPProxyConf:
+		pxy = &SUDPProxy{
 			BaseProxy: &baseProxy,
 			cfg:       cfg,
 			closeCh:   make(chan struct{}),
@@ -124,14 +124,14 @@ type BaseProxy struct {
 }
 
 // TCP
-type TcpProxy struct {
+type TCPProxy struct {
 	*BaseProxy
 
-	cfg         *config.TcpProxyConf
+	cfg         *config.TCPProxyConf
 	proxyPlugin plugin.Plugin
 }
 
-func (pxy *TcpProxy) Run() (err error) {
+func (pxy *TCPProxy) Run() (err error) {
 	if pxy.cfg.Plugin != "" {
 		pxy.proxyPlugin, err = plugin.Create(pxy.cfg.Plugin, pxy.cfg.PluginParams)
 		if err != nil {
@@ -141,26 +141,26 @@ func (pxy *TcpProxy) Run() (err error) {
 	return
 }
 
-func (pxy *TcpProxy) Close() {
+func (pxy *TCPProxy) Close() {
 	if pxy.proxyPlugin != nil {
 		pxy.proxyPlugin.Close()
 	}
 }
 
-func (pxy *TcpProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
-	HandleTcpWorkConnection(pxy.ctx, &pxy.cfg.LocalSvrConf, pxy.proxyPlugin, &pxy.cfg.BaseProxyConf, pxy.limiter,
+func (pxy *TCPProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
+	HandleTCPWorkConnection(pxy.ctx, &pxy.cfg.LocalSvrConf, pxy.proxyPlugin, &pxy.cfg.BaseProxyConf, pxy.limiter,
 		conn, []byte(pxy.clientCfg.Token), m)
 }
 
 // TCP Multiplexer
-type TcpMuxProxy struct {
+type TCPMuxProxy struct {
 	*BaseProxy
 
-	cfg         *config.TcpMuxProxyConf
+	cfg         *config.TCPMuxProxyConf
 	proxyPlugin plugin.Plugin
 }
 
-func (pxy *TcpMuxProxy) Run() (err error) {
+func (pxy *TCPMuxProxy) Run() (err error) {
 	if pxy.cfg.Plugin != "" {
 		pxy.proxyPlugin, err = plugin.Create(pxy.cfg.Plugin, pxy.cfg.PluginParams)
 		if err != nil {
@@ -170,26 +170,26 @@ func (pxy *TcpMuxProxy) Run() (err error) {
 	return
 }
 
-func (pxy *TcpMuxProxy) Close() {
+func (pxy *TCPMuxProxy) Close() {
 	if pxy.proxyPlugin != nil {
 		pxy.proxyPlugin.Close()
 	}
 }
 
-func (pxy *TcpMuxProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
-	HandleTcpWorkConnection(pxy.ctx, &pxy.cfg.LocalSvrConf, pxy.proxyPlugin, &pxy.cfg.BaseProxyConf, pxy.limiter,
+func (pxy *TCPMuxProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
+	HandleTCPWorkConnection(pxy.ctx, &pxy.cfg.LocalSvrConf, pxy.proxyPlugin, &pxy.cfg.BaseProxyConf, pxy.limiter,
 		conn, []byte(pxy.clientCfg.Token), m)
 }
 
 // HTTP
-type HttpProxy struct {
+type HTTPProxy struct {
 	*BaseProxy
 
-	cfg         *config.HttpProxyConf
+	cfg         *config.HTTPProxyConf
 	proxyPlugin plugin.Plugin
 }
 
-func (pxy *HttpProxy) Run() (err error) {
+func (pxy *HTTPProxy) Run() (err error) {
 	if pxy.cfg.Plugin != "" {
 		pxy.proxyPlugin, err = plugin.Create(pxy.cfg.Plugin, pxy.cfg.PluginParams)
 		if err != nil {
@@ -199,26 +199,26 @@ func (pxy *HttpProxy) Run() (err error) {
 	return
 }
 
-func (pxy *HttpProxy) Close() {
+func (pxy *HTTPProxy) Close() {
 	if pxy.proxyPlugin != nil {
 		pxy.proxyPlugin.Close()
 	}
 }
 
-func (pxy *HttpProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
-	HandleTcpWorkConnection(pxy.ctx, &pxy.cfg.LocalSvrConf, pxy.proxyPlugin, &pxy.cfg.BaseProxyConf, pxy.limiter,
+func (pxy *HTTPProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
+	HandleTCPWorkConnection(pxy.ctx, &pxy.cfg.LocalSvrConf, pxy.proxyPlugin, &pxy.cfg.BaseProxyConf, pxy.limiter,
 		conn, []byte(pxy.clientCfg.Token), m)
 }
 
 // HTTPS
-type HttpsProxy struct {
+type HTTPSProxy struct {
 	*BaseProxy
 
-	cfg         *config.HttpsProxyConf
+	cfg         *config.HTTPSProxyConf
 	proxyPlugin plugin.Plugin
 }
 
-func (pxy *HttpsProxy) Run() (err error) {
+func (pxy *HTTPSProxy) Run() (err error) {
 	if pxy.cfg.Plugin != "" {
 		pxy.proxyPlugin, err = plugin.Create(pxy.cfg.Plugin, pxy.cfg.PluginParams)
 		if err != nil {
@@ -228,26 +228,26 @@ func (pxy *HttpsProxy) Run() (err error) {
 	return
 }
 
-func (pxy *HttpsProxy) Close() {
+func (pxy *HTTPSProxy) Close() {
 	if pxy.proxyPlugin != nil {
 		pxy.proxyPlugin.Close()
 	}
 }
 
-func (pxy *HttpsProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
-	HandleTcpWorkConnection(pxy.ctx, &pxy.cfg.LocalSvrConf, pxy.proxyPlugin, &pxy.cfg.BaseProxyConf, pxy.limiter,
+func (pxy *HTTPSProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
+	HandleTCPWorkConnection(pxy.ctx, &pxy.cfg.LocalSvrConf, pxy.proxyPlugin, &pxy.cfg.BaseProxyConf, pxy.limiter,
 		conn, []byte(pxy.clientCfg.Token), m)
 }
 
 // STCP
-type StcpProxy struct {
+type STCPProxy struct {
 	*BaseProxy
 
-	cfg         *config.StcpProxyConf
+	cfg         *config.STCPProxyConf
 	proxyPlugin plugin.Plugin
 }
 
-func (pxy *StcpProxy) Run() (err error) {
+func (pxy *STCPProxy) Run() (err error) {
 	if pxy.cfg.Plugin != "" {
 		pxy.proxyPlugin, err = plugin.Create(pxy.cfg.Plugin, pxy.cfg.PluginParams)
 		if err != nil {
@@ -257,26 +257,26 @@ func (pxy *StcpProxy) Run() (err error) {
 	return
 }
 
-func (pxy *StcpProxy) Close() {
+func (pxy *STCPProxy) Close() {
 	if pxy.proxyPlugin != nil {
 		pxy.proxyPlugin.Close()
 	}
 }
 
-func (pxy *StcpProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
-	HandleTcpWorkConnection(pxy.ctx, &pxy.cfg.LocalSvrConf, pxy.proxyPlugin, &pxy.cfg.BaseProxyConf, pxy.limiter,
+func (pxy *STCPProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
+	HandleTCPWorkConnection(pxy.ctx, &pxy.cfg.LocalSvrConf, pxy.proxyPlugin, &pxy.cfg.BaseProxyConf, pxy.limiter,
 		conn, []byte(pxy.clientCfg.Token), m)
 }
 
 // XTCP
-type XtcpProxy struct {
+type XTCPProxy struct {
 	*BaseProxy
 
-	cfg         *config.XtcpProxyConf
+	cfg         *config.XTCPProxyConf
 	proxyPlugin plugin.Plugin
 }
 
-func (pxy *XtcpProxy) Run() (err error) {
+func (pxy *XTCPProxy) Run() (err error) {
 	if pxy.cfg.Plugin != "" {
 		pxy.proxyPlugin, err = plugin.Create(pxy.cfg.Plugin, pxy.cfg.PluginParams)
 		if err != nil {
@@ -286,13 +286,13 @@ func (pxy *XtcpProxy) Run() (err error) {
 	return
 }
 
-func (pxy *XtcpProxy) Close() {
+func (pxy *XTCPProxy) Close() {
 	if pxy.proxyPlugin != nil {
 		pxy.proxyPlugin.Close()
 	}
 }
 
-func (pxy *XtcpProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
+func (pxy *XTCPProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
 	xl := pxy.xl
 	defer conn.Close()
 	var natHoleSidMsg msg.NatHoleSid
@@ -389,7 +389,7 @@ func (pxy *XtcpProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
 
 	lConn.WriteToUDP(sidBuf[:n], uAddr)
 
-	kcpConn, err := frpNet.NewKcpConnFromUdp(lConn, false, uAddr.String())
+	kcpConn, err := frpNet.NewKCPConnFromUDP(lConn, false, uAddr.String())
 	if err != nil {
 		xl.Error("create kcp connection from udp connection error: %v", err)
 		return
@@ -410,11 +410,11 @@ func (pxy *XtcpProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
 		return
 	}
 
-	HandleTcpWorkConnection(pxy.ctx, &pxy.cfg.LocalSvrConf, pxy.proxyPlugin, &pxy.cfg.BaseProxyConf, pxy.limiter,
+	HandleTCPWorkConnection(pxy.ctx, &pxy.cfg.LocalSvrConf, pxy.proxyPlugin, &pxy.cfg.BaseProxyConf, pxy.limiter,
 		muxConn, []byte(pxy.cfg.Sk), m)
 }
 
-func (pxy *XtcpProxy) sendDetectMsg(addr string, port int, laddr *net.UDPAddr, content []byte) (err error) {
+func (pxy *XTCPProxy) sendDetectMsg(addr string, port int, laddr *net.UDPAddr, content []byte) (err error) {
 	daddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", addr, port))
 	if err != nil {
 		return err
@@ -434,28 +434,28 @@ func (pxy *XtcpProxy) sendDetectMsg(addr string, port int, laddr *net.UDPAddr, c
 }
 
 // UDP
-type UdpProxy struct {
+type UDPProxy struct {
 	*BaseProxy
 
-	cfg *config.UdpProxyConf
+	cfg *config.UDPProxyConf
 
 	localAddr *net.UDPAddr
-	readCh    chan *msg.UdpPacket
+	readCh    chan *msg.UDPPacket
 
-	// include msg.UdpPacket and msg.Ping
+	// include msg.UDPPacket and msg.Ping
 	sendCh   chan msg.Message
 	workConn net.Conn
 }
 
-func (pxy *UdpProxy) Run() (err error) {
-	pxy.localAddr, err = net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", pxy.cfg.LocalIp, pxy.cfg.LocalPort))
+func (pxy *UDPProxy) Run() (err error) {
+	pxy.localAddr, err = net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", pxy.cfg.LocalIP, pxy.cfg.LocalPort))
 	if err != nil {
 		return
 	}
 	return
 }
 
-func (pxy *UdpProxy) Close() {
+func (pxy *UDPProxy) Close() {
 	pxy.mu.Lock()
 	defer pxy.mu.Unlock()
 
@@ -473,7 +473,7 @@ func (pxy *UdpProxy) Close() {
 	}
 }
 
-func (pxy *UdpProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
+func (pxy *UDPProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
 	xl := pxy.xl
 	xl.Info("incoming a new work connection for udp proxy, %s", conn.RemoteAddr().String())
 	// close resources releated with old workConn
@@ -488,14 +488,14 @@ func (pxy *UdpProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
 
 	pxy.mu.Lock()
 	pxy.workConn = conn
-	pxy.readCh = make(chan *msg.UdpPacket, 1024)
+	pxy.readCh = make(chan *msg.UDPPacket, 1024)
 	pxy.sendCh = make(chan msg.Message, 1024)
 	pxy.closed = false
 	pxy.mu.Unlock()
 
-	workConnReaderFn := func(conn net.Conn, readCh chan *msg.UdpPacket) {
+	workConnReaderFn := func(conn net.Conn, readCh chan *msg.UDPPacket) {
 		for {
-			var udpMsg msg.UdpPacket
+			var udpMsg msg.UDPPacket
 			if errRet := msg.ReadMsgInto(conn, &udpMsg); errRet != nil {
 				xl.Warn("read from workConn for udp error: %v", errRet)
 				return
@@ -516,7 +516,7 @@ func (pxy *UdpProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
 		var errRet error
 		for rawMsg := range sendCh {
 			switch m := rawMsg.(type) {
-			case *msg.UdpPacket:
+			case *msg.UDPPacket:
 				xl.Trace("send udp package to workConn: %s", m.Content)
 			case *msg.Ping:
 				xl.Trace("send ping message to udp workConn")
@@ -543,28 +543,28 @@ func (pxy *UdpProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
 	go workConnSenderFn(pxy.workConn, pxy.sendCh)
 	go workConnReaderFn(pxy.workConn, pxy.readCh)
 	go heartbeatFn(pxy.workConn, pxy.sendCh)
-	udp.Forwarder(pxy.localAddr, pxy.readCh, pxy.sendCh, int(pxy.clientCfg.UdpPacketSize))
+	udp.Forwarder(pxy.localAddr, pxy.readCh, pxy.sendCh, int(pxy.clientCfg.UDPPacketSize))
 }
 
-type SudpProxy struct {
+type SUDPProxy struct {
 	*BaseProxy
 
-	cfg *config.SudpProxyConf
+	cfg *config.SUDPProxyConf
 
 	localAddr *net.UDPAddr
 
 	closeCh chan struct{}
 }
 
-func (pxy *SudpProxy) Run() (err error) {
-	pxy.localAddr, err = net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", pxy.cfg.LocalIp, pxy.cfg.LocalPort))
+func (pxy *SUDPProxy) Run() (err error) {
+	pxy.localAddr, err = net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", pxy.cfg.LocalIP, pxy.cfg.LocalPort))
 	if err != nil {
 		return
 	}
 	return
 }
 
-func (pxy *SudpProxy) Close() {
+func (pxy *SUDPProxy) Close() {
 	pxy.mu.Lock()
 	defer pxy.mu.Unlock()
 	select {
@@ -575,7 +575,7 @@ func (pxy *SudpProxy) Close() {
 	}
 }
 
-func (pxy *SudpProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
+func (pxy *SUDPProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
 	xl := pxy.xl
 	xl.Info("incoming a new work connection for sudp proxy, %s", conn.RemoteAddr().String())
 
@@ -587,7 +587,7 @@ func (pxy *SudpProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
 	}
 
 	workConn := conn
-	readCh := make(chan *msg.UdpPacket, 1024)
+	readCh := make(chan *msg.UDPPacket, 1024)
 	sendCh := make(chan msg.Message, 1024)
 	isClose := false
 
@@ -609,7 +609,7 @@ func (pxy *SudpProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
 	}
 
 	// udp service <- frpc <- frps <- frpc visitor <- user
-	workConnReaderFn := func(conn net.Conn, readCh chan *msg.UdpPacket) {
+	workConnReaderFn := func(conn net.Conn, readCh chan *msg.UDPPacket) {
 		defer closeFn()
 
 		for {
@@ -621,7 +621,7 @@ func (pxy *SudpProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
 			default:
 			}
 
-			var udpMsg msg.UdpPacket
+			var udpMsg msg.UDPPacket
 			if errRet := msg.ReadMsgInto(conn, &udpMsg); errRet != nil {
 				xl.Warn("read from workConn for sudp error: %v", errRet)
 				return
@@ -646,7 +646,7 @@ func (pxy *SudpProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
 		var errRet error
 		for rawMsg := range sendCh {
 			switch m := rawMsg.(type) {
-			case *msg.UdpPacket:
+			case *msg.UDPPacket:
 				xl.Trace("frpc send udp package to frpc visitor, [udp local: %v, remote: %v], [tcp work conn local: %v, remote: %v]",
 					m.LocalAddr.String(), m.RemoteAddr.String(), conn.LocalAddr().String(), conn.RemoteAddr().String())
 			case *msg.Ping:
@@ -688,11 +688,11 @@ func (pxy *SudpProxy) InWorkConn(conn net.Conn, m *msg.StartWorkConn) {
 	go workConnReaderFn(workConn, readCh)
 	go heartbeatFn(workConn, sendCh)
 
-	udp.Forwarder(pxy.localAddr, readCh, sendCh, int(pxy.clientCfg.UdpPacketSize))
+	udp.Forwarder(pxy.localAddr, readCh, sendCh, int(pxy.clientCfg.UDPPacketSize))
 }
 
 // Common handler for tcp work connections.
-func HandleTcpWorkConnection(ctx context.Context, localInfo *config.LocalSvrConf, proxyPlugin plugin.Plugin,
+func HandleTCPWorkConnection(ctx context.Context, localInfo *config.LocalSvrConf, proxyPlugin plugin.Plugin,
 	baseInfo *config.BaseProxyConf, limiter *rate.Limiter, workConn net.Conn, encKey []byte, m *msg.StartWorkConn) {
 	xl := xlog.FromContextSafe(ctx)
 	var (
@@ -759,22 +759,22 @@ func HandleTcpWorkConnection(ctx context.Context, localInfo *config.LocalSvrConf
 		proxyPlugin.Handle(remote, workConn, extraInfo)
 		xl.Debug("handle by plugin finished")
 		return
-	} else {
-		localConn, err := frpNet.ConnectServer("tcp", fmt.Sprintf("%s:%d", localInfo.LocalIp, localInfo.LocalPort))
-		if err != nil {
-			workConn.Close()
-			xl.Error("connect to local service [%s:%d] error: %v", localInfo.LocalIp, localInfo.LocalPort, err)
-			return
-		}
+	}
 
-		xl.Debug("join connections, localConn(l[%s] r[%s]) workConn(l[%s] r[%s])", localConn.LocalAddr().String(),
-			localConn.RemoteAddr().String(), workConn.LocalAddr().String(), workConn.RemoteAddr().String())
+	localConn, err := frpNet.ConnectServer("tcp", fmt.Sprintf("%s:%d", localInfo.LocalIP, localInfo.LocalPort))
+	if err != nil {
+		workConn.Close()
+		xl.Error("connect to local service [%s:%d] error: %v", localInfo.LocalIP, localInfo.LocalPort, err)
+		return
+	}
 
-		if len(extraInfo) > 0 {
-			localConn.Write(extraInfo)
-		}
+	xl.Debug("join connections, localConn(l[%s] r[%s]) workConn(l[%s] r[%s])", localConn.LocalAddr().String(),
+		localConn.RemoteAddr().String(), workConn.LocalAddr().String(), workConn.RemoteAddr().String())
 
-		frpIo.Join(localConn, remote)
-		xl.Debug("join connections closed")
+	if len(extraInfo) > 0 {
+		localConn.Write(extraInfo)
 	}
+
+	frpIo.Join(localConn, remote)
+	xl.Debug("join connections closed")
 }

client/proxy/proxy_manager.go

@@ -14,9 +14,9 @@ import (
 	"github.com/fatedier/golib/errors"
 )
 
-type ProxyManager struct {
+type Manager struct {
 	sendCh  chan (msg.Message)
-	proxies map[string]*ProxyWrapper
+	proxies map[string]*Wrapper
 
 	closed bool
 	mu     sync.RWMutex
@@ -29,10 +29,10 @@ type ProxyManager struct {
 	ctx context.Context
 }
 
-func NewProxyManager(ctx context.Context, msgSendCh chan (msg.Message), clientCfg config.ClientCommonConf, serverUDPPort int) *ProxyManager {
-	return &ProxyManager{
+func NewManager(ctx context.Context, msgSendCh chan (msg.Message), clientCfg config.ClientCommonConf, serverUDPPort int) *Manager {
+	return &Manager{
 		sendCh:        msgSendCh,
-		proxies:       make(map[string]*ProxyWrapper),
+		proxies:       make(map[string]*Wrapper),
 		closed:        false,
 		clientCfg:     clientCfg,
 		serverUDPPort: serverUDPPort,
@@ -40,7 +40,7 @@ func NewProxyManager(ctx context.Context, msgSendCh chan (msg.Message), clientCf
 	}
 }
 
-func (pm *ProxyManager) StartProxy(name string, remoteAddr string, serverRespErr string) error {
+func (pm *Manager) StartProxy(name string, remoteAddr string, serverRespErr string) error {
 	pm.mu.RLock()
 	pxy, ok := pm.proxies[name]
 	pm.mu.RUnlock()
@@ -55,16 +55,16 @@ func (pm *ProxyManager) StartProxy(name string, remoteAddr string, serverRespErr
 	return nil
 }
 
-func (pm *ProxyManager) Close() {
+func (pm *Manager) Close() {
 	pm.mu.Lock()
 	defer pm.mu.Unlock()
 	for _, pxy := range pm.proxies {
 		pxy.Stop()
 	}
-	pm.proxies = make(map[string]*ProxyWrapper)
+	pm.proxies = make(map[string]*Wrapper)
 }
 
-func (pm *ProxyManager) HandleWorkConn(name string, workConn net.Conn, m *msg.StartWorkConn) {
+func (pm *Manager) HandleWorkConn(name string, workConn net.Conn, m *msg.StartWorkConn) {
 	pm.mu.RLock()
 	pw, ok := pm.proxies[name]
 	pm.mu.RUnlock()
@@ -75,7 +75,7 @@ func (pm *ProxyManager) HandleWorkConn(name string, workConn net.Conn, m *msg.St
 	}
 }
 
-func (pm *ProxyManager) HandleEvent(evType event.EventType, payload interface{}) error {
+func (pm *Manager) HandleEvent(evType event.Type, payload interface{}) error {
 	var m msg.Message
 	switch e := payload.(type) {
 	case *event.StartProxyPayload:
@@ -92,8 +92,8 @@ func (pm *ProxyManager) HandleEvent(evType event.EventType, payload interface{})
 	return err
 }
 
-func (pm *ProxyManager) GetAllProxyStatus() []*ProxyStatus {
-	ps := make([]*ProxyStatus, 0)
+func (pm *Manager) GetAllProxyStatus() []*WorkingStatus {
+	ps := make([]*WorkingStatus, 0)
 	pm.mu.RLock()
 	defer pm.mu.RUnlock()
 	for _, pxy := range pm.proxies {
@@ -102,7 +102,7 @@ func (pm *ProxyManager) GetAllProxyStatus() []*ProxyStatus {
 	return ps
 }
 
-func (pm *ProxyManager) Reload(pxyCfgs map[string]config.ProxyConf) {
+func (pm *Manager) Reload(pxyCfgs map[string]config.ProxyConf) {
 	xl := xlog.FromContextSafe(pm.ctx)
 	pm.mu.Lock()
 	defer pm.mu.Unlock()
@@ -133,7 +133,7 @@ func (pm *ProxyManager) Reload(pxyCfgs map[string]config.ProxyConf) {
 	addPxyNames := make([]string, 0)
 	for name, cfg := range pxyCfgs {
 		if _, ok := pm.proxies[name]; !ok {
-			pxy := NewProxyWrapper(pm.ctx, cfg, pm.clientCfg, pm.HandleEvent, pm.serverUDPPort)
+			pxy := NewWrapper(pm.ctx, cfg, pm.clientCfg, pm.HandleEvent, pm.serverUDPPort)
 			pm.proxies[name] = pxy
 			addPxyNames = append(addPxyNames, name)
 

client/proxy/proxy_wrapper.go

@@ -18,12 +18,12 @@ import (
 )
 
 const (
-	ProxyStatusNew         = "new"
-	ProxyStatusWaitStart   = "wait start"
-	ProxyStatusStartErr    = "start error"
-	ProxyStatusRunning     = "running"
-	ProxyStatusCheckFailed = "check failed"
-	ProxyStatusClosed      = "closed"
+	ProxyPhaseNew         = "new"
+	ProxyPhaseWaitStart   = "wait start"
+	ProxyPhaseStartErr    = "start error"
+	ProxyPhaseRunning     = "running"
+	ProxyPhaseCheckFailed = "check failed"
+	ProxyPhaseClosed      = "closed"
 )
 
 var (
@@ -32,29 +32,29 @@ var (
 	startErrTimeout                   = 30 * time.Second
 )
 
-type ProxyStatus struct {
-	Name   string           `json:"name"`
-	Type   string           `json:"type"`
-	Status string           `json:"status"`
-	Err    string           `json:"err"`
-	Cfg    config.ProxyConf `json:"cfg"`
+type WorkingStatus struct {
+	Name  string           `json:"name"`
+	Type  string           `json:"type"`
+	Phase string           `json:"status"`
+	Err   string           `json:"err"`
+	Cfg   config.ProxyConf `json:"cfg"`
 
 	// Got from server.
 	RemoteAddr string `json:"remote_addr"`
 }
 
-type ProxyWrapper struct {
-	ProxyStatus
+type Wrapper struct {
+	WorkingStatus
 
 	// underlying proxy
 	pxy Proxy
 
 	// if ProxyConf has healcheck config
 	// monitor will watch if it is alive
-	monitor *health.HealthCheckMonitor
+	monitor *health.Monitor
 
 	// event handler
-	handler event.EventHandler
+	handler event.Handler
 
 	health           uint32
 	lastSendStartMsg time.Time
@@ -67,15 +67,15 @@ type ProxyWrapper struct {
 	ctx context.Context
 }
 
-func NewProxyWrapper(ctx context.Context, cfg config.ProxyConf, clientCfg config.ClientCommonConf, eventHandler event.EventHandler, serverUDPPort int) *ProxyWrapper {
+func NewWrapper(ctx context.Context, cfg config.ProxyConf, clientCfg config.ClientCommonConf, eventHandler event.Handler, serverUDPPort int) *Wrapper {
 	baseInfo := cfg.GetBaseInfo()
 	xl := xlog.FromContextSafe(ctx).Spawn().AppendPrefix(baseInfo.ProxyName)
-	pw := &ProxyWrapper{
-		ProxyStatus: ProxyStatus{
-			Name:   baseInfo.ProxyName,
-			Type:   baseInfo.ProxyType,
-			Status: ProxyStatusNew,
-			Cfg:    cfg,
+	pw := &Wrapper{
+		WorkingStatus: WorkingStatus{
+			Name:  baseInfo.ProxyName,
+			Type:  baseInfo.ProxyType,
+			Phase: ProxyPhaseNew,
+			Cfg:   cfg,
 		},
 		closeCh:        make(chan struct{}),
 		healthNotifyCh: make(chan struct{}),
@@ -86,9 +86,9 @@ func NewProxyWrapper(ctx context.Context, cfg config.ProxyConf, clientCfg config
 
 	if baseInfo.HealthCheckType != "" {
 		pw.health = 1 // means failed
-		pw.monitor = health.NewHealthCheckMonitor(pw.ctx, baseInfo.HealthCheckType, baseInfo.HealthCheckIntervalS,
+		pw.monitor = health.NewMonitor(pw.ctx, baseInfo.HealthCheckType, baseInfo.HealthCheckIntervalS,
 			baseInfo.HealthCheckTimeoutS, baseInfo.HealthCheckMaxFailed, baseInfo.HealthCheckAddr,
-			baseInfo.HealthCheckUrl, pw.statusNormalCallback, pw.statusFailedCallback)
+			baseInfo.HealthCheckURL, pw.statusNormalCallback, pw.statusFailedCallback)
 		xl.Trace("enable health check monitor")
 	}
 
@@ -96,16 +96,16 @@ func NewProxyWrapper(ctx context.Context, cfg config.ProxyConf, clientCfg config
 	return pw
 }
 
-func (pw *ProxyWrapper) SetRunningStatus(remoteAddr string, respErr string) error {
+func (pw *Wrapper) SetRunningStatus(remoteAddr string, respErr string) error {
 	pw.mu.Lock()
 	defer pw.mu.Unlock()
-	if pw.Status != ProxyStatusWaitStart {
+	if pw.Phase != ProxyPhaseWaitStart {
 		return fmt.Errorf("status not wait start, ignore start message")
 	}
 
 	pw.RemoteAddr = remoteAddr
 	if respErr != "" {
-		pw.Status = ProxyStatusStartErr
+		pw.Phase = ProxyPhaseStartErr
 		pw.Err = respErr
 		pw.lastStartErr = time.Now()
 		return fmt.Errorf(pw.Err)
@@ -113,25 +113,25 @@ func (pw *ProxyWrapper) SetRunningStatus(remoteAddr string, respErr string) erro
 
 	if err := pw.pxy.Run(); err != nil {
 		pw.close()
-		pw.Status = ProxyStatusStartErr
+		pw.Phase = ProxyPhaseStartErr
 		pw.Err = err.Error()
 		pw.lastStartErr = time.Now()
 		return err
 	}
 
-	pw.Status = ProxyStatusRunning
+	pw.Phase = ProxyPhaseRunning
 	pw.Err = ""
 	return nil
 }
 
-func (pw *ProxyWrapper) Start() {
+func (pw *Wrapper) Start() {
 	go pw.checkWorker()
 	if pw.monitor != nil {
 		go pw.monitor.Start()
 	}
 }
 
-func (pw *ProxyWrapper) Stop() {
+func (pw *Wrapper) Stop() {
 	pw.mu.Lock()
 	defer pw.mu.Unlock()
 	close(pw.closeCh)
@@ -140,11 +140,11 @@ func (pw *ProxyWrapper) Stop() {
 	if pw.monitor != nil {
 		pw.monitor.Stop()
 	}
-	pw.Status = ProxyStatusClosed
+	pw.Phase = ProxyPhaseClosed
 	pw.close()
 }
 
-func (pw *ProxyWrapper) close() {
+func (pw *Wrapper) close() {
 	pw.handler(event.EvCloseProxy, &event.CloseProxyPayload{
 		CloseProxyMsg: &msg.CloseProxy{
 			ProxyName: pw.Name,
@@ -152,7 +152,7 @@ func (pw *ProxyWrapper) close() {
 	})
 }
 
-func (pw *ProxyWrapper) checkWorker() {
+func (pw *Wrapper) checkWorker() {
 	xl := pw.xl
 	if pw.monitor != nil {
 		// let monitor do check request first
@@ -163,13 +163,13 @@ func (pw *ProxyWrapper) checkWorker() {
 		now := time.Now()
 		if atomic.LoadUint32(&pw.health) == 0 {
 			pw.mu.Lock()
-			if pw.Status == ProxyStatusNew ||
-				pw.Status == ProxyStatusCheckFailed ||
-				(pw.Status == ProxyStatusWaitStart && now.After(pw.lastSendStartMsg.Add(waitResponseTimeout))) ||
-				(pw.Status == ProxyStatusStartErr && now.After(pw.lastStartErr.Add(startErrTimeout))) {
+			if pw.Phase == ProxyPhaseNew ||
+				pw.Phase == ProxyPhaseCheckFailed ||
+				(pw.Phase == ProxyPhaseWaitStart && now.After(pw.lastSendStartMsg.Add(waitResponseTimeout))) ||
+				(pw.Phase == ProxyPhaseStartErr && now.After(pw.lastStartErr.Add(startErrTimeout))) {
 
-				xl.Trace("change status from [%s] to [%s]", pw.Status, ProxyStatusWaitStart)
-				pw.Status = ProxyStatusWaitStart
+				xl.Trace("change status from [%s] to [%s]", pw.Phase, ProxyPhaseWaitStart)
+				pw.Phase = ProxyPhaseWaitStart
 
 				var newProxyMsg msg.NewProxy
 				pw.Cfg.MarshalToMsg(&newProxyMsg)
@@ -181,10 +181,10 @@ func (pw *ProxyWrapper) checkWorker() {
 			pw.mu.Unlock()
 		} else {
 			pw.mu.Lock()
-			if pw.Status == ProxyStatusRunning || pw.Status == ProxyStatusWaitStart {
+			if pw.Phase == ProxyPhaseRunning || pw.Phase == ProxyPhaseWaitStart {
 				pw.close()
-				xl.Trace("change status from [%s] to [%s]", pw.Status, ProxyStatusCheckFailed)
-				pw.Status = ProxyStatusCheckFailed
+				xl.Trace("change status from [%s] to [%s]", pw.Phase, ProxyPhaseCheckFailed)
+				pw.Phase = ProxyPhaseCheckFailed
 			}
 			pw.mu.Unlock()
 		}
@@ -198,7 +198,7 @@ func (pw *ProxyWrapper) checkWorker() {
 	}
 }
 
-func (pw *ProxyWrapper) statusNormalCallback() {
+func (pw *Wrapper) statusNormalCallback() {
 	xl := pw.xl
 	atomic.StoreUint32(&pw.health, 0)
 	errors.PanicToError(func() {
@@ -210,7 +210,7 @@ func (pw *ProxyWrapper) statusNormalCallback() {
 	xl.Info("health check success")
 }
 
-func (pw *ProxyWrapper) statusFailedCallback() {
+func (pw *Wrapper) statusFailedCallback() {
 	xl := pw.xl
 	atomic.StoreUint32(&pw.health, 1)
 	errors.PanicToError(func() {
@@ -222,7 +222,7 @@ func (pw *ProxyWrapper) statusFailedCallback() {
 	xl.Info("health check failed")
 }
 
-func (pw *ProxyWrapper) InWorkConn(workConn net.Conn, m *msg.StartWorkConn) {
+func (pw *Wrapper) InWorkConn(workConn net.Conn, m *msg.StartWorkConn) {
 	xl := pw.xl
 	pw.mu.RLock()
 	pxy := pw.pxy
@@ -235,13 +235,13 @@ func (pw *ProxyWrapper) InWorkConn(workConn net.Conn, m *msg.StartWorkConn) {
 	}
 }
 
-func (pw *ProxyWrapper) GetStatus() *ProxyStatus {
+func (pw *Wrapper) GetStatus() *WorkingStatus {
 	pw.mu.RLock()
 	defer pw.mu.RUnlock()
-	ps := &ProxyStatus{
+	ps := &WorkingStatus{
 		Name:       pw.Name,
 		Type:       pw.Type,
-		Status:     pw.Status,
+		Phase:      pw.Phase,
 		Err:        pw.Err,
 		Cfg:        pw.Cfg,
 		RemoteAddr: pw.RemoteAddr,

client/service.go

@@ -40,7 +40,7 @@ import (
 // Service is a client service.
 type Service struct {
 	// uniq id got from frps, attach it in loginMsg
-	runId string
+	runID string
 
 	// manager control connection with server
 	ctl   *Control
@@ -73,7 +73,7 @@ func NewService(cfg config.ClientCommonConf, pxyCfgs map[string]config.ProxyConf
 
 	ctx, cancel := context.WithCancel(context.Background())
 	svr = &Service{
-		authSetter:  auth.NewAuthSetter(cfg.AuthClientConfig),
+		authSetter:  auth.NewAuthSetter(cfg.ClientConfig),
 		cfg:         cfg,
 		cfgFile:     cfgFile,
 		pxyCfgs:     pxyCfgs,
@@ -104,12 +104,11 @@ func (svr *Service) Run() error {
 			// otherwise sleep a while and try again to connect to server
 			if svr.cfg.LoginFailExit {
 				return err
-			} else {
-				time.Sleep(10 * time.Second)
 			}
+			time.Sleep(10 * time.Second)
 		} else {
 			// login success
-			ctl := NewControl(svr.ctx, svr.runId, conn, session, svr.cfg, svr.pxyCfgs, svr.visitorCfgs, svr.serverUDPPort, svr.authSetter)
+			ctl := NewControl(svr.ctx, svr.runID, conn, session, svr.cfg, svr.pxyCfgs, svr.visitorCfgs, svr.serverUDPPort, svr.authSetter)
 			ctl.Run()
 			svr.ctlMu.Lock()
 			svr.ctl = ctl
@@ -185,7 +184,7 @@ func (svr *Service) keepControllerWorking() {
 			// reconnect success, init delayTime
 			delayTime = time.Second
 
-			ctl := NewControl(svr.ctx, svr.runId, conn, session, svr.cfg, svr.pxyCfgs, svr.visitorCfgs, svr.serverUDPPort, svr.authSetter)
+			ctl := NewControl(svr.ctx, svr.runID, conn, session, svr.cfg, svr.pxyCfgs, svr.visitorCfgs, svr.serverUDPPort, svr.authSetter)
 			ctl.Run()
 			svr.ctlMu.Lock()
 			if svr.ctl != nil {
@@ -209,7 +208,7 @@ func (svr *Service) login() (conn net.Conn, session *fmux.Session, err error) {
 			InsecureSkipVerify: true,
 		}
 	}
-	conn, err = frpNet.ConnectServerByProxyWithTLS(svr.cfg.HttpProxy, svr.cfg.Protocol,
+	conn, err = frpNet.ConnectServerByProxyWithTLS(svr.cfg.HTTPProxy, svr.cfg.Protocol,
 		fmt.Sprintf("%s:%d", svr.cfg.ServerAddr, svr.cfg.ServerPort), tlsConfig)
 	if err != nil {
 		return
@@ -224,7 +223,7 @@ func (svr *Service) login() (conn net.Conn, session *fmux.Session, err error) {
 		}
 	}()
 
-	if svr.cfg.TcpMux {
+	if svr.cfg.TCPMux {
 		fmuxCfg := fmux.DefaultConfig()
 		fmuxCfg.KeepAliveInterval = 20 * time.Second
 		fmuxCfg.LogOutput = ioutil.Discard
@@ -248,7 +247,7 @@ func (svr *Service) login() (conn net.Conn, session *fmux.Session, err error) {
 		User:      svr.cfg.User,
 		Version:   version.Full(),
 		Timestamp: time.Now().Unix(),
-		RunId:     svr.runId,
+		RunID:     svr.runID,
 		Metas:     svr.cfg.Metas,
 	}
 
@@ -274,12 +273,12 @@ func (svr *Service) login() (conn net.Conn, session *fmux.Session, err error) {
 		return
 	}
 
-	svr.runId = loginRespMsg.RunId
+	svr.runID = loginRespMsg.RunID
 	xl.ResetPrefixes()
-	xl.AppendPrefix(svr.runId)
+	xl.AppendPrefix(svr.runID)
 
-	svr.serverUDPPort = loginRespMsg.ServerUdpPort
-	xl.Info("login to server success, get run id [%s], server udp port [%d]", loginRespMsg.RunId, loginRespMsg.ServerUdpPort)
+	svr.serverUDPPort = loginRespMsg.ServerUDPPort
+	xl.Info("login to server success, get run id [%s], server udp port [%d]", loginRespMsg.RunID, loginRespMsg.ServerUDPPort)
 	return
 }
 

client/visitor.go

@@ -50,18 +50,18 @@ func NewVisitor(ctx context.Context, ctl *Control, cfg config.VisitorConf) (visi
 		ctx: xlog.NewContext(ctx, xl),
 	}
 	switch cfg := cfg.(type) {
-	case *config.StcpVisitorConf:
-		visitor = &StcpVisitor{
+	case *config.STCPVisitorConf:
+		visitor = &STCPVisitor{
 			BaseVisitor: &baseVisitor,
 			cfg:         cfg,
 		}
-	case *config.XtcpVisitorConf:
-		visitor = &XtcpVisitor{
+	case *config.XTCPVisitorConf:
+		visitor = &XTCPVisitor{
 			BaseVisitor: &baseVisitor,
 			cfg:         cfg,
 		}
-	case *config.SudpVisitorConf:
-		visitor = &SudpVisitor{
+	case *config.SUDPVisitorConf:
+		visitor = &SUDPVisitor{
 			BaseVisitor:  &baseVisitor,
 			cfg:          cfg,
 			checkCloseCh: make(chan struct{}),
@@ -79,13 +79,13 @@ type BaseVisitor struct {
 	ctx context.Context
 }
 
-type StcpVisitor struct {
+type STCPVisitor struct {
 	*BaseVisitor
 
-	cfg *config.StcpVisitorConf
+	cfg *config.STCPVisitorConf
 }
 
-func (sv *StcpVisitor) Run() (err error) {
+func (sv *STCPVisitor) Run() (err error) {
 	sv.l, err = net.Listen("tcp", fmt.Sprintf("%s:%d", sv.cfg.BindAddr, sv.cfg.BindPort))
 	if err != nil {
 		return
@@ -95,11 +95,11 @@ func (sv *StcpVisitor) Run() (err error) {
 	return
 }
 
-func (sv *StcpVisitor) Close() {
+func (sv *STCPVisitor) Close() {
 	sv.l.Close()
 }
 
-func (sv *StcpVisitor) worker() {
+func (sv *STCPVisitor) worker() {
 	xl := xlog.FromContextSafe(sv.ctx)
 	for {
 		conn, err := sv.l.Accept()
@@ -112,7 +112,7 @@ func (sv *StcpVisitor) worker() {
 	}
 }
 
-func (sv *StcpVisitor) handleConn(userConn net.Conn) {
+func (sv *STCPVisitor) handleConn(userConn net.Conn) {
 	xl := xlog.FromContextSafe(sv.ctx)
 	defer userConn.Close()
 
@@ -168,13 +168,13 @@ func (sv *StcpVisitor) handleConn(userConn net.Conn) {
 	frpIo.Join(userConn, remote)
 }
 
-type XtcpVisitor struct {
+type XTCPVisitor struct {
 	*BaseVisitor
 
-	cfg *config.XtcpVisitorConf
+	cfg *config.XTCPVisitorConf
 }
 
-func (sv *XtcpVisitor) Run() (err error) {
+func (sv *XTCPVisitor) Run() (err error) {
 	sv.l, err = net.Listen("tcp", fmt.Sprintf("%s:%d", sv.cfg.BindAddr, sv.cfg.BindPort))
 	if err != nil {
 		return
@@ -184,11 +184,11 @@ func (sv *XtcpVisitor) Run() (err error) {
 	return
 }
 
-func (sv *XtcpVisitor) Close() {
+func (sv *XTCPVisitor) Close() {
 	sv.l.Close()
 }
 
-func (sv *XtcpVisitor) worker() {
+func (sv *XTCPVisitor) worker() {
 	xl := xlog.FromContextSafe(sv.ctx)
 	for {
 		conn, err := sv.l.Accept()
@@ -201,7 +201,7 @@ func (sv *XtcpVisitor) worker() {
 	}
 }
 
-func (sv *XtcpVisitor) handleConn(userConn net.Conn) {
+func (sv *XTCPVisitor) handleConn(userConn net.Conn) {
 	xl := xlog.FromContextSafe(sv.ctx)
 	defer userConn.Close()
 
@@ -300,7 +300,7 @@ func (sv *XtcpVisitor) handleConn(userConn net.Conn) {
 
 	// wrap kcp connection
 	var remote io.ReadWriteCloser
-	remote, err = frpNet.NewKcpConnFromUdp(lConn, true, natHoleRespMsg.ClientAddr)
+	remote, err = frpNet.NewKCPConnFromUDP(lConn, true, natHoleRespMsg.ClientAddr)
 	if err != nil {
 		xl.Error("create kcp connection from udp connection error: %v", err)
 		return
@@ -337,20 +337,20 @@ func (sv *XtcpVisitor) handleConn(userConn net.Conn) {
 	xl.Debug("join connections closed")
 }
 
-type SudpVisitor struct {
+type SUDPVisitor struct {
 	*BaseVisitor
 
 	checkCloseCh chan struct{}
 	// udpConn is the listener of udp packet
 	udpConn *net.UDPConn
-	readCh  chan *msg.UdpPacket
-	sendCh  chan *msg.UdpPacket
+	readCh  chan *msg.UDPPacket
+	sendCh  chan *msg.UDPPacket
 
-	cfg *config.SudpVisitorConf
+	cfg *config.SUDPVisitorConf
 }
 
 // SUDP Run start listen a udp port
-func (sv *SudpVisitor) Run() (err error) {
+func (sv *SUDPVisitor) Run() (err error) {
 	xl := xlog.FromContextSafe(sv.ctx)
 
 	addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", sv.cfg.BindAddr, sv.cfg.BindPort))
@@ -363,18 +363,18 @@ func (sv *SudpVisitor) Run() (err error) {
 		return fmt.Errorf("listen udp port %s error: %v", addr.String(), err)
 	}
 
-	sv.sendCh = make(chan *msg.UdpPacket, 1024)
-	sv.readCh = make(chan *msg.UdpPacket, 1024)
+	sv.sendCh = make(chan *msg.UDPPacket, 1024)
+	sv.readCh = make(chan *msg.UDPPacket, 1024)
 
 	xl.Info("sudp start to work")
 
 	go sv.dispatcher()
-	go udp.ForwardUserConn(sv.udpConn, sv.readCh, sv.sendCh, int(sv.ctl.clientCfg.UdpPacketSize))
+	go udp.ForwardUserConn(sv.udpConn, sv.readCh, sv.sendCh, int(sv.ctl.clientCfg.UDPPacketSize))
 
 	return
 }
 
-func (sv *SudpVisitor) dispatcher() {
+func (sv *SUDPVisitor) dispatcher() {
 	xl := xlog.FromContextSafe(sv.ctx)
 
 	for {
@@ -409,7 +409,7 @@ func (sv *SudpVisitor) dispatcher() {
 	}
 }
 
-func (sv *SudpVisitor) worker(workConn net.Conn) {
+func (sv *SUDPVisitor) worker(workConn net.Conn) {
 	xl := xlog.FromContextSafe(sv.ctx)
 	xl.Debug("starting sudp proxy worker")
 
@@ -443,7 +443,7 @@ func (sv *SudpVisitor) worker(workConn net.Conn) {
 			case *msg.Ping:
 				xl.Debug("frpc visitor get ping message from frpc")
 				continue
-			case *msg.UdpPacket:
+			case *msg.UDPPacket:
 				if errRet := errors.PanicToError(func() {
 					sv.readCh <- m
 					xl.Trace("frpc visitor get udp packet from frpc")
@@ -488,7 +488,7 @@ func (sv *SudpVisitor) worker(workConn net.Conn) {
 	xl.Info("sudp worker is closed")
 }
 
-func (sv *SudpVisitor) getNewVisitorConn() (visitorConn net.Conn, err error) {
+func (sv *SUDPVisitor) getNewVisitorConn() (visitorConn net.Conn, err error) {
 	visitorConn, err = sv.ctl.connectServer()
 	if err != nil {
 		return nil, fmt.Errorf("frpc connect frps error: %v", err)
@@ -521,7 +521,7 @@ func (sv *SudpVisitor) getNewVisitorConn() (visitorConn net.Conn, err error) {
 	return
 }
 
-func (sv *SudpVisitor) Close() {
+func (sv *SUDPVisitor) Close() {
 	sv.mu.Lock()
 	defer sv.mu.Unlock()
 

cmd/frpc/sub/http.go

@@ -29,7 +29,7 @@ func init() {
 	RegisterCommonFlags(httpCmd)
 
 	httpCmd.PersistentFlags().StringVarP(&proxyName, "proxy_name", "n", "", "proxy name")
-	httpCmd.PersistentFlags().StringVarP(&localIp, "local_ip", "i", "127.0.0.1", "local ip")
+	httpCmd.PersistentFlags().StringVarP(&localIP, "local_ip", "i", "127.0.0.1", "local ip")
 	httpCmd.PersistentFlags().IntVarP(&localPort, "local_port", "l", 0, "local port")
 	httpCmd.PersistentFlags().StringVarP(&customDomains, "custom_domain", "d", "", "custom domain")
 	httpCmd.PersistentFlags().StringVarP(&subDomain, "sd", "", "", "sub domain")
@@ -53,20 +53,20 @@ var httpCmd = &cobra.Command{
 			os.Exit(1)
 		}
 
-		cfg := &config.HttpProxyConf{}
+		cfg := &config.HTTPProxyConf{}
 		var prefix string
 		if user != "" {
 			prefix = user + "."
 		}
 		cfg.ProxyName = prefix + proxyName
-		cfg.ProxyType = consts.HttpProxy
-		cfg.LocalIp = localIp
+		cfg.ProxyType = consts.HTTPProxy
+		cfg.LocalIP = localIP
 		cfg.LocalPort = localPort
 		cfg.CustomDomains = strings.Split(customDomains, ",")
 		cfg.SubDomain = subDomain
 		cfg.Locations = strings.Split(locations, ",")
-		cfg.HttpUser = httpUser
-		cfg.HttpPwd = httpPwd
+		cfg.HTTPUser = httpUser
+		cfg.HTTPPwd = httpPwd
 		cfg.HostHeaderRewrite = hostHeaderRewrite
 		cfg.UseEncryption = useEncryption
 		cfg.UseCompression = useCompression

cmd/frpc/sub/https.go

@@ -29,7 +29,7 @@ func init() {
 	RegisterCommonFlags(httpsCmd)
 
 	httpsCmd.PersistentFlags().StringVarP(&proxyName, "proxy_name", "n", "", "proxy name")
-	httpsCmd.PersistentFlags().StringVarP(&localIp, "local_ip", "i", "127.0.0.1", "local ip")
+	httpsCmd.PersistentFlags().StringVarP(&localIP, "local_ip", "i", "127.0.0.1", "local ip")
 	httpsCmd.PersistentFlags().IntVarP(&localPort, "local_port", "l", 0, "local port")
 	httpsCmd.PersistentFlags().StringVarP(&customDomains, "custom_domain", "d", "", "custom domain")
 	httpsCmd.PersistentFlags().StringVarP(&subDomain, "sd", "", "", "sub domain")
@@ -49,14 +49,14 @@ var httpsCmd = &cobra.Command{
 			os.Exit(1)
 		}
 
-		cfg := &config.HttpsProxyConf{}
+		cfg := &config.HTTPSProxyConf{}
 		var prefix string
 		if user != "" {
 			prefix = user + "."
 		}
 		cfg.ProxyName = prefix + proxyName
-		cfg.ProxyType = consts.HttpsProxy
-		cfg.LocalIp = localIp
+		cfg.ProxyType = consts.HTTPSProxy
+		cfg.LocalIP = localIP
 		cfg.LocalPort = localPort
 		cfg.CustomDomains = strings.Split(customDomains, ",")
 		cfg.SubDomain = subDomain

cmd/frpc/sub/root.go

@@ -53,7 +53,7 @@ var (
 	disableLogColor bool
 
 	proxyName         string
-	localIp           string
+	localIP           string
 	localPort         int
 	remotePort        int
 	useEncryption     bool
@@ -184,7 +184,7 @@ func parseClientCommonCfgFromCmd() (cfg config.ClientCommonConf, err error) {
 	cfg.DisableLogColor = disableLogColor
 
 	// Only token authentication is supported in cmd mode
-	cfg.AuthClientConfig = auth.GetDefaultAuthClientConf()
+	cfg.ClientConfig = auth.GetDefaultClientConf()
 	cfg.Token = token
 	cfg.TLSEnable = tlsEnable
 
@@ -216,8 +216,8 @@ func startService(cfg config.ClientCommonConf, pxyCfgs map[string]config.ProxyCo
 	log.InitLog(cfg.LogWay, cfg.LogFile, cfg.LogLevel,
 		cfg.LogMaxDays, cfg.DisableLogColor)
 
-	if cfg.DnsServer != "" {
-		s := cfg.DnsServer
+	if cfg.DNSServer != "" {
+		s := cfg.DNSServer
 		if !strings.Contains(s, ":") {
 			s += ":53"
 		}

cmd/frpc/sub/status.go

@@ -95,55 +95,55 @@ func status(clientCfg config.ClientCommonConf) error {
 	}
 
 	fmt.Println("Proxy Status...")
-	if len(res.Tcp) > 0 {
+	if len(res.TCP) > 0 {
 		fmt.Printf("TCP")
 		tbl := table.New("Name", "Status", "LocalAddr", "Plugin", "RemoteAddr", "Error")
-		for _, ps := range res.Tcp {
+		for _, ps := range res.TCP {
 			tbl.AddRow(ps.Name, ps.Status, ps.LocalAddr, ps.Plugin, ps.RemoteAddr, ps.Err)
 		}
 		tbl.Print()
 		fmt.Println("")
 	}
-	if len(res.Udp) > 0 {
+	if len(res.UDP) > 0 {
 		fmt.Printf("UDP")
 		tbl := table.New("Name", "Status", "LocalAddr", "Plugin", "RemoteAddr", "Error")
-		for _, ps := range res.Udp {
+		for _, ps := range res.UDP {
 			tbl.AddRow(ps.Name, ps.Status, ps.LocalAddr, ps.Plugin, ps.RemoteAddr, ps.Err)
 		}
 		tbl.Print()
 		fmt.Println("")
 	}
-	if len(res.Http) > 0 {
+	if len(res.HTTP) > 0 {
 		fmt.Printf("HTTP")
 		tbl := table.New("Name", "Status", "LocalAddr", "Plugin", "RemoteAddr", "Error")
-		for _, ps := range res.Http {
+		for _, ps := range res.HTTP {
 			tbl.AddRow(ps.Name, ps.Status, ps.LocalAddr, ps.Plugin, ps.RemoteAddr, ps.Err)
 		}
 		tbl.Print()
 		fmt.Println("")
 	}
-	if len(res.Https) > 0 {
+	if len(res.HTTPS) > 0 {
 		fmt.Printf("HTTPS")
 		tbl := table.New("Name", "Status", "LocalAddr", "Plugin", "RemoteAddr", "Error")
-		for _, ps := range res.Https {
+		for _, ps := range res.HTTPS {
 			tbl.AddRow(ps.Name, ps.Status, ps.LocalAddr, ps.Plugin, ps.RemoteAddr, ps.Err)
 		}
 		tbl.Print()
 		fmt.Println("")
 	}
-	if len(res.Stcp) > 0 {
+	if len(res.STCP) > 0 {
 		fmt.Printf("STCP")
 		tbl := table.New("Name", "Status", "LocalAddr", "Plugin", "RemoteAddr", "Error")
-		for _, ps := range res.Stcp {
+		for _, ps := range res.STCP {
 			tbl.AddRow(ps.Name, ps.Status, ps.LocalAddr, ps.Plugin, ps.RemoteAddr, ps.Err)
 		}
 		tbl.Print()
 		fmt.Println("")
 	}
-	if len(res.Xtcp) > 0 {
+	if len(res.XTCP) > 0 {
 		fmt.Printf("XTCP")
 		tbl := table.New("Name", "Status", "LocalAddr", "Plugin", "RemoteAddr", "Error")
-		for _, ps := range res.Xtcp {
+		for _, ps := range res.XTCP {
 			tbl.AddRow(ps.Name, ps.Status, ps.LocalAddr, ps.Plugin, ps.RemoteAddr, ps.Err)
 		}
 		tbl.Print()

cmd/frpc/sub/stcp.go

@@ -31,7 +31,7 @@ func init() {
 	stcpCmd.PersistentFlags().StringVarP(&role, "role", "", "server", "role")
 	stcpCmd.PersistentFlags().StringVarP(&sk, "sk", "", "", "secret key")
 	stcpCmd.PersistentFlags().StringVarP(&serverName, "server_name", "", "", "server name")
-	stcpCmd.PersistentFlags().StringVarP(&localIp, "local_ip", "i", "127.0.0.1", "local ip")
+	stcpCmd.PersistentFlags().StringVarP(&localIP, "local_ip", "i", "127.0.0.1", "local ip")
 	stcpCmd.PersistentFlags().IntVarP(&localPort, "local_port", "l", 0, "local port")
 	stcpCmd.PersistentFlags().StringVarP(&bindAddr, "bind_addr", "", "", "bind addr")
 	stcpCmd.PersistentFlags().IntVarP(&bindPort, "bind_port", "", 0, "bind port")
@@ -60,14 +60,14 @@ var stcpCmd = &cobra.Command{
 		}
 
 		if role == "server" {
-			cfg := &config.StcpProxyConf{}
+			cfg := &config.STCPProxyConf{}
 			cfg.ProxyName = prefix + proxyName
-			cfg.ProxyType = consts.StcpProxy
+			cfg.ProxyType = consts.STCPProxy
 			cfg.UseEncryption = useEncryption
 			cfg.UseCompression = useCompression
 			cfg.Role = role
 			cfg.Sk = sk
-			cfg.LocalIp = localIp
+			cfg.LocalIP = localIP
 			cfg.LocalPort = localPort
 			err = cfg.CheckForCli()
 			if err != nil {
@@ -76,9 +76,9 @@ var stcpCmd = &cobra.Command{
 			}
 			proxyConfs[cfg.ProxyName] = cfg
 		} else if role == "visitor" {
-			cfg := &config.StcpVisitorConf{}
+			cfg := &config.STCPVisitorConf{}
 			cfg.ProxyName = prefix + proxyName
-			cfg.ProxyType = consts.StcpProxy
+			cfg.ProxyType = consts.STCPProxy
 			cfg.UseEncryption = useEncryption
 			cfg.UseCompression = useCompression
 			cfg.Role = role

cmd/frpc/sub/sudp.go

@@ -31,7 +31,7 @@ func init() {
 	sudpCmd.PersistentFlags().StringVarP(&role, "role", "", "server", "role")
 	sudpCmd.PersistentFlags().StringVarP(&sk, "sk", "", "", "secret key")
 	sudpCmd.PersistentFlags().StringVarP(&serverName, "server_name", "", "", "server name")
-	sudpCmd.PersistentFlags().StringVarP(&localIp, "local_ip", "i", "127.0.0.1", "local ip")
+	sudpCmd.PersistentFlags().StringVarP(&localIP, "local_ip", "i", "127.0.0.1", "local ip")
 	sudpCmd.PersistentFlags().IntVarP(&localPort, "local_port", "l", 0, "local port")
 	sudpCmd.PersistentFlags().StringVarP(&bindAddr, "bind_addr", "", "", "bind addr")
 	sudpCmd.PersistentFlags().IntVarP(&bindPort, "bind_port", "", 0, "bind port")
@@ -60,14 +60,14 @@ var sudpCmd = &cobra.Command{
 		}
 
 		if role == "server" {
-			cfg := &config.SudpProxyConf{}
+			cfg := &config.SUDPProxyConf{}
 			cfg.ProxyName = prefix + proxyName
-			cfg.ProxyType = consts.SudpProxy
+			cfg.ProxyType = consts.SUDPProxy
 			cfg.UseEncryption = useEncryption
 			cfg.UseCompression = useCompression
 			cfg.Role = role
 			cfg.Sk = sk
-			cfg.LocalIp = localIp
+			cfg.LocalIP = localIP
 			cfg.LocalPort = localPort
 			err = cfg.CheckForCli()
 			if err != nil {
@@ -76,9 +76,9 @@ var sudpCmd = &cobra.Command{
 			}
 			proxyConfs[cfg.ProxyName] = cfg
 		} else if role == "visitor" {
-			cfg := &config.SudpVisitorConf{}
+			cfg := &config.SUDPVisitorConf{}
 			cfg.ProxyName = prefix + proxyName
-			cfg.ProxyType = consts.SudpProxy
+			cfg.ProxyType = consts.SUDPProxy
 			cfg.UseEncryption = useEncryption
 			cfg.UseCompression = useCompression
 			cfg.Role = role

cmd/frpc/sub/tcp.go

@@ -28,7 +28,7 @@ func init() {
 	RegisterCommonFlags(tcpCmd)
 
 	tcpCmd.PersistentFlags().StringVarP(&proxyName, "proxy_name", "n", "", "proxy name")
-	tcpCmd.PersistentFlags().StringVarP(&localIp, "local_ip", "i", "127.0.0.1", "local ip")
+	tcpCmd.PersistentFlags().StringVarP(&localIP, "local_ip", "i", "127.0.0.1", "local ip")
 	tcpCmd.PersistentFlags().IntVarP(&localPort, "local_port", "l", 0, "local port")
 	tcpCmd.PersistentFlags().IntVarP(&remotePort, "remote_port", "r", 0, "remote port")
 	tcpCmd.PersistentFlags().BoolVarP(&useEncryption, "ue", "", false, "use encryption")
@@ -47,14 +47,14 @@ var tcpCmd = &cobra.Command{
 			os.Exit(1)
 		}
 
-		cfg := &config.TcpProxyConf{}
+		cfg := &config.TCPProxyConf{}
 		var prefix string
 		if user != "" {
 			prefix = user + "."
 		}
 		cfg.ProxyName = prefix + proxyName
-		cfg.ProxyType = consts.TcpProxy
-		cfg.LocalIp = localIp
+		cfg.ProxyType = consts.TCPProxy
+		cfg.LocalIP = localIP
 		cfg.LocalPort = localPort
 		cfg.RemotePort = remotePort
 		cfg.UseEncryption = useEncryption

cmd/frpc/sub/tcpmux.go

@@ -29,7 +29,7 @@ func init() {
 	RegisterCommonFlags(tcpMuxCmd)
 
 	tcpMuxCmd.PersistentFlags().StringVarP(&proxyName, "proxy_name", "n", "", "proxy name")
-	tcpMuxCmd.PersistentFlags().StringVarP(&localIp, "local_ip", "i", "127.0.0.1", "local ip")
+	tcpMuxCmd.PersistentFlags().StringVarP(&localIP, "local_ip", "i", "127.0.0.1", "local ip")
 	tcpMuxCmd.PersistentFlags().IntVarP(&localPort, "local_port", "l", 0, "local port")
 	tcpMuxCmd.PersistentFlags().StringVarP(&customDomains, "custom_domain", "d", "", "custom domain")
 	tcpMuxCmd.PersistentFlags().StringVarP(&subDomain, "sd", "", "", "sub domain")
@@ -50,14 +50,14 @@ var tcpMuxCmd = &cobra.Command{
 			os.Exit(1)
 		}
 
-		cfg := &config.TcpMuxProxyConf{}
+		cfg := &config.TCPMuxProxyConf{}
 		var prefix string
 		if user != "" {
 			prefix = user + "."
 		}
 		cfg.ProxyName = prefix + proxyName
-		cfg.ProxyType = consts.TcpMuxProxy
-		cfg.LocalIp = localIp
+		cfg.ProxyType = consts.TCPMuxProxy
+		cfg.LocalIP = localIP
 		cfg.LocalPort = localPort
 		cfg.CustomDomains = strings.Split(customDomains, ",")
 		cfg.SubDomain = subDomain

cmd/frpc/sub/udp.go

@@ -28,7 +28,7 @@ func init() {
 	RegisterCommonFlags(udpCmd)
 
 	udpCmd.PersistentFlags().StringVarP(&proxyName, "proxy_name", "n", "", "proxy name")
-	udpCmd.PersistentFlags().StringVarP(&localIp, "local_ip", "i", "127.0.0.1", "local ip")
+	udpCmd.PersistentFlags().StringVarP(&localIP, "local_ip", "i", "127.0.0.1", "local ip")
 	udpCmd.PersistentFlags().IntVarP(&localPort, "local_port", "l", 0, "local port")
 	udpCmd.PersistentFlags().IntVarP(&remotePort, "remote_port", "r", 0, "remote port")
 	udpCmd.PersistentFlags().BoolVarP(&useEncryption, "ue", "", false, "use encryption")
@@ -47,14 +47,14 @@ var udpCmd = &cobra.Command{
 			os.Exit(1)
 		}
 
-		cfg := &config.UdpProxyConf{}
+		cfg := &config.UDPProxyConf{}
 		var prefix string
 		if user != "" {
 			prefix = user + "."
 		}
 		cfg.ProxyName = prefix + proxyName
-		cfg.ProxyType = consts.UdpProxy
-		cfg.LocalIp = localIp
+		cfg.ProxyType = consts.UDPProxy
+		cfg.LocalIP = localIP
 		cfg.LocalPort = localPort
 		cfg.RemotePort = remotePort
 		cfg.UseEncryption = useEncryption

cmd/frpc/sub/xtcp.go

@@ -31,7 +31,7 @@ func init() {
 	xtcpCmd.PersistentFlags().StringVarP(&role, "role", "", "server", "role")
 	xtcpCmd.PersistentFlags().StringVarP(&sk, "sk", "", "", "secret key")
 	xtcpCmd.PersistentFlags().StringVarP(&serverName, "server_name", "", "", "server name")
-	xtcpCmd.PersistentFlags().StringVarP(&localIp, "local_ip", "i", "127.0.0.1", "local ip")
+	xtcpCmd.PersistentFlags().StringVarP(&localIP, "local_ip", "i", "127.0.0.1", "local ip")
 	xtcpCmd.PersistentFlags().IntVarP(&localPort, "local_port", "l", 0, "local port")
 	xtcpCmd.PersistentFlags().StringVarP(&bindAddr, "bind_addr", "", "", "bind addr")
 	xtcpCmd.PersistentFlags().IntVarP(&bindPort, "bind_port", "", 0, "bind port")
@@ -60,14 +60,14 @@ var xtcpCmd = &cobra.Command{
 		}
 
 		if role == "server" {
-			cfg := &config.XtcpProxyConf{}
+			cfg := &config.XTCPProxyConf{}
 			cfg.ProxyName = prefix + proxyName
-			cfg.ProxyType = consts.XtcpProxy
+			cfg.ProxyType = consts.XTCPProxy
 			cfg.UseEncryption = useEncryption
 			cfg.UseCompression = useCompression
 			cfg.Role = role
 			cfg.Sk = sk
-			cfg.LocalIp = localIp
+			cfg.LocalIP = localIP
 			cfg.LocalPort = localPort
 			err = cfg.CheckForCli()
 			if err != nil {
@@ -76,9 +76,9 @@ var xtcpCmd = &cobra.Command{
 			}
 			proxyConfs[cfg.ProxyName] = cfg
 		} else if role == "visitor" {
-			cfg := &config.XtcpVisitorConf{}
+			cfg := &config.XTCPVisitorConf{}
 			cfg.ProxyName = prefix + proxyName
-			cfg.ProxyType = consts.XtcpProxy
+			cfg.ProxyType = consts.XTCPProxy
 			cfg.UseEncryption = useEncryption
 			cfg.UseCompression = useCompression
 			cfg.Role = role

cmd/frps/root.go

@@ -39,12 +39,12 @@ var (
 
 	bindAddr          string
 	bindPort          int
-	bindUdpPort       int
+	bindUDPPort       int
 	kcpBindPort       int
 	proxyBindAddr     string
-	vhostHttpPort     int
-	vhostHttpsPort    int
-	vhostHttpTimeout  int64
+	vhostHTTPPort     int
+	vhostHTTPSPort    int
+	vhostHTTPTimeout  int64
 	dashboardAddr     string
 	dashboardPort     int
 	dashboardUser     string
@@ -69,12 +69,12 @@ func init() {
 
 	rootCmd.PersistentFlags().StringVarP(&bindAddr, "bind_addr", "", "0.0.0.0", "bind address")
 	rootCmd.PersistentFlags().IntVarP(&bindPort, "bind_port", "p", 7000, "bind port")
-	rootCmd.PersistentFlags().IntVarP(&bindUdpPort, "bind_udp_port", "", 0, "bind udp port")
+	rootCmd.PersistentFlags().IntVarP(&bindUDPPort, "bind_udp_port", "", 0, "bind udp port")
 	rootCmd.PersistentFlags().IntVarP(&kcpBindPort, "kcp_bind_port", "", 0, "kcp bind udp port")
 	rootCmd.PersistentFlags().StringVarP(&proxyBindAddr, "proxy_bind_addr", "", "0.0.0.0", "proxy bind address")
-	rootCmd.PersistentFlags().IntVarP(&vhostHttpPort, "vhost_http_port", "", 0, "vhost http port")
-	rootCmd.PersistentFlags().IntVarP(&vhostHttpsPort, "vhost_https_port", "", 0, "vhost https port")
-	rootCmd.PersistentFlags().Int64VarP(&vhostHttpTimeout, "vhost_http_timeout", "", 60, "vhost http response header timeout")
+	rootCmd.PersistentFlags().IntVarP(&vhostHTTPPort, "vhost_http_port", "", 0, "vhost http port")
+	rootCmd.PersistentFlags().IntVarP(&vhostHTTPSPort, "vhost_https_port", "", 0, "vhost https port")
+	rootCmd.PersistentFlags().Int64VarP(&vhostHTTPTimeout, "vhost_http_timeout", "", 60, "vhost http response header timeout")
 	rootCmd.PersistentFlags().StringVarP(&dashboardAddr, "dashboard_addr", "", "0.0.0.0", "dasboard address")
 	rootCmd.PersistentFlags().IntVarP(&dashboardPort, "dashboard_port", "", 0, "dashboard port")
 	rootCmd.PersistentFlags().StringVarP(&dashboardUser, "dashboard_user", "", "admin", "dashboard user")
@@ -161,12 +161,12 @@ func parseServerCommonCfgFromCmd() (cfg config.ServerCommonConf, err error) {
 
 	cfg.BindAddr = bindAddr
 	cfg.BindPort = bindPort
-	cfg.BindUdpPort = bindUdpPort
-	cfg.KcpBindPort = kcpBindPort
+	cfg.BindUDPPort = bindUDPPort
+	cfg.KCPBindPort = kcpBindPort
 	cfg.ProxyBindAddr = proxyBindAddr
-	cfg.VhostHttpPort = vhostHttpPort
-	cfg.VhostHttpsPort = vhostHttpsPort
-	cfg.VhostHttpTimeout = vhostHttpTimeout
+	cfg.VhostHTTPPort = vhostHTTPPort
+	cfg.VhostHTTPSPort = vhostHTTPSPort
+	cfg.VhostHTTPTimeout = vhostHTTPTimeout
 	cfg.DashboardAddr = dashboardAddr
 	cfg.DashboardPort = dashboardPort
 	cfg.DashboardUser = dashboardUser
@@ -175,10 +175,10 @@ func parseServerCommonCfgFromCmd() (cfg config.ServerCommonConf, err error) {
 	cfg.LogLevel = logLevel
 	cfg.LogMaxDays = logMaxDays
 	cfg.SubDomainHost = subDomainHost
-	cfg.TlsOnly = tlsOnly
+	cfg.TLSOnly = tlsOnly
 
 	// Only token authentication is supported in cmd mode
-	cfg.AuthServerConfig = auth.GetDefaultAuthServerConf()
+	cfg.ServerConfig = auth.GetDefaultServerConf()
 	cfg.Token = token
 	if len(allowPorts) > 0 {
 		// e.g. 1000-2000,2001,2002,3000-4000

models/auth/auth.go

@@ -72,42 +72,42 @@ func unmarshalBaseConfFromIni(conf ini.File) baseConfig {
 	return cfg
 }
 
-type AuthClientConfig struct {
+type ClientConfig struct {
 	baseConfig
 	oidcClientConfig
 	tokenConfig
 }
 
-func GetDefaultAuthClientConf() AuthClientConfig {
-	return AuthClientConfig{
+func GetDefaultClientConf() ClientConfig {
+	return ClientConfig{
 		baseConfig:       getDefaultBaseConf(),
 		oidcClientConfig: getDefaultOidcClientConf(),
 		tokenConfig:      getDefaultTokenConf(),
 	}
 }
 
-func UnmarshalAuthClientConfFromIni(conf ini.File) (cfg AuthClientConfig) {
+func UnmarshalClientConfFromIni(conf ini.File) (cfg ClientConfig) {
 	cfg.baseConfig = unmarshalBaseConfFromIni(conf)
 	cfg.oidcClientConfig = unmarshalOidcClientConfFromIni(conf)
 	cfg.tokenConfig = unmarshalTokenConfFromIni(conf)
 	return cfg
 }
 
-type AuthServerConfig struct {
+type ServerConfig struct {
 	baseConfig
 	oidcServerConfig
 	tokenConfig
 }
 
-func GetDefaultAuthServerConf() AuthServerConfig {
-	return AuthServerConfig{
+func GetDefaultServerConf() ServerConfig {
+	return ServerConfig{
 		baseConfig:       getDefaultBaseConf(),
 		oidcServerConfig: getDefaultOidcServerConf(),
 		tokenConfig:      getDefaultTokenConf(),
 	}
 }
 
-func UnmarshalAuthServerConfFromIni(conf ini.File) (cfg AuthServerConfig) {
+func UnmarshalServerConfFromIni(conf ini.File) (cfg ServerConfig) {
 	cfg.baseConfig = unmarshalBaseConfFromIni(conf)
 	cfg.oidcServerConfig = unmarshalOidcServerConfFromIni(conf)
 	cfg.tokenConfig = unmarshalTokenConfFromIni(conf)
@@ -120,7 +120,7 @@ type Setter interface {
 	SetNewWorkConn(*msg.NewWorkConn) error
 }
 
-func NewAuthSetter(cfg AuthClientConfig) (authProvider Setter) {
+func NewAuthSetter(cfg ClientConfig) (authProvider Setter) {
 	switch cfg.AuthenticationMethod {
 	case consts.TokenAuthMethod:
 		authProvider = NewTokenAuth(cfg.baseConfig, cfg.tokenConfig)
@@ -139,7 +139,7 @@ type Verifier interface {
 	VerifyNewWorkConn(*msg.NewWorkConn) error
 }
 
-func NewAuthVerifier(cfg AuthServerConfig) (authVerifier Verifier) {
+func NewAuthVerifier(cfg ServerConfig) (authVerifier Verifier) {
 	switch cfg.AuthenticationMethod {
 	case consts.TokenAuthMethod:
 		authVerifier = NewTokenAuth(cfg.baseConfig, cfg.tokenConfig)

models/auth/oidc.go

@@ -26,10 +26,10 @@ import (
 )
 
 type oidcClientConfig struct {
-	// OidcClientId specifies the client ID to use to get a token in OIDC
+	// OidcClientID specifies the client ID to use to get a token in OIDC
 	// authentication if AuthenticationMethod == "oidc". By default, this value
 	// is "".
-	OidcClientId string `json:"oidc_client_id"`
+	OidcClientID string `json:"oidc_client_id"`
 	// OidcClientSecret specifies the client secret to use to get a token in OIDC
 	// authentication if AuthenticationMethod == "oidc". By default, this value
 	// is "".
@@ -37,18 +37,18 @@ type oidcClientConfig struct {
 	// OidcAudience specifies the audience of the token in OIDC authentication
 	//if AuthenticationMethod == "oidc". By default, this value is "".
 	OidcAudience string `json:"oidc_audience"`
-	// OidcTokenEndpointUrl specifies the URL which implements OIDC Token Endpoint.
+	// OidcTokenEndpointURL specifies the URL which implements OIDC Token Endpoint.
 	// It will be used to get an OIDC token if AuthenticationMethod == "oidc".
 	// By default, this value is "".
-	OidcTokenEndpointUrl string `json:"oidc_token_endpoint_url"`
+	OidcTokenEndpointURL string `json:"oidc_token_endpoint_url"`
 }
 
 func getDefaultOidcClientConf() oidcClientConfig {
 	return oidcClientConfig{
-		OidcClientId:         "",
+		OidcClientID:         "",
 		OidcClientSecret:     "",
 		OidcAudience:         "",
-		OidcTokenEndpointUrl: "",
+		OidcTokenEndpointURL: "",
 	}
 }
 
@@ -61,7 +61,7 @@ func unmarshalOidcClientConfFromIni(conf ini.File) oidcClientConfig {
 	cfg := getDefaultOidcClientConf()
 
 	if tmpStr, ok = conf.Get("common", "oidc_client_id"); ok {
-		cfg.OidcClientId = tmpStr
+		cfg.OidcClientID = tmpStr
 	}
 
 	if tmpStr, ok = conf.Get("common", "oidc_client_secret"); ok {
@@ -73,7 +73,7 @@ func unmarshalOidcClientConfFromIni(conf ini.File) oidcClientConfig {
 	}
 
 	if tmpStr, ok = conf.Get("common", "oidc_token_endpoint_url"); ok {
-		cfg.OidcTokenEndpointUrl = tmpStr
+		cfg.OidcTokenEndpointURL = tmpStr
 	}
 
 	return cfg
@@ -148,10 +148,10 @@ type OidcAuthProvider struct {
 
 func NewOidcAuthSetter(baseCfg baseConfig, cfg oidcClientConfig) *OidcAuthProvider {
 	tokenGenerator := &clientcredentials.Config{
-		ClientID:     cfg.OidcClientId,
+		ClientID:     cfg.OidcClientID,
 		ClientSecret: cfg.OidcClientSecret,
 		Scopes:       []string{cfg.OidcAudience},
-		TokenURL:     cfg.OidcTokenEndpointUrl,
+		TokenURL:     cfg.OidcTokenEndpointURL,
 	}
 
 	return &OidcAuthProvider{

models/config/client_common.go

@@ -29,17 +29,17 @@ import (
 // recommended to use GetDefaultClientConf instead of creating this object
 // directly, so that all unspecified fields have reasonable default values.
 type ClientCommonConf struct {
-	auth.AuthClientConfig
+	auth.ClientConfig
 	// ServerAddr specifies the address of the server to connect to. By
 	// default, this value is "0.0.0.0".
 	ServerAddr string `json:"server_addr"`
 	// ServerPort specifies the port to connect to the server on. By default,
 	// this value is 7000.
 	ServerPort int `json:"server_port"`
-	// HttpProxy specifies a proxy address to connect to the server through. If
+	// HTTPProxy specifies a proxy address to connect to the server through. If
 	// this value is "", the server will be connected to directly. By default,
 	// this value is read from the "http_proxy" environment variable.
-	HttpProxy string `json:"http_proxy"`
+	HTTPProxy string `json:"http_proxy"`
 	// LogFile specifies a file where logs will be written to. This value will
 	// only be used if LogWay is set appropriately. By default, this value is
 	// "console".
@@ -79,18 +79,18 @@ type ClientCommonConf struct {
 	// PoolCount specifies the number of connections the client will make to
 	// the server in advance. By default, this value is 0.
 	PoolCount int `json:"pool_count"`
-	// TcpMux toggles TCP stream multiplexing. This allows multiple requests
+	// TCPMux toggles TCP stream multiplexing. This allows multiple requests
 	// from a client to share a single TCP connection. If this value is true,
 	// the server must have TCP multiplexing enabled as well. By default, this
 	// value is true.
-	TcpMux bool `json:"tcp_mux"`
+	TCPMux bool `json:"tcp_mux"`
 	// User specifies a prefix for proxy names to distinguish them from other
 	// clients. If this value is not "", proxy names will automatically be
 	// changed to "{user}.{proxy_name}". By default, this value is "".
 	User string `json:"user"`
-	// DnsServer specifies a DNS server address for FRPC to use. If this value
+	// DNSServer specifies a DNS server address for FRPC to use. If this value
 	// is "", the default DNS will be used. By default, this value is "".
-	DnsServer string `json:"dns_server"`
+	DNSServer string `json:"dns_server"`
 	// LoginFailExit controls whether or not the client should exit after a
 	// failed login attempt. If false, the client will retry until a login
 	// attempt succeeds. By default, this value is true.
@@ -116,9 +116,9 @@ type ClientCommonConf struct {
 	HeartBeatTimeout int64 `json:"heartbeat_timeout"`
 	// Client meta info
 	Metas map[string]string `json:"metas"`
-	// UdpPacketSize specifies the udp packet size
+	// UDPPacketSize specifies the udp packet size
 	// By default, this value is 1500
-	UdpPacketSize int64 `json:"udp_packet_size"`
+	UDPPacketSize int64 `json:"udp_packet_size"`
 }
 
 // GetDefaultClientConf returns a client configuration with default values.
@@ -126,7 +126,7 @@ func GetDefaultClientConf() ClientCommonConf {
 	return ClientCommonConf{
 		ServerAddr:        "0.0.0.0",
 		ServerPort:        7000,
-		HttpProxy:         os.Getenv("http_proxy"),
+		HTTPProxy:         os.Getenv("http_proxy"),
 		LogFile:           "console",
 		LogWay:            "console",
 		LogLevel:          "info",
@@ -138,9 +138,9 @@ func GetDefaultClientConf() ClientCommonConf {
 		AdminPwd:          "",
 		AssetsDir:         "",
 		PoolCount:         1,
-		TcpMux:            true,
+		TCPMux:            true,
 		User:              "",
-		DnsServer:         "",
+		DNSServer:         "",
 		LoginFailExit:     true,
 		Start:             make(map[string]struct{}),
 		Protocol:          "tcp",
@@ -148,7 +148,7 @@ func GetDefaultClientConf() ClientCommonConf {
 		HeartBeatInterval: 30,
 		HeartBeatTimeout:  90,
 		Metas:             make(map[string]string),
-		UdpPacketSize:     1500,
+		UDPPacketSize:     1500,
 	}
 }
 
@@ -160,7 +160,7 @@ func UnmarshalClientConfFromIni(content string) (cfg ClientCommonConf, err error
 		return ClientCommonConf{}, fmt.Errorf("parse ini conf file error: %v", err)
 	}
 
-	cfg.AuthClientConfig = auth.UnmarshalAuthClientConfFromIni(conf)
+	cfg.ClientConfig = auth.UnmarshalClientConfFromIni(conf)
 
 	var (
 		tmpStr string
@@ -185,7 +185,7 @@ func UnmarshalClientConfFromIni(content string) (cfg ClientCommonConf, err error
 	}
 
 	if tmpStr, ok = conf.Get("common", "http_proxy"); ok {
-		cfg.HttpProxy = tmpStr
+		cfg.HTTPProxy = tmpStr
 	}
 
 	if tmpStr, ok = conf.Get("common", "log_file"); ok {
@@ -239,9 +239,9 @@ func UnmarshalClientConfFromIni(content string) (cfg ClientCommonConf, err error
 	}
 
 	if tmpStr, ok = conf.Get("common", "tcp_mux"); ok && tmpStr == "false" {
-		cfg.TcpMux = false
+		cfg.TCPMux = false
 	} else {
-		cfg.TcpMux = true
+		cfg.TCPMux = true
 	}
 
 	if tmpStr, ok = conf.Get("common", "user"); ok {
@@ -249,7 +249,7 @@ func UnmarshalClientConfFromIni(content string) (cfg ClientCommonConf, err error
 	}
 
 	if tmpStr, ok = conf.Get("common", "dns_server"); ok {
-		cfg.DnsServer = tmpStr
+		cfg.DNSServer = tmpStr
 	}
 
 	if tmpStr, ok = conf.Get("common", "start"); ok {
@@ -284,18 +284,16 @@ func UnmarshalClientConfFromIni(content string) (cfg ClientCommonConf, err error
 		if v, err = strconv.ParseInt(tmpStr, 10, 64); err != nil {
 			err = fmt.Errorf("Parse conf error: invalid heartbeat_timeout")
 			return
-		} else {
-			cfg.HeartBeatTimeout = v
 		}
+		cfg.HeartBeatTimeout = v
 	}
 
 	if tmpStr, ok = conf.Get("common", "heartbeat_interval"); ok {
 		if v, err = strconv.ParseInt(tmpStr, 10, 64); err != nil {
 			err = fmt.Errorf("Parse conf error: invalid heartbeat_interval")
 			return
-		} else {
-			cfg.HeartBeatInterval = v
 		}
+		cfg.HeartBeatInterval = v
 	}
 	for k, v := range conf.Section("common") {
 		if strings.HasPrefix(k, "meta_") {
@@ -306,9 +304,8 @@ func UnmarshalClientConfFromIni(content string) (cfg ClientCommonConf, err error
 		if v, err = strconv.ParseInt(tmpStr, 10, 64); err != nil {
 			err = fmt.Errorf("Parse conf error: invalid udp_packet_size")
 			return
-		} else {
-			cfg.UdpPacketSize = v
 		}
+		cfg.UDPPacketSize = v
 	}
 	return
 }

models/config/proxy.go

@@ -33,14 +33,14 @@ var (
 
 func init() {
 	proxyConfTypeMap = make(map[string]reflect.Type)
-	proxyConfTypeMap[consts.TcpProxy] = reflect.TypeOf(TcpProxyConf{})
-	proxyConfTypeMap[consts.TcpMuxProxy] = reflect.TypeOf(TcpMuxProxyConf{})
-	proxyConfTypeMap[consts.UdpProxy] = reflect.TypeOf(UdpProxyConf{})
-	proxyConfTypeMap[consts.HttpProxy] = reflect.TypeOf(HttpProxyConf{})
-	proxyConfTypeMap[consts.HttpsProxy] = reflect.TypeOf(HttpsProxyConf{})
-	proxyConfTypeMap[consts.StcpProxy] = reflect.TypeOf(StcpProxyConf{})
-	proxyConfTypeMap[consts.XtcpProxy] = reflect.TypeOf(XtcpProxyConf{})
-	proxyConfTypeMap[consts.SudpProxy] = reflect.TypeOf(SudpProxyConf{})
+	proxyConfTypeMap[consts.TCPProxy] = reflect.TypeOf(TCPProxyConf{})
+	proxyConfTypeMap[consts.TCPMuxProxy] = reflect.TypeOf(TCPMuxProxyConf{})
+	proxyConfTypeMap[consts.UDPProxy] = reflect.TypeOf(UDPProxyConf{})
+	proxyConfTypeMap[consts.HTTPProxy] = reflect.TypeOf(HTTPProxyConf{})
+	proxyConfTypeMap[consts.HTTPSProxy] = reflect.TypeOf(HTTPSProxyConf{})
+	proxyConfTypeMap[consts.STCPProxy] = reflect.TypeOf(STCPProxyConf{})
+	proxyConfTypeMap[consts.XTCPProxy] = reflect.TypeOf(XTCPProxyConf{})
+	proxyConfTypeMap[consts.SUDPProxy] = reflect.TypeOf(SUDPProxyConf{})
 }
 
 // NewConfByType creates a empty ProxyConf object by proxyType.
@@ -66,7 +66,7 @@ type ProxyConf interface {
 
 func NewProxyConfFromMsg(pMsg *msg.NewProxy, serverCfg ServerCommonConf) (cfg ProxyConf, err error) {
 	if pMsg.ProxyType == "" {
-		pMsg.ProxyType = consts.TcpProxy
+		pMsg.ProxyType = consts.TCPProxy
 	}
 
 	cfg = NewConfByType(pMsg.ProxyType)
@@ -82,8 +82,8 @@ func NewProxyConfFromMsg(pMsg *msg.NewProxy, serverCfg ServerCommonConf) (cfg Pr
 func NewProxyConfFromIni(prefix string, name string, section ini.Section) (cfg ProxyConf, err error) {
 	proxyType := section["type"]
 	if proxyType == "" {
-		proxyType = consts.TcpProxy
-		section["type"] = consts.TcpProxy
+		proxyType = consts.TCPProxy
+		section["type"] = consts.TCPProxy
 	}
 	cfg = NewConfByType(proxyType)
 	if cfg == nil {
@@ -210,14 +210,14 @@ func (cfg *BaseProxyConf) UnmarshalFromIni(prefix string, name string, section i
 	}
 
 	if cfg.HealthCheckType == "tcp" && cfg.Plugin == "" {
-		cfg.HealthCheckAddr = cfg.LocalIp + fmt.Sprintf(":%d", cfg.LocalPort)
+		cfg.HealthCheckAddr = cfg.LocalIP + fmt.Sprintf(":%d", cfg.LocalPort)
 	}
-	if cfg.HealthCheckType == "http" && cfg.Plugin == "" && cfg.HealthCheckUrl != "" {
-		s := fmt.Sprintf("http://%s:%d", cfg.LocalIp, cfg.LocalPort)
-		if !strings.HasPrefix(cfg.HealthCheckUrl, "/") {
+	if cfg.HealthCheckType == "http" && cfg.Plugin == "" && cfg.HealthCheckURL != "" {
+		s := fmt.Sprintf("http://%s:%d", cfg.LocalIP, cfg.LocalPort)
+		if !strings.HasPrefix(cfg.HealthCheckURL, "/") {
 			s += "/"
 		}
-		cfg.HealthCheckUrl = s + cfg.HealthCheckUrl
+		cfg.HealthCheckURL = s + cfg.HealthCheckURL
 	}
 
 	cfg.Metas = make(map[string]string)
@@ -280,9 +280,8 @@ func (cfg *BindInfoConf) UnmarshalFromIni(prefix string, name string, section in
 	if tmpStr, ok = section["remote_port"]; ok {
 		if v, err = strconv.ParseInt(tmpStr, 10, 64); err != nil {
 			return fmt.Errorf("Parse conf error: proxy [%s] remote_port error", name)
-		} else {
-			cfg.RemotePort = int(v)
 		}
+		cfg.RemotePort = int(v)
 	} else {
 		return fmt.Errorf("Parse conf error: proxy [%s] remote_port not found", name)
 	}
@@ -377,8 +376,8 @@ func (cfg *DomainConf) checkForSvr(serverCfg ServerCommonConf) (err error) {
 // LocalSvrConf configures what location the client will proxy to, or what
 // plugin will be used.
 type LocalSvrConf struct {
-	// LocalIp specifies the IP address or host name to proxy to.
-	LocalIp string `json:"local_ip"`
+	// LocalIP specifies the IP address or host name to proxy to.
+	LocalIP string `json:"local_ip"`
 	// LocalPort specifies the port to proxy to.
 	LocalPort int `json:"local_port"`
 
@@ -392,7 +391,7 @@ type LocalSvrConf struct {
 }
 
 func (cfg *LocalSvrConf) compare(cmp *LocalSvrConf) bool {
-	if cfg.LocalIp != cmp.LocalIp ||
+	if cfg.LocalIP != cmp.LocalIP ||
 		cfg.LocalPort != cmp.LocalPort {
 		return false
 	}
@@ -420,8 +419,8 @@ func (cfg *LocalSvrConf) UnmarshalFromIni(prefix string, name string, section in
 			}
 		}
 	} else {
-		if cfg.LocalIp = section["local_ip"]; cfg.LocalIp == "" {
-			cfg.LocalIp = "127.0.0.1"
+		if cfg.LocalIP = section["local_ip"]; cfg.LocalIP == "" {
+			cfg.LocalIP = "127.0.0.1"
 		}
 
 		if tmpStr, ok := section["local_port"]; ok {
@@ -437,7 +436,7 @@ func (cfg *LocalSvrConf) UnmarshalFromIni(prefix string, name string, section in
 
 func (cfg *LocalSvrConf) checkForCli() (err error) {
 	if cfg.Plugin == "" {
-		if cfg.LocalIp == "" {
+		if cfg.LocalIP == "" {
 			err = fmt.Errorf("local ip or plugin is required")
 			return
 		}
@@ -460,7 +459,7 @@ type HealthCheckConf struct {
 	// server. If a connection cannot be established, the health check fails.
 	//
 	// If the type is "http", a GET request will be made to the endpoint
-	// specified by HealthCheckUrl. If the response is not a 200, the health
+	// specified by HealthCheckURL. If the response is not a 200, the health
 	// check fails.
 	HealthCheckType string `json:"health_check_type"` // tcp | http
 	// HealthCheckTimeoutS specifies the number of seconds to wait for a health
@@ -473,9 +472,9 @@ type HealthCheckConf struct {
 	// HealthCheckIntervalS specifies the time in seconds between health
 	// checks. By default, this value is 10.
 	HealthCheckIntervalS int `json:"health_check_interval_s"`
-	// HealthCheckUrl specifies the address to send health checks to if the
+	// HealthCheckURL specifies the address to send health checks to if the
 	// health check type is "http".
-	HealthCheckUrl string `json:"health_check_url"`
+	HealthCheckURL string `json:"health_check_url"`
 	// HealthCheckAddr specifies the address to connect to if the health check
 	// type is "tcp".
 	HealthCheckAddr string `json:"-"`
@@ -486,7 +485,7 @@ func (cfg *HealthCheckConf) compare(cmp *HealthCheckConf) bool {
 		cfg.HealthCheckTimeoutS != cmp.HealthCheckTimeoutS ||
 		cfg.HealthCheckMaxFailed != cmp.HealthCheckMaxFailed ||
 		cfg.HealthCheckIntervalS != cmp.HealthCheckIntervalS ||
-		cfg.HealthCheckUrl != cmp.HealthCheckUrl {
+		cfg.HealthCheckURL != cmp.HealthCheckURL {
 		return false
 	}
 	return true
@@ -494,7 +493,7 @@ func (cfg *HealthCheckConf) compare(cmp *HealthCheckConf) bool {
 
 func (cfg *HealthCheckConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
 	cfg.HealthCheckType = section["health_check_type"]
-	cfg.HealthCheckUrl = section["health_check_url"]
+	cfg.HealthCheckURL = section["health_check_url"]
 
 	if tmpStr, ok := section["health_check_timeout_s"]; ok {
 		if cfg.HealthCheckTimeoutS, err = strconv.Atoi(tmpStr); err != nil {
@@ -521,7 +520,7 @@ func (cfg *HealthCheckConf) checkForCli() error {
 		return fmt.Errorf("unsupport health check type")
 	}
 	if cfg.HealthCheckType != "" {
-		if cfg.HealthCheckType == "http" && cfg.HealthCheckUrl == "" {
+		if cfg.HealthCheckType == "http" && cfg.HealthCheckURL == "" {
 			return fmt.Errorf("health_check_url is required for health check type 'http'")
 		}
 	}
@@ -529,13 +528,13 @@ func (cfg *HealthCheckConf) checkForCli() error {
 }
 
 // TCP
-type TcpProxyConf struct {
+type TCPProxyConf struct {
 	BaseProxyConf
 	BindInfoConf
 }
 
-func (cfg *TcpProxyConf) Compare(cmp ProxyConf) bool {
-	cmpConf, ok := cmp.(*TcpProxyConf)
+func (cfg *TCPProxyConf) Compare(cmp ProxyConf) bool {
+	cmpConf, ok := cmp.(*TCPProxyConf)
 	if !ok {
 		return false
 	}
@@ -547,12 +546,12 @@ func (cfg *TcpProxyConf) Compare(cmp ProxyConf) bool {
 	return true
 }
 
-func (cfg *TcpProxyConf) UnmarshalFromMsg(pMsg *msg.NewProxy) {
+func (cfg *TCPProxyConf) UnmarshalFromMsg(pMsg *msg.NewProxy) {
 	cfg.BaseProxyConf.UnmarshalFromMsg(pMsg)
 	cfg.BindInfoConf.UnmarshalFromMsg(pMsg)
 }
 
-func (cfg *TcpProxyConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
+func (cfg *TCPProxyConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
 	if err = cfg.BaseProxyConf.UnmarshalFromIni(prefix, name, section); err != nil {
 		return
 	}
@@ -562,30 +561,30 @@ func (cfg *TcpProxyConf) UnmarshalFromIni(prefix string, name string, section in
 	return
 }
 
-func (cfg *TcpProxyConf) MarshalToMsg(pMsg *msg.NewProxy) {
+func (cfg *TCPProxyConf) MarshalToMsg(pMsg *msg.NewProxy) {
 	cfg.BaseProxyConf.MarshalToMsg(pMsg)
 	cfg.BindInfoConf.MarshalToMsg(pMsg)
 }
 
-func (cfg *TcpProxyConf) CheckForCli() (err error) {
+func (cfg *TCPProxyConf) CheckForCli() (err error) {
 	if err = cfg.BaseProxyConf.checkForCli(); err != nil {
 		return err
 	}
 	return
 }
 
-func (cfg *TcpProxyConf) CheckForSvr(serverCfg ServerCommonConf) error { return nil }
+func (cfg *TCPProxyConf) CheckForSvr(serverCfg ServerCommonConf) error { return nil }
 
 // TCP Multiplexer
-type TcpMuxProxyConf struct {
+type TCPMuxProxyConf struct {
 	BaseProxyConf
 	DomainConf
 
 	Multiplexer string `json:"multiplexer"`
 }
 
-func (cfg *TcpMuxProxyConf) Compare(cmp ProxyConf) bool {
-	cmpConf, ok := cmp.(*TcpMuxProxyConf)
+func (cfg *TCPMuxProxyConf) Compare(cmp ProxyConf) bool {
+	cmpConf, ok := cmp.(*TCPMuxProxyConf)
 	if !ok {
 		return false
 	}
@@ -598,13 +597,13 @@ func (cfg *TcpMuxProxyConf) Compare(cmp ProxyConf) bool {
 	return true
 }
 
-func (cfg *TcpMuxProxyConf) UnmarshalFromMsg(pMsg *msg.NewProxy) {
+func (cfg *TCPMuxProxyConf) UnmarshalFromMsg(pMsg *msg.NewProxy) {
 	cfg.BaseProxyConf.UnmarshalFromMsg(pMsg)
 	cfg.DomainConf.UnmarshalFromMsg(pMsg)
 	cfg.Multiplexer = pMsg.Multiplexer
 }
 
-func (cfg *TcpMuxProxyConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
+func (cfg *TCPMuxProxyConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
 	if err = cfg.BaseProxyConf.UnmarshalFromIni(prefix, name, section); err != nil {
 		return
 	}
@@ -613,37 +612,37 @@ func (cfg *TcpMuxProxyConf) UnmarshalFromIni(prefix string, name string, section
 	}
 
 	cfg.Multiplexer = section["multiplexer"]
-	if cfg.Multiplexer != consts.HttpConnectTcpMultiplexer {
+	if cfg.Multiplexer != consts.HTTPConnectTCPMultiplexer {
 		return fmt.Errorf("parse conf error: proxy [%s] incorrect multiplexer [%s]", name, cfg.Multiplexer)
 	}
 	return
 }
 
-func (cfg *TcpMuxProxyConf) MarshalToMsg(pMsg *msg.NewProxy) {
+func (cfg *TCPMuxProxyConf) MarshalToMsg(pMsg *msg.NewProxy) {
 	cfg.BaseProxyConf.MarshalToMsg(pMsg)
 	cfg.DomainConf.MarshalToMsg(pMsg)
 	pMsg.Multiplexer = cfg.Multiplexer
 }
 
-func (cfg *TcpMuxProxyConf) CheckForCli() (err error) {
+func (cfg *TCPMuxProxyConf) CheckForCli() (err error) {
 	if err = cfg.BaseProxyConf.checkForCli(); err != nil {
 		return err
 	}
 	if err = cfg.DomainConf.checkForCli(); err != nil {
 		return err
 	}
-	if cfg.Multiplexer != consts.HttpConnectTcpMultiplexer {
+	if cfg.Multiplexer != consts.HTTPConnectTCPMultiplexer {
 		return fmt.Errorf("parse conf error: incorrect multiplexer [%s]", cfg.Multiplexer)
 	}
 	return
 }
 
-func (cfg *TcpMuxProxyConf) CheckForSvr(serverCfg ServerCommonConf) (err error) {
-	if cfg.Multiplexer != consts.HttpConnectTcpMultiplexer {
+func (cfg *TCPMuxProxyConf) CheckForSvr(serverCfg ServerCommonConf) (err error) {
+	if cfg.Multiplexer != consts.HTTPConnectTCPMultiplexer {
 		return fmt.Errorf("proxy [%s] incorrect multiplexer [%s]", cfg.ProxyName, cfg.Multiplexer)
 	}
 
-	if cfg.Multiplexer == consts.HttpConnectTcpMultiplexer && serverCfg.TcpMuxHttpConnectPort == 0 {
+	if cfg.Multiplexer == consts.HTTPConnectTCPMultiplexer && serverCfg.TCPMuxHTTPConnectPort == 0 {
 		return fmt.Errorf("proxy [%s] type [tcpmux] with multiplexer [httpconnect] requires tcpmux_httpconnect_port configuration", cfg.ProxyName)
 	}
 
@@ -655,13 +654,13 @@ func (cfg *TcpMuxProxyConf) CheckForSvr(serverCfg ServerCommonConf) (err error)
 }
 
 // UDP
-type UdpProxyConf struct {
+type UDPProxyConf struct {
 	BaseProxyConf
 	BindInfoConf
 }
 
-func (cfg *UdpProxyConf) Compare(cmp ProxyConf) bool {
-	cmpConf, ok := cmp.(*UdpProxyConf)
+func (cfg *UDPProxyConf) Compare(cmp ProxyConf) bool {
+	cmpConf, ok := cmp.(*UDPProxyConf)
 	if !ok {
 		return false
 	}
@@ -673,12 +672,12 @@ func (cfg *UdpProxyConf) Compare(cmp ProxyConf) bool {
 	return true
 }
 
-func (cfg *UdpProxyConf) UnmarshalFromMsg(pMsg *msg.NewProxy) {
+func (cfg *UDPProxyConf) UnmarshalFromMsg(pMsg *msg.NewProxy) {
 	cfg.BaseProxyConf.UnmarshalFromMsg(pMsg)
 	cfg.BindInfoConf.UnmarshalFromMsg(pMsg)
 }
 
-func (cfg *UdpProxyConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
+func (cfg *UDPProxyConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
 	if err = cfg.BaseProxyConf.UnmarshalFromIni(prefix, name, section); err != nil {
 		return
 	}
@@ -688,34 +687,34 @@ func (cfg *UdpProxyConf) UnmarshalFromIni(prefix string, name string, section in
 	return
 }
 
-func (cfg *UdpProxyConf) MarshalToMsg(pMsg *msg.NewProxy) {
+func (cfg *UDPProxyConf) MarshalToMsg(pMsg *msg.NewProxy) {
 	cfg.BaseProxyConf.MarshalToMsg(pMsg)
 	cfg.BindInfoConf.MarshalToMsg(pMsg)
 }
 
-func (cfg *UdpProxyConf) CheckForCli() (err error) {
+func (cfg *UDPProxyConf) CheckForCli() (err error) {
 	if err = cfg.BaseProxyConf.checkForCli(); err != nil {
 		return
 	}
 	return
 }
 
-func (cfg *UdpProxyConf) CheckForSvr(serverCfg ServerCommonConf) error { return nil }
+func (cfg *UDPProxyConf) CheckForSvr(serverCfg ServerCommonConf) error { return nil }
 
 // HTTP
-type HttpProxyConf struct {
+type HTTPProxyConf struct {
 	BaseProxyConf
 	DomainConf
 
 	Locations         []string          `json:"locations"`
-	HttpUser          string            `json:"http_user"`
-	HttpPwd           string            `json:"http_pwd"`
+	HTTPUser          string            `json:"http_user"`
+	HTTPPwd           string            `json:"http_pwd"`
 	HostHeaderRewrite string            `json:"host_header_rewrite"`
 	Headers           map[string]string `json:"headers"`
 }
 
-func (cfg *HttpProxyConf) Compare(cmp ProxyConf) bool {
-	cmpConf, ok := cmp.(*HttpProxyConf)
+func (cfg *HTTPProxyConf) Compare(cmp ProxyConf) bool {
+	cmpConf, ok := cmp.(*HTTPProxyConf)
 	if !ok {
 		return false
 	}
@@ -724,36 +723,36 @@ func (cfg *HttpProxyConf) Compare(cmp ProxyConf) bool {
 		!cfg.DomainConf.compare(&cmpConf.DomainConf) ||
 		strings.Join(cfg.Locations, " ") != strings.Join(cmpConf.Locations, " ") ||
 		cfg.HostHeaderRewrite != cmpConf.HostHeaderRewrite ||
-		cfg.HttpUser != cmpConf.HttpUser ||
-		cfg.HttpPwd != cmpConf.HttpPwd ||
+		cfg.HTTPUser != cmpConf.HTTPUser ||
+		cfg.HTTPPwd != cmpConf.HTTPPwd ||
 		len(cfg.Headers) != len(cmpConf.Headers) {
 		return false
 	}
 
 	for k, v := range cfg.Headers {
-		if v2, ok := cmpConf.Headers[k]; !ok {
+		v2, ok := cmpConf.Headers[k]
+		if !ok {
+			return false
+		}
+		if v != v2 {
 			return false
-		} else {
-			if v != v2 {
-				return false
-			}
 		}
 	}
 	return true
 }
 
-func (cfg *HttpProxyConf) UnmarshalFromMsg(pMsg *msg.NewProxy) {
+func (cfg *HTTPProxyConf) UnmarshalFromMsg(pMsg *msg.NewProxy) {
 	cfg.BaseProxyConf.UnmarshalFromMsg(pMsg)
 	cfg.DomainConf.UnmarshalFromMsg(pMsg)
 
 	cfg.Locations = pMsg.Locations
 	cfg.HostHeaderRewrite = pMsg.HostHeaderRewrite
-	cfg.HttpUser = pMsg.HttpUser
-	cfg.HttpPwd = pMsg.HttpPwd
+	cfg.HTTPUser = pMsg.HTTPUser
+	cfg.HTTPPwd = pMsg.HTTPPwd
 	cfg.Headers = pMsg.Headers
 }
 
-func (cfg *HttpProxyConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
+func (cfg *HTTPProxyConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
 	if err = cfg.BaseProxyConf.UnmarshalFromIni(prefix, name, section); err != nil {
 		return
 	}
@@ -772,8 +771,8 @@ func (cfg *HttpProxyConf) UnmarshalFromIni(prefix string, name string, section i
 	}
 
 	cfg.HostHeaderRewrite = section["host_header_rewrite"]
-	cfg.HttpUser = section["http_user"]
-	cfg.HttpPwd = section["http_pwd"]
+	cfg.HTTPUser = section["http_user"]
+	cfg.HTTPPwd = section["http_pwd"]
 	cfg.Headers = make(map[string]string)
 
 	for k, v := range section {
@@ -784,18 +783,18 @@ func (cfg *HttpProxyConf) UnmarshalFromIni(prefix string, name string, section i
 	return
 }
 
-func (cfg *HttpProxyConf) MarshalToMsg(pMsg *msg.NewProxy) {
+func (cfg *HTTPProxyConf) MarshalToMsg(pMsg *msg.NewProxy) {
 	cfg.BaseProxyConf.MarshalToMsg(pMsg)
 	cfg.DomainConf.MarshalToMsg(pMsg)
 
 	pMsg.Locations = cfg.Locations
 	pMsg.HostHeaderRewrite = cfg.HostHeaderRewrite
-	pMsg.HttpUser = cfg.HttpUser
-	pMsg.HttpPwd = cfg.HttpPwd
+	pMsg.HTTPUser = cfg.HTTPUser
+	pMsg.HTTPPwd = cfg.HTTPPwd
 	pMsg.Headers = cfg.Headers
 }
 
-func (cfg *HttpProxyConf) CheckForCli() (err error) {
+func (cfg *HTTPProxyConf) CheckForCli() (err error) {
 	if err = cfg.BaseProxyConf.checkForCli(); err != nil {
 		return
 	}
@@ -805,8 +804,8 @@ func (cfg *HttpProxyConf) CheckForCli() (err error) {
 	return
 }
 
-func (cfg *HttpProxyConf) CheckForSvr(serverCfg ServerCommonConf) (err error) {
-	if serverCfg.VhostHttpPort == 0 {
+func (cfg *HTTPProxyConf) CheckForSvr(serverCfg ServerCommonConf) (err error) {
+	if serverCfg.VhostHTTPPort == 0 {
 		return fmt.Errorf("type [http] not support when vhost_http_port is not set")
 	}
 	if err = cfg.DomainConf.checkForSvr(serverCfg); err != nil {
@@ -817,13 +816,13 @@ func (cfg *HttpProxyConf) CheckForSvr(serverCfg ServerCommonConf) (err error) {
 }
 
 // HTTPS
-type HttpsProxyConf struct {
+type HTTPSProxyConf struct {
 	BaseProxyConf
 	DomainConf
 }
 
-func (cfg *HttpsProxyConf) Compare(cmp ProxyConf) bool {
-	cmpConf, ok := cmp.(*HttpsProxyConf)
+func (cfg *HTTPSProxyConf) Compare(cmp ProxyConf) bool {
+	cmpConf, ok := cmp.(*HTTPSProxyConf)
 	if !ok {
 		return false
 	}
@@ -835,12 +834,12 @@ func (cfg *HttpsProxyConf) Compare(cmp ProxyConf) bool {
 	return true
 }
 
-func (cfg *HttpsProxyConf) UnmarshalFromMsg(pMsg *msg.NewProxy) {
+func (cfg *HTTPSProxyConf) UnmarshalFromMsg(pMsg *msg.NewProxy) {
 	cfg.BaseProxyConf.UnmarshalFromMsg(pMsg)
 	cfg.DomainConf.UnmarshalFromMsg(pMsg)
 }
 
-func (cfg *HttpsProxyConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
+func (cfg *HTTPSProxyConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
 	if err = cfg.BaseProxyConf.UnmarshalFromIni(prefix, name, section); err != nil {
 		return
 	}
@@ -850,12 +849,12 @@ func (cfg *HttpsProxyConf) UnmarshalFromIni(prefix string, name string, section
 	return
 }
 
-func (cfg *HttpsProxyConf) MarshalToMsg(pMsg *msg.NewProxy) {
+func (cfg *HTTPSProxyConf) MarshalToMsg(pMsg *msg.NewProxy) {
 	cfg.BaseProxyConf.MarshalToMsg(pMsg)
 	cfg.DomainConf.MarshalToMsg(pMsg)
 }
 
-func (cfg *HttpsProxyConf) CheckForCli() (err error) {
+func (cfg *HTTPSProxyConf) CheckForCli() (err error) {
 	if err = cfg.BaseProxyConf.checkForCli(); err != nil {
 		return
 	}
@@ -865,8 +864,8 @@ func (cfg *HttpsProxyConf) CheckForCli() (err error) {
 	return
 }
 
-func (cfg *HttpsProxyConf) CheckForSvr(serverCfg ServerCommonConf) (err error) {
-	if serverCfg.VhostHttpsPort == 0 {
+func (cfg *HTTPSProxyConf) CheckForSvr(serverCfg ServerCommonConf) (err error) {
+	if serverCfg.VhostHTTPSPort == 0 {
 		return fmt.Errorf("type [https] not support when vhost_https_port is not set")
 	}
 	if err = cfg.DomainConf.checkForSvr(serverCfg); err != nil {
@@ -877,15 +876,15 @@ func (cfg *HttpsProxyConf) CheckForSvr(serverCfg ServerCommonConf) (err error) {
 }
 
 // SUDP
-type SudpProxyConf struct {
+type SUDPProxyConf struct {
 	BaseProxyConf
 
 	Role string `json:"role"`
 	Sk   string `json:"sk"`
 }
 
-func (cfg *SudpProxyConf) Compare(cmp ProxyConf) bool {
-	cmpConf, ok := cmp.(*SudpProxyConf)
+func (cfg *SUDPProxyConf) Compare(cmp ProxyConf) bool {
+	cmpConf, ok := cmp.(*SUDPProxyConf)
 	if !ok {
 		return false
 	}
@@ -898,7 +897,7 @@ func (cfg *SudpProxyConf) Compare(cmp ProxyConf) bool {
 	return true
 }
 
-func (cfg *SudpProxyConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
+func (cfg *SUDPProxyConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
 	if err = cfg.BaseProxyConf.UnmarshalFromIni(prefix, name, section); err != nil {
 		return
 	}
@@ -916,12 +915,12 @@ func (cfg *SudpProxyConf) UnmarshalFromIni(prefix string, name string, section i
 	return
 }
 
-func (cfg *SudpProxyConf) MarshalToMsg(pMsg *msg.NewProxy) {
+func (cfg *SUDPProxyConf) MarshalToMsg(pMsg *msg.NewProxy) {
 	cfg.BaseProxyConf.MarshalToMsg(pMsg)
 	pMsg.Sk = cfg.Sk
 }
 
-func (cfg *SudpProxyConf) CheckForCli() (err error) {
+func (cfg *SUDPProxyConf) CheckForCli() (err error) {
 	if err = cfg.BaseProxyConf.checkForCli(); err != nil {
 		return
 	}
@@ -932,26 +931,26 @@ func (cfg *SudpProxyConf) CheckForCli() (err error) {
 	return
 }
 
-func (cfg *SudpProxyConf) CheckForSvr(serverCfg ServerCommonConf) (err error) {
+func (cfg *SUDPProxyConf) CheckForSvr(serverCfg ServerCommonConf) (err error) {
 	return
 }
 
 // Only for role server.
-func (cfg *SudpProxyConf) UnmarshalFromMsg(pMsg *msg.NewProxy) {
+func (cfg *SUDPProxyConf) UnmarshalFromMsg(pMsg *msg.NewProxy) {
 	cfg.BaseProxyConf.UnmarshalFromMsg(pMsg)
 	cfg.Sk = pMsg.Sk
 }
 
 // STCP
-type StcpProxyConf struct {
+type STCPProxyConf struct {
 	BaseProxyConf
 
 	Role string `json:"role"`
 	Sk   string `json:"sk"`
 }
 
-func (cfg *StcpProxyConf) Compare(cmp ProxyConf) bool {
-	cmpConf, ok := cmp.(*StcpProxyConf)
+func (cfg *STCPProxyConf) Compare(cmp ProxyConf) bool {
+	cmpConf, ok := cmp.(*STCPProxyConf)
 	if !ok {
 		return false
 	}
@@ -965,12 +964,12 @@ func (cfg *StcpProxyConf) Compare(cmp ProxyConf) bool {
 }
 
 // Only for role server.
-func (cfg *StcpProxyConf) UnmarshalFromMsg(pMsg *msg.NewProxy) {
+func (cfg *STCPProxyConf) UnmarshalFromMsg(pMsg *msg.NewProxy) {
 	cfg.BaseProxyConf.UnmarshalFromMsg(pMsg)
 	cfg.Sk = pMsg.Sk
 }
 
-func (cfg *StcpProxyConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
+func (cfg *STCPProxyConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
 	if err = cfg.BaseProxyConf.UnmarshalFromIni(prefix, name, section); err != nil {
 		return
 	}
@@ -988,12 +987,12 @@ func (cfg *StcpProxyConf) UnmarshalFromIni(prefix string, name string, section i
 	return
 }
 
-func (cfg *StcpProxyConf) MarshalToMsg(pMsg *msg.NewProxy) {
+func (cfg *STCPProxyConf) MarshalToMsg(pMsg *msg.NewProxy) {
 	cfg.BaseProxyConf.MarshalToMsg(pMsg)
 	pMsg.Sk = cfg.Sk
 }
 
-func (cfg *StcpProxyConf) CheckForCli() (err error) {
+func (cfg *STCPProxyConf) CheckForCli() (err error) {
 	if err = cfg.BaseProxyConf.checkForCli(); err != nil {
 		return
 	}
@@ -1004,20 +1003,20 @@ func (cfg *StcpProxyConf) CheckForCli() (err error) {
 	return
 }
 
-func (cfg *StcpProxyConf) CheckForSvr(serverCfg ServerCommonConf) (err error) {
+func (cfg *STCPProxyConf) CheckForSvr(serverCfg ServerCommonConf) (err error) {
 	return
 }
 
 // XTCP
-type XtcpProxyConf struct {
+type XTCPProxyConf struct {
 	BaseProxyConf
 
 	Role string `json:"role"`
 	Sk   string `json:"sk"`
 }
 
-func (cfg *XtcpProxyConf) Compare(cmp ProxyConf) bool {
-	cmpConf, ok := cmp.(*XtcpProxyConf)
+func (cfg *XTCPProxyConf) Compare(cmp ProxyConf) bool {
+	cmpConf, ok := cmp.(*XTCPProxyConf)
 	if !ok {
 		return false
 	}
@@ -1032,12 +1031,12 @@ func (cfg *XtcpProxyConf) Compare(cmp ProxyConf) bool {
 }
 
 // Only for role server.
-func (cfg *XtcpProxyConf) UnmarshalFromMsg(pMsg *msg.NewProxy) {
+func (cfg *XTCPProxyConf) UnmarshalFromMsg(pMsg *msg.NewProxy) {
 	cfg.BaseProxyConf.UnmarshalFromMsg(pMsg)
 	cfg.Sk = pMsg.Sk
 }
 
-func (cfg *XtcpProxyConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
+func (cfg *XTCPProxyConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
 	if err = cfg.BaseProxyConf.UnmarshalFromIni(prefix, name, section); err != nil {
 		return
 	}
@@ -1055,12 +1054,12 @@ func (cfg *XtcpProxyConf) UnmarshalFromIni(prefix string, name string, section i
 	return
 }
 
-func (cfg *XtcpProxyConf) MarshalToMsg(pMsg *msg.NewProxy) {
+func (cfg *XTCPProxyConf) MarshalToMsg(pMsg *msg.NewProxy) {
 	cfg.BaseProxyConf.MarshalToMsg(pMsg)
 	pMsg.Sk = cfg.Sk
 }
 
-func (cfg *XtcpProxyConf) CheckForCli() (err error) {
+func (cfg *XTCPProxyConf) CheckForCli() (err error) {
 	if err = cfg.BaseProxyConf.checkForCli(); err != nil {
 		return
 	}
@@ -1071,7 +1070,7 @@ func (cfg *XtcpProxyConf) CheckForCli() (err error) {
 	return
 }
 
-func (cfg *XtcpProxyConf) CheckForSvr(serverCfg ServerCommonConf) (err error) {
+func (cfg *XTCPProxyConf) CheckForSvr(serverCfg ServerCommonConf) (err error) {
 	return
 }
 

models/config/server_common.go

@@ -30,40 +30,40 @@ import (
 // recommended to use GetDefaultServerConf instead of creating this object
 // directly, so that all unspecified fields have reasonable default values.
 type ServerCommonConf struct {
-	auth.AuthServerConfig
+	auth.ServerConfig
 	// BindAddr specifies the address that the server binds to. By default,
 	// this value is "0.0.0.0".
 	BindAddr string `json:"bind_addr"`
 	// BindPort specifies the port that the server listens on. By default, this
 	// value is 7000.
 	BindPort int `json:"bind_port"`
-	// BindUdpPort specifies the UDP port that the server listens on. If this
+	// BindUDPPort specifies the UDP port that the server listens on. If this
 	// value is 0, the server will not listen for UDP connections. By default,
 	// this value is 0
-	BindUdpPort int `json:"bind_udp_port"`
-	// BindKcpPort specifies the KCP port that the server listens on. If this
+	BindUDPPort int `json:"bind_udp_port"`
+	// KCPBindPort specifies the KCP port that the server listens on. If this
 	// value is 0, the server will not listen for KCP connections. By default,
 	// this value is 0.
-	KcpBindPort int `json:"kcp_bind_port"`
+	KCPBindPort int `json:"kcp_bind_port"`
 	// ProxyBindAddr specifies the address that the proxy binds to. This value
 	// may be the same as BindAddr. By default, this value is "0.0.0.0".
 	ProxyBindAddr string `json:"proxy_bind_addr"`
-	// VhostHttpPort specifies the port that the server listens for HTTP Vhost
+	// VhostHTTPPort specifies the port that the server listens for HTTP Vhost
 	// requests. If this value is 0, the server will not listen for HTTP
 	// requests. By default, this value is 0.
-	VhostHttpPort int `json:"vhost_http_port"`
-	// VhostHttpsPort specifies the port that the server listens for HTTPS
+	VhostHTTPPort int `json:"vhost_http_port"`
+	// VhostHTTPSPort specifies the port that the server listens for HTTPS
 	// Vhost requests. If this value is 0, the server will not listen for HTTPS
 	// requests. By default, this value is 0.
-	VhostHttpsPort int `json:"vhost_https_port"`
-	// TcpMuxHttpConnectPort specifies the port that the server listens for TCP
+	VhostHTTPSPort int `json:"vhost_https_port"`
+	// TCPMuxHTTPConnectPort specifies the port that the server listens for TCP
 	// HTTP CONNECT requests. If the value is 0, the server will not multiplex TCP
 	// requests on one single port. If it's not - it will listen on this value for
 	// HTTP CONNECT requests. By default, this value is 0.
-	TcpMuxHttpConnectPort int `json:"tcpmux_httpconnect_port"`
-	// VhostHttpTimeout specifies the response header timeout for the Vhost
+	TCPMuxHTTPConnectPort int `json:"tcpmux_httpconnect_port"`
+	// VhostHTTPTimeout specifies the response header timeout for the Vhost
 	// HTTP server, in seconds. By default, this value is 60.
-	VhostHttpTimeout int64 `json:"vhost_http_timeout"`
+	VhostHTTPTimeout int64 `json:"vhost_http_timeout"`
 	// DashboardAddr specifies the address that the dashboard binds to. By
 	// default, this value is "0.0.0.0".
 	DashboardAddr string `json:"dashboard_addr"`
@@ -113,10 +113,10 @@ type ServerCommonConf struct {
 	// "test", the resulting URL would be "test.frps.com". By default, this
 	// value is "".
 	SubDomainHost string `json:"subdomain_host"`
-	// TcpMux toggles TCP stream multiplexing. This allows multiple requests
+	// TCPMux toggles TCP stream multiplexing. This allows multiple requests
 	// from a client to share a single TCP connection. By default, this value
 	// is true.
-	TcpMux bool `json:"tcp_mux"`
+	TCPMux bool `json:"tcp_mux"`
 	// Custom404Page specifies a path to a custom 404 page to display. If this
 	// value is "", a default page will be displayed. By default, this value is
 	// "".
@@ -133,9 +133,9 @@ type ServerCommonConf struct {
 	// may proxy to. If this value is 0, no limit will be applied. By default,
 	// this value is 0.
 	MaxPortsPerClient int64 `json:"max_ports_per_client"`
-	// TlsOnly specifies whether to only accept TLS-encrypted connections. By
+	// TLSOnly specifies whether to only accept TLS-encrypted connections. By
 	// default, the value is false.
-	TlsOnly bool `json:"tls_only"`
+	TLSOnly bool `json:"tls_only"`
 	// HeartBeatTimeout specifies the maximum time to wait for a heartbeat
 	// before terminating the connection. It is not recommended to change this
 	// value. By default, this value is 90.
@@ -145,9 +145,9 @@ type ServerCommonConf struct {
 	UserConnTimeout int64 `json:"user_conn_timeout"`
 	// HTTPPlugins specify the server plugins support HTTP protocol.
 	HTTPPlugins map[string]plugin.HTTPPluginOptions `json:"http_plugins"`
-	// UdpPacketSize specifies the udp packet size
+	// UDPPacketSize specifies the UDP packet size
 	// By default, this value is 1500
-	UdpPacketSize int64 `json:"udp_packet_size"`
+	UDPPacketSize int64 `json:"udp_packet_size"`
 }
 
 // GetDefaultServerConf returns a server configuration with reasonable
@@ -156,13 +156,13 @@ func GetDefaultServerConf() ServerCommonConf {
 	return ServerCommonConf{
 		BindAddr:               "0.0.0.0",
 		BindPort:               7000,
-		BindUdpPort:            0,
-		KcpBindPort:            0,
+		BindUDPPort:            0,
+		KCPBindPort:            0,
 		ProxyBindAddr:          "0.0.0.0",
-		VhostHttpPort:          0,
-		VhostHttpsPort:         0,
-		TcpMuxHttpConnectPort:  0,
-		VhostHttpTimeout:       60,
+		VhostHTTPPort:          0,
+		VhostHTTPSPort:         0,
+		TCPMuxHTTPConnectPort:  0,
+		VhostHTTPTimeout:       60,
 		DashboardAddr:          "0.0.0.0",
 		DashboardPort:          0,
 		DashboardUser:          "admin",
@@ -176,16 +176,16 @@ func GetDefaultServerConf() ServerCommonConf {
 		DisableLogColor:        false,
 		DetailedErrorsToClient: true,
 		SubDomainHost:          "",
-		TcpMux:                 true,
+		TCPMux:                 true,
 		AllowPorts:             make(map[int]struct{}),
 		MaxPoolCount:           5,
 		MaxPortsPerClient:      0,
-		TlsOnly:                false,
+		TLSOnly:                false,
 		HeartBeatTimeout:       90,
 		UserConnTimeout:        10,
 		Custom404Page:          "",
 		HTTPPlugins:            make(map[string]plugin.HTTPPluginOptions),
-		UdpPacketSize:          1500,
+		UDPPacketSize:          1500,
 	}
 }
 
@@ -202,7 +202,7 @@ func UnmarshalServerConfFromIni(content string) (cfg ServerCommonConf, err error
 
 	UnmarshalPluginsFromIni(conf, &cfg)
 
-	cfg.AuthServerConfig = auth.UnmarshalAuthServerConfFromIni(conf)
+	cfg.ServerConfig = auth.UnmarshalServerConfFromIni(conf)
 
 	var (
 		tmpStr string
@@ -217,27 +217,24 @@ func UnmarshalServerConfFromIni(content string) (cfg ServerCommonConf, err error
 		if v, err = strconv.ParseInt(tmpStr, 10, 64); err != nil {
 			err = fmt.Errorf("Parse conf error: invalid bind_port")
 			return
-		} else {
-			cfg.BindPort = int(v)
 		}
+		cfg.BindPort = int(v)
 	}
 
 	if tmpStr, ok = conf.Get("common", "bind_udp_port"); ok {
 		if v, err = strconv.ParseInt(tmpStr, 10, 64); err != nil {
 			err = fmt.Errorf("Parse conf error: invalid bind_udp_port")
 			return
-		} else {
-			cfg.BindUdpPort = int(v)
 		}
+		cfg.BindUDPPort = int(v)
 	}
 
 	if tmpStr, ok = conf.Get("common", "kcp_bind_port"); ok {
 		if v, err = strconv.ParseInt(tmpStr, 10, 64); err != nil {
 			err = fmt.Errorf("Parse conf error: invalid kcp_bind_port")
 			return
-		} else {
-			cfg.KcpBindPort = int(v)
 		}
+		cfg.KCPBindPort = int(v)
 	}
 
 	if tmpStr, ok = conf.Get("common", "proxy_bind_addr"); ok {
@@ -250,33 +247,30 @@ func UnmarshalServerConfFromIni(content string) (cfg ServerCommonConf, err error
 		if v, err = strconv.ParseInt(tmpStr, 10, 64); err != nil {
 			err = fmt.Errorf("Parse conf error: invalid vhost_http_port")
 			return
-		} else {
-			cfg.VhostHttpPort = int(v)
 		}
+		cfg.VhostHTTPPort = int(v)
 	} else {
-		cfg.VhostHttpPort = 0
+		cfg.VhostHTTPPort = 0
 	}
 
 	if tmpStr, ok = conf.Get("common", "vhost_https_port"); ok {
 		if v, err = strconv.ParseInt(tmpStr, 10, 64); err != nil {
 			err = fmt.Errorf("Parse conf error: invalid vhost_https_port")
 			return
-		} else {
-			cfg.VhostHttpsPort = int(v)
 		}
+		cfg.VhostHTTPSPort = int(v)
 	} else {
-		cfg.VhostHttpsPort = 0
+		cfg.VhostHTTPSPort = 0
 	}
 
 	if tmpStr, ok = conf.Get("common", "tcpmux_httpconnect_port"); ok {
 		if v, err = strconv.ParseInt(tmpStr, 10, 64); err != nil {
 			err = fmt.Errorf("Parse conf error: invalid tcpmux_httpconnect_port")
 			return
-		} else {
-			cfg.TcpMuxHttpConnectPort = int(v)
 		}
+		cfg.TCPMuxHTTPConnectPort = int(v)
 	} else {
-		cfg.TcpMuxHttpConnectPort = 0
+		cfg.TCPMuxHTTPConnectPort = 0
 	}
 
 	if tmpStr, ok = conf.Get("common", "vhost_http_timeout"); ok {
@@ -284,9 +278,8 @@ func UnmarshalServerConfFromIni(content string) (cfg ServerCommonConf, err error
 		if errRet != nil || v < 0 {
 			err = fmt.Errorf("Parse conf error: invalid vhost_http_timeout")
 			return
-		} else {
-			cfg.VhostHttpTimeout = v
 		}
+		cfg.VhostHTTPTimeout = v
 	}
 
 	if tmpStr, ok = conf.Get("common", "dashboard_addr"); ok {
@@ -299,9 +292,8 @@ func UnmarshalServerConfFromIni(content string) (cfg ServerCommonConf, err error
 		if v, err = strconv.ParseInt(tmpStr, 10, 64); err != nil {
 			err = fmt.Errorf("Parse conf error: invalid dashboard_port")
 			return
-		} else {
-			cfg.DashboardPort = int(v)
 		}
+		cfg.DashboardPort = int(v)
 	} else {
 		cfg.DashboardPort = 0
 	}
@@ -369,26 +361,26 @@ func UnmarshalServerConfFromIni(content string) (cfg ServerCommonConf, err error
 		if v, err = strconv.ParseInt(tmpStr, 10, 64); err != nil {
 			err = fmt.Errorf("Parse conf error: invalid max_pool_count")
 			return
-		} else {
-			if v < 0 {
-				err = fmt.Errorf("Parse conf error: invalid max_pool_count")
-				return
-			}
-			cfg.MaxPoolCount = v
 		}
+
+		if v < 0 {
+			err = fmt.Errorf("Parse conf error: invalid max_pool_count")
+			return
+		}
+		cfg.MaxPoolCount = v
 	}
 
 	if tmpStr, ok = conf.Get("common", "max_ports_per_client"); ok {
 		if v, err = strconv.ParseInt(tmpStr, 10, 64); err != nil {
 			err = fmt.Errorf("Parse conf error: invalid max_ports_per_client")
 			return
-		} else {
-			if v < 0 {
-				err = fmt.Errorf("Parse conf error: invalid max_ports_per_client")
-				return
-			}
-			cfg.MaxPortsPerClient = v
 		}
+
+		if v < 0 {
+			err = fmt.Errorf("Parse conf error: invalid max_ports_per_client")
+			return
+		}
+		cfg.MaxPortsPerClient = v
 	}
 
 	if tmpStr, ok = conf.Get("common", "subdomain_host"); ok {
@@ -396,9 +388,9 @@ func UnmarshalServerConfFromIni(content string) (cfg ServerCommonConf, err error
 	}
 
 	if tmpStr, ok = conf.Get("common", "tcp_mux"); ok && tmpStr == "false" {
-		cfg.TcpMux = false
+		cfg.TCPMux = false
 	} else {
-		cfg.TcpMux = true
+		cfg.TCPMux = true
 	}
 
 	if tmpStr, ok = conf.Get("common", "custom_404_page"); ok {
@@ -410,24 +402,22 @@ func UnmarshalServerConfFromIni(content string) (cfg ServerCommonConf, err error
 		if errRet != nil {
 			err = fmt.Errorf("Parse conf error: heartbeat_timeout is incorrect")
 			return
-		} else {
-			cfg.HeartBeatTimeout = v
 		}
+		cfg.HeartBeatTimeout = v
 	}
 
 	if tmpStr, ok = conf.Get("common", "tls_only"); ok && tmpStr == "true" {
-		cfg.TlsOnly = true
+		cfg.TLSOnly = true
 	} else {
-		cfg.TlsOnly = false
+		cfg.TLSOnly = false
 	}
 
 	if tmpStr, ok = conf.Get("common", "udp_packet_size"); ok {
 		if v, err = strconv.ParseInt(tmpStr, 10, 64); err != nil {
 			err = fmt.Errorf("Parse conf error: invalid udp_packet_size")
 			return
-		} else {
-			cfg.UdpPacketSize = v
 		}
+		cfg.UDPPacketSize = v
 	}
 	return
 }
@@ -442,7 +432,7 @@ func UnmarshalPluginsFromIni(sections ini.File, cfg *ServerCommonConf) {
 				Path: section["path"],
 				Ops:  strings.Split(section["ops"], ","),
 			}
-			for i, _ := range options.Ops {
+			for i := range options.Ops {
 				options.Ops[i] = strings.TrimSpace(options.Ops[i])
 			}
 			cfg.HTTPPlugins[name] = options

models/config/visitor.go

@@ -30,9 +30,9 @@ var (
 
 func init() {
 	visitorConfTypeMap = make(map[string]reflect.Type)
-	visitorConfTypeMap[consts.StcpProxy] = reflect.TypeOf(StcpVisitorConf{})
-	visitorConfTypeMap[consts.XtcpProxy] = reflect.TypeOf(XtcpVisitorConf{})
-	visitorConfTypeMap[consts.SudpProxy] = reflect.TypeOf(SudpVisitorConf{})
+	visitorConfTypeMap[consts.STCPProxy] = reflect.TypeOf(STCPVisitorConf{})
+	visitorConfTypeMap[consts.XTCPProxy] = reflect.TypeOf(XTCPVisitorConf{})
+	visitorConfTypeMap[consts.SUDPProxy] = reflect.TypeOf(SUDPVisitorConf{})
 }
 
 type VisitorConf interface {
@@ -153,12 +153,12 @@ func (cfg *BaseVisitorConf) UnmarshalFromIni(prefix string, name string, section
 	return nil
 }
 
-type SudpVisitorConf struct {
+type SUDPVisitorConf struct {
 	BaseVisitorConf
 }
 
-func (cfg *SudpVisitorConf) Compare(cmp VisitorConf) bool {
-	cmpConf, ok := cmp.(*SudpVisitorConf)
+func (cfg *SUDPVisitorConf) Compare(cmp VisitorConf) bool {
+	cmpConf, ok := cmp.(*SUDPVisitorConf)
 	if !ok {
 		return false
 	}
@@ -169,26 +169,26 @@ func (cfg *SudpVisitorConf) Compare(cmp VisitorConf) bool {
 	return true
 }
 
-func (cfg *SudpVisitorConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
+func (cfg *SUDPVisitorConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
 	if err = cfg.BaseVisitorConf.UnmarshalFromIni(prefix, name, section); err != nil {
 		return
 	}
 	return
 }
 
-func (cfg *SudpVisitorConf) Check() (err error) {
+func (cfg *SUDPVisitorConf) Check() (err error) {
 	if err = cfg.BaseVisitorConf.check(); err != nil {
 		return
 	}
 	return
 }
 
-type StcpVisitorConf struct {
+type STCPVisitorConf struct {
 	BaseVisitorConf
 }
 
-func (cfg *StcpVisitorConf) Compare(cmp VisitorConf) bool {
-	cmpConf, ok := cmp.(*StcpVisitorConf)
+func (cfg *STCPVisitorConf) Compare(cmp VisitorConf) bool {
+	cmpConf, ok := cmp.(*STCPVisitorConf)
 	if !ok {
 		return false
 	}
@@ -199,26 +199,26 @@ func (cfg *StcpVisitorConf) Compare(cmp VisitorConf) bool {
 	return true
 }
 
-func (cfg *StcpVisitorConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
+func (cfg *STCPVisitorConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
 	if err = cfg.BaseVisitorConf.UnmarshalFromIni(prefix, name, section); err != nil {
 		return
 	}
 	return
 }
 
-func (cfg *StcpVisitorConf) Check() (err error) {
+func (cfg *STCPVisitorConf) Check() (err error) {
 	if err = cfg.BaseVisitorConf.check(); err != nil {
 		return
 	}
 	return
 }
 
-type XtcpVisitorConf struct {
+type XTCPVisitorConf struct {
 	BaseVisitorConf
 }
 
-func (cfg *XtcpVisitorConf) Compare(cmp VisitorConf) bool {
-	cmpConf, ok := cmp.(*XtcpVisitorConf)
+func (cfg *XTCPVisitorConf) Compare(cmp VisitorConf) bool {
+	cmpConf, ok := cmp.(*XTCPVisitorConf)
 	if !ok {
 		return false
 	}
@@ -229,14 +229,14 @@ func (cfg *XtcpVisitorConf) Compare(cmp VisitorConf) bool {
 	return true
 }
 
-func (cfg *XtcpVisitorConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
+func (cfg *XTCPVisitorConf) UnmarshalFromIni(prefix string, name string, section ini.Section) (err error) {
 	if err = cfg.BaseVisitorConf.UnmarshalFromIni(prefix, name, section); err != nil {
 		return
 	}
 	return
 }
 
-func (cfg *XtcpVisitorConf) Check() (err error) {
+func (cfg *XTCPVisitorConf) Check() (err error) {
 	if err = cfg.BaseVisitorConf.check(); err != nil {
 		return
 	}

models/consts/consts.go

@@ -23,19 +23,19 @@ var (
 	Offline string = "offline"
 
 	// proxy type
-	TcpProxy    string = "tcp"
-	UdpProxy    string = "udp"
-	TcpMuxProxy string = "tcpmux"
-	HttpProxy   string = "http"
-	HttpsProxy  string = "https"
-	StcpProxy   string = "stcp"
-	XtcpProxy   string = "xtcp"
-	SudpProxy   string = "sudp"
+	TCPProxy    string = "tcp"
+	UDPProxy    string = "udp"
+	TCPMuxProxy string = "tcpmux"
+	HTTPProxy   string = "http"
+	HTTPSProxy  string = "https"
+	STCPProxy   string = "stcp"
+	XTCPProxy   string = "xtcp"
+	SUDPProxy   string = "sudp"
 
 	// authentication method
 	TokenAuthMethod string = "token"
 	OidcAuthMethod  string = "oidc"
 
-	// tcp multiplexer
-	HttpConnectTcpMultiplexer string = "httpconnect"
+	// TCP multiplexer
+	HTTPConnectTCPMultiplexer string = "httpconnect"
 )

models/msg/msg.go

@@ -29,7 +29,7 @@ const (
 	TypeNewVisitorConnResp    = '3'
 	TypePing                  = 'h'
 	TypePong                  = '4'
-	TypeUdpPacket             = 'u'
+	TypeUDPPacket             = 'u'
 	TypeNatHoleVisitor        = 'i'
 	TypeNatHoleClient         = 'n'
 	TypeNatHoleResp           = 'm'
@@ -51,7 +51,7 @@ var (
 		TypeNewVisitorConnResp:    NewVisitorConnResp{},
 		TypePing:                  Ping{},
 		TypePong:                  Pong{},
-		TypeUdpPacket:             UdpPacket{},
+		TypeUDPPacket:             UDPPacket{},
 		TypeNatHoleVisitor:        NatHoleVisitor{},
 		TypeNatHoleClient:         NatHoleClient{},
 		TypeNatHoleResp:           NatHoleResp{},
@@ -69,7 +69,7 @@ type Login struct {
 	User         string            `json:"user"`
 	PrivilegeKey string            `json:"privilege_key"`
 	Timestamp    int64             `json:"timestamp"`
-	RunId        string            `json:"run_id"`
+	RunID        string            `json:"run_id"`
 	Metas        map[string]string `json:"metas"`
 
 	// Some global configures.
@@ -78,8 +78,8 @@ type Login struct {
 
 type LoginResp struct {
 	Version       string `json:"version"`
-	RunId         string `json:"run_id"`
-	ServerUdpPort int    `json:"server_udp_port"`
+	RunID         string `json:"run_id"`
+	ServerUDPPort int    `json:"server_udp_port"`
 	Error         string `json:"error"`
 }
 
@@ -100,8 +100,8 @@ type NewProxy struct {
 	CustomDomains     []string          `json:"custom_domains"`
 	SubDomain         string            `json:"subdomain"`
 	Locations         []string          `json:"locations"`
-	HttpUser          string            `json:"http_user"`
-	HttpPwd           string            `json:"http_pwd"`
+	HTTPUser          string            `json:"http_user"`
+	HTTPPwd           string            `json:"http_pwd"`
 	HostHeaderRewrite string            `json:"host_header_rewrite"`
 	Headers           map[string]string `json:"headers"`
 
@@ -123,7 +123,7 @@ type CloseProxy struct {
 }
 
 type NewWorkConn struct {
-	RunId        string `json:"run_id"`
+	RunID        string `json:"run_id"`
 	PrivilegeKey string `json:"privilege_key"`
 	Timestamp    int64  `json:"timestamp"`
 }
@@ -162,7 +162,7 @@ type Pong struct {
 	Error string `json:"error"`
 }
 
-type UdpPacket struct {
+type UDPPacket struct {
 	Content    string       `json:"c"`
 	LocalAddr  *net.UDPAddr `json:"l"`
 	RemoteAddr *net.UDPAddr `json:"r"`

models/nathole/nathole.go

@@ -23,16 +23,16 @@ type SidRequest struct {
 	NotifyCh chan struct{}
 }
 
-type NatHoleController struct {
+type Controller struct {
 	listener *net.UDPConn
 
-	clientCfgs map[string]*NatHoleClientCfg
-	sessions   map[string]*NatHoleSession
+	clientCfgs map[string]*ClientCfg
+	sessions   map[string]*Session
 
 	mu sync.RWMutex
 }
 
-func NewNatHoleController(udpBindAddr string) (nc *NatHoleController, err error) {
+func NewController(udpBindAddr string) (nc *Controller, err error) {
 	addr, err := net.ResolveUDPAddr("udp", udpBindAddr)
 	if err != nil {
 		return nil, err
@@ -41,16 +41,16 @@ func NewNatHoleController(udpBindAddr string) (nc *NatHoleController, err error)
 	if err != nil {
 		return nil, err
 	}
-	nc = &NatHoleController{
+	nc = &Controller{
 		listener:   lconn,
-		clientCfgs: make(map[string]*NatHoleClientCfg),
-		sessions:   make(map[string]*NatHoleSession),
+		clientCfgs: make(map[string]*ClientCfg),
+		sessions:   make(map[string]*Session),
 	}
 	return nc, nil
 }
 
-func (nc *NatHoleController) ListenClient(name string, sk string) (sidCh chan *SidRequest) {
-	clientCfg := &NatHoleClientCfg{
+func (nc *Controller) ListenClient(name string, sk string) (sidCh chan *SidRequest) {
+	clientCfg := &ClientCfg{
 		Name:  name,
 		Sk:    sk,
 		SidCh: make(chan *SidRequest),
@@ -61,13 +61,13 @@ func (nc *NatHoleController) ListenClient(name string, sk string) (sidCh chan *S
 	return clientCfg.SidCh
 }
 
-func (nc *NatHoleController) CloseClient(name string) {
+func (nc *Controller) CloseClient(name string) {
 	nc.mu.Lock()
 	defer nc.mu.Unlock()
 	delete(nc.clientCfgs, name)
 }
 
-func (nc *NatHoleController) Run() {
+func (nc *Controller) Run() {
 	for {
 		buf := pool.GetBuf(1024)
 		n, raddr, err := nc.listener.ReadFromUDP(buf)
@@ -96,15 +96,15 @@ func (nc *NatHoleController) Run() {
 	}
 }
 
-func (nc *NatHoleController) GenSid() string {
+func (nc *Controller) GenSid() string {
 	t := time.Now().Unix()
-	id, _ := util.RandId()
+	id, _ := util.RandID()
 	return fmt.Sprintf("%d%s", t, id)
 }
 
-func (nc *NatHoleController) HandleVisitor(m *msg.NatHoleVisitor, raddr *net.UDPAddr) {
+func (nc *Controller) HandleVisitor(m *msg.NatHoleVisitor, raddr *net.UDPAddr) {
 	sid := nc.GenSid()
-	session := &NatHoleSession{
+	session := &Session{
 		Sid:         sid,
 		VisitorAddr: raddr,
 		NotifyCh:    make(chan struct{}, 0),
@@ -157,7 +157,7 @@ func (nc *NatHoleController) HandleVisitor(m *msg.NatHoleVisitor, raddr *net.UDP
 	}
 }
 
-func (nc *NatHoleController) HandleClient(m *msg.NatHoleClient, raddr *net.UDPAddr) {
+func (nc *Controller) HandleClient(m *msg.NatHoleClient, raddr *net.UDPAddr) {
 	nc.mu.RLock()
 	session, ok := nc.sessions[m.Sid]
 	nc.mu.RUnlock()
@@ -172,7 +172,7 @@ func (nc *NatHoleController) HandleClient(m *msg.NatHoleClient, raddr *net.UDPAd
 	nc.listener.WriteToUDP(resp, raddr)
 }
 
-func (nc *NatHoleController) GenNatHoleResponse(session *NatHoleSession, errInfo string) []byte {
+func (nc *Controller) GenNatHoleResponse(session *Session, errInfo string) []byte {
 	var (
 		sid         string
 		visitorAddr string
@@ -197,7 +197,7 @@ func (nc *NatHoleController) GenNatHoleResponse(session *NatHoleSession, errInfo
 	return b.Bytes()
 }
 
-type NatHoleSession struct {
+type Session struct {
 	Sid         string
 	VisitorAddr *net.UDPAddr
 	ClientAddr  *net.UDPAddr
@@ -205,7 +205,7 @@ type NatHoleSession struct {
 	NotifyCh chan struct{}
 }
 
-type NatHoleClientCfg struct {
+type ClientCfg struct {
 	Name  string
 	Sk    string
 	SidCh chan *SidRequest

models/plugin/client/http_proxy.go

@@ -28,25 +28,25 @@ import (
 	gnet "github.com/fatedier/golib/net"
 )
 
-const PluginHttpProxy = "http_proxy"
+const PluginHTTPProxy = "http_proxy"
 
 func init() {
-	Register(PluginHttpProxy, NewHttpProxyPlugin)
+	Register(PluginHTTPProxy, NewHTTPProxyPlugin)
 }
 
-type HttpProxy struct {
+type HTTPProxy struct {
 	l          *Listener
 	s          *http.Server
 	AuthUser   string
 	AuthPasswd string
 }
 
-func NewHttpProxyPlugin(params map[string]string) (Plugin, error) {
+func NewHTTPProxyPlugin(params map[string]string) (Plugin, error) {
 	user := params["plugin_http_user"]
 	passwd := params["plugin_http_passwd"]
 	listener := NewProxyListener()
 
-	hp := &HttpProxy{
+	hp := &HTTPProxy{
 		l:          listener,
 		AuthUser:   user,
 		AuthPasswd: passwd,
@@ -60,11 +60,11 @@ func NewHttpProxyPlugin(params map[string]string) (Plugin, error) {
 	return hp, nil
 }
 
-func (hp *HttpProxy) Name() string {
-	return PluginHttpProxy
+func (hp *HTTPProxy) Name() string {
+	return PluginHTTPProxy
 }
 
-func (hp *HttpProxy) Handle(conn io.ReadWriteCloser, realConn net.Conn, extraBufToLocal []byte) {
+func (hp *HTTPProxy) Handle(conn io.ReadWriteCloser, realConn net.Conn, extraBufToLocal []byte) {
 	wrapConn := frpNet.WrapReadWriteCloserToConn(conn, realConn)
 
 	sc, rd := gnet.NewSharedConn(wrapConn)
@@ -90,13 +90,13 @@ func (hp *HttpProxy) Handle(conn io.ReadWriteCloser, realConn net.Conn, extraBuf
 	return
 }
 
-func (hp *HttpProxy) Close() error {
+func (hp *HTTPProxy) Close() error {
 	hp.s.Close()
 	hp.l.Close()
 	return nil
 }
 
-func (hp *HttpProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
+func (hp *HTTPProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
 	if ok := hp.Auth(req); !ok {
 		rw.Header().Set("Proxy-Authenticate", "Basic")
 		rw.WriteHeader(http.StatusProxyAuthRequired)
@@ -108,11 +108,11 @@ func (hp *HttpProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
 		// Connect request is handled in Handle function.
 		hp.ConnectHandler(rw, req)
 	} else {
-		hp.HttpHandler(rw, req)
+		hp.HTTPHandler(rw, req)
 	}
 }
 
-func (hp *HttpProxy) HttpHandler(rw http.ResponseWriter, req *http.Request) {
+func (hp *HTTPProxy) HTTPHandler(rw http.ResponseWriter, req *http.Request) {
 	removeProxyHeaders(req)
 
 	resp, err := http.DefaultTransport.RoundTrip(req)
@@ -134,7 +134,7 @@ func (hp *HttpProxy) HttpHandler(rw http.ResponseWriter, req *http.Request) {
 // deprecated
 // Hijack needs to SetReadDeadline on the Conn of the request, but if we use stream compression here,
 // we may always get i/o timeout error.
-func (hp *HttpProxy) ConnectHandler(rw http.ResponseWriter, req *http.Request) {
+func (hp *HTTPProxy) ConnectHandler(rw http.ResponseWriter, req *http.Request) {
 	hj, ok := rw.(http.Hijacker)
 	if !ok {
 		rw.WriteHeader(http.StatusInternalServerError)
@@ -158,7 +158,7 @@ func (hp *HttpProxy) ConnectHandler(rw http.ResponseWriter, req *http.Request) {
 	go frpIo.Join(remote, client)
 }
 
-func (hp *HttpProxy) Auth(req *http.Request) bool {
+func (hp *HTTPProxy) Auth(req *http.Request) bool {
 	if hp.AuthUser == "" && hp.AuthPasswd == "" {
 		return true
 	}
@@ -184,7 +184,7 @@ func (hp *HttpProxy) Auth(req *http.Request) bool {
 	return true
 }
 
-func (hp *HttpProxy) handleConnectReq(req *http.Request, rwc io.ReadWriteCloser) {
+func (hp *HTTPProxy) handleConnectReq(req *http.Request, rwc io.ReadWriteCloser) {
 	defer rwc.Close()
 	if ok := hp.Auth(req); !ok {
 		res := getBadResponse()

models/plugin/client/static_file.go

@@ -64,8 +64,8 @@ func NewStaticFilePlugin(params map[string]string) (Plugin, error) {
 	}
 
 	router := mux.NewRouter()
-	router.Use(frpNet.NewHttpAuthMiddleware(httpUser, httpPasswd).Middleware)
-	router.PathPrefix(prefix).Handler(frpNet.MakeHttpGzipHandler(http.StripPrefix(prefix, http.FileServer(http.Dir(localPath))))).Methods("GET")
+	router.Use(frpNet.NewHTTPAuthMiddleware(httpUser, httpPasswd).Middleware)
+	router.PathPrefix(prefix).Handler(frpNet.MakeHTTPGzipHandler(http.StripPrefix(prefix, http.FileServer(http.Dir(localPath))))).Methods("GET")
 	sp.s = &http.Server{
 		Handler: router,
 	}

models/plugin/server/manager.go

@@ -72,7 +72,7 @@ func (m *Manager) Login(content *LoginContent) (*LoginContent, error) {
 		retContent interface{}
 		err        error
 	)
-	reqid, _ := util.RandId()
+	reqid, _ := util.RandID()
 	xl := xlog.New().AppendPrefix("reqid: " + reqid)
 	ctx := xlog.NewContext(context.Background(), xl)
 	ctx = NewReqidContext(ctx, reqid)
@@ -106,7 +106,7 @@ func (m *Manager) NewProxy(content *NewProxyContent) (*NewProxyContent, error) {
 		retContent interface{}
 		err        error
 	)
-	reqid, _ := util.RandId()
+	reqid, _ := util.RandID()
 	xl := xlog.New().AppendPrefix("reqid: " + reqid)
 	ctx := xlog.NewContext(context.Background(), xl)
 	ctx = NewReqidContext(ctx, reqid)
@@ -140,7 +140,7 @@ func (m *Manager) Ping(content *PingContent) (*PingContent, error) {
 		retContent interface{}
 		err        error
 	)
-	reqid, _ := util.RandId()
+	reqid, _ := util.RandID()
 	xl := xlog.New().AppendPrefix("reqid: " + reqid)
 	ctx := xlog.NewContext(context.Background(), xl)
 	ctx = NewReqidContext(ctx, reqid)
@@ -174,7 +174,7 @@ func (m *Manager) NewWorkConn(content *NewWorkConnContent) (*NewWorkConnContent,
 		retContent interface{}
 		err        error
 	)
-	reqid, _ := util.RandId()
+	reqid, _ := util.RandID()
 	xl := xlog.New().AppendPrefix("reqid: " + reqid)
 	ctx := xlog.NewContext(context.Background(), xl)
 	ctx = NewReqidContext(ctx, reqid)
@@ -208,7 +208,7 @@ func (m *Manager) NewUserConn(content *NewUserConnContent) (*NewUserConnContent,
 		retContent interface{}
 		err        error
 	)
-	reqid, _ := util.RandId()
+	reqid, _ := util.RandID()
 	xl := xlog.New().AppendPrefix("reqid: " + reqid)
 	ctx := xlog.NewContext(context.Background(), xl)
 	ctx = NewReqidContext(ctx, reqid)

models/plugin/server/types.go

@@ -38,7 +38,7 @@ type LoginContent struct {
 type UserInfo struct {
 	User  string            `json:"user"`
 	Metas map[string]string `json:"metas"`
-	RunId string            `json:"run_id"`
+	RunID string            `json:"run_id"`
 }
 
 type NewProxyContent struct {

models/proto/udp/udp.go

@@ -26,20 +26,20 @@ import (
 	"github.com/fatedier/golib/pool"
 )
 
-func NewUdpPacket(buf []byte, laddr, raddr *net.UDPAddr) *msg.UdpPacket {
-	return &msg.UdpPacket{
+func NewUDPPacket(buf []byte, laddr, raddr *net.UDPAddr) *msg.UDPPacket {
+	return &msg.UDPPacket{
 		Content:    base64.StdEncoding.EncodeToString(buf),
 		LocalAddr:  laddr,
 		RemoteAddr: raddr,
 	}
 }
 
-func GetContent(m *msg.UdpPacket) (buf []byte, err error) {
+func GetContent(m *msg.UDPPacket) (buf []byte, err error) {
 	buf, err = base64.StdEncoding.DecodeString(m.Content)
 	return
 }
 
-func ForwardUserConn(udpConn *net.UDPConn, readCh <-chan *msg.UdpPacket, sendCh chan<- *msg.UdpPacket, bufSize int) {
+func ForwardUserConn(udpConn *net.UDPConn, readCh <-chan *msg.UDPPacket, sendCh chan<- *msg.UDPPacket, bufSize int) {
 	// read
 	go func() {
 		for udpMsg := range readCh {
@@ -60,7 +60,7 @@ func ForwardUserConn(udpConn *net.UDPConn, readCh <-chan *msg.UdpPacket, sendCh
 			return
 		}
 		// buf[:n] will be encoded to string, so the bytes can be reused
-		udpMsg := NewUdpPacket(buf[:n], nil, remoteAddr)
+		udpMsg := NewUDPPacket(buf[:n], nil, remoteAddr)
 
 		select {
 		case sendCh <- udpMsg:
@@ -69,7 +69,7 @@ func ForwardUserConn(udpConn *net.UDPConn, readCh <-chan *msg.UdpPacket, sendCh
 	}
 }
 
-func Forwarder(dstAddr *net.UDPAddr, readCh <-chan *msg.UdpPacket, sendCh chan<- msg.Message, bufSize int) {
+func Forwarder(dstAddr *net.UDPAddr, readCh <-chan *msg.UDPPacket, sendCh chan<- msg.Message, bufSize int) {
 	var (
 		mu sync.RWMutex
 	)
@@ -93,7 +93,7 @@ func Forwarder(dstAddr *net.UDPAddr, readCh <-chan *msg.UdpPacket, sendCh chan<-
 				return
 			}
 
-			udpMsg := NewUdpPacket(buf[:n], nil, raddr)
+			udpMsg := NewUDPPacket(buf[:n], nil, raddr)
 			if err = errors.PanicToError(func() {
 				select {
 				case sendCh <- udpMsg:

models/proto/udp/udp_test.go

@@ -10,7 +10,7 @@ func TestUdpPacket(t *testing.T) {
 	assert := assert.New(t)
 
 	buf := []byte("hello world")
-	udpMsg := NewUdpPacket(buf, nil, nil)
+	udpMsg := NewUDPPacket(buf, nil, nil)
 
 	newBuf, err := GetContent(udpMsg)
 	assert.NoError(err)

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.

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

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)

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)

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()

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

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

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()

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()

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()
 }

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]

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())
 }

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())
 }

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)
 	}
 }

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()
 }

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)
 }

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() {

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)
 }

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()
 

tests/ci/auth_test.go

@@ -38,7 +38,7 @@ local_port = 10701
 remote_port = 20801
 `
 
-func TestTcpWithTokenAuthentication(t *testing.T) {
+func TestTCPWithTokenAuthentication(t *testing.T) {
 	assert := assert.New(t)
 	frpsCfgPath, err := config.GenerateConfigFile(consts.FRPS_NORMAL_CONFIG, FRPS_TOKEN_TCP_CONF)
 	if assert.NoError(err) {
@@ -66,7 +66,7 @@ func TestTcpWithTokenAuthentication(t *testing.T) {
 	time.Sleep(500 * time.Millisecond)
 
 	// test tcp
-	res, err := util.SendTcpMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
+	res, err := util.SendTCPMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 }

tests/ci/cmd_test.go

@@ -10,7 +10,7 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestCmdTcp(t *testing.T) {
+func TestCmdTCP(t *testing.T) {
 	assert := assert.New(t)
 
 	var err error
@@ -29,12 +29,12 @@ func TestCmdTcp(t *testing.T) {
 	}
 	time.Sleep(500 * time.Millisecond)
 
-	res, err := util.SendTcpMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
+	res, err := util.SendTCPMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 }
 
-func TestCmdUdp(t *testing.T) {
+func TestCmdUDP(t *testing.T) {
 	assert := assert.New(t)
 
 	var err error
@@ -53,12 +53,12 @@ func TestCmdUdp(t *testing.T) {
 	}
 	time.Sleep(500 * time.Millisecond)
 
-	res, err := util.SendUdpMsg("127.0.0.1:20802", consts.TEST_UDP_ECHO_STR)
+	res, err := util.SendUDPMsg("127.0.0.1:20802", consts.TEST_UDP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_UDP_ECHO_STR, res)
 }
 
-func TestCmdHttp(t *testing.T) {
+func TestCmdHTTP(t *testing.T) {
 	assert := assert.New(t)
 
 	var err error
@@ -77,7 +77,7 @@ func TestCmdHttp(t *testing.T) {
 	}
 	time.Sleep(500 * time.Millisecond)
 
-	code, body, _, err := util.SendHttpMsg("GET", "http://127.0.0.1:20001", "", nil, "")
+	code, body, _, err := util.SendHTTPMsg("GET", "http://127.0.0.1:20001", "", nil, "")
 	if assert.NoError(err) {
 		assert.Equal(200, code)
 		assert.Equal(consts.TEST_HTTP_NORMAL_STR, body)

tests/ci/health/health_test.go

@@ -102,7 +102,7 @@ func TestHealthCheck(t *testing.T) {
 	var healthMu sync.RWMutex
 	svc1Health := true
 	svc2Health := true
-	httpSvc1 := mock.NewHttpServer(15003, func(w http.ResponseWriter, r *http.Request) {
+	httpSvc1 := mock.NewHTTPServer(15003, func(w http.ResponseWriter, r *http.Request) {
 		if strings.Contains(r.URL.Path, "health") {
 			healthMu.RLock()
 			defer healthMu.RUnlock()
@@ -120,7 +120,7 @@ func TestHealthCheck(t *testing.T) {
 		defer httpSvc1.Stop()
 	}
 
-	httpSvc2 := mock.NewHttpServer(15004, func(w http.ResponseWriter, r *http.Request) {
+	httpSvc2 := mock.NewHTTPServer(15004, func(w http.ResponseWriter, r *http.Request) {
 		if strings.Contains(r.URL.Path, "health") {
 			healthMu.RLock()
 			defer healthMu.RUnlock()
@@ -138,7 +138,7 @@ func TestHealthCheck(t *testing.T) {
 		defer httpSvc2.Stop()
 	}
 
-	httpSvc3 := mock.NewHttpServer(15005, func(w http.ResponseWriter, r *http.Request) {
+	httpSvc3 := mock.NewHTTPServer(15005, func(w http.ResponseWriter, r *http.Request) {
 		w.Write([]byte("http3"))
 	})
 	err = httpSvc3.Start()
@@ -146,7 +146,7 @@ func TestHealthCheck(t *testing.T) {
 		defer httpSvc3.Stop()
 	}
 
-	httpSvc4 := mock.NewHttpServer(15006, func(w http.ResponseWriter, r *http.Request) {
+	httpSvc4 := mock.NewHTTPServer(15006, func(w http.ResponseWriter, r *http.Request) {
 		w.Write([]byte("http4"))
 	})
 	err = httpSvc4.Start()
@@ -185,11 +185,11 @@ func TestHealthCheck(t *testing.T) {
 	// ****** healcheck type tcp ******
 	// echo1 and echo2 is ok
 	result := make([]string, 0)
-	res, err := util.SendTcpMsg("127.0.0.1:15000", "echo")
+	res, err := util.SendTCPMsg("127.0.0.1:15000", "echo")
 	assert.NoError(err)
 	result = append(result, res)
 
-	res, err = util.SendTcpMsg("127.0.0.1:15000", "echo")
+	res, err = util.SendTCPMsg("127.0.0.1:15000", "echo")
 	assert.NoError(err)
 	result = append(result, res)
 
@@ -201,11 +201,11 @@ func TestHealthCheck(t *testing.T) {
 	time.Sleep(1200 * time.Millisecond)
 
 	result = make([]string, 0)
-	res, err = util.SendTcpMsg("127.0.0.1:15000", "echo")
+	res, err = util.SendTCPMsg("127.0.0.1:15000", "echo")
 	assert.NoError(err)
 	result = append(result, res)
 
-	res, err = util.SendTcpMsg("127.0.0.1:15000", "echo")
+	res, err = util.SendTCPMsg("127.0.0.1:15000", "echo")
 	assert.NoError(err)
 	result = append(result, res)
 
@@ -221,11 +221,11 @@ func TestHealthCheck(t *testing.T) {
 	time.Sleep(1200 * time.Millisecond)
 
 	result = make([]string, 0)
-	res, err = util.SendTcpMsg("127.0.0.1:15000", "echo")
+	res, err = util.SendTCPMsg("127.0.0.1:15000", "echo")
 	assert.NoError(err)
 	result = append(result, res)
 
-	res, err = util.SendTcpMsg("127.0.0.1:15000", "echo")
+	res, err = util.SendTCPMsg("127.0.0.1:15000", "echo")
 	assert.NoError(err)
 	result = append(result, res)
 
@@ -234,12 +234,12 @@ func TestHealthCheck(t *testing.T) {
 
 	// ****** healcheck type http ******
 	// http1 and http2 is ok
-	code, body, _, err := util.SendHttpMsg("GET", "http://127.0.0.1:14000/xxx", "test1.com", nil, "")
+	code, body, _, err := util.SendHTTPMsg("GET", "http://127.0.0.1:14000/xxx", "test1.com", nil, "")
 	assert.NoError(err)
 	assert.Equal(200, code)
 	assert.Equal("http1", body)
 
-	code, body, _, err = util.SendHttpMsg("GET", "http://127.0.0.1:14000/xxx", "test2.com", nil, "")
+	code, body, _, err = util.SendHTTPMsg("GET", "http://127.0.0.1:14000/xxx", "test2.com", nil, "")
 	assert.NoError(err)
 	assert.Equal(200, code)
 	assert.Equal("http2", body)
@@ -250,12 +250,12 @@ func TestHealthCheck(t *testing.T) {
 	healthMu.Unlock()
 	time.Sleep(1200 * time.Millisecond)
 
-	code, body, _, err = util.SendHttpMsg("GET", "http://127.0.0.1:14000/xxx", "test1.com", nil, "")
+	code, body, _, err = util.SendHTTPMsg("GET", "http://127.0.0.1:14000/xxx", "test1.com", nil, "")
 	assert.NoError(err)
 	assert.Equal(200, code)
 	assert.Equal("http1", body)
 
-	code, _, _, err = util.SendHttpMsg("GET", "http://127.0.0.1:14000/xxx", "test2.com", nil, "")
+	code, _, _, err = util.SendHTTPMsg("GET", "http://127.0.0.1:14000/xxx", "test2.com", nil, "")
 	assert.NoError(err)
 	assert.Equal(404, code)
 
@@ -265,12 +265,12 @@ func TestHealthCheck(t *testing.T) {
 	healthMu.Unlock()
 	time.Sleep(1200 * time.Millisecond)
 
-	code, body, _, err = util.SendHttpMsg("GET", "http://127.0.0.1:14000/xxx", "test1.com", nil, "")
+	code, body, _, err = util.SendHTTPMsg("GET", "http://127.0.0.1:14000/xxx", "test1.com", nil, "")
 	assert.NoError(err)
 	assert.Equal(200, code)
 	assert.Equal("http1", body)
 
-	code, body, _, err = util.SendHttpMsg("GET", "http://127.0.0.1:14000/xxx", "test2.com", nil, "")
+	code, body, _, err = util.SendHTTPMsg("GET", "http://127.0.0.1:14000/xxx", "test2.com", nil, "")
 	assert.NoError(err)
 	assert.Equal(200, code)
 	assert.Equal("http2", body)
@@ -278,12 +278,12 @@ func TestHealthCheck(t *testing.T) {
 	// ****** load balancing type http ******
 	result = make([]string, 0)
 
-	code, body, _, err = util.SendHttpMsg("GET", "http://127.0.0.1:14000/xxx", "test.balancing.com", nil, "")
+	code, body, _, err = util.SendHTTPMsg("GET", "http://127.0.0.1:14000/xxx", "test.balancing.com", nil, "")
 	assert.NoError(err)
 	assert.Equal(200, code)
 	result = append(result, body)
 
-	code, body, _, err = util.SendHttpMsg("GET", "http://127.0.0.1:14000/xxx", "test.balancing.com", nil, "")
+	code, body, _, err = util.SendHTTPMsg("GET", "http://127.0.0.1:14000/xxx", "test.balancing.com", nil, "")
 	assert.NoError(err)
 	assert.Equal(200, code)
 	result = append(result, body)

tests/ci/normal_test.go

@@ -33,9 +33,9 @@ func TestMain(m *testing.M) {
 		panic(err)
 	}
 
-	go mock.StartUdpEchoServer(consts.TEST_UDP_PORT)
+	go mock.StartUDPEchoServer(consts.TEST_UDP_PORT)
 	go mock.StartUnixDomainServer(consts.TEST_UNIX_DOMAIN_ADDR)
-	go mock.StartHttpServer(consts.TEST_HTTP_PORT)
+	go mock.StartHTTPServer(consts.TEST_HTTP_PORT)
 
 	p1 := util.NewProcess(consts.FRPS_BIN_PATH, []string{"-c", "./auto_test_frps.ini"})
 	if err = p1.Start(); err != nil {
@@ -61,32 +61,32 @@ func TestMain(m *testing.M) {
 	os.Exit(exitCode)
 }
 
-func TestTcp(t *testing.T) {
+func TestTCP(t *testing.T) {
 	assert := assert.New(t)
 	// Normal
 	addr := fmt.Sprintf("127.0.0.1:%d", consts.TEST_TCP_FRP_PORT)
-	res, err := util.SendTcpMsg(addr, consts.TEST_TCP_ECHO_STR)
+	res, err := util.SendTCPMsg(addr, consts.TEST_TCP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 
 	// Encrytion and compression
 	addr = fmt.Sprintf("127.0.0.1:%d", consts.TEST_TCP_EC_FRP_PORT)
-	res, err = util.SendTcpMsg(addr, consts.TEST_TCP_ECHO_STR)
+	res, err = util.SendTCPMsg(addr, consts.TEST_TCP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 }
 
-func TestUdp(t *testing.T) {
+func TestUDP(t *testing.T) {
 	assert := assert.New(t)
 	// Normal
 	addr := fmt.Sprintf("127.0.0.1:%d", consts.TEST_UDP_FRP_PORT)
-	res, err := util.SendUdpMsg(addr, consts.TEST_UDP_ECHO_STR)
+	res, err := util.SendUDPMsg(addr, consts.TEST_UDP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_UDP_ECHO_STR, res)
 
 	// Encrytion and compression
 	addr = fmt.Sprintf("127.0.0.1:%d", consts.TEST_UDP_EC_FRP_PORT)
-	res, err = util.SendUdpMsg(addr, consts.TEST_UDP_ECHO_STR)
+	res, err = util.SendUDPMsg(addr, consts.TEST_UDP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_UDP_ECHO_STR, res)
 }
@@ -95,97 +95,97 @@ func TestUnixDomain(t *testing.T) {
 	assert := assert.New(t)
 	// Normal
 	addr := fmt.Sprintf("127.0.0.1:%d", consts.TEST_UNIX_DOMAIN_FRP_PORT)
-	res, err := util.SendTcpMsg(addr, consts.TEST_UNIX_DOMAIN_STR)
+	res, err := util.SendTCPMsg(addr, consts.TEST_UNIX_DOMAIN_STR)
 	if assert.NoError(err) {
 		assert.Equal(consts.TEST_UNIX_DOMAIN_STR, res)
 	}
 }
 
-func TestStcp(t *testing.T) {
+func TestSTCP(t *testing.T) {
 	assert := assert.New(t)
 	// Normal
 	addr := fmt.Sprintf("127.0.0.1:%d", consts.TEST_STCP_FRP_PORT)
-	res, err := util.SendTcpMsg(addr, consts.TEST_STCP_ECHO_STR)
+	res, err := util.SendTCPMsg(addr, consts.TEST_STCP_ECHO_STR)
 	if assert.NoError(err) {
 		assert.Equal(consts.TEST_STCP_ECHO_STR, res)
 	}
 
 	// Encrytion and compression
 	addr = fmt.Sprintf("127.0.0.1:%d", consts.TEST_STCP_EC_FRP_PORT)
-	res, err = util.SendTcpMsg(addr, consts.TEST_STCP_ECHO_STR)
+	res, err = util.SendTCPMsg(addr, consts.TEST_STCP_ECHO_STR)
 	if assert.NoError(err) {
 		assert.Equal(consts.TEST_STCP_ECHO_STR, res)
 	}
 }
 
-func TestSudp(t *testing.T) {
+func TestSUDP(t *testing.T) {
 	assert := assert.New(t)
 	// Normal
 	addr := fmt.Sprintf("127.0.0.1:%d", consts.TEST_SUDP_FRP_PORT)
-	res, err := util.SendUdpMsg(addr, consts.TEST_SUDP_ECHO_STR)
+	res, err := util.SendUDPMsg(addr, consts.TEST_SUDP_ECHO_STR)
 
 	assert.NoError(err)
 	assert.Equal(consts.TEST_SUDP_ECHO_STR, res)
 }
 
-func TestHttp(t *testing.T) {
+func TestHTTP(t *testing.T) {
 	assert := assert.New(t)
 	// web01
-	code, body, _, err := util.SendHttpMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "", nil, "")
+	code, body, _, err := util.SendHTTPMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "", nil, "")
 	if assert.NoError(err) {
 		assert.Equal(200, code)
 		assert.Equal(consts.TEST_HTTP_NORMAL_STR, body)
 	}
 
 	// web02
-	code, body, _, err = util.SendHttpMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "test2.frp.com", nil, "")
+	code, body, _, err = util.SendHTTPMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "test2.frp.com", nil, "")
 	if assert.NoError(err) {
 		assert.Equal(200, code)
 		assert.Equal(consts.TEST_HTTP_NORMAL_STR, body)
 	}
 
 	// error host header
-	code, body, _, err = util.SendHttpMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "errorhost.frp.com", nil, "")
+	code, body, _, err = util.SendHTTPMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "errorhost.frp.com", nil, "")
 	if assert.NoError(err) {
 		assert.Equal(404, code)
 	}
 
 	// web03
-	code, body, _, err = util.SendHttpMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "test3.frp.com", nil, "")
+	code, body, _, err = util.SendHTTPMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "test3.frp.com", nil, "")
 	if assert.NoError(err) {
 		assert.Equal(200, code)
 		assert.Equal(consts.TEST_HTTP_NORMAL_STR, body)
 	}
 
-	code, body, _, err = util.SendHttpMsg("GET", fmt.Sprintf("http://127.0.0.1:%d/foo", consts.TEST_HTTP_FRP_PORT), "test3.frp.com", nil, "")
+	code, body, _, err = util.SendHTTPMsg("GET", fmt.Sprintf("http://127.0.0.1:%d/foo", consts.TEST_HTTP_FRP_PORT), "test3.frp.com", nil, "")
 	if assert.NoError(err) {
 		assert.Equal(200, code)
 		assert.Equal(consts.TEST_HTTP_FOO_STR, body)
 	}
 
 	// web04
-	code, body, _, err = util.SendHttpMsg("GET", fmt.Sprintf("http://127.0.0.1:%d/bar", consts.TEST_HTTP_FRP_PORT), "test3.frp.com", nil, "")
+	code, body, _, err = util.SendHTTPMsg("GET", fmt.Sprintf("http://127.0.0.1:%d/bar", consts.TEST_HTTP_FRP_PORT), "test3.frp.com", nil, "")
 	if assert.NoError(err) {
 		assert.Equal(200, code)
 		assert.Equal(consts.TEST_HTTP_BAR_STR, body)
 	}
 
 	// web05
-	code, body, _, err = util.SendHttpMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "test5.frp.com", nil, "")
+	code, body, _, err = util.SendHTTPMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "test5.frp.com", nil, "")
 	if assert.NoError(err) {
 		assert.Equal(401, code)
 	}
 
 	headers := make(map[string]string)
 	headers["Authorization"] = util.BasicAuth("test", "test")
-	code, body, _, err = util.SendHttpMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "test5.frp.com", headers, "")
+	code, body, _, err = util.SendHTTPMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "test5.frp.com", headers, "")
 	if assert.NoError(err) {
 		assert.Equal(401, code)
 	}
 
 	// web06
 	var header http.Header
-	code, body, header, err = util.SendHttpMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "test6.frp.com", nil, "")
+	code, body, header, err = util.SendHTTPMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "test6.frp.com", nil, "")
 	if assert.NoError(err) {
 		assert.Equal(200, code)
 		assert.Equal(consts.TEST_HTTP_NORMAL_STR, body)
@@ -194,40 +194,40 @@ func TestHttp(t *testing.T) {
 
 	// wildcard_http
 	// test.frp1.com match *.frp1.com
-	code, body, _, err = util.SendHttpMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "test.frp1.com", nil, "")
+	code, body, _, err = util.SendHTTPMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "test.frp1.com", nil, "")
 	if assert.NoError(err) {
 		assert.Equal(200, code)
 		assert.Equal(consts.TEST_HTTP_NORMAL_STR, body)
 	}
 
 	// new.test.frp1.com also match *.frp1.com
-	code, body, _, err = util.SendHttpMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "new.test.frp1.com", nil, "")
+	code, body, _, err = util.SendHTTPMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "new.test.frp1.com", nil, "")
 	if assert.NoError(err) {
 		assert.Equal(200, code)
 		assert.Equal(consts.TEST_HTTP_NORMAL_STR, body)
 	}
 
 	// subhost01
-	code, body, _, err = util.SendHttpMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "test01.sub.com", nil, "")
+	code, body, _, err = util.SendHTTPMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "test01.sub.com", nil, "")
 	if assert.NoError(err) {
 		assert.Equal(200, code)
 		assert.Equal("test01.sub.com", body)
 	}
 
 	// subhost02
-	code, body, _, err = util.SendHttpMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "test02.sub.com", nil, "")
+	code, body, _, err = util.SendHTTPMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT), "test02.sub.com", nil, "")
 	if assert.NoError(err) {
 		assert.Equal(200, code)
 		assert.Equal("test02.sub.com", body)
 	}
 }
 
-func TestTcpMux(t *testing.T) {
+func TestTCPMux(t *testing.T) {
 	assert := assert.New(t)
 
 	conn, err := gnet.DialTcpByProxy(fmt.Sprintf("http://%s:%d", "127.0.0.1", consts.TEST_TCP_MUX_FRP_PORT), "tunnel1")
 	if assert.NoError(err) {
-		res, err := util.SendTcpMsgByConn(conn, consts.TEST_TCP_ECHO_STR)
+		res, err := util.SendTCPMsgByConn(conn, consts.TEST_TCP_ECHO_STR)
 		assert.NoError(err)
 		assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 	}
@@ -252,66 +252,66 @@ func TestWebSocket(t *testing.T) {
 func TestAllowPorts(t *testing.T) {
 	assert := assert.New(t)
 	// Port not allowed
-	status, err := util.GetProxyStatus(consts.ADMIN_ADDR, consts.ADMIN_USER, consts.ADMIN_PWD, consts.ProxyTcpPortNotAllowed)
+	status, err := util.GetProxyStatus(consts.ADMIN_ADDR, consts.ADMIN_USER, consts.ADMIN_PWD, consts.ProxyTCPPortNotAllowed)
 	if assert.NoError(err) {
-		assert.Equal(proxy.ProxyStatusStartErr, status.Status)
+		assert.Equal(proxy.ProxyPhaseStartErr, status.Status)
 		assert.True(strings.Contains(status.Err, ports.ErrPortNotAllowed.Error()))
 	}
 
-	status, err = util.GetProxyStatus(consts.ADMIN_ADDR, consts.ADMIN_USER, consts.ADMIN_PWD, consts.ProxyUdpPortNotAllowed)
+	status, err = util.GetProxyStatus(consts.ADMIN_ADDR, consts.ADMIN_USER, consts.ADMIN_PWD, consts.ProxyUDPPortNotAllowed)
 	if assert.NoError(err) {
-		assert.Equal(proxy.ProxyStatusStartErr, status.Status)
+		assert.Equal(proxy.ProxyPhaseStartErr, status.Status)
 		assert.True(strings.Contains(status.Err, ports.ErrPortNotAllowed.Error()))
 	}
 
-	status, err = util.GetProxyStatus(consts.ADMIN_ADDR, consts.ADMIN_USER, consts.ADMIN_PWD, consts.ProxyTcpPortUnavailable)
+	status, err = util.GetProxyStatus(consts.ADMIN_ADDR, consts.ADMIN_USER, consts.ADMIN_PWD, consts.ProxyTCPPortUnavailable)
 	if assert.NoError(err) {
-		assert.Equal(proxy.ProxyStatusStartErr, status.Status)
+		assert.Equal(proxy.ProxyPhaseStartErr, status.Status)
 		assert.True(strings.Contains(status.Err, ports.ErrPortUnAvailable.Error()))
 	}
 
 	// Port normal
-	status, err = util.GetProxyStatus(consts.ADMIN_ADDR, consts.ADMIN_USER, consts.ADMIN_PWD, consts.ProxyTcpPortNormal)
+	status, err = util.GetProxyStatus(consts.ADMIN_ADDR, consts.ADMIN_USER, consts.ADMIN_PWD, consts.ProxyTCPPortNormal)
 	if assert.NoError(err) {
-		assert.Equal(proxy.ProxyStatusRunning, status.Status)
+		assert.Equal(proxy.ProxyPhaseRunning, status.Status)
 	}
 
-	status, err = util.GetProxyStatus(consts.ADMIN_ADDR, consts.ADMIN_USER, consts.ADMIN_PWD, consts.ProxyUdpPortNormal)
+	status, err = util.GetProxyStatus(consts.ADMIN_ADDR, consts.ADMIN_USER, consts.ADMIN_PWD, consts.ProxyUDPPortNormal)
 	if assert.NoError(err) {
-		assert.Equal(proxy.ProxyStatusRunning, status.Status)
+		assert.Equal(proxy.ProxyPhaseRunning, status.Status)
 	}
 }
 
 func TestRandomPort(t *testing.T) {
 	assert := assert.New(t)
 	// tcp
-	status, err := util.GetProxyStatus(consts.ADMIN_ADDR, consts.ADMIN_USER, consts.ADMIN_PWD, consts.ProxyTcpRandomPort)
+	status, err := util.GetProxyStatus(consts.ADMIN_ADDR, consts.ADMIN_USER, consts.ADMIN_PWD, consts.ProxyTCPRandomPort)
 	if assert.NoError(err) {
 		addr := status.RemoteAddr
-		res, err := util.SendTcpMsg(addr, consts.TEST_TCP_ECHO_STR)
+		res, err := util.SendTCPMsg(addr, consts.TEST_TCP_ECHO_STR)
 		assert.NoError(err)
 		assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 	}
 
 	// udp
-	status, err = util.GetProxyStatus(consts.ADMIN_ADDR, consts.ADMIN_USER, consts.ADMIN_PWD, consts.ProxyUdpRandomPort)
+	status, err = util.GetProxyStatus(consts.ADMIN_ADDR, consts.ADMIN_USER, consts.ADMIN_PWD, consts.ProxyUDPRandomPort)
 	if assert.NoError(err) {
 		addr := status.RemoteAddr
-		res, err := util.SendUdpMsg(addr, consts.TEST_UDP_ECHO_STR)
+		res, err := util.SendUDPMsg(addr, consts.TEST_UDP_ECHO_STR)
 		assert.NoError(err)
 		assert.Equal(consts.TEST_UDP_ECHO_STR, res)
 	}
 }
 
-func TestPluginHttpProxy(t *testing.T) {
+func TestPluginHTTPProxy(t *testing.T) {
 	assert := assert.New(t)
-	status, err := util.GetProxyStatus(consts.ADMIN_ADDR, consts.ADMIN_USER, consts.ADMIN_PWD, consts.ProxyHttpProxy)
+	status, err := util.GetProxyStatus(consts.ADMIN_ADDR, consts.ADMIN_USER, consts.ADMIN_PWD, consts.ProxyHTTPProxy)
 	if assert.NoError(err) {
-		assert.Equal(proxy.ProxyStatusRunning, status.Status)
+		assert.Equal(proxy.ProxyPhaseRunning, status.Status)
 
 		// http proxy
 		addr := status.RemoteAddr
-		code, body, _, err := util.SendHttpMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT),
+		code, body, _, err := util.SendHTTPMsg("GET", fmt.Sprintf("http://127.0.0.1:%d", consts.TEST_HTTP_FRP_PORT),
 			"", nil, "http://"+addr)
 		if assert.NoError(err) {
 			assert.Equal(200, code)
@@ -321,7 +321,7 @@ func TestPluginHttpProxy(t *testing.T) {
 		// connect method
 		conn, err := gnet.DialTcpByProxy("http://"+addr, fmt.Sprintf("127.0.0.1:%d", consts.TEST_TCP_FRP_PORT))
 		if assert.NoError(err) {
-			res, err := util.SendTcpMsgByConn(conn, consts.TEST_TCP_ECHO_STR)
+			res, err := util.SendTCPMsgByConn(conn, consts.TEST_TCP_ECHO_STR)
 			assert.NoError(err)
 			assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 		}
@@ -332,10 +332,10 @@ func TestRangePortsMapping(t *testing.T) {
 	assert := assert.New(t)
 
 	for i := 0; i < 3; i++ {
-		name := fmt.Sprintf("%s_%d", consts.ProxyRangeTcpPrefix, i)
+		name := fmt.Sprintf("%s_%d", consts.ProxyRangeTCPPrefix, i)
 		status, err := util.GetProxyStatus(consts.ADMIN_ADDR, consts.ADMIN_USER, consts.ADMIN_PWD, name)
 		if assert.NoError(err) {
-			assert.Equal(proxy.ProxyStatusRunning, status.Status)
+			assert.Equal(proxy.ProxyPhaseRunning, status.Status)
 		}
 	}
 }
@@ -350,7 +350,7 @@ func TestGroup(t *testing.T) {
 	addr := fmt.Sprintf("127.0.0.1:%d", consts.TEST_TCP2_FRP_PORT)
 
 	for i := 0; i < 6; i++ {
-		res, err := util.SendTcpMsg(addr, consts.TEST_TCP_ECHO_STR)
+		res, err := util.SendTCPMsg(addr, consts.TEST_TCP_ECHO_STR)
 		assert.NoError(err)
 		switch res {
 		case consts.TEST_TCP_ECHO_STR:

tests/ci/reconnect_test.go

@@ -66,7 +66,7 @@ func TestReconnect(t *testing.T) {
 	time.Sleep(500 * time.Millisecond)
 
 	// test tcp
-	res, err := util.SendTcpMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
+	res, err := util.SendTCPMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 
@@ -75,7 +75,7 @@ func TestReconnect(t *testing.T) {
 	time.Sleep(200 * time.Millisecond)
 
 	// test tcp, expect failed
-	_, err = util.SendTcpMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
+	_, err = util.SendTCPMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
 	assert.Error(err)
 
 	// restart frpc
@@ -87,7 +87,7 @@ func TestReconnect(t *testing.T) {
 	time.Sleep(500 * time.Millisecond)
 
 	// test tcp
-	res, err = util.SendTcpMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
+	res, err = util.SendTCPMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 
@@ -96,7 +96,7 @@ func TestReconnect(t *testing.T) {
 	time.Sleep(200 * time.Millisecond)
 
 	// test tcp, expect failed
-	_, err = util.SendTcpMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
+	_, err = util.SendTCPMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
 	assert.Error(err)
 
 	// restart frps
@@ -109,7 +109,7 @@ func TestReconnect(t *testing.T) {
 	time.Sleep(2 * time.Second)
 
 	// test tcp
-	res, err = util.SendTcpMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
+	res, err = util.SendTCPMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 }

tests/ci/reload_test.go

@@ -105,17 +105,17 @@ func TestReload(t *testing.T) {
 	time.Sleep(500 * time.Millisecond)
 
 	// test tcp1
-	res, err := util.SendTcpMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
+	res, err := util.SendTCPMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 
 	// test tcp2
-	res, err = util.SendTcpMsg("127.0.0.1:20802", consts.TEST_TCP_ECHO_STR)
+	res, err = util.SendTCPMsg("127.0.0.1:20802", consts.TEST_TCP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 
 	// test tcp3
-	res, err = util.SendTcpMsg("127.0.0.1:20803", consts.TEST_TCP_ECHO_STR)
+	res, err = util.SendTCPMsg("127.0.0.1:20803", consts.TEST_TCP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 
@@ -131,20 +131,20 @@ func TestReload(t *testing.T) {
 	time.Sleep(time.Second)
 
 	// test tcp1
-	res, err = util.SendTcpMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
+	res, err = util.SendTCPMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 
 	// test origin tcp2, expect failed
-	res, err = util.SendTcpMsg("127.0.0.1:20802", consts.TEST_TCP_ECHO_STR)
+	res, err = util.SendTCPMsg("127.0.0.1:20802", consts.TEST_TCP_ECHO_STR)
 	assert.Error(err)
 
 	// test new origin tcp2 with different port
-	res, err = util.SendTcpMsg("127.0.0.1:20902", consts.TEST_TCP_ECHO_STR)
+	res, err = util.SendTCPMsg("127.0.0.1:20902", consts.TEST_TCP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 
 	// test tcp3, expect failed
-	res, err = util.SendTcpMsg("127.0.0.1:20803", consts.TEST_TCP_ECHO_STR)
+	res, err = util.SendTCPMsg("127.0.0.1:20803", consts.TEST_TCP_ECHO_STR)
 	assert.Error(err)
 }

tests/ci/template_test.go

@@ -66,7 +66,7 @@ func TestConfTemplate(t *testing.T) {
 	time.Sleep(500 * time.Millisecond)
 
 	// test tcp1
-	res, err := util.SendTcpMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
+	res, err := util.SendTCPMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 }

tests/ci/tls_test.go

@@ -37,7 +37,7 @@ local_port = 10701
 remote_port = 20801
 `
 
-func TestTlsOverTCP(t *testing.T) {
+func TestTLSOverTCP(t *testing.T) {
 	assert := assert.New(t)
 	frpsCfgPath, err := config.GenerateConfigFile(consts.FRPS_NORMAL_CONFIG, FRPS_TLS_TCP_CONF)
 	if assert.NoError(err) {
@@ -65,7 +65,7 @@ func TestTlsOverTCP(t *testing.T) {
 	time.Sleep(500 * time.Millisecond)
 
 	// test tcp
-	res, err := util.SendTcpMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
+	res, err := util.SendTCPMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 }
@@ -124,7 +124,7 @@ func TestTLSOverKCP(t *testing.T) {
 	time.Sleep(500 * time.Millisecond)
 
 	// test tcp
-	res, err := util.SendTcpMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
+	res, err := util.SendTCPMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 }
@@ -182,7 +182,7 @@ func TestTLSOverWebsocket(t *testing.T) {
 	time.Sleep(500 * time.Millisecond)
 
 	// test tcp
-	res, err := util.SendTcpMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
+	res, err := util.SendTCPMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_TCP_ECHO_STR, res)
 }
@@ -229,16 +229,16 @@ local_port = 10701
 remote_port = 20802
 `
 
-func TestTlsOnlyOverTCP(t *testing.T) {
+func TestTLSOnlyOverTCP(t *testing.T) {
 	assert := assert.New(t)
 	frpsCfgPath, err := config.GenerateConfigFile(consts.FRPS_NORMAL_CONFIG, FRPS_TLS_ONLY_TCP_CONF)
 	if assert.NoError(err) {
 		defer os.Remove(frpsCfgPath)
 	}
 
-	frpcWithTlsCfgPath, err := config.GenerateConfigFile(consts.FRPC_NORMAL_CONFIG, FRPC_TLS_ONLY_TCP_CONF)
+	frpcWithTLSCfgPath, err := config.GenerateConfigFile(consts.FRPC_NORMAL_CONFIG, FRPC_TLS_ONLY_TCP_CONF)
 	if assert.NoError(err) {
-		defer os.Remove(frpcWithTlsCfgPath)
+		defer os.Remove(frpcWithTLSCfgPath)
 	}
 
 	frpsProcess := util.NewProcess(consts.FRPS_BIN_PATH, []string{"-c", frpsCfgPath})
@@ -249,32 +249,32 @@ func TestTlsOnlyOverTCP(t *testing.T) {
 
 	time.Sleep(200 * time.Millisecond)
 
-	frpcProcessWithTls := util.NewProcess(consts.FRPC_BIN_PATH, []string{"-c", frpcWithTlsCfgPath})
-	err = frpcProcessWithTls.Start()
+	frpcProcessWithTLS := util.NewProcess(consts.FRPC_BIN_PATH, []string{"-c", frpcWithTLSCfgPath})
+	err = frpcProcessWithTLS.Start()
 	if assert.NoError(err) {
-		defer frpcProcessWithTls.Stop()
+		defer frpcProcessWithTLS.Stop()
 	}
 	time.Sleep(500 * time.Millisecond)
 
-	// test tcp over tls
-	res, err := util.SendTcpMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
+	// test tcp over TLS
+	res, err := util.SendTCPMsg("127.0.0.1:20801", consts.TEST_TCP_ECHO_STR)
 	assert.NoError(err)
 	assert.Equal(consts.TEST_TCP_ECHO_STR, res)
-	frpcProcessWithTls.Stop()
+	frpcProcessWithTLS.Stop()
 
-	frpcWithoutTlsCfgPath, err := config.GenerateConfigFile(consts.FRPC_NORMAL_CONFIG, FRPC_TLS_ONLY_NO_TLS_TCP_CONF)
+	frpcWithoutTLSCfgPath, err := config.GenerateConfigFile(consts.FRPC_NORMAL_CONFIG, FRPC_TLS_ONLY_NO_TLS_TCP_CONF)
 	if assert.NoError(err) {
-		defer os.Remove(frpcWithTlsCfgPath)
+		defer os.Remove(frpcWithTLSCfgPath)
 	}
 
-	frpcProcessWithoutTls := util.NewProcess(consts.FRPC_BIN_PATH, []string{"-c", frpcWithoutTlsCfgPath})
-	err = frpcProcessWithoutTls.Start()
+	frpcProcessWithoutTLS := util.NewProcess(consts.FRPC_BIN_PATH, []string{"-c", frpcWithoutTLSCfgPath})
+	err = frpcProcessWithoutTLS.Start()
 	if assert.NoError(err) {
-		defer frpcProcessWithoutTls.Stop()
+		defer frpcProcessWithoutTLS.Stop()
 	}
 	time.Sleep(500 * time.Millisecond)
 
-	// test tcp without tls
-	_, err = util.SendTcpMsg("127.0.0.1:20802", consts.TEST_TCP_ECHO_STR)
+	// test tcp without TLS
+	_, err = util.SendTCPMsg("127.0.0.1:20802", consts.TEST_TCP_ECHO_STR)
 	assert.Error(err)
 }

tests/consts/consts.go

@@ -49,16 +49,16 @@ var (
 	TEST_SUDP_FRP_PORT int    = 10816
 	TEST_SUDP_ECHO_STR string = "sudp type:" + TEST_STR
 
-	ProxyTcpPortNotAllowed  string = "tcp_port_not_allowed"
-	ProxyTcpPortUnavailable string = "tcp_port_unavailable"
-	ProxyTcpPortNormal      string = "tcp_port_normal"
-	ProxyTcpRandomPort      string = "tcp_random_port"
-	ProxyUdpPortNotAllowed  string = "udp_port_not_allowed"
-	ProxyUdpPortNormal      string = "udp_port_normal"
-	ProxyUdpRandomPort      string = "udp_random_port"
-	ProxyHttpProxy          string = "http_proxy"
-
-	ProxyRangeTcpPrefix string = "range_tcp"
+	ProxyTCPPortNotAllowed  string = "tcp_port_not_allowed"
+	ProxyTCPPortUnavailable string = "tcp_port_unavailable"
+	ProxyTCPPortNormal      string = "tcp_port_normal"
+	ProxyTCPRandomPort      string = "tcp_random_port"
+	ProxyUDPPortNotAllowed  string = "udp_port_not_allowed"
+	ProxyUDPPortNormal      string = "udp_port_normal"
+	ProxyUDPRandomPort      string = "udp_random_port"
+	ProxyHTTPProxy          string = "http_proxy"
+
+	ProxyRangeTCPPrefix string = "range_tcp"
 )
 
 func init() {

tests/mock/echo_server.go

@@ -54,7 +54,7 @@ func (es *EchoServer) Stop() {
 	es.l.Close()
 }
 
-func StartUdpEchoServer(port int) {
+func StartUDPEchoServer(port int) {
 	l, err := frpNet.ListenUDP("127.0.0.1", port)
 	if err != nil {
 		fmt.Printf("udp echo server listen error: %v\n", err)

tests/mock/http_server.go

@@ -13,21 +13,21 @@ import (
 	"github.com/gorilla/websocket"
 )
 
-type HttpServer struct {
+type HTTPServer struct {
 	l net.Listener
 
 	port    int
 	handler http.HandlerFunc
 }
 
-func NewHttpServer(port int, handler http.HandlerFunc) *HttpServer {
-	return &HttpServer{
+func NewHTTPServer(port int, handler http.HandlerFunc) *HTTPServer {
+	return &HTTPServer{
 		port:    port,
 		handler: handler,
 	}
 }
 
-func (hs *HttpServer) Start() error {
+func (hs *HTTPServer) Start() error {
 	l, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", hs.port))
 	if err != nil {
 		fmt.Printf("http server listen error: %v\n", err)
@@ -39,14 +39,14 @@ func (hs *HttpServer) Start() error {
 	return nil
 }
 
-func (hs *HttpServer) Stop() {
+func (hs *HTTPServer) Stop() {
 	hs.l.Close()
 }
 
 var upgrader = websocket.Upgrader{}
 
-func StartHttpServer(port int) {
-	http.HandleFunc("/", handleHttp)
+func StartHTTPServer(port int) {
+	http.HandleFunc("/", handleHTTP)
 	http.HandleFunc("/ws", handleWebSocket)
 	http.ListenAndServe(fmt.Sprintf("0.0.0.0:%d", port), nil)
 }
@@ -71,7 +71,7 @@ func handleWebSocket(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func handleHttp(w http.ResponseWriter, r *http.Request) {
+func handleHTTP(w http.ResponseWriter, r *http.Request) {
 	if r.Header.Get("X-From-Where") == "frp" {
 		w.Header().Set("X-Header-Set", "true")
 	}

tests/util/util.go

@@ -41,37 +41,37 @@ func GetProxyStatus(statusAddr string, user string, passwd string, name string)
 	if err != nil {
 		return status, fmt.Errorf("unmarshal http response error: %s", strings.TrimSpace(string(body)))
 	}
-	for _, s := range allStatus.Tcp {
+	for _, s := range allStatus.TCP {
 		if s.Name == name {
 			return &s, nil
 		}
 	}
-	for _, s := range allStatus.Udp {
+	for _, s := range allStatus.UDP {
 		if s.Name == name {
 			return &s, nil
 		}
 	}
-	for _, s := range allStatus.Http {
+	for _, s := range allStatus.HTTP {
 		if s.Name == name {
 			return &s, nil
 		}
 	}
-	for _, s := range allStatus.Https {
+	for _, s := range allStatus.HTTPS {
 		if s.Name == name {
 			return &s, nil
 		}
 	}
-	for _, s := range allStatus.Stcp {
+	for _, s := range allStatus.STCP {
 		if s.Name == name {
 			return &s, nil
 		}
 	}
-	for _, s := range allStatus.Xtcp {
+	for _, s := range allStatus.XTCP {
 		if s.Name == name {
 			return &s, nil
 		}
 	}
-	for _, s := range allStatus.Sudp {
+	for _, s := range allStatus.SUDP {
 		if s.Name == name {
 			return &s, nil
 		}
@@ -101,17 +101,17 @@ func ReloadConf(reloadAddr string, user string, passwd string) error {
 	return nil
 }
 
-func SendTcpMsg(addr string, msg string) (res string, err error) {
+func SendTCPMsg(addr string, msg string) (res string, err error) {
 	c, err := net.Dial("tcp", addr)
 	if err != nil {
 		err = fmt.Errorf("connect to tcp server error: %v", err)
 		return
 	}
 	defer c.Close()
-	return SendTcpMsgByConn(c, msg)
+	return SendTCPMsgByConn(c, msg)
 }
 
-func SendTcpMsgByConn(c net.Conn, msg string) (res string, err error) {
+func SendTCPMsgByConn(c net.Conn, msg string) (res string, err error) {
 	timer := time.Now().Add(5 * time.Second)
 	c.SetDeadline(timer)
 	c.Write([]byte(msg))
@@ -125,7 +125,7 @@ func SendTcpMsgByConn(c net.Conn, msg string) (res string, err error) {
 	return string(buf[:n]), nil
 }
 
-func SendUdpMsg(addr string, msg string) (res string, err error) {
+func SendUDPMsg(addr string, msg string) (res string, err error) {
 	udpAddr, errRet := net.ResolveUDPAddr("udp", addr)
 	if errRet != nil {
 		err = fmt.Errorf("resolve udp addr error: %v", err)
@@ -153,7 +153,7 @@ func SendUdpMsg(addr string, msg string) (res string, err error) {
 	return string(buf[:n]), nil
 }
 
-func SendHttpMsg(method, urlStr string, host string, headers map[string]string, proxy string) (code int, body string, header http.Header, err error) {
+func SendHTTPMsg(method, urlStr string, host string, headers map[string]string, proxy string) (code int, body string, header http.Header, err error) {
 	req, errRet := http.NewRequest(method, urlStr, nil)
 	if errRet != nil {
 		err = errRet

utils/net/conn.go

@@ -58,7 +58,7 @@ type ContextConn struct {
 	ctx context.Context
 }
 
-func NewContextConn(c net.Conn, ctx context.Context) *ContextConn {
+func NewContextConn(ctx context.Context, c net.Conn) *ContextConn {
 	return &ContextConn{
 		Conn: c,
 		ctx:  ctx,
@@ -227,8 +227,8 @@ func ConnectServerByProxy(proxyURL string, protocol string, addr string) (c net.
 	}
 }
 
-func ConnectServerByProxyWithTLS(proxyUrl string, protocol string, addr string, tlsConfig *tls.Config) (c net.Conn, err error) {
-	c, err = ConnectServerByProxy(proxyUrl, protocol, addr)
+func ConnectServerByProxyWithTLS(proxyURL string, protocol string, addr string, tlsConfig *tls.Config) (c net.Conn, err error) {
+	c, err = ConnectServerByProxy(proxyURL, protocol, addr)
 	if err != nil {
 		return
 	}

utils/net/http.go

@@ -21,21 +21,21 @@ import (
 	"strings"
 )
 
-type HttpAuthWraper struct {
+type HTTPAuthWraper struct {
 	h      http.Handler
 	user   string
 	passwd string
 }
 
-func NewHttpBasicAuthWraper(h http.Handler, user, passwd string) http.Handler {
-	return &HttpAuthWraper{
+func NewHTTPBasicAuthWraper(h http.Handler, user, passwd string) http.Handler {
+	return &HTTPAuthWraper{
 		h:      h,
 		user:   user,
 		passwd: passwd,
 	}
 }
 
-func (aw *HttpAuthWraper) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+func (aw *HTTPAuthWraper) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	user, passwd, hasAuth := r.BasicAuth()
 	if (aw.user == "" && aw.passwd == "") || (hasAuth && user == aw.user && passwd == aw.passwd) {
 		aw.h.ServeHTTP(w, r)
@@ -45,19 +45,19 @@ func (aw *HttpAuthWraper) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-type HttpAuthMiddleware struct {
+type HTTPAuthMiddleware struct {
 	user   string
 	passwd string
 }
 
-func NewHttpAuthMiddleware(user, passwd string) *HttpAuthMiddleware {
-	return &HttpAuthMiddleware{
+func NewHTTPAuthMiddleware(user, passwd string) *HTTPAuthMiddleware {
+	return &HTTPAuthMiddleware{
 		user:   user,
 		passwd: passwd,
 	}
 }
 
-func (authMid *HttpAuthMiddleware) Middleware(next http.Handler) http.Handler {
+func (authMid *HTTPAuthMiddleware) Middleware(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		reqUser, reqPasswd, hasAuth := r.BasicAuth()
 		if (authMid.user == "" && authMid.passwd == "") ||
@@ -70,7 +70,7 @@ func (authMid *HttpAuthMiddleware) Middleware(next http.Handler) http.Handler {
 	})
 }
 
-func HttpBasicAuth(h http.HandlerFunc, user, passwd string) http.HandlerFunc {
+func HTTPBasicAuth(h http.HandlerFunc, user, passwd string) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		reqUser, reqPasswd, hasAuth := r.BasicAuth()
 		if (user == "" && passwd == "") ||
@@ -83,11 +83,11 @@ func HttpBasicAuth(h http.HandlerFunc, user, passwd string) http.HandlerFunc {
 	}
 }
 
-type HttpGzipWraper struct {
+type HTTPGzipWraper struct {
 	h http.Handler
 }
 
-func (gw *HttpGzipWraper) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+func (gw *HTTPGzipWraper) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
 		gw.h.ServeHTTP(w, r)
 		return
@@ -99,8 +99,8 @@ func (gw *HttpGzipWraper) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	gw.h.ServeHTTP(gzr, r)
 }
 
-func MakeHttpGzipHandler(h http.Handler) http.Handler {
-	return &HttpGzipWraper{
+func MakeHTTPGzipHandler(h http.Handler) http.Handler {
+	return &HTTPGzipWraper{
 		h: h,
 	}
 }

utils/net/kcp.go

@@ -21,13 +21,13 @@ import (
 	kcp "github.com/fatedier/kcp-go"
 )
 
-type KcpListener struct {
+type KCPListener struct {
 	listener  net.Listener
 	acceptCh  chan net.Conn
 	closeFlag bool
 }
 
-func ListenKcp(bindAddr string, bindPort int) (l *KcpListener, err error) {
+func ListenKcp(bindAddr string, bindPort int) (l *KCPListener, err error) {
 	listener, err := kcp.ListenWithOptions(fmt.Sprintf("%s:%d", bindAddr, bindPort), nil, 10, 3)
 	if err != nil {
 		return l, err
@@ -35,7 +35,7 @@ func ListenKcp(bindAddr string, bindPort int) (l *KcpListener, err error) {
 	listener.SetReadBuffer(4194304)
 	listener.SetWriteBuffer(4194304)
 
-	l = &KcpListener{
+	l = &KCPListener{
 		listener:  listener,
 		acceptCh:  make(chan net.Conn),
 		closeFlag: false,
@@ -64,7 +64,7 @@ func ListenKcp(bindAddr string, bindPort int) (l *KcpListener, err error) {
 	return l, err
 }
 
-func (l *KcpListener) Accept() (net.Conn, error) {
+func (l *KCPListener) Accept() (net.Conn, error) {
 	conn, ok := <-l.acceptCh
 	if !ok {
 		return conn, fmt.Errorf("channel for kcp listener closed")
@@ -72,7 +72,7 @@ func (l *KcpListener) Accept() (net.Conn, error) {
 	return conn, nil
 }
 
-func (l *KcpListener) Close() error {
+func (l *KCPListener) Close() error {
 	if !l.closeFlag {
 		l.closeFlag = true
 		l.listener.Close()
@@ -80,11 +80,11 @@ func (l *KcpListener) Close() error {
 	return nil
 }
 
-func (l *KcpListener) Addr() net.Addr {
+func (l *KCPListener) Addr() net.Addr {
 	return l.listener.Addr()
 }
 
-func NewKcpConnFromUdp(conn *net.UDPConn, connected bool, raddr string) (net.Conn, error) {
+func NewKCPConnFromUDP(conn *net.UDPConn, connected bool, raddr string) (net.Conn, error) {
 	kcpConn, err := kcp.NewConnEx(1, connected, raddr, nil, 10, 3, conn)
 	if err != nil {
 		return nil, err

utils/net/tls.go

@@ -24,11 +24,11 @@ import (
 )
 
 var (
-	FRP_TLS_HEAD_BYTE = 0x17
+	FRPTLSHeadByte = 0x17
 )
 
 func WrapTLSClientConn(c net.Conn, tlsConfig *tls.Config) (out net.Conn) {
-	c.Write([]byte{byte(FRP_TLS_HEAD_BYTE)})
+	c.Write([]byte{byte(FRPTLSHeadByte)})
 	out = tls.Client(c, tlsConfig)
 	return
 }
@@ -44,7 +44,7 @@ func CheckAndEnableTLSServerConnWithTimeout(c net.Conn, tlsConfig *tls.Config, t
 		return
 	}
 
-	if n == 1 && int(buf[0]) == FRP_TLS_HEAD_BYTE {
+	if n == 1 && int(buf[0]) == FRPTLSHeadByte {
 		out = tls.Server(c, tlsConfig)
 	} else {
 		if tlsOnly {

utils/net/udp.go

@@ -24,14 +24,14 @@ import (
 	"github.com/fatedier/golib/pool"
 )
 
-type UdpPacket struct {
+type UDPPacket struct {
 	Buf        []byte
 	LocalAddr  net.Addr
 	RemoteAddr net.Addr
 }
 
-type FakeUdpConn struct {
-	l *UdpListener
+type FakeUDPConn struct {
+	l *UDPListener
 
 	localAddr  net.Addr
 	remoteAddr net.Addr
@@ -42,8 +42,8 @@ type FakeUdpConn struct {
 	mu         sync.RWMutex
 }
 
-func NewFakeUdpConn(l *UdpListener, laddr, raddr net.Addr) *FakeUdpConn {
-	fc := &FakeUdpConn{
+func NewFakeUDPConn(l *UDPListener, laddr, raddr net.Addr) *FakeUDPConn {
+	fc := &FakeUDPConn{
 		l:          l,
 		localAddr:  laddr,
 		remoteAddr: raddr,
@@ -65,7 +65,7 @@ func NewFakeUdpConn(l *UdpListener, laddr, raddr net.Addr) *FakeUdpConn {
 	return fc
 }
 
-func (c *FakeUdpConn) putPacket(content []byte) {
+func (c *FakeUDPConn) putPacket(content []byte) {
 	defer func() {
 		if err := recover(); err != nil {
 		}
@@ -77,7 +77,7 @@ func (c *FakeUdpConn) putPacket(content []byte) {
 	}
 }
 
-func (c *FakeUdpConn) Read(b []byte) (n int, err error) {
+func (c *FakeUDPConn) Read(b []byte) (n int, err error) {
 	content, ok := <-c.packets
 	if !ok {
 		return 0, io.EOF
@@ -95,7 +95,7 @@ func (c *FakeUdpConn) Read(b []byte) (n int, err error) {
 	return n, nil
 }
 
-func (c *FakeUdpConn) Write(b []byte) (n int, err error) {
+func (c *FakeUDPConn) Write(b []byte) (n int, err error) {
 	c.mu.RLock()
 	if c.closeFlag {
 		c.mu.RUnlock()
@@ -103,12 +103,12 @@ func (c *FakeUdpConn) Write(b []byte) (n int, err error) {
 	}
 	c.mu.RUnlock()
 
-	packet := &UdpPacket{
+	packet := &UDPPacket{
 		Buf:        b,
 		LocalAddr:  c.localAddr,
 		RemoteAddr: c.remoteAddr,
 	}
-	c.l.writeUdpPacket(packet)
+	c.l.writeUDPPacket(packet)
 
 	c.mu.Lock()
 	c.lastActive = time.Now()
@@ -116,7 +116,7 @@ func (c *FakeUdpConn) Write(b []byte) (n int, err error) {
 	return len(b), nil
 }
 
-func (c *FakeUdpConn) Close() error {
+func (c *FakeUDPConn) Close() error {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	if !c.closeFlag {
@@ -126,54 +126,54 @@ func (c *FakeUdpConn) Close() error {
 	return nil
 }
 
-func (c *FakeUdpConn) IsClosed() bool {
+func (c *FakeUDPConn) IsClosed() bool {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 	return c.closeFlag
 }
 
-func (c *FakeUdpConn) LocalAddr() net.Addr {
+func (c *FakeUDPConn) LocalAddr() net.Addr {
 	return c.localAddr
 }
 
-func (c *FakeUdpConn) RemoteAddr() net.Addr {
+func (c *FakeUDPConn) RemoteAddr() net.Addr {
 	return c.remoteAddr
 }
 
-func (c *FakeUdpConn) SetDeadline(t time.Time) error {
+func (c *FakeUDPConn) SetDeadline(t time.Time) error {
 	return nil
 }
 
-func (c *FakeUdpConn) SetReadDeadline(t time.Time) error {
+func (c *FakeUDPConn) SetReadDeadline(t time.Time) error {
 	return nil
 }
 
-func (c *FakeUdpConn) SetWriteDeadline(t time.Time) error {
+func (c *FakeUDPConn) SetWriteDeadline(t time.Time) error {
 	return nil
 }
 
-type UdpListener struct {
+type UDPListener struct {
 	addr      net.Addr
 	acceptCh  chan net.Conn
-	writeCh   chan *UdpPacket
+	writeCh   chan *UDPPacket
 	readConn  net.Conn
 	closeFlag bool
 
-	fakeConns map[string]*FakeUdpConn
+	fakeConns map[string]*FakeUDPConn
 }
 
-func ListenUDP(bindAddr string, bindPort int) (l *UdpListener, err error) {
+func ListenUDP(bindAddr string, bindPort int) (l *UDPListener, err error) {
 	udpAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", bindAddr, bindPort))
 	if err != nil {
 		return l, err
 	}
 	readConn, err := net.ListenUDP("udp", udpAddr)
 
-	l = &UdpListener{
+	l = &UDPListener{
 		addr:      udpAddr,
 		acceptCh:  make(chan net.Conn),
-		writeCh:   make(chan *UdpPacket, 1000),
-		fakeConns: make(map[string]*FakeUdpConn),
+		writeCh:   make(chan *UDPPacket, 1000),
+		fakeConns: make(map[string]*FakeUDPConn),
 	}
 
 	// for reading
@@ -189,7 +189,7 @@ func ListenUDP(bindAddr string, bindPort int) (l *UdpListener, err error) {
 
 			fakeConn, exist := l.fakeConns[remoteAddr.String()]
 			if !exist || fakeConn.IsClosed() {
-				fakeConn = NewFakeUdpConn(l, l.Addr(), remoteAddr)
+				fakeConn = NewFakeUDPConn(l, l.Addr(), remoteAddr)
 				l.fakeConns[remoteAddr.String()] = fakeConn
 			}
 			fakeConn.putPacket(buf[:n])
@@ -215,7 +215,7 @@ func ListenUDP(bindAddr string, bindPort int) (l *UdpListener, err error) {
 	return
 }
 
-func (l *UdpListener) writeUdpPacket(packet *UdpPacket) (err error) {
+func (l *UDPListener) writeUDPPacket(packet *UDPPacket) (err error) {
 	defer func() {
 		if errRet := recover(); errRet != nil {
 			err = fmt.Errorf("udp write closed listener")
@@ -225,17 +225,17 @@ func (l *UdpListener) writeUdpPacket(packet *UdpPacket) (err error) {
 	return
 }
 
-func (l *UdpListener) WriteMsg(buf []byte, remoteAddr *net.UDPAddr) (err error) {
+func (l *UDPListener) WriteMsg(buf []byte, remoteAddr *net.UDPAddr) (err error) {
 	// only set remote addr here
-	packet := &UdpPacket{
+	packet := &UDPPacket{
 		Buf:        buf,
 		RemoteAddr: remoteAddr,
 	}
-	err = l.writeUdpPacket(packet)
+	err = l.writeUDPPacket(packet)
 	return
 }
 
-func (l *UdpListener) Accept() (net.Conn, error) {
+func (l *UDPListener) Accept() (net.Conn, error) {
 	conn, ok := <-l.acceptCh
 	if !ok {
 		return conn, fmt.Errorf("channel for udp listener closed")
@@ -243,7 +243,7 @@ func (l *UdpListener) Accept() (net.Conn, error) {
 	return conn, nil
 }
 
-func (l *UdpListener) Close() error {
+func (l *UDPListener) Close() error {
 	if !l.closeFlag {
 		l.closeFlag = true
 		l.readConn.Close()
@@ -251,6 +251,6 @@ func (l *UdpListener) Close() error {
 	return nil
 }
 
-func (l *UdpListener) Addr() net.Addr {
+func (l *UDPListener) Addr() net.Addr {
 	return l.addr
 }

utils/tcpmux/httpconnect.go

@@ -26,16 +26,16 @@ import (
 	"github.com/fatedier/frp/utils/vhost"
 )
 
-type HttpConnectTcpMuxer struct {
-	*vhost.VhostMuxer
+type HTTPConnectTCPMuxer struct {
+	*vhost.Muxer
 }
 
-func NewHttpConnectTcpMuxer(listener net.Listener, timeout time.Duration) (*HttpConnectTcpMuxer, error) {
-	mux, err := vhost.NewVhostMuxer(listener, getHostFromHttpConnect, nil, sendHttpOk, nil, timeout)
-	return &HttpConnectTcpMuxer{mux}, err
+func NewHTTPConnectTCPMuxer(listener net.Listener, timeout time.Duration) (*HTTPConnectTCPMuxer, error) {
+	mux, err := vhost.NewMuxer(listener, getHostFromHTTPConnect, nil, sendHTTPOk, nil, timeout)
+	return &HTTPConnectTCPMuxer{mux}, err
 }
 
-func readHttpConnectRequest(rd io.Reader) (host string, err error) {
+func readHTTPConnectRequest(rd io.Reader) (host string, err error) {
 	bufioReader := bufio.NewReader(rd)
 
 	req, err := http.ReadRequest(bufioReader)
@@ -52,13 +52,13 @@ func readHttpConnectRequest(rd io.Reader) (host string, err error) {
 	return
 }
 
-func sendHttpOk(c net.Conn) error {
+func sendHTTPOk(c net.Conn) error {
 	return util.OkResponse().Write(c)
 }
 
-func getHostFromHttpConnect(c net.Conn) (_ net.Conn, _ map[string]string, err error) {
+func getHostFromHTTPConnect(c net.Conn) (_ net.Conn, _ map[string]string, err error) {
 	reqInfoMap := make(map[string]string, 0)
-	host, err := readHttpConnectRequest(c)
+	host, err := readHTTPConnectRequest(c)
 	if err != nil {
 		return nil, reqInfoMap, err
 	}

utils/util/util.go

@@ -23,13 +23,13 @@ import (
 	"strings"
 )
 
-// RandId return a rand string used in frp.
-func RandId() (id string, err error) {
-	return RandIdWithLen(8)
+// RandID return a rand string used in frp.
+func RandID() (id string, err error) {
+	return RandIDWithLen(8)
 }
 
-// RandIdWithLen return a rand string with idLen length.
-func RandIdWithLen(idLen int) (id string, err error) {
+// RandIDWithLen return a rand string with idLen length.
+func RandIDWithLen(idLen int) (id string, err error) {
 	b := make([]byte, idLen)
 	_, err = rand.Read(b)
 	if err != nil {
@@ -105,7 +105,6 @@ func ParseRangeNumbers(rangeStr string) (numbers []int64, err error) {
 func GenerateResponseErrorString(summary string, err error, detailed bool) string {
 	if detailed {
 		return err.Error()
-	} else {
-		return summary
 	}
+	return summary
 }

utils/util/util_test.go

@@ -8,7 +8,7 @@ import (
 
 func TestRandId(t *testing.T) {
 	assert := assert.New(t)
-	id, err := RandId()
+	id, err := RandID()
 	assert.NoError(err)
 	t.Log(id)
 	assert.Equal(16, len(id))

utils/vhost/http.go

@@ -35,30 +35,30 @@ var (
 	ErrNoDomain = errors.New("no such domain")
 )
 
-type HttpReverseProxyOptions struct {
+type HTTPReverseProxyOptions struct {
 	ResponseHeaderTimeoutS int64
 }
 
-type HttpReverseProxy struct {
+type HTTPReverseProxy struct {
 	proxy       *ReverseProxy
-	vhostRouter *VhostRouters
+	vhostRouter *Routers
 
 	responseHeaderTimeout time.Duration
 }
 
-func NewHttpReverseProxy(option HttpReverseProxyOptions, vhostRouter *VhostRouters) *HttpReverseProxy {
+func NewHTTPReverseProxy(option HTTPReverseProxyOptions, vhostRouter *Routers) *HTTPReverseProxy {
 	if option.ResponseHeaderTimeoutS <= 0 {
 		option.ResponseHeaderTimeoutS = 60
 	}
-	rp := &HttpReverseProxy{
+	rp := &HTTPReverseProxy{
 		responseHeaderTimeout: time.Duration(option.ResponseHeaderTimeoutS) * time.Second,
 		vhostRouter:           vhostRouter,
 	}
 	proxy := &ReverseProxy{
 		Director: func(req *http.Request) {
 			req.URL.Scheme = "http"
-			url := req.Context().Value("url").(string)
-			oldHost := util.GetHostFromAddr(req.Context().Value("host").(string))
+			url := req.Context().Value(RouteInfoURL).(string)
+			oldHost := util.GetHostFromAddr(req.Context().Value(RouteInfoHost).(string))
 			host := rp.GetRealHost(oldHost, url)
 			if host != "" {
 				req.Host = host
@@ -74,9 +74,9 @@ func NewHttpReverseProxy(option HttpReverseProxyOptions, vhostRouter *VhostRoute
 			ResponseHeaderTimeout: rp.responseHeaderTimeout,
 			DisableKeepAlives:     true,
 			DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
-				url := ctx.Value("url").(string)
-				host := util.GetHostFromAddr(ctx.Value("host").(string))
-				remote := ctx.Value("remote").(string)
+				url := ctx.Value(RouteInfoURL).(string)
+				host := util.GetHostFromAddr(ctx.Value(RouteInfoHost).(string))
+				remote := ctx.Value(RouteInfoRemote).(string)
 				return rp.CreateConnection(host, url, remote)
 			},
 		},
@@ -94,7 +94,7 @@ func NewHttpReverseProxy(option HttpReverseProxyOptions, vhostRouter *VhostRoute
 
 // Register register the route config to reverse proxy
 // reverse proxy will use CreateConnFn from routeCfg to create a connection to the remote service
-func (rp *HttpReverseProxy) Register(routeCfg VhostRouteConfig) error {
+func (rp *HTTPReverseProxy) Register(routeCfg RouteConfig) error {
 	err := rp.vhostRouter.Add(routeCfg.Domain, routeCfg.Location, &routeCfg)
 	if err != nil {
 		return err
@@ -103,31 +103,31 @@ func (rp *HttpReverseProxy) Register(routeCfg VhostRouteConfig) error {
 }
 
 // UnRegister unregister route config by domain and location
-func (rp *HttpReverseProxy) UnRegister(domain string, location string) {
+func (rp *HTTPReverseProxy) UnRegister(domain string, location string) {
 	rp.vhostRouter.Del(domain, location)
 }
 
-func (rp *HttpReverseProxy) GetRealHost(domain string, location string) (host string) {
+func (rp *HTTPReverseProxy) GetRealHost(domain string, location string) (host string) {
 	vr, ok := rp.getVhost(domain, location)
 	if ok {
-		host = vr.payload.(*VhostRouteConfig).RewriteHost
+		host = vr.payload.(*RouteConfig).RewriteHost
 	}
 	return
 }
 
-func (rp *HttpReverseProxy) GetHeaders(domain string, location string) (headers map[string]string) {
+func (rp *HTTPReverseProxy) GetHeaders(domain string, location string) (headers map[string]string) {
 	vr, ok := rp.getVhost(domain, location)
 	if ok {
-		headers = vr.payload.(*VhostRouteConfig).Headers
+		headers = vr.payload.(*RouteConfig).Headers
 	}
 	return
 }
 
 // CreateConnection create a new connection by route config
-func (rp *HttpReverseProxy) CreateConnection(domain string, location string, remoteAddr string) (net.Conn, error) {
+func (rp *HTTPReverseProxy) CreateConnection(domain string, location string, remoteAddr string) (net.Conn, error) {
 	vr, ok := rp.getVhost(domain, location)
 	if ok {
-		fn := vr.payload.(*VhostRouteConfig).CreateConnFn
+		fn := vr.payload.(*RouteConfig).CreateConnFn
 		if fn != nil {
 			return fn(remoteAddr)
 		}
@@ -135,11 +135,11 @@ func (rp *HttpReverseProxy) CreateConnection(domain string, location string, rem
 	return nil, fmt.Errorf("%v: %s %s", ErrNoDomain, domain, location)
 }
 
-func (rp *HttpReverseProxy) CheckAuth(domain, location, user, passwd string) bool {
+func (rp *HTTPReverseProxy) CheckAuth(domain, location, user, passwd string) bool {
 	vr, ok := rp.getVhost(domain, location)
 	if ok {
-		checkUser := vr.payload.(*VhostRouteConfig).Username
-		checkPasswd := vr.payload.(*VhostRouteConfig).Password
+		checkUser := vr.payload.(*RouteConfig).Username
+		checkPasswd := vr.payload.(*RouteConfig).Password
 		if (checkUser != "" || checkPasswd != "") && (checkUser != user || checkPasswd != passwd) {
 			return false
 		}
@@ -148,7 +148,7 @@ func (rp *HttpReverseProxy) CheckAuth(domain, location, user, passwd string) boo
 }
 
 // getVhost get vhost router by domain and location
-func (rp *HttpReverseProxy) getVhost(domain string, location string) (vr *VhostRouter, ok bool) {
+func (rp *HTTPReverseProxy) getVhost(domain string, location string) (vr *Router, ok bool) {
 	// first we check the full hostname
 	// if not exist, then check the wildcard_domain such as *.example.com
 	vr, ok = rp.vhostRouter.Get(domain, location)
@@ -176,7 +176,7 @@ func (rp *HttpReverseProxy) getVhost(domain string, location string) (vr *VhostR
 	}
 }
 
-func (rp *HttpReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
+func (rp *HTTPReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
 	domain := util.GetHostFromAddr(req.Host)
 	location := req.URL.Path
 	user, passwd, _ := req.BasicAuth()

utils/vhost/https.go

@@ -43,13 +43,13 @@ const (
 	extensionRenegotiationInfo   uint16 = 0xff01
 )
 
-type HttpsMuxer struct {
-	*VhostMuxer
+type HTTPSMuxer struct {
+	*Muxer
 }
 
-func NewHttpsMuxer(listener net.Listener, timeout time.Duration) (*HttpsMuxer, error) {
-	mux, err := NewVhostMuxer(listener, GetHttpsHostname, nil, nil, nil, timeout)
-	return &HttpsMuxer{mux}, err
+func NewHTTPSMuxer(listener net.Listener, timeout time.Duration) (*HTTPSMuxer, error) {
+	mux, err := NewMuxer(listener, GetHTTPSHostname, nil, nil, nil, timeout)
+	return &HTTPSMuxer{mux}, err
 }
 
 func readHandshake(rd io.Reader) (host string, err error) {
@@ -65,9 +65,8 @@ func readHandshake(rd io.Reader) (host string, err error) {
 	length, err := rd.Read(data[47:])
 	if err != nil {
 		return
-	} else {
-		length += 47
 	}
+	length += 47
 	data = data[:length]
 	if uint8(data[5]) != typeClientHello {
 		err = fmt.Errorf("readHandshake: type[%d] is not clientHello", uint16(data[5]))
@@ -75,12 +74,12 @@ func readHandshake(rd io.Reader) (host string, err error) {
 	}
 
 	// session
-	sessionIdLen := int(data[43])
-	if sessionIdLen > 32 || len(data) < 44+sessionIdLen {
-		err = fmt.Errorf("readHandshake: sessionIdLen[%d] is long", sessionIdLen)
+	sessionIDLen := int(data[43])
+	if sessionIDLen > 32 || len(data) < 44+sessionIDLen {
+		err = fmt.Errorf("readHandshake: sessionIdLen[%d] is long", sessionIDLen)
 		return
 	}
-	data = data[44+sessionIdLen:]
+	data = data[44+sessionIDLen:]
 	if len(data) < 2 {
 		err = fmt.Errorf("readHandshake: dataLen[%d] after session is short", len(data))
 		return
@@ -181,7 +180,7 @@ func readHandshake(rd io.Reader) (host string, err error) {
 	return
 }
 
-func GetHttpsHostname(c net.Conn) (_ net.Conn, _ map[string]string, err error) {
+func GetHTTPSHostname(c net.Conn) (_ net.Conn, _ map[string]string, err error) {
 	reqInfoMap := make(map[string]string, 0)
 	sc, rd := gnet.NewSharedConn(c)
 	host, err := readHandshake(rd)

utils/vhost/reverseproxy.go

@@ -202,9 +202,9 @@ func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
 
 	// =============================
 	// Modified for frp
-	outreq = outreq.WithContext(context.WithValue(outreq.Context(), "url", req.URL.Path))
-	outreq = outreq.WithContext(context.WithValue(outreq.Context(), "host", req.Host))
-	outreq = outreq.WithContext(context.WithValue(outreq.Context(), "remote", req.RemoteAddr))
+	outreq = outreq.WithContext(context.WithValue(outreq.Context(), RouteInfoURL, req.URL.Path))
+	outreq = outreq.WithContext(context.WithValue(outreq.Context(), RouteInfoHost, req.Host))
+	outreq = outreq.WithContext(context.WithValue(outreq.Context(), RouteInfoRemote, req.RemoteAddr))
 	// =============================
 
 	p.Director(outreq)

utils/vhost/router.go

@@ -11,25 +11,25 @@ var (
 	ErrRouterConfigConflict = errors.New("router config conflict")
 )
 
-type VhostRouters struct {
-	RouterByDomain map[string][]*VhostRouter
+type Routers struct {
+	RouterByDomain map[string][]*Router
 	mutex          sync.RWMutex
 }
 
-type VhostRouter struct {
+type Router struct {
 	domain   string
 	location string
 
 	payload interface{}
 }
 
-func NewVhostRouters() *VhostRouters {
-	return &VhostRouters{
-		RouterByDomain: make(map[string][]*VhostRouter),
+func NewRouters() *Routers {
+	return &Routers{
+		RouterByDomain: make(map[string][]*Router),
 	}
 }
 
-func (r *VhostRouters) Add(domain, location string, payload interface{}) error {
+func (r *Routers) Add(domain, location string, payload interface{}) error {
 	r.mutex.Lock()
 	defer r.mutex.Unlock()
 
@@ -39,10 +39,10 @@ func (r *VhostRouters) Add(domain, location string, payload interface{}) error {
 
 	vrs, found := r.RouterByDomain[domain]
 	if !found {
-		vrs = make([]*VhostRouter, 0, 1)
+		vrs = make([]*Router, 0, 1)
 	}
 
-	vr := &VhostRouter{
+	vr := &Router{
 		domain:   domain,
 		location: location,
 		payload:  payload,
@@ -54,7 +54,7 @@ func (r *VhostRouters) Add(domain, location string, payload interface{}) error {
 	return nil
 }
 
-func (r *VhostRouters) Del(domain, location string) {
+func (r *Routers) Del(domain, location string) {
 	r.mutex.Lock()
 	defer r.mutex.Unlock()
 
@@ -62,7 +62,7 @@ func (r *VhostRouters) Del(domain, location string) {
 	if !found {
 		return
 	}
-	newVrs := make([]*VhostRouter, 0)
+	newVrs := make([]*Router, 0)
 	for _, vr := range vrs {
 		if vr.location != location {
 			newVrs = append(newVrs, vr)
@@ -71,7 +71,7 @@ func (r *VhostRouters) Del(domain, location string) {
 	r.RouterByDomain[domain] = newVrs
 }
 
-func (r *VhostRouters) Get(host, path string) (vr *VhostRouter, exist bool) {
+func (r *Routers) Get(host, path string) (vr *Router, exist bool) {
 	r.mutex.RLock()
 	defer r.mutex.RUnlock()
 
@@ -90,7 +90,7 @@ func (r *VhostRouters) Get(host, path string) (vr *VhostRouter, exist bool) {
 	return
 }
 
-func (r *VhostRouters) exist(host, path string) (vr *VhostRouter, exist bool) {
+func (r *Routers) exist(host, path string) (vr *Router, exist bool) {
 	vrs, found := r.RouterByDomain[host]
 	if !found {
 		return
@@ -106,7 +106,7 @@ func (r *VhostRouters) exist(host, path string) (vr *VhostRouter, exist bool) {
 }
 
 // sort by location
-type ByLocation []*VhostRouter
+type ByLocation []*Router
 
 func (a ByLocation) Len() int {
 	return len(a)

utils/vhost/vhost.go

@@ -26,30 +26,38 @@ import (
 	"github.com/fatedier/golib/errors"
 )
 
+type RouteInfo string
+
+const (
+	RouteInfoURL    RouteInfo = "url"
+	RouteInfoHost   RouteInfo = "host"
+	RouteInfoRemote RouteInfo = "remote"
+)
+
 type muxFunc func(net.Conn) (net.Conn, map[string]string, error)
 type httpAuthFunc func(net.Conn, string, string, string) (bool, error)
 type hostRewriteFunc func(net.Conn, string) (net.Conn, error)
 type successFunc func(net.Conn) error
 
-type VhostMuxer struct {
+type Muxer struct {
 	listener       net.Listener
 	timeout        time.Duration
 	vhostFunc      muxFunc
 	authFunc       httpAuthFunc
 	successFunc    successFunc
 	rewriteFunc    hostRewriteFunc
-	registryRouter *VhostRouters
+	registryRouter *Routers
 }
 
-func NewVhostMuxer(listener net.Listener, vhostFunc muxFunc, authFunc httpAuthFunc, successFunc successFunc, rewriteFunc hostRewriteFunc, timeout time.Duration) (mux *VhostMuxer, err error) {
-	mux = &VhostMuxer{
+func NewMuxer(listener net.Listener, vhostFunc muxFunc, authFunc httpAuthFunc, successFunc successFunc, rewriteFunc hostRewriteFunc, timeout time.Duration) (mux *Muxer, err error) {
+	mux = &Muxer{
 		listener:       listener,
 		timeout:        timeout,
 		vhostFunc:      vhostFunc,
 		authFunc:       authFunc,
 		successFunc:    successFunc,
 		rewriteFunc:    rewriteFunc,
-		registryRouter: NewVhostRouters(),
+		registryRouter: NewRouters(),
 	}
 	go mux.run()
 	return mux, nil
@@ -57,8 +65,8 @@ func NewVhostMuxer(listener net.Listener, vhostFunc muxFunc, authFunc httpAuthFu
 
 type CreateConnFunc func(remoteAddr string) (net.Conn, error)
 
-// VhostRouteConfig is the params used to match HTTP requests
-type VhostRouteConfig struct {
+// RouteConfig is the params used to match HTTP requests
+type RouteConfig struct {
 	Domain      string
 	Location    string
 	RewriteHost string
@@ -71,7 +79,7 @@ type VhostRouteConfig struct {
 
 // listen for a new domain name, if rewriteHost is not empty  and rewriteFunc is not nil
 // then rewrite the host header to rewriteHost
-func (v *VhostMuxer) Listen(ctx context.Context, cfg *VhostRouteConfig) (l *Listener, err error) {
+func (v *Muxer) Listen(ctx context.Context, cfg *RouteConfig) (l *Listener, err error) {
 	l = &Listener{
 		name:        cfg.Domain,
 		location:    cfg.Location,
@@ -89,7 +97,7 @@ func (v *VhostMuxer) Listen(ctx context.Context, cfg *VhostRouteConfig) (l *List
 	return l, nil
 }
 
-func (v *VhostMuxer) getListener(name, path string) (l *Listener, exist bool) {
+func (v *Muxer) getListener(name, path string) (l *Listener, exist bool) {
 	// first we check the full hostname
 	// if not exist, then check the wildcard_domain such as *.example.com
 	vr, found := v.registryRouter.Get(name, path)
@@ -118,7 +126,7 @@ func (v *VhostMuxer) getListener(name, path string) (l *Listener, exist bool) {
 	}
 }
 
-func (v *VhostMuxer) run() {
+func (v *Muxer) run() {
 	for {
 		conn, err := v.listener.Accept()
 		if err != nil {
@@ -128,7 +136,7 @@ func (v *VhostMuxer) run() {
 	}
 }
 
-func (v *VhostMuxer) handle(c net.Conn) {
+func (v *Muxer) handle(c net.Conn) {
 	if err := c.SetDeadline(time.Now().Add(v.timeout)); err != nil {
 		c.Close()
 		return
@@ -195,7 +203,7 @@ type Listener struct {
 	rewriteHost string
 	userName    string
 	passWord    string
-	mux         *VhostMuxer // for closing VhostMuxer
+	mux         *Muxer // for closing Muxer
 	accept      chan net.Conn
 	ctx         context.Context
 }
@@ -219,7 +227,7 @@ func (l *Listener) Accept() (net.Conn, error) {
 		xl.Debug("rewrite host to [%s] success", l.rewriteHost)
 		conn = sConn
 	}
-	return frpNet.NewContextConn(conn, l.ctx), nil
+	return frpNet.NewContextConn(l.ctx, conn), nil
 }
 
 func (l *Listener) Close() error {