fix by golint (#1822)

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