extern/frp
1
1
Fork 0
mirror of https://github.com/fatedier/frp.git synced 2024-12-12 09:41:19 +01:00
Code Issues Packages Projects Releases Wiki Activity

fix by golint (#1822)

Browse Source
This commit is contained in:
fatedier 2020-05-24 17:48:37 +08:00 committed by GitHub
parent 2170c481ce
commit 8b75b8b837
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
80 changed files with 1315 additions and 1324 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
client/admin.go
View File

@ -36,7 +36,7 @@ func (svr *Service) RunAdminServer(addr string, port int) (err error) {
router := mux.NewRouter() router := mux.NewRouter()
user, passwd := svr.cfg.AdminUser, svr.cfg.AdminPwd 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 // api, see dashboard_api.go
router.HandleFunc("/api/reload", svr.apiReload).Methods("GET") router.HandleFunc("/api/reload", svr.apiReload).Methods("GET")
@ -46,7 +46,7 @@ func (svr *Service) RunAdminServer(addr string, port int) (err error) {
// view // view
router.Handle("/favicon.ico", http.FileServer(assets.FileSystem)).Methods("GET") 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) { router.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "/static/", http.StatusMovedPermanently) http.Redirect(w, r, "/static/", http.StatusMovedPermanently)
}) })

88
client/admin_api.go
View File

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

42
client/control.go
View File

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

6
client/event/event.go
View File

@ -6,10 +6,10 @@ import (
"github.com/fatedier/frp/models/msg" "github.com/fatedier/frp/models/msg"
) )
type EventType int type Type int
const ( const (
EvStartProxy EventType = iota EvStartProxy Type = iota
EvCloseProxy EvCloseProxy
) )
@ -17,7 +17,7 @@ var (
ErrPayloadType = errors.New("error payload type") 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 { type StartProxyPayload struct {
NewProxyMsg *msg.NewProxy NewProxyMsg *msg.NewProxy

24
client/health/health.go
View File

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

192
client/proxy/proxy.go
View File

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

28
client/proxy/proxy_manager.go
View File

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

100
client/proxy/proxy_wrapper.go
View File

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

25
client/service.go
View File

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

64
client/visitor.go
View File

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

12
cmd/frpc/sub/http.go
View File

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

8
cmd/frpc/sub/https.go
View File

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

8
cmd/frpc/sub/root.go
View File

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

24
cmd/frpc/sub/status.go
View File

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

12
cmd/frpc/sub/stcp.go
View File

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

12
cmd/frpc/sub/sudp.go
View File

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

8
cmd/frpc/sub/tcp.go
View File

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

8
cmd/frpc/sub/tcpmux.go
View File

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

8
cmd/frpc/sub/udp.go
View File

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

12
cmd/frpc/sub/xtcp.go
View File

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

30
cmd/frps/root.go
View File

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

20
models/auth/auth.go
View File

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

20
models/auth/oidc.go
View File

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

45
models/config/client_common.go
View File

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

229
models/config/proxy.go
View File

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

128
models/config/server_common.go
View File

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

36
models/config/visitor.go
View File

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

20
models/consts/consts.go
View File

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

18
models/msg/msg.go
View File

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

38
models/nathole/nathole.go
View File

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

30
models/plugin/client/http_proxy.go
View File

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

4
models/plugin/client/static_file.go
View File

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

10
models/plugin/server/manager.go
View File

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

2
models/plugin/server/types.go
View File

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

14
models/proto/udp/udp.go
View File

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

2
models/proto/udp/udp_test.go
View File

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

69
server/control.go
View File

@ -43,42 +43,42 @@ import (
type ControlManager struct { type ControlManager struct {
// controls indexed by run id // controls indexed by run id
ctlsByRunId map[string]*Control ctlsByRunID map[string]*Control
mu sync.RWMutex mu sync.RWMutex
} }
func NewControlManager() *ControlManager { func NewControlManager() *ControlManager {
return &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() cm.mu.Lock()
defer cm.mu.Unlock() defer cm.mu.Unlock()
oldCtl, ok := cm.ctlsByRunId[runId] oldCtl, ok := cm.ctlsByRunID[runID]
if ok { if ok {
oldCtl.Replaced(ctl) oldCtl.Replaced(ctl)
} }
cm.ctlsByRunId[runId] = ctl cm.ctlsByRunID[runID] = ctl
return return
} }
// we should make sure if it's the same control to prevent delete a new one // 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() cm.mu.Lock()
defer cm.mu.Unlock() defer cm.mu.Unlock()
if c, ok := cm.ctlsByRunId[runId]; ok && c == ctl { if c, ok := cm.ctlsByRunID[runID]; ok && c == ctl {
delete(cm.ctlsByRunId, runId) 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() cm.mu.RLock()
defer cm.mu.RUnlock() defer cm.mu.RUnlock()
ctl, ok = cm.ctlsByRunId[runId] ctl, ok = cm.ctlsByRunID[runID]
return return
} }
@ -87,7 +87,7 @@ type Control struct {
rc *controller.ResourceController rc *controller.ResourceController
// proxy manager // proxy manager
pxyManager *proxy.ProxyManager pxyManager *proxy.Manager
// plugin manager // plugin manager
pluginManager *plugin.Manager pluginManager *plugin.Manager
@ -125,7 +125,7 @@ type Control struct {
// A new run id will be generated when a new client login. // 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 // 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. // replace old controller instantly.
runId string runID string
// control status // control status
status string status string
@ -147,7 +147,7 @@ type Control struct {
func NewControl( func NewControl(
ctx context.Context, ctx context.Context,
rc *controller.ResourceController, rc *controller.ResourceController,
pxyManager *proxy.ProxyManager, pxyManager *proxy.Manager,
pluginManager *plugin.Manager, pluginManager *plugin.Manager,
authVerifier auth.Verifier, authVerifier auth.Verifier,
ctlConn net.Conn, ctlConn net.Conn,
@ -173,7 +173,7 @@ func NewControl(
poolCount: poolCount, poolCount: poolCount,
portsUsedNum: 0, portsUsedNum: 0,
lastPing: time.Now(), lastPing: time.Now(),
runId: loginMsg.RunId, runID: loginMsg.RunID,
status: consts.Working, status: consts.Working,
readerShutdown: shutdown.New(), readerShutdown: shutdown.New(),
writerShutdown: shutdown.New(), writerShutdown: shutdown.New(),
@ -189,8 +189,8 @@ func NewControl(
func (ctl *Control) Start() { func (ctl *Control) Start() {
loginRespMsg := &msg.LoginResp{ loginRespMsg := &msg.LoginResp{
Version: version.Full(), Version: version.Full(),
RunId: ctl.runId, RunID: ctl.runID,
ServerUdpPort: ctl.serverCfg.BindUdpPort, ServerUDPPort: ctl.serverCfg.BindUDPPort,
Error: "", Error: "",
} }
msg.WriteMsg(ctl.conn, loginRespMsg) msg.WriteMsg(ctl.conn, loginRespMsg)
@ -280,8 +280,8 @@ func (ctl *Control) GetWorkConn() (workConn net.Conn, err error) {
func (ctl *Control) Replaced(newCtl *Control) { func (ctl *Control) Replaced(newCtl *Control) {
xl := ctl.xl xl := ctl.xl
xl.Info("Replaced by client [%s]", newCtl.runId) xl.Info("Replaced by client [%s]", newCtl.runID)
ctl.runId = "" ctl.runID = ""
ctl.allShutdown.Start() ctl.allShutdown.Start()
} }
@ -304,14 +304,15 @@ func (ctl *Control) writer() {
return return
} }
for { for {
if m, ok := <-ctl.sendCh; !ok { m, ok := <-ctl.sendCh
if !ok {
xl.Info("control writer is closing") xl.Info("control writer is closing")
return return
} else { }
if err := msg.WriteMsg(encWriter, m); err != nil {
xl.Warn("write message to control connection error: %v", err) if err := msg.WriteMsg(encWriter, m); err != nil {
return 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)) encReader := crypto.NewReader(ctl.conn, []byte(ctl.serverCfg.Token))
for { for {
if m, err := msg.ReadMsg(encReader); err != nil { m, err := msg.ReadMsg(encReader)
if err != nil {
if err == io.EOF { if err == io.EOF {
xl.Debug("control connection closed") xl.Debug("control connection closed")
return return
} else {
xl.Warn("read error: %v", err)
ctl.conn.Close()
return
} }
} else { xl.Warn("read error: %v", err)
ctl.readCh <- m ctl.conn.Close()
return
} }
ctl.readCh <- m
} }
} }
@ -422,7 +423,7 @@ func (ctl *Control) manager() {
User: plugin.UserInfo{ User: plugin.UserInfo{
User: ctl.loginMsg.User, User: ctl.loginMsg.User,
Metas: ctl.loginMsg.Metas, Metas: ctl.loginMsg.Metas,
RunId: ctl.loginMsg.RunId, RunID: ctl.loginMsg.RunID,
}, },
NewProxy: *m, NewProxy: *m,
} }
@ -454,7 +455,7 @@ func (ctl *Control) manager() {
User: plugin.UserInfo{ User: plugin.UserInfo{
User: ctl.loginMsg.User, User: ctl.loginMsg.User,
Metas: ctl.loginMsg.Metas, Metas: ctl.loginMsg.Metas,
RunId: ctl.loginMsg.RunId, RunID: ctl.loginMsg.RunID,
}, },
Ping: *m, Ping: *m,
} }
@ -490,7 +491,7 @@ func (ctl *Control) RegisterProxy(pxyMsg *msg.NewProxy) (remoteAddr string, err
userInfo := plugin.UserInfo{ userInfo := plugin.UserInfo{
User: ctl.loginMsg.User, User: ctl.loginMsg.User,
Metas: ctl.loginMsg.Metas, Metas: ctl.loginMsg.Metas,
RunId: ctl.runId, RunID: ctl.runID,
} }
// NewProxy will return a interface Proxy. // NewProxy will return a interface Proxy.

30
server/controller/resource.go
View File

@ -27,34 +27,34 @@ import (
// All resource managers and controllers // All resource managers and controllers
type ResourceController struct { type ResourceController struct {
// Manage all visitor listeners // Manage all visitor listeners
VisitorManager *visitor.VisitorManager VisitorManager *visitor.Manager
// Tcp Group Controller // TCP Group Controller
TcpGroupCtl *group.TcpGroupCtl TCPGroupCtl *group.TCPGroupCtl
// HTTP Group Controller // HTTP Group Controller
HTTPGroupCtl *group.HTTPGroupController HTTPGroupCtl *group.HTTPGroupController
// TCP Mux Group Controller // TCP Mux Group Controller
TcpMuxGroupCtl *group.TcpMuxGroupCtl TCPMuxGroupCtl *group.TCPMuxGroupCtl
// Manage all tcp ports // Manage all TCP ports
TcpPortManager *ports.PortManager TCPPortManager *ports.Manager
// Manage all udp ports // Manage all UDP ports
UdpPortManager *ports.PortManager UDPPortManager *ports.Manager
// For http proxies, forwarding http requests // For HTTP proxies, forwarding HTTP requests
HttpReverseProxy *vhost.HttpReverseProxy HTTPReverseProxy *vhost.HTTPReverseProxy
// For https proxies, route requests to different clients by hostname and other information // For HTTPS proxies, route requests to different clients by hostname and other information
VhostHttpsMuxer *vhost.HttpsMuxer VhostHTTPSMuxer *vhost.HTTPSMuxer
// Controller for nat hole connections // Controller for nat hole connections
NatHoleController *nathole.NatHoleController NatHoleController *nathole.Controller
// TcpMux HTTP CONNECT multiplexer // TCPMux HTTP CONNECT multiplexer
TcpMuxHttpConnectMuxer *tcpmux.HttpConnectTcpMuxer TCPMuxHTTPConnectMuxer *tcpmux.HTTPConnectTCPMuxer
// All server manager plugin // All server manager plugin
PluginManager *plugin.Manager PluginManager *plugin.Manager

12
server/dashboard.go
View File

@ -37,7 +37,7 @@ func (svr *Service) RunDashboardServer(addr string, port int) (err error) {
router := mux.NewRouter() router := mux.NewRouter()
user, passwd := svr.cfg.DashboardUser, svr.cfg.DashboardPwd user, passwd := svr.cfg.DashboardUser, svr.cfg.DashboardPwd
router.Use(frpNet.NewHttpAuthMiddleware(user, passwd).Middleware) router.Use(frpNet.NewHTTPAuthMiddleware(user, passwd).Middleware)
// metrics // metrics
if svr.cfg.EnablePrometheus { if svr.cfg.EnablePrometheus {
@ -45,14 +45,14 @@ func (svr *Service) RunDashboardServer(addr string, port int) (err error) {
} }
// api, see dashboard_api.go // api, see dashboard_api.go
router.HandleFunc("/api/serverinfo", svr.ApiServerInfo).Methods("GET") router.HandleFunc("/api/serverinfo", svr.APIServerInfo).Methods("GET")
router.HandleFunc("/api/proxy/{type}", svr.ApiProxyByType).Methods("GET") router.HandleFunc("/api/proxy/{type}", svr.APIProxyByType).Methods("GET")
router.HandleFunc("/api/proxy/{type}/{name}", svr.ApiProxyByTypeAndName).Methods("GET") router.HandleFunc("/api/proxy/{type}/{name}", svr.APIProxyByTypeAndName).Methods("GET")
router.HandleFunc("/api/traffic/{name}", svr.ApiProxyTraffic).Methods("GET") router.HandleFunc("/api/traffic/{name}", svr.APIProxyTraffic).Methods("GET")
// view // view
router.Handle("/favicon.ico", http.FileServer(assets.FileSystem)).Methods("GET") 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) { router.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "/static/", http.StatusMovedPermanently) http.Redirect(w, r, "/static/", http.StatusMovedPermanently)

75
server/dashboard_api.go
View File

@ -32,13 +32,13 @@ type GeneralResponse struct {
Msg string Msg string
} }
type ServerInfoResp struct { type serverInfoResp struct {
Version string `json:"version"` Version string `json:"version"`
BindPort int `json:"bind_port"` BindPort int `json:"bind_port"`
BindUdpPort int `json:"bind_udp_port"` BindUDPPort int `json:"bind_udp_port"`
VhostHttpPort int `json:"vhost_http_port"` VhostHTTPPort int `json:"vhost_http_port"`
VhostHttpsPort int `json:"vhost_https_port"` VhostHTTPSPort int `json:"vhost_https_port"`
KcpBindPort int `json:"kcp_bind_port"` KCPBindPort int `json:"kcp_bind_port"`
SubdomainHost string `json:"subdomain_host"` SubdomainHost string `json:"subdomain_host"`
MaxPoolCount int64 `json:"max_pool_count"` MaxPoolCount int64 `json:"max_pool_count"`
MaxPortsPerClient int64 `json:"max_ports_per_client"` MaxPortsPerClient int64 `json:"max_ports_per_client"`
@ -52,7 +52,7 @@ type ServerInfoResp struct {
} }
// api/serverinfo // 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} res := GeneralResponse{Code: 200}
defer func() { defer func() {
log.Info("Http response [%s]: code [%d]", r.URL.Path, res.Code) 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) log.Info("Http request: [%s]", r.URL.Path)
serverStats := mem.StatsCollector.GetServer() serverStats := mem.StatsCollector.GetServer()
svrResp := ServerInfoResp{ svrResp := serverInfoResp{
Version: version.Full(), Version: version.Full(),
BindPort: svr.cfg.BindPort, BindPort: svr.cfg.BindPort,
BindUdpPort: svr.cfg.BindUdpPort, BindUDPPort: svr.cfg.BindUDPPort,
VhostHttpPort: svr.cfg.VhostHttpPort, VhostHTTPPort: svr.cfg.VhostHTTPPort,
VhostHttpsPort: svr.cfg.VhostHttpsPort, VhostHTTPSPort: svr.cfg.VhostHTTPSPort,
KcpBindPort: svr.cfg.KcpBindPort, KCPBindPort: svr.cfg.KCPBindPort,
SubdomainHost: svr.cfg.SubDomainHost, SubdomainHost: svr.cfg.SubDomainHost,
MaxPoolCount: svr.cfg.MaxPoolCount, MaxPoolCount: svr.cfg.MaxPoolCount,
MaxPortsPerClient: svr.cfg.MaxPortsPerClient, MaxPortsPerClient: svr.cfg.MaxPortsPerClient,
@ -91,58 +91,58 @@ type BaseOutConf struct {
config.BaseProxyConf config.BaseProxyConf
} }
type TcpOutConf struct { type TCPOutConf struct {
BaseOutConf BaseOutConf
RemotePort int `json:"remote_port"` RemotePort int `json:"remote_port"`
} }
type TcpMuxOutConf struct { type TCPMuxOutConf struct {
BaseOutConf BaseOutConf
config.DomainConf config.DomainConf
Multiplexer string `json:"multiplexer"` Multiplexer string `json:"multiplexer"`
} }
type UdpOutConf struct { type UDPOutConf struct {
BaseOutConf BaseOutConf
RemotePort int `json:"remote_port"` RemotePort int `json:"remote_port"`
} }
type HttpOutConf struct { type HTTPOutConf struct {
BaseOutConf BaseOutConf
config.DomainConf config.DomainConf
Locations []string `json:"locations"` Locations []string `json:"locations"`
HostHeaderRewrite string `json:"host_header_rewrite"` HostHeaderRewrite string `json:"host_header_rewrite"`
} }
type HttpsOutConf struct { type HTTPSOutConf struct {
BaseOutConf BaseOutConf
config.DomainConf config.DomainConf
} }
type StcpOutConf struct { type STCPOutConf struct {
BaseOutConf BaseOutConf
} }
type XtcpOutConf struct { type XTCPOutConf struct {
BaseOutConf BaseOutConf
} }
func getConfByType(proxyType string) interface{} { func getConfByType(proxyType string) interface{} {
switch proxyType { switch proxyType {
case consts.TcpProxy: case consts.TCPProxy:
return &TcpOutConf{} return &TCPOutConf{}
case consts.TcpMuxProxy: case consts.TCPMuxProxy:
return &TcpMuxOutConf{} return &TCPMuxOutConf{}
case consts.UdpProxy: case consts.UDPProxy:
return &UdpOutConf{} return &UDPOutConf{}
case consts.HttpProxy: case consts.HTTPProxy:
return &HttpOutConf{} return &HTTPOutConf{}
case consts.HttpsProxy: case consts.HTTPSProxy:
return &HttpsOutConf{} return &HTTPSOutConf{}
case consts.StcpProxy: case consts.STCPProxy:
return &StcpOutConf{} return &STCPOutConf{}
case consts.XtcpProxy: case consts.XTCPProxy:
return &XtcpOutConf{} return &XTCPOutConf{}
default: default:
return nil return nil
} }
@ -165,7 +165,7 @@ type GetProxyInfoResp struct {
} }
// api/proxy/:type // 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} res := GeneralResponse{Code: 200}
params := mux.Vars(r) params := mux.Vars(r)
proxyType := params["type"] proxyType := params["type"]
@ -230,7 +230,7 @@ type GetProxyStatsResp struct {
} }
// api/proxy/:type/:name // 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} res := GeneralResponse{Code: 200}
params := mux.Vars(r) params := mux.Vars(r)
proxyType := params["type"] proxyType := params["type"]
@ -299,7 +299,7 @@ type GetProxyTrafficResp struct {
TrafficOut []int64 `json:"traffic_out"` 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} res := GeneralResponse{Code: 200}
params := mux.Vars(r) params := mux.Vars(r)
name := params["name"] name := params["name"]
@ -321,10 +321,9 @@ func (svr *Service) ApiProxyTraffic(w http.ResponseWriter, r *http.Request) {
res.Code = 404 res.Code = 404
res.Msg = "no proxy info found" res.Msg = "no proxy info found"
return return
} else {
trafficResp.TrafficIn = proxyTrafficInfo.TrafficIn
trafficResp.TrafficOut = proxyTrafficInfo.TrafficOut
} }
trafficResp.TrafficIn = proxyTrafficInfo.TrafficIn
trafficResp.TrafficOut = proxyTrafficInfo.TrafficOut
buf, _ := json.Marshal(&trafficResp) buf, _ := json.Marshal(&trafficResp)
res.Msg = string(buf) res.Msg = string(buf)

8
server/group/http.go
View File

@ -12,12 +12,12 @@ import (
type HTTPGroupController struct { type HTTPGroupController struct {
groups map[string]*HTTPGroup groups map[string]*HTTPGroup
vhostRouter *vhost.VhostRouters vhostRouter *vhost.Routers
mu sync.Mutex mu sync.Mutex
} }
func NewHTTPGroupController(vhostRouter *vhost.VhostRouters) *HTTPGroupController { func NewHTTPGroupController(vhostRouter *vhost.Routers) *HTTPGroupController {
return &HTTPGroupController{ return &HTTPGroupController{
groups: make(map[string]*HTTPGroup), groups: make(map[string]*HTTPGroup),
vhostRouter: vhostRouter, vhostRouter: vhostRouter,
@ -25,7 +25,7 @@ func NewHTTPGroupController(vhostRouter *vhost.VhostRouters) *HTTPGroupControlle
} }
func (ctl *HTTPGroupController) Register(proxyName, group, groupKey string, 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) indexKey := httpGroupIndex(group, routeConfig.Domain, routeConfig.Location)
ctl.mu.Lock() ctl.mu.Lock()
@ -76,7 +76,7 @@ func NewHTTPGroup(ctl *HTTPGroupController) *HTTPGroup {
} }
func (g *HTTPGroup) Register(proxyName, group, groupKey string, func (g *HTTPGroup) Register(proxyName, group, groupKey string,
routeConfig vhost.VhostRouteConfig) (err error) { routeConfig vhost.RouteConfig) (err error) {
g.mu.Lock() g.mu.Lock()
defer g.mu.Unlock() defer g.mu.Unlock()

78
server/group/tcp.go
View File

@ -24,32 +24,32 @@ import (
gerr "github.com/fatedier/golib/errors" gerr "github.com/fatedier/golib/errors"
) )
// TcpGroupCtl manage all TcpGroups // TCPGroupCtl manage all TCPGroups
type TcpGroupCtl struct { type TCPGroupCtl struct {
groups map[string]*TcpGroup groups map[string]*TCPGroup
// portManager is used to manage port // portManager is used to manage port
portManager *ports.PortManager portManager *ports.Manager
mu sync.Mutex mu sync.Mutex
} }
// NewTcpGroupCtl return a new TcpGroupCtl // NewTCPGroupCtl return a new TcpGroupCtl
func NewTcpGroupCtl(portManager *ports.PortManager) *TcpGroupCtl { func NewTCPGroupCtl(portManager *ports.Manager) *TCPGroupCtl {
return &TcpGroupCtl{ return &TCPGroupCtl{
groups: make(map[string]*TcpGroup), groups: make(map[string]*TCPGroup),
portManager: portManager, 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 // 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) { addr string, port int) (l net.Listener, realPort int, err error) {
tgc.mu.Lock() tgc.mu.Lock()
tcpGroup, ok := tgc.groups[group] tcpGroup, ok := tgc.groups[group]
if !ok { if !ok {
tcpGroup = NewTcpGroup(tgc) tcpGroup = NewTCPGroup(tgc)
tgc.groups[group] = tcpGroup tgc.groups[group] = tcpGroup
} }
tgc.mu.Unlock() 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) return tcpGroup.Listen(proxyName, group, groupKey, addr, port)
} }
// RemoveGroup remove TcpGroup from controller // RemoveGroup remove TCPGroup from controller
func (tgc *TcpGroupCtl) RemoveGroup(group string) { func (tgc *TCPGroupCtl) RemoveGroup(group string) {
tgc.mu.Lock() tgc.mu.Lock()
defer tgc.mu.Unlock() defer tgc.mu.Unlock()
delete(tgc.groups, group) delete(tgc.groups, group)
} }
// TcpGroup route connections to different proxies // TCPGroup route connections to different proxies
type TcpGroup struct { type TCPGroup struct {
group string group string
groupKey string groupKey string
addr string addr string
@ -75,24 +75,24 @@ type TcpGroup struct {
acceptCh chan net.Conn acceptCh chan net.Conn
index uint64 index uint64
tcpLn net.Listener tcpLn net.Listener
lns []*TcpGroupListener lns []*TCPGroupListener
ctl *TcpGroupCtl ctl *TCPGroupCtl
mu sync.Mutex mu sync.Mutex
} }
// NewTcpGroup return a new TcpGroup // NewTCPGroup return a new TCPGroup
func NewTcpGroup(ctl *TcpGroupCtl) *TcpGroup { func NewTCPGroup(ctl *TCPGroupCtl) *TCPGroup {
return &TcpGroup{ return &TCPGroup{
lns: make([]*TcpGroupListener, 0), lns: make([]*TCPGroupListener, 0),
ctl: ctl, ctl: ctl,
acceptCh: make(chan net.Conn), acceptCh: make(chan net.Conn),
} }
} }
// Listen will return a new TcpGroupListener // Listen will return a new TCPGroupListener
// if TcpGroup already has a listener, just add a new TcpGroupListener to the queues // if TCPGroup already has a listener, just add a new TCPGroupListener to the queues
// otherwise, listen on the real address // 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() tg.mu.Lock()
defer tg.mu.Unlock() defer tg.mu.Unlock()
if len(tg.lns) == 0 { if len(tg.lns) == 0 {
@ -106,7 +106,7 @@ func (tg *TcpGroup) Listen(proxyName string, group string, groupKey string, addr
err = errRet err = errRet
return return
} }
ln = newTcpGroupListener(group, tg, tcpLn.Addr()) ln = newTCPGroupListener(group, tg, tcpLn.Addr())
tg.group = group tg.group = group
tg.groupKey = groupKey tg.groupKey = groupKey
@ -133,7 +133,7 @@ func (tg *TcpGroup) Listen(proxyName string, group string, groupKey string, addr
err = ErrGroupAuthFailed err = ErrGroupAuthFailed
return return
} }
ln = newTcpGroupListener(group, tg, tg.lns[0].Addr()) ln = newTCPGroupListener(group, tg, tg.lns[0].Addr())
realPort = tg.realPort realPort = tg.realPort
tg.lns = append(tg.lns, ln) 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 // worker is called when the real tcp listener has been created
func (tg *TcpGroup) worker() { func (tg *TCPGroup) worker() {
for { for {
c, err := tg.tcpLn.Accept() c, err := tg.tcpLn.Accept()
if err != nil { 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 return tg.acceptCh
} }
// CloseListener remove the TcpGroupListener from the TcpGroup // CloseListener remove the TCPGroupListener from the TCPGroup
func (tg *TcpGroup) CloseListener(ln *TcpGroupListener) { func (tg *TCPGroup) CloseListener(ln *TCPGroupListener) {
tg.mu.Lock() tg.mu.Lock()
defer tg.mu.Unlock() defer tg.mu.Unlock()
for i, tmpLn := range tg.lns { for i, tmpLn := range tg.lns {
@ -178,17 +178,17 @@ func (tg *TcpGroup) CloseListener(ln *TcpGroupListener) {
} }
} }
// TcpGroupListener // TCPGroupListener
type TcpGroupListener struct { type TCPGroupListener struct {
groupName string groupName string
group *TcpGroup group *TCPGroup
addr net.Addr addr net.Addr
closeCh chan struct{} closeCh chan struct{}
} }
func newTcpGroupListener(name string, group *TcpGroup, addr net.Addr) *TcpGroupListener { func newTCPGroupListener(name string, group *TCPGroup, addr net.Addr) *TCPGroupListener {
return &TcpGroupListener{ return &TCPGroupListener{
groupName: name, groupName: name,
group: group, group: group,
addr: addr, addr: addr,
@ -196,8 +196,8 @@ func newTcpGroupListener(name string, group *TcpGroup, addr net.Addr) *TcpGroupL
} }
} }
// Accept will accept connections from TcpGroup // Accept will accept connections from TCPGroup
func (ln *TcpGroupListener) Accept() (c net.Conn, err error) { func (ln *TCPGroupListener) Accept() (c net.Conn, err error) {
var ok bool var ok bool
select { select {
case <-ln.closeCh: 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 return ln.addr
} }
// Close close the listener // Close close the listener
func (ln *TcpGroupListener) Close() (err error) { func (ln *TCPGroupListener) Close() (err error) {
close(ln.closeCh) close(ln.closeCh)
// remove self from TcpGroup // remove self from TcpGroup

93
server/group/tcpmux.go
View File

@ -27,53 +27,54 @@ import (
gerr "github.com/fatedier/golib/errors" gerr "github.com/fatedier/golib/errors"
) )
// TcpMuxGroupCtl manage all TcpMuxGroups // TCPMuxGroupCtl manage all TCPMuxGroups
type TcpMuxGroupCtl struct { type TCPMuxGroupCtl struct {
groups map[string]*TcpMuxGroup groups map[string]*TCPMuxGroup
// portManager is used to manage port // portManager is used to manage port
tcpMuxHttpConnectMuxer *tcpmux.HttpConnectTcpMuxer tcpMuxHTTPConnectMuxer *tcpmux.HTTPConnectTCPMuxer
mu sync.Mutex mu sync.Mutex
} }
// NewTcpMuxGroupCtl return a new TcpMuxGroupCtl // NewTCPMuxGroupCtl return a new TCPMuxGroupCtl
func NewTcpMuxGroupCtl(tcpMuxHttpConnectMuxer *tcpmux.HttpConnectTcpMuxer) *TcpMuxGroupCtl { func NewTCPMuxGroupCtl(tcpMuxHTTPConnectMuxer *tcpmux.HTTPConnectTCPMuxer) *TCPMuxGroupCtl {
return &TcpMuxGroupCtl{ return &TCPMuxGroupCtl{
groups: make(map[string]*TcpMuxGroup), groups: make(map[string]*TCPMuxGroup),
tcpMuxHttpConnectMuxer: tcpMuxHttpConnectMuxer, 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 // If there are no group, we will create one here
func (tmgc *TcpMuxGroupCtl) Listen(multiplexer string, group string, groupKey string, func (tmgc *TCPMuxGroupCtl) Listen(ctx context.Context, multiplexer string, group string, groupKey string,
domain string, ctx context.Context) (l net.Listener, err error) { domain string) (l net.Listener, err error) {
tmgc.mu.Lock() tmgc.mu.Lock()
tcpMuxGroup, ok := tmgc.groups[group] tcpMuxGroup, ok := tmgc.groups[group]
if !ok { if !ok {
tcpMuxGroup = NewTcpMuxGroup(tmgc) tcpMuxGroup = NewTCPMuxGroup(tmgc)
tmgc.groups[group] = tcpMuxGroup tmgc.groups[group] = tcpMuxGroup
} }
tmgc.mu.Unlock() tmgc.mu.Unlock()
switch multiplexer { switch multiplexer {
case consts.HttpConnectTcpMultiplexer: case consts.HTTPConnectTCPMultiplexer:
return tcpMuxGroup.HttpConnectListen(group, groupKey, domain, ctx) return tcpMuxGroup.HTTPConnectListen(ctx, group, groupKey, domain)
default: default:
err = fmt.Errorf("unknown multiplexer [%s]", multiplexer) err = fmt.Errorf("unknown multiplexer [%s]", multiplexer)
return return
} }
} }
// RemoveGroup remove TcpMuxGroup from controller // RemoveGroup remove TCPMuxGroup from controller
func (tmgc *TcpMuxGroupCtl) RemoveGroup(group string) { func (tmgc *TCPMuxGroupCtl) RemoveGroup(group string) {
tmgc.mu.Lock() tmgc.mu.Lock()
defer tmgc.mu.Unlock() defer tmgc.mu.Unlock()
delete(tmgc.groups, group) delete(tmgc.groups, group)
} }
// TcpMuxGroup route connections to different proxies // TCPMuxGroup route connections to different proxies
type TcpMuxGroup struct { type TCPMuxGroup struct {
group string group string
groupKey string groupKey string
domain string domain string
@ -81,36 +82,36 @@ type TcpMuxGroup struct {
acceptCh chan net.Conn acceptCh chan net.Conn
index uint64 index uint64
tcpMuxLn net.Listener tcpMuxLn net.Listener
lns []*TcpMuxGroupListener lns []*TCPMuxGroupListener
ctl *TcpMuxGroupCtl ctl *TCPMuxGroupCtl
mu sync.Mutex mu sync.Mutex
} }
// NewTcpMuxGroup return a new TcpMuxGroup // NewTCPMuxGroup return a new TCPMuxGroup
func NewTcpMuxGroup(ctl *TcpMuxGroupCtl) *TcpMuxGroup { func NewTCPMuxGroup(ctl *TCPMuxGroupCtl) *TCPMuxGroup {
return &TcpMuxGroup{ return &TCPMuxGroup{
lns: make([]*TcpMuxGroupListener, 0), lns: make([]*TCPMuxGroupListener, 0),
ctl: ctl, ctl: ctl,
acceptCh: make(chan net.Conn), acceptCh: make(chan net.Conn),
} }
} }
// Listen will return a new TcpMuxGroupListener // Listen will return a new TCPMuxGroupListener
// if TcpMuxGroup already has a listener, just add a new TcpMuxGroupListener to the queues // if TCPMuxGroup already has a listener, just add a new TCPMuxGroupListener to the queues
// otherwise, listen on the real address // 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() tmg.mu.Lock()
defer tmg.mu.Unlock() defer tmg.mu.Unlock()
if len(tmg.lns) == 0 { if len(tmg.lns) == 0 {
// the first listener, listen on the real address // the first listener, listen on the real address
routeConfig := &vhost.VhostRouteConfig{ routeConfig := &vhost.RouteConfig{
Domain: domain, Domain: domain,
} }
tcpMuxLn, errRet := tmg.ctl.tcpMuxHttpConnectMuxer.Listen(context, routeConfig) tcpMuxLn, errRet := tmg.ctl.tcpMuxHTTPConnectMuxer.Listen(ctx, routeConfig)
if errRet != nil { if errRet != nil {
return nil, errRet return nil, errRet
} }
ln = newTcpMuxGroupListener(group, tmg, tcpMuxLn.Addr()) ln = newTCPMuxGroupListener(group, tmg, tcpMuxLn.Addr())
tmg.group = group tmg.group = group
tmg.groupKey = groupKey tmg.groupKey = groupKey
@ -129,14 +130,14 @@ func (tmg *TcpMuxGroup) HttpConnectListen(group string, groupKey string, domain
if tmg.groupKey != groupKey { if tmg.groupKey != groupKey {
return nil, ErrGroupAuthFailed 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) tmg.lns = append(tmg.lns, ln)
} }
return return
} }
// worker is called when the real tcp listener has been created // worker is called when the real TCP listener has been created
func (tmg *TcpMuxGroup) worker() { func (tmg *TCPMuxGroup) worker() {
for { for {
c, err := tmg.tcpMuxLn.Accept() c, err := tmg.tcpMuxLn.Accept()
if err != nil { 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 return tmg.acceptCh
} }
// CloseListener remove the TcpMuxGroupListener from the TcpMuxGroup // CloseListener remove the TCPMuxGroupListener from the TCPMuxGroup
func (tmg *TcpMuxGroup) CloseListener(ln *TcpMuxGroupListener) { func (tmg *TCPMuxGroup) CloseListener(ln *TCPMuxGroupListener) {
tmg.mu.Lock() tmg.mu.Lock()
defer tmg.mu.Unlock() defer tmg.mu.Unlock()
for i, tmpLn := range tmg.lns { for i, tmpLn := range tmg.lns {
@ -172,17 +173,17 @@ func (tmg *TcpMuxGroup) CloseListener(ln *TcpMuxGroupListener) {
} }
} }
// TcpMuxGroupListener // TCPMuxGroupListener
type TcpMuxGroupListener struct { type TCPMuxGroupListener struct {
groupName string groupName string
group *TcpMuxGroup group *TCPMuxGroup
addr net.Addr addr net.Addr
closeCh chan struct{} closeCh chan struct{}
} }
func newTcpMuxGroupListener(name string, group *TcpMuxGroup, addr net.Addr) *TcpMuxGroupListener { func newTCPMuxGroupListener(name string, group *TCPMuxGroup, addr net.Addr) *TCPMuxGroupListener {
return &TcpMuxGroupListener{ return &TCPMuxGroupListener{
groupName: name, groupName: name,
group: group, group: group,
addr: addr, addr: addr,
@ -190,8 +191,8 @@ func newTcpMuxGroupListener(name string, group *TcpMuxGroup, addr net.Addr) *Tcp
} }
} }
// Accept will accept connections from TcpMuxGroup // Accept will accept connections from TCPMuxGroup
func (ln *TcpMuxGroupListener) Accept() (c net.Conn, err error) { func (ln *TCPMuxGroupListener) Accept() (c net.Conn, err error) {
var ok bool var ok bool
select { select {
case <-ln.closeCh: 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 return ln.addr
} }
// Close close the listener // Close close the listener
func (ln *TcpMuxGroupListener) Close() (err error) { func (ln *TCPMuxGroupListener) Close() (err error) {
close(ln.closeCh) close(ln.closeCh)
// remove self from TcpMuxGroup // remove self from TcpMuxGroup

32
server/ports/ports.go
View File

@ -29,7 +29,7 @@ type PortCtx struct {
UpdateTime time.Time UpdateTime time.Time
} }
type PortManager struct { type Manager struct {
reservedPorts map[string]*PortCtx reservedPorts map[string]*PortCtx
usedPorts map[int]*PortCtx usedPorts map[int]*PortCtx
freePorts map[int]struct{} freePorts map[int]struct{}
@ -39,8 +39,8 @@ type PortManager struct {
mu sync.Mutex mu sync.Mutex
} }
func NewPortManager(netType string, bindAddr string, allowPorts map[int]struct{}) *PortManager { func NewManager(netType string, bindAddr string, allowPorts map[int]struct{}) *Manager {
pm := &PortManager{ pm := &Manager{
reservedPorts: make(map[string]*PortCtx), reservedPorts: make(map[string]*PortCtx),
usedPorts: make(map[int]*PortCtx), usedPorts: make(map[int]*PortCtx),
freePorts: make(map[int]struct{}), freePorts: make(map[int]struct{}),
@ -48,7 +48,7 @@ func NewPortManager(netType string, bindAddr string, allowPorts map[int]struct{}
netType: netType, netType: netType,
} }
if len(allowPorts) > 0 { if len(allowPorts) > 0 {
for port, _ := range allowPorts { for port := range allowPorts {
pm.freePorts[port] = struct{}{} pm.freePorts[port] = struct{}{}
} }
} else { } else {
@ -60,7 +60,7 @@ func NewPortManager(netType string, bindAddr string, allowPorts map[int]struct{}
return pm 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{ portCtx := &PortCtx{
ProxyName: name, ProxyName: name,
Closed: false, Closed: false,
@ -94,7 +94,7 @@ func (pm *PortManager) Acquire(name string, port int) (realPort int, err error)
// get random port // get random port
count := 0 count := 0
maxTryTimes := 5 maxTryTimes := 5
for k, _ := range pm.freePorts { for k := range pm.freePorts {
count++ count++
if count > maxTryTimes { if count > maxTryTimes {
break break
@ -132,7 +132,7 @@ func (pm *PortManager) Acquire(name string, port int) (realPort int, err error)
return return
} }
func (pm *PortManager) isPortAvailable(port int) bool { func (pm *Manager) isPortAvailable(port int) bool {
if pm.netType == "udp" { if pm.netType == "udp" {
addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", pm.bindAddr, port)) addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", pm.bindAddr, port))
if err != nil { if err != nil {
@ -144,17 +144,17 @@ func (pm *PortManager) isPortAvailable(port int) bool {
} }
l.Close() l.Close()
return true 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() pm.mu.Lock()
defer pm.mu.Unlock() defer pm.mu.Unlock()
if ctx, ok := pm.usedPorts[port]; ok { 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. // Release reserved port if it isn't used in last 24 hours.
func (pm *PortManager) cleanReservedPortsWorker() { func (pm *Manager) cleanReservedPortsWorker() {
for { for {
time.Sleep(CleanReservedPortsInterval) time.Sleep(CleanReservedPortsInterval)
pm.mu.Lock() pm.mu.Lock()

32
server/proxy/http.go
View File

@ -28,20 +28,20 @@ import (
frpIo "github.com/fatedier/golib/io" frpIo "github.com/fatedier/golib/io"
) )
type HttpProxy struct { type HTTPProxy struct {
*BaseProxy *BaseProxy
cfg *config.HttpProxyConf cfg *config.HTTPProxyConf
closeFuncs []func() closeFuncs []func()
} }
func (pxy *HttpProxy) Run() (remoteAddr string, err error) { func (pxy *HTTPProxy) Run() (remoteAddr string, err error) {
xl := pxy.xl xl := pxy.xl
routeConfig := vhost.VhostRouteConfig{ routeConfig := vhost.RouteConfig{
RewriteHost: pxy.cfg.HostHeaderRewrite, RewriteHost: pxy.cfg.HostHeaderRewrite,
Headers: pxy.cfg.Headers, Headers: pxy.cfg.Headers,
Username: pxy.cfg.HttpUser, Username: pxy.cfg.HTTPUser,
Password: pxy.cfg.HttpPwd, Password: pxy.cfg.HTTPPwd,
CreateConnFn: pxy.GetRealConn, CreateConnFn: pxy.GetRealConn,
} }
@ -80,15 +80,15 @@ func (pxy *HttpProxy) Run() (remoteAddr string, err error) {
}) })
} else { } else {
// no group // no group
err = pxy.rc.HttpReverseProxy.Register(routeConfig) err = pxy.rc.HTTPReverseProxy.Register(routeConfig)
if err != nil { if err != nil {
return return
} }
pxy.closeFuncs = append(pxy.closeFuncs, func() { 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) 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) pxy.rc.HTTPGroupCtl.UnRegister(pxy.name, pxy.cfg.Group, tmpDomain, tmpLocation)
}) })
} else { } else {
err = pxy.rc.HttpReverseProxy.Register(routeConfig) err = pxy.rc.HTTPReverseProxy.Register(routeConfig)
if err != nil { if err != nil {
return return
} }
pxy.closeFuncs = append(pxy.closeFuncs, func() { 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) 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 return
} }
func (pxy *HttpProxy) GetConf() config.ProxyConf { func (pxy *HTTPProxy) GetConf() config.ProxyConf {
return pxy.cfg 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 xl := pxy.xl
rAddr, errRet := net.ResolveTCPAddr("tcp", remoteAddr) rAddr, errRet := net.ResolveTCPAddr("tcp", remoteAddr)
if errRet != nil { if errRet != nil {
@ -163,7 +163,7 @@ func (pxy *HttpProxy) GetRealConn(remoteAddr string) (workConn net.Conn, err err
return return
} }
func (pxy *HttpProxy) updateStatsAfterClosedConn(totalRead, totalWrite int64) { func (pxy *HTTPProxy) updateStatsAfterClosedConn(totalRead, totalWrite int64) {
name := pxy.GetName() name := pxy.GetName()
proxyType := pxy.GetConf().GetBaseInfo().ProxyType proxyType := pxy.GetConf().GetBaseInfo().ProxyType
metrics.Server.CloseConnection(name, proxyType) metrics.Server.CloseConnection(name, proxyType)
@ -171,7 +171,7 @@ func (pxy *HttpProxy) updateStatsAfterClosedConn(totalRead, totalWrite int64) {
metrics.Server.AddTrafficOut(name, proxyType, totalRead) metrics.Server.AddTrafficOut(name, proxyType, totalRead)
} }
func (pxy *HttpProxy) Close() { func (pxy *HTTPProxy) Close() {
pxy.BaseProxy.Close() pxy.BaseProxy.Close()
for _, closeFn := range pxy.closeFuncs { for _, closeFn := range pxy.closeFuncs {
closeFn() closeFn()

22
server/proxy/https.go
View File

@ -22,14 +22,14 @@ import (
"github.com/fatedier/frp/utils/vhost" "github.com/fatedier/frp/utils/vhost"
) )
type HttpsProxy struct { type HTTPSProxy struct {
*BaseProxy *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 xl := pxy.xl
routeConfig := &vhost.VhostRouteConfig{} routeConfig := &vhost.RouteConfig{}
defer func() { defer func() {
if err != nil { if err != nil {
@ -43,37 +43,37 @@ func (pxy *HttpsProxy) Run() (remoteAddr string, err error) {
} }
routeConfig.Domain = domain routeConfig.Domain = domain
l, errRet := pxy.rc.VhostHttpsMuxer.Listen(pxy.ctx, routeConfig) l, errRet := pxy.rc.VhostHTTPSMuxer.Listen(pxy.ctx, routeConfig)
if errRet != nil { if errRet != nil {
err = errRet err = errRet
return return
} }
xl.Info("https proxy listen for host [%s]", routeConfig.Domain) xl.Info("https proxy listen for host [%s]", routeConfig.Domain)
pxy.listeners = append(pxy.listeners, l) 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 != "" { if pxy.cfg.SubDomain != "" {
routeConfig.Domain = pxy.cfg.SubDomain + "." + pxy.serverCfg.SubDomainHost 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 { if errRet != nil {
err = errRet err = errRet
return return
} }
xl.Info("https proxy listen for host [%s]", routeConfig.Domain) xl.Info("https proxy listen for host [%s]", routeConfig.Domain)
pxy.listeners = append(pxy.listeners, l) 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, ",") remoteAddr = strings.Join(addrs, ",")
return return
} }
func (pxy *HttpsProxy) GetConf() config.ProxyConf { func (pxy *HTTPSProxy) GetConf() config.ProxyConf {
return pxy.cfg return pxy.cfg
} }
func (pxy *HttpsProxy) Close() { func (pxy *HTTPSProxy) Close() {
pxy.BaseProxy.Close() pxy.BaseProxy.Close()
} }

50
server/proxy/proxy.go
View File

@ -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.Info("get a new work connection: [%s]", workConn.RemoteAddr().String())
xl.Spawn().AppendPrefix(pxy.GetName()) xl.Spawn().AppendPrefix(pxy.GetName())
workConn = frpNet.NewContextConn(workConn, pxy.ctx) workConn = frpNet.NewContextConn(pxy.ctx, workConn)
var ( var (
srcAddr string srcAddr string
@ -182,45 +182,45 @@ func NewProxy(ctx context.Context, userInfo plugin.UserInfo, rc *controller.Reso
userInfo: userInfo, userInfo: userInfo,
} }
switch cfg := pxyConf.(type) { switch cfg := pxyConf.(type) {
case *config.TcpProxyConf: case *config.TCPProxyConf:
basePxy.usedPortsNum = 1 basePxy.usedPortsNum = 1
pxy = &TcpProxy{ pxy = &TCPProxy{
BaseProxy: &basePxy, BaseProxy: &basePxy,
cfg: cfg, cfg: cfg,
} }
case *config.TcpMuxProxyConf: case *config.TCPMuxProxyConf:
pxy = &TcpMuxProxy{ pxy = &TCPMuxProxy{
BaseProxy: &basePxy, BaseProxy: &basePxy,
cfg: cfg, cfg: cfg,
} }
case *config.HttpProxyConf: case *config.HTTPProxyConf:
pxy = &HttpProxy{ pxy = &HTTPProxy{
BaseProxy: &basePxy, BaseProxy: &basePxy,
cfg: cfg, cfg: cfg,
} }
case *config.HttpsProxyConf: case *config.HTTPSProxyConf:
pxy = &HttpsProxy{ pxy = &HTTPSProxy{
BaseProxy: &basePxy, BaseProxy: &basePxy,
cfg: cfg, cfg: cfg,
} }
case *config.UdpProxyConf: case *config.UDPProxyConf:
basePxy.usedPortsNum = 1 basePxy.usedPortsNum = 1
pxy = &UdpProxy{ pxy = &UDPProxy{
BaseProxy: &basePxy, BaseProxy: &basePxy,
cfg: cfg, cfg: cfg,
} }
case *config.StcpProxyConf: case *config.STCPProxyConf:
pxy = &StcpProxy{ pxy = &STCPProxy{
BaseProxy: &basePxy, BaseProxy: &basePxy,
cfg: cfg, cfg: cfg,
} }
case *config.XtcpProxyConf: case *config.XTCPProxyConf:
pxy = &XtcpProxy{ pxy = &XTCPProxy{
BaseProxy: &basePxy, BaseProxy: &basePxy,
cfg: cfg, cfg: cfg,
} }
case *config.SudpProxyConf: case *config.SUDPProxyConf:
pxy = &SudpProxy{ pxy = &SUDPProxy{
BaseProxy: &basePxy, BaseProxy: &basePxy,
cfg: cfg, cfg: cfg,
} }
@ -230,9 +230,9 @@ func NewProxy(ctx context.Context, userInfo plugin.UserInfo, rc *controller.Reso
return 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. // 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()) xl := xlog.FromContextSafe(pxy.Context())
defer userConn.Close() defer userConn.Close()
@ -283,20 +283,20 @@ func HandleUserTcpConnection(pxy Proxy, userConn net.Conn, serverCfg config.Serv
xl.Debug("join connections closed") xl.Debug("join connections closed")
} }
type ProxyManager struct { type Manager struct {
// proxies indexed by proxy name // proxies indexed by proxy name
pxys map[string]Proxy pxys map[string]Proxy
mu sync.RWMutex mu sync.RWMutex
} }
func NewProxyManager() *ProxyManager { func NewManager() *Manager {
return &ProxyManager{ return &Manager{
pxys: make(map[string]Proxy), 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() pm.mu.Lock()
defer pm.mu.Unlock() defer pm.mu.Unlock()
if _, ok := pm.pxys[name]; ok { if _, ok := pm.pxys[name]; ok {
@ -307,13 +307,13 @@ func (pm *ProxyManager) Add(name string, pxy Proxy) error {
return nil return nil
} }
func (pm *ProxyManager) Del(name string) { func (pm *Manager) Del(name string) {
pm.mu.Lock() pm.mu.Lock()
defer pm.mu.Unlock() defer pm.mu.Unlock()
delete(pm.pxys, name) 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() pm.mu.RLock()
defer pm.mu.RUnlock() defer pm.mu.RUnlock()
pxy, ok = pm.pxys[name] pxy, ok = pm.pxys[name]

12
server/proxy/stcp.go
View File

@ -18,12 +18,12 @@ import (
"github.com/fatedier/frp/models/config" "github.com/fatedier/frp/models/config"
) )
type StcpProxy struct { type STCPProxy struct {
*BaseProxy *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 xl := pxy.xl
listener, errRet := pxy.rc.VisitorManager.Listen(pxy.GetName(), pxy.cfg.Sk) listener, errRet := pxy.rc.VisitorManager.Listen(pxy.GetName(), pxy.cfg.Sk)
if errRet != nil { if errRet != nil {
@ -33,15 +33,15 @@ func (pxy *StcpProxy) Run() (remoteAddr string, err error) {
pxy.listeners = append(pxy.listeners, listener) pxy.listeners = append(pxy.listeners, listener)
xl.Info("stcp proxy custom listen success") xl.Info("stcp proxy custom listen success")
pxy.startListenHandler(pxy, HandleUserTcpConnection) pxy.startListenHandler(pxy, HandleUserTCPConnection)
return return
} }
func (pxy *StcpProxy) GetConf() config.ProxyConf { func (pxy *STCPProxy) GetConf() config.ProxyConf {
return pxy.cfg return pxy.cfg
} }
func (pxy *StcpProxy) Close() { func (pxy *STCPProxy) Close() {
pxy.BaseProxy.Close() pxy.BaseProxy.Close()
pxy.rc.VisitorManager.CloseListener(pxy.GetName()) pxy.rc.VisitorManager.CloseListener(pxy.GetName())
} }

12
server/proxy/sudp.go
View File

@ -18,12 +18,12 @@ import (
"github.com/fatedier/frp/models/config" "github.com/fatedier/frp/models/config"
) )
type SudpProxy struct { type SUDPProxy struct {
*BaseProxy *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 xl := pxy.xl
listener, errRet := pxy.rc.VisitorManager.Listen(pxy.GetName(), pxy.cfg.Sk) 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) pxy.listeners = append(pxy.listeners, listener)
xl.Info("sudp proxy custom listen success") xl.Info("sudp proxy custom listen success")
pxy.startListenHandler(pxy, HandleUserTcpConnection) pxy.startListenHandler(pxy, HandleUserTCPConnection)
return return
} }
func (pxy *SudpProxy) GetConf() config.ProxyConf { func (pxy *SUDPProxy) GetConf() config.ProxyConf {
return pxy.cfg return pxy.cfg
} }
func (pxy *SudpProxy) Close() { func (pxy *SUDPProxy) Close() {
pxy.BaseProxy.Close() pxy.BaseProxy.Close()
pxy.rc.VisitorManager.CloseListener(pxy.GetName()) pxy.rc.VisitorManager.CloseListener(pxy.GetName())
} }

20
server/proxy/tcp.go
View File

@ -21,17 +21,17 @@ import (
"github.com/fatedier/frp/models/config" "github.com/fatedier/frp/models/config"
) )
type TcpProxy struct { type TCPProxy struct {
*BaseProxy *BaseProxy
cfg *config.TcpProxyConf cfg *config.TCPProxyConf
realPort int realPort int
} }
func (pxy *TcpProxy) Run() (remoteAddr string, err error) { func (pxy *TCPProxy) Run() (remoteAddr string, err error) {
xl := pxy.xl xl := pxy.xl
if pxy.cfg.Group != "" { 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 { if errRet != nil {
err = errRet err = errRet
return return
@ -45,13 +45,13 @@ func (pxy *TcpProxy) Run() (remoteAddr string, err error) {
pxy.listeners = append(pxy.listeners, l) pxy.listeners = append(pxy.listeners, l)
xl.Info("tcp proxy listen port [%d] in group [%s]", pxy.cfg.RemotePort, pxy.cfg.Group) xl.Info("tcp proxy listen port [%d] in group [%s]", pxy.cfg.RemotePort, pxy.cfg.Group)
} else { } 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 { if err != nil {
return return
} }
defer func() { defer func() {
if err != nil { 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)) 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 pxy.cfg.RemotePort = pxy.realPort
remoteAddr = fmt.Sprintf(":%d", pxy.realPort) remoteAddr = fmt.Sprintf(":%d", pxy.realPort)
pxy.startListenHandler(pxy, HandleUserTcpConnection) pxy.startListenHandler(pxy, HandleUserTCPConnection)
return return
} }
func (pxy *TcpProxy) GetConf() config.ProxyConf { func (pxy *TCPProxy) GetConf() config.ProxyConf {
return pxy.cfg return pxy.cfg
} }
func (pxy *TcpProxy) Close() { func (pxy *TCPProxy) Close() {
pxy.BaseProxy.Close() pxy.BaseProxy.Close()
if pxy.cfg.Group == "" { if pxy.cfg.Group == "" {
pxy.rc.TcpPortManager.Release(pxy.realPort) pxy.rc.TCPPortManager.Release(pxy.realPort)
} }
} }

26
server/proxy/tcpmux.go
View File

@ -25,30 +25,30 @@ import (
"github.com/fatedier/frp/utils/vhost" "github.com/fatedier/frp/utils/vhost"
) )
type TcpMuxProxy struct { type TCPMuxProxy struct {
*BaseProxy *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 var l net.Listener
if pxy.cfg.Group != "" { 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 { } else {
routeConfig := &vhost.VhostRouteConfig{ routeConfig := &vhost.RouteConfig{
Domain: domain, Domain: domain,
} }
l, err = pxy.rc.TcpMuxHttpConnectMuxer.Listen(pxy.ctx, routeConfig) l, err = pxy.rc.TCPMuxHTTPConnectMuxer.Listen(pxy.ctx, routeConfig)
} }
if err != nil { if err != nil {
return nil, err return nil, err
} }
pxy.xl.Info("tcpmux httpconnect multiplexer listens for host [%s]", domain) pxy.xl.Info("tcpmux httpconnect multiplexer listens for host [%s]", domain)
pxy.listeners = append(pxy.listeners, l) 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) addrs := make([]string, 0)
for _, domain := range pxy.cfg.CustomDomains { for _, domain := range pxy.cfg.CustomDomains {
if domain == "" { 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, ",") remoteAddr = strings.Join(addrs, ",")
return remoteAddr, err return remoteAddr, err
} }
func (pxy *TcpMuxProxy) Run() (remoteAddr string, err error) { func (pxy *TCPMuxProxy) Run() (remoteAddr string, err error) {
switch pxy.cfg.Multiplexer { switch pxy.cfg.Multiplexer {
case consts.HttpConnectTcpMultiplexer: case consts.HTTPConnectTCPMultiplexer:
remoteAddr, err = pxy.httpConnectRun() remoteAddr, err = pxy.httpConnectRun()
default: default:
err = fmt.Errorf("unknown multiplexer [%s]", pxy.cfg.Multiplexer) err = fmt.Errorf("unknown multiplexer [%s]", pxy.cfg.Multiplexer)
@ -87,10 +87,10 @@ func (pxy *TcpMuxProxy) Run() (remoteAddr string, err error) {
return remoteAddr, err return remoteAddr, err
} }
func (pxy *TcpMuxProxy) GetConf() config.ProxyConf { func (pxy *TCPMuxProxy) GetConf() config.ProxyConf {
return pxy.cfg return pxy.cfg
} }
func (pxy *TcpMuxProxy) Close() { func (pxy *TCPMuxProxy) Close() {
pxy.BaseProxy.Close() pxy.BaseProxy.Close()
} }

43
server/proxy/udp.go
View File

@ -28,9 +28,9 @@ import (
"github.com/fatedier/golib/errors" "github.com/fatedier/golib/errors"
) )
type UdpProxy struct { type UDPProxy struct {
*BaseProxy *BaseProxy
cfg *config.UdpProxyConf cfg *config.UDPProxyConf
realPort int realPort int
@ -42,10 +42,10 @@ type UdpProxy struct {
workConn net.Conn workConn net.Conn
// sendCh is used for sending packages to workConn // 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 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 is used for watching if workConn is closed
checkCloseCh chan int checkCloseCh chan int
@ -53,15 +53,15 @@ type UdpProxy struct {
isClosed bool isClosed bool
} }
func (pxy *UdpProxy) Run() (remoteAddr string, err error) { func (pxy *UDPProxy) Run() (remoteAddr string, err error) {
xl := pxy.xl 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 { if err != nil {
return return
} }
defer func() { defer func() {
if err != nil { 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) xl.Info("udp proxy listen port [%d]", pxy.cfg.RemotePort)
pxy.udpConn = udpConn pxy.udpConn = udpConn
pxy.sendCh = make(chan *msg.UdpPacket, 1024) pxy.sendCh = make(chan *msg.UDPPacket, 1024)
pxy.readCh = make(chan *msg.UdpPacket, 1024) pxy.readCh = make(chan *msg.UDPPacket, 1024)
pxy.checkCloseCh = make(chan int) pxy.checkCloseCh = make(chan int)
// read message from workConn, if it returns any error, notify proxy to start a new workConn // 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: case *msg.Ping:
xl.Trace("udp work conn get ping message") xl.Trace("udp work conn get ping message")
continue continue
case *msg.UdpPacket: case *msg.UDPPacket:
if errRet := errors.PanicToError(func() { if errRet := errors.PanicToError(func() {
xl.Trace("get udp message from workConn: %s", m.Content) xl.Trace("get udp message from workConn: %s", m.Content)
pxy.readCh <- m 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) xl.Info("sender goroutine for udp work connection closed: %v", errRet)
conn.Close() conn.Close()
return 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(): case <-ctx.Done():
xl.Info("sender goroutine for udp work connection closed") xl.Info("sender goroutine for udp work connection closed")
return 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. // Response will be wrapped to be forwarded by work connection to server.
// Close readCh and sendCh at the end. // Close readCh and sendCh at the end.
go func() { 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() pxy.Close()
}() }()
return remoteAddr, nil return remoteAddr, nil
} }
func (pxy *UdpProxy) GetConf() config.ProxyConf { func (pxy *UDPProxy) GetConf() config.ProxyConf {
return pxy.cfg return pxy.cfg
} }
func (pxy *UdpProxy) Close() { func (pxy *UDPProxy) Close() {
pxy.mu.Lock() pxy.mu.Lock()
defer pxy.mu.Unlock() defer pxy.mu.Unlock()
if !pxy.isClosed { if !pxy.isClosed {
@ -223,5 +222,5 @@ func (pxy *UdpProxy) Close() {
close(pxy.readCh) close(pxy.readCh)
close(pxy.sendCh) close(pxy.sendCh)
} }
pxy.rc.UdpPortManager.Release(pxy.realPort) pxy.rc.UDPPortManager.Release(pxy.realPort)
} }

10
server/proxy/xtcp.go
View File

@ -23,14 +23,14 @@ import (
"github.com/fatedier/golib/errors" "github.com/fatedier/golib/errors"
) )
type XtcpProxy struct { type XTCPProxy struct {
*BaseProxy *BaseProxy
cfg *config.XtcpProxyConf cfg *config.XTCPProxyConf
closeCh chan struct{} closeCh chan struct{}
} }
func (pxy *XtcpProxy) Run() (remoteAddr string, err error) { func (pxy *XTCPProxy) Run() (remoteAddr string, err error) {
xl := pxy.xl xl := pxy.xl
if pxy.rc.NatHoleController == nil { if pxy.rc.NatHoleController == nil {
@ -84,11 +84,11 @@ func (pxy *XtcpProxy) Run() (remoteAddr string, err error) {
return return
} }
func (pxy *XtcpProxy) GetConf() config.ProxyConf { func (pxy *XTCPProxy) GetConf() config.ProxyConf {
return pxy.cfg return pxy.cfg
} }
func (pxy *XtcpProxy) Close() { func (pxy *XTCPProxy) Close() {
pxy.BaseProxy.Close() pxy.BaseProxy.Close()
pxy.rc.NatHoleController.CloseClient(pxy.GetName()) pxy.rc.NatHoleController.CloseClient(pxy.GetName())
errors.PanicToError(func() { errors.PanicToError(func() {

104
server/service.go
View File

@ -80,13 +80,13 @@ type Service struct {
ctlManager *ControlManager ctlManager *ControlManager
// Manage all proxies // Manage all proxies
pxyManager *proxy.ProxyManager pxyManager *proxy.Manager
// Manage all plugins // Manage all plugins
pluginManager *plugin.Manager pluginManager *plugin.Manager
// HTTP vhost router // HTTP vhost router
httpVhostRouter *vhost.VhostRouters httpVhostRouter *vhost.Routers
// All resource managers and controllers // All resource managers and controllers
rc *controller.ResourceController rc *controller.ResourceController
@ -102,34 +102,34 @@ type Service struct {
func NewService(cfg config.ServerCommonConf) (svr *Service, err error) { func NewService(cfg config.ServerCommonConf) (svr *Service, err error) {
svr = &Service{ svr = &Service{
ctlManager: NewControlManager(), ctlManager: NewControlManager(),
pxyManager: proxy.NewProxyManager(), pxyManager: proxy.NewManager(),
pluginManager: plugin.NewManager(), pluginManager: plugin.NewManager(),
rc: &controller.ResourceController{ rc: &controller.ResourceController{
VisitorManager: visitor.NewVisitorManager(), VisitorManager: visitor.NewManager(),
TcpPortManager: ports.NewPortManager("tcp", cfg.ProxyBindAddr, cfg.AllowPorts), TCPPortManager: ports.NewManager("tcp", cfg.ProxyBindAddr, cfg.AllowPorts),
UdpPortManager: ports.NewPortManager("udp", cfg.ProxyBindAddr, cfg.AllowPorts), UDPPortManager: ports.NewManager("udp", cfg.ProxyBindAddr, cfg.AllowPorts),
}, },
httpVhostRouter: vhost.NewVhostRouters(), httpVhostRouter: vhost.NewRouters(),
authVerifier: auth.NewAuthVerifier(cfg.AuthServerConfig), authVerifier: auth.NewAuthVerifier(cfg.ServerConfig),
tlsConfig: generateTLSConfig(), tlsConfig: generateTLSConfig(),
cfg: cfg, cfg: cfg,
} }
// Create tcpmux httpconnect multiplexer. // Create tcpmux httpconnect multiplexer.
if cfg.TcpMuxHttpConnectPort > 0 { if cfg.TCPMuxHTTPConnectPort > 0 {
var l net.Listener 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 { if err != nil {
err = fmt.Errorf("Create server listener error, %v", err) err = fmt.Errorf("Create server listener error, %v", err)
return return
} }
svr.rc.TcpMuxHttpConnectMuxer, err = tcpmux.NewHttpConnectTcpMuxer(l, vhostReadWriteTimeout) svr.rc.TCPMuxHTTPConnectMuxer, err = tcpmux.NewHTTPConnectTCPMuxer(l, vhostReadWriteTimeout)
if err != nil { if err != nil {
err = fmt.Errorf("Create vhost tcpMuxer error, %v", err) err = fmt.Errorf("Create vhost tcpMuxer error, %v", err)
return 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 // Init all plugins
@ -140,13 +140,13 @@ func NewService(cfg config.ServerCommonConf) (svr *Service, err error) {
svr.rc.PluginManager = svr.pluginManager svr.rc.PluginManager = svr.pluginManager
// Init group controller // Init group controller
svr.rc.TcpGroupCtl = group.NewTcpGroupCtl(svr.rc.TcpPortManager) svr.rc.TCPGroupCtl = group.NewTCPGroupCtl(svr.rc.TCPPortManager)
// Init HTTP group controller // Init HTTP group controller
svr.rc.HTTPGroupCtl = group.NewHTTPGroupController(svr.httpVhostRouter) svr.rc.HTTPGroupCtl = group.NewHTTPGroupController(svr.httpVhostRouter)
// Init TCP mux group controller // 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 // Init 404 not found page
vhost.NotFoundPagePath = cfg.Custom404Page vhost.NotFoundPagePath = cfg.Custom404Page
@ -156,10 +156,10 @@ func NewService(cfg config.ServerCommonConf) (svr *Service, err error) {
httpsMuxOn bool httpsMuxOn bool
) )
if cfg.BindAddr == cfg.ProxyBindAddr { if cfg.BindAddr == cfg.ProxyBindAddr {
if cfg.BindPort == cfg.VhostHttpPort { if cfg.BindPort == cfg.VhostHTTPPort {
httpMuxOn = true httpMuxOn = true
} }
if cfg.BindPort == cfg.VhostHttpsPort { if cfg.BindPort == cfg.VhostHTTPSPort {
httpsMuxOn = true 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) log.Info("frps tcp listen on %s:%d", cfg.BindAddr, cfg.BindPort)
// Listen for accepting connections from client using kcp protocol. // Listen for accepting connections from client using kcp protocol.
if cfg.KcpBindPort > 0 { if cfg.KCPBindPort > 0 {
svr.kcpListener, err = frpNet.ListenKcp(cfg.BindAddr, cfg.KcpBindPort) svr.kcpListener, err = frpNet.ListenKcp(cfg.BindAddr, cfg.KCPBindPort)
if err != nil { 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 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. // 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) svr.websocketListener = frpNet.NewWebsocketListener(websocketLn)
// Create http vhost muxer. // Create http vhost muxer.
if cfg.VhostHttpPort > 0 { if cfg.VhostHTTPPort > 0 {
rp := vhost.NewHttpReverseProxy(vhost.HttpReverseProxyOptions{ rp := vhost.NewHTTPReverseProxy(vhost.HTTPReverseProxyOptions{
ResponseHeaderTimeoutS: cfg.VhostHttpTimeout, ResponseHeaderTimeoutS: cfg.VhostHTTPTimeout,
}, svr.httpVhostRouter) }, 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{ server := &http.Server{
Addr: address, Addr: address,
Handler: rp, Handler: rp,
@ -218,46 +218,46 @@ func NewService(cfg config.ServerCommonConf) (svr *Service, err error) {
} }
} }
go server.Serve(l) 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. // Create https vhost muxer.
if cfg.VhostHttpsPort > 0 { if cfg.VhostHTTPSPort > 0 {
var l net.Listener var l net.Listener
if httpsMuxOn { if httpsMuxOn {
l = svr.muxer.ListenHttps(1) l = svr.muxer.ListenHttps(1)
} else { } 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 { if err != nil {
err = fmt.Errorf("Create server listener error, %v", err) err = fmt.Errorf("Create server listener error, %v", err)
return return
} }
} }
svr.rc.VhostHttpsMuxer, err = vhost.NewHttpsMuxer(l, vhostReadWriteTimeout) svr.rc.VhostHTTPSMuxer, err = vhost.NewHTTPSMuxer(l, vhostReadWriteTimeout)
if err != nil { if err != nil {
err = fmt.Errorf("Create vhost httpsMuxer error, %v", err) err = fmt.Errorf("Create vhost httpsMuxer error, %v", err)
return 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 // frp tls listener
svr.tlsListener = svr.muxer.Listen(1, 1, func(data []byte) bool { 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. // Create nat hole controller.
if cfg.BindUdpPort > 0 { if cfg.BindUDPPort > 0 {
var nc *nathole.NatHoleController var nc *nathole.Controller
addr := fmt.Sprintf("%s:%d", cfg.BindAddr, cfg.BindUdpPort) addr := fmt.Sprintf("%s:%d", cfg.BindAddr, cfg.BindUDPPort)
nc, err = nathole.NewNatHoleController(addr) nc, err = nathole.NewController(addr)
if err != nil { if err != nil {
err = fmt.Errorf("Create nat hole controller error, %v", err) err = fmt.Errorf("Create nat hole controller error, %v", err)
return return
} }
svr.rc.NatHoleController = nc 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 var statsEnable bool
@ -291,7 +291,7 @@ func (svr *Service) Run() {
if svr.rc.NatHoleController != nil { if svr.rc.NatHoleController != nil {
go svr.rc.NatHoleController.Run() go svr.rc.NatHoleController.Run()
} }
if svr.cfg.KcpBindPort > 0 { if svr.cfg.KCPBindPort > 0 {
go svr.HandleListener(svr.kcpListener) go svr.HandleListener(svr.kcpListener)
} }
@ -375,11 +375,11 @@ func (svr *Service) HandleListener(l net.Listener) {
xl := xlog.New() xl := xlog.New()
ctx := context.Background() 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...") log.Trace("start check TLS connection...")
originConn := c 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 { if err != nil {
log.Warn("CheckAndEnableTLSServerConnWithTimeout error: %v", err) log.Warn("CheckAndEnableTLSServerConnWithTimeout error: %v", err)
originConn.Close() originConn.Close()
@ -389,7 +389,7 @@ func (svr *Service) HandleListener(l net.Listener) {
// Start a new goroutine for dealing connections. // Start a new goroutine for dealing connections.
go func(ctx context.Context, frpConn net.Conn) { go func(ctx context.Context, frpConn net.Conn) {
if svr.cfg.TcpMux { if svr.cfg.TCPMux {
fmuxCfg := fmux.DefaultConfig() fmuxCfg := fmux.DefaultConfig()
fmuxCfg.KeepAliveInterval = 20 * time.Second fmuxCfg.KeepAliveInterval = 20 * time.Second
fmuxCfg.LogOutput = ioutil.Discard 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) { 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. // 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 == "" { if loginMsg.RunID == "" {
loginMsg.RunId, err = util.RandId() loginMsg.RunID, err = util.RandID()
if err != nil { if err != nil {
return return
} }
@ -428,7 +428,7 @@ func (svr *Service) RegisterControl(ctlConn net.Conn, loginMsg *msg.Login) (err
ctx := frpNet.NewContextFromConn(ctlConn) ctx := frpNet.NewContextFromConn(ctlConn)
xl := xlog.FromContextSafe(ctx) xl := xlog.FromContextSafe(ctx)
xl.AppendPrefix(loginMsg.RunId) xl.AppendPrefix(loginMsg.RunID)
ctx = xlog.NewContext(ctx, xl) ctx = xlog.NewContext(ctx, xl)
xl.Info("client login info: ip [%s] version [%s] hostname [%s] os [%s] arch [%s]", 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) 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) 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() oldCtl.allShutdown.WaitDone()
} }
@ -457,7 +457,7 @@ func (svr *Service) RegisterControl(ctlConn net.Conn, loginMsg *msg.Login) (err
go func() { go func() {
// block until control closed // block until control closed
ctl.WaitClosed() ctl.WaitClosed()
svr.ctlManager.Del(loginMsg.RunId, ctl) svr.ctlManager.Del(loginMsg.RunID, ctl)
}() }()
return 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. // RegisterWorkConn register a new work connection to control and proxies need it.
func (svr *Service) RegisterWorkConn(workConn net.Conn, newMsg *msg.NewWorkConn) error { func (svr *Service) RegisterWorkConn(workConn net.Conn, newMsg *msg.NewWorkConn) error {
xl := frpNet.NewLogFromConn(workConn) xl := frpNet.NewLogFromConn(workConn)
ctl, exist := svr.ctlManager.GetById(newMsg.RunId) ctl, exist := svr.ctlManager.GetByID(newMsg.RunID)
if !exist { if !exist {
xl.Warn("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) return fmt.Errorf("no client control found for run id [%s]", newMsg.RunID)
} }
// server plugin hook // server plugin hook
content := &plugin.NewWorkConnContent{ content := &plugin.NewWorkConnContent{
User: plugin.UserInfo{ User: plugin.UserInfo{
User: ctl.loginMsg.User, User: ctl.loginMsg.User,
Metas: ctl.loginMsg.Metas, Metas: ctl.loginMsg.Metas,
RunId: ctl.loginMsg.RunId, RunID: ctl.loginMsg.RunID,
}, },
NewWorkConn: *newMsg, NewWorkConn: *newMsg,
} }
@ -486,11 +486,11 @@ func (svr *Service) RegisterWorkConn(workConn net.Conn, newMsg *msg.NewWorkConn)
err = svr.authVerifier.VerifyNewWorkConn(newMsg) err = svr.authVerifier.VerifyNewWorkConn(newMsg)
} }
if err != nil { 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{ msg.WriteMsg(workConn, &msg.StartWorkConn{
Error: util.GenerateResponseErrorString("invalid NewWorkConn", err, ctl.serverCfg.DetailedErrorsToClient), 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) return ctl.RegisterWorkConn(workConn)
} }

12
server/visitor/visitor.go
View File

@ -27,21 +27,21 @@ import (
) )
// Manager for visitor listeners. // Manager for visitor listeners.
type VisitorManager struct { type Manager struct {
visitorListeners map[string]*frpNet.CustomListener visitorListeners map[string]*frpNet.CustomListener
skMap map[string]string skMap map[string]string
mu sync.RWMutex mu sync.RWMutex
} }
func NewVisitorManager() *VisitorManager { func NewManager() *Manager {
return &VisitorManager{ return &Manager{
visitorListeners: make(map[string]*frpNet.CustomListener), visitorListeners: make(map[string]*frpNet.CustomListener),
skMap: make(map[string]string), 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() vm.mu.Lock()
defer vm.mu.Unlock() defer vm.mu.Unlock()
@ -56,7 +56,7 @@ func (vm *VisitorManager) Listen(name string, sk string) (l *frpNet.CustomListen
return 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) { useEncryption bool, useCompression bool) (err error) {
vm.mu.RLock() vm.mu.RLock()
@ -87,7 +87,7 @@ func (vm *VisitorManager) NewConn(name string, conn net.Conn, timestamp int64, s
return return
} }
func (vm *VisitorManager) CloseListener(name string) { func (vm *Manager) CloseListener(name string) {
vm.mu.Lock() vm.mu.Lock()
defer vm.mu.Unlock() defer vm.mu.Unlock()

4
tests/ci/auth_test.go
View File

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

12
tests/ci/cmd_test.go
View File

@ -10,7 +10,7 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
) )
func TestCmdTcp(t *testing.T) { func TestCmdTCP(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
var err error var err error
@ -29,12 +29,12 @@ func TestCmdTcp(t *testing.T) {
} }
time.Sleep(500 * time.Millisecond) 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.NoError(err)
assert.Equal(consts.TEST_TCP_ECHO_STR, res) assert.Equal(consts.TEST_TCP_ECHO_STR, res)
} }
func TestCmdUdp(t *testing.T) { func TestCmdUDP(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
var err error var err error
@ -53,12 +53,12 @@ func TestCmdUdp(t *testing.T) {
} }
time.Sleep(500 * time.Millisecond) 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.NoError(err)
assert.Equal(consts.TEST_UDP_ECHO_STR, res) assert.Equal(consts.TEST_UDP_ECHO_STR, res)
} }
func TestCmdHttp(t *testing.T) { func TestCmdHTTP(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
var err error var err error
@ -77,7 +77,7 @@ func TestCmdHttp(t *testing.T) {
} }
time.Sleep(500 * time.Millisecond) 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) { if assert.NoError(err) {
assert.Equal(200, code) assert.Equal(200, code)
assert.Equal(consts.TEST_HTTP_NORMAL_STR, body) assert.Equal(consts.TEST_HTTP_NORMAL_STR, body)

36
tests/ci/health/health_test.go
View File

@ -102,7 +102,7 @@ func TestHealthCheck(t *testing.T) {
var healthMu sync.RWMutex var healthMu sync.RWMutex
svc1Health := true svc1Health := true
svc2Health := 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") { if strings.Contains(r.URL.Path, "health") {
healthMu.RLock() healthMu.RLock()
defer healthMu.RUnlock() defer healthMu.RUnlock()
@ -120,7 +120,7 @@ func TestHealthCheck(t *testing.T) {
defer httpSvc1.Stop() 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") { if strings.Contains(r.URL.Path, "health") {
healthMu.RLock() healthMu.RLock()
defer healthMu.RUnlock() defer healthMu.RUnlock()
@ -138,7 +138,7 @@ func TestHealthCheck(t *testing.T) {
defer httpSvc2.Stop() 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")) w.Write([]byte("http3"))
}) })
err = httpSvc3.Start() err = httpSvc3.Start()
@ -146,7 +146,7 @@ func TestHealthCheck(t *testing.T) {
defer httpSvc3.Stop() 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")) w.Write([]byte("http4"))
}) })
err = httpSvc4.Start() err = httpSvc4.Start()
@ -185,11 +185,11 @@ func TestHealthCheck(t *testing.T) {
// ****** healcheck type tcp ****** // ****** healcheck type tcp ******
// echo1 and echo2 is ok // echo1 and echo2 is ok
result := make([]string, 0) 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) assert.NoError(err)
result = append(result, res) 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) assert.NoError(err)
result = append(result, res) result = append(result, res)
@ -201,11 +201,11 @@ func TestHealthCheck(t *testing.T) {
time.Sleep(1200 * time.Millisecond) time.Sleep(1200 * time.Millisecond)
result = make([]string, 0) 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) assert.NoError(err)
result = append(result, res) 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) assert.NoError(err)
result = append(result, res) result = append(result, res)
@ -221,11 +221,11 @@ func TestHealthCheck(t *testing.T) {
time.Sleep(1200 * time.Millisecond) time.Sleep(1200 * time.Millisecond)
result = make([]string, 0) 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) assert.NoError(err)
result = append(result, res) 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) assert.NoError(err)
result = append(result, res) result = append(result, res)
@ -234,12 +234,12 @@ func TestHealthCheck(t *testing.T) {
// ****** healcheck type http ****** // ****** healcheck type http ******
// http1 and http2 is ok // 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.NoError(err)
assert.Equal(200, code) assert.Equal(200, code)
assert.Equal("http1", body) 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.NoError(err)
assert.Equal(200, code) assert.Equal(200, code)
assert.Equal("http2", body) assert.Equal("http2", body)
@ -250,12 +250,12 @@ func TestHealthCheck(t *testing.T) {
healthMu.Unlock() healthMu.Unlock()
time.Sleep(1200 * time.Millisecond) 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.NoError(err)
assert.Equal(200, code) assert.Equal(200, code)
assert.Equal("http1", body) 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.NoError(err)
assert.Equal(404, code) assert.Equal(404, code)
@ -265,12 +265,12 @@ func TestHealthCheck(t *testing.T) {
healthMu.Unlock() healthMu.Unlock()
time.Sleep(1200 * time.Millisecond) 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.NoError(err)
assert.Equal(200, code) assert.Equal(200, code)
assert.Equal("http1", body) 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.NoError(err)
assert.Equal(200, code) assert.Equal(200, code)
assert.Equal("http2", body) assert.Equal("http2", body)
@ -278,12 +278,12 @@ func TestHealthCheck(t *testing.T) {
// ****** load balancing type http ****** // ****** load balancing type http ******
result = make([]string, 0) 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.NoError(err)
assert.Equal(200, code) assert.Equal(200, code)
result = append(result, body) 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.NoError(err)
assert.Equal(200, code) assert.Equal(200, code)
result = append(result, body) result = append(result, body)

104
tests/ci/normal_test.go
View File

@ -33,9 +33,9 @@ func TestMain(m *testing.M) {
panic(err) 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.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"}) p1 := util.NewProcess(consts.FRPS_BIN_PATH, []string{"-c", "./auto_test_frps.ini"})
if err = p1.Start(); err != nil { if err = p1.Start(); err != nil {
@ -61,32 +61,32 @@ func TestMain(m *testing.M) {
os.Exit(exitCode) os.Exit(exitCode)
} }
func TestTcp(t *testing.T) { func TestTCP(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
// Normal // Normal
addr := fmt.Sprintf("127.0.0.1:%d", consts.TEST_TCP_FRP_PORT) 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.NoError(err)
assert.Equal(consts.TEST_TCP_ECHO_STR, res) assert.Equal(consts.TEST_TCP_ECHO_STR, res)
// Encrytion and compression // Encrytion and compression
addr = fmt.Sprintf("127.0.0.1:%d", consts.TEST_TCP_EC_FRP_PORT) 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.NoError(err)
assert.Equal(consts.TEST_TCP_ECHO_STR, res) assert.Equal(consts.TEST_TCP_ECHO_STR, res)
} }
func TestUdp(t *testing.T) { func TestUDP(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
// Normal // Normal
addr := fmt.Sprintf("127.0.0.1:%d", consts.TEST_UDP_FRP_PORT) 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.NoError(err)
assert.Equal(consts.TEST_UDP_ECHO_STR, res) assert.Equal(consts.TEST_UDP_ECHO_STR, res)
// Encrytion and compression // Encrytion and compression
addr = fmt.Sprintf("127.0.0.1:%d", consts.TEST_UDP_EC_FRP_PORT) 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.NoError(err)
assert.Equal(consts.TEST_UDP_ECHO_STR, res) assert.Equal(consts.TEST_UDP_ECHO_STR, res)
} }
@ -95,97 +95,97 @@ func TestUnixDomain(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
// Normal // Normal
addr := fmt.Sprintf("127.0.0.1:%d", consts.TEST_UNIX_DOMAIN_FRP_PORT) 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) { if assert.NoError(err) {
assert.Equal(consts.TEST_UNIX_DOMAIN_STR, res) assert.Equal(consts.TEST_UNIX_DOMAIN_STR, res)
} }
} }
func TestStcp(t *testing.T) { func TestSTCP(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
// Normal // Normal
addr := fmt.Sprintf("127.0.0.1:%d", consts.TEST_STCP_FRP_PORT) 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) { if assert.NoError(err) {
assert.Equal(consts.TEST_STCP_ECHO_STR, res) assert.Equal(consts.TEST_STCP_ECHO_STR, res)
} }
// Encrytion and compression // Encrytion and compression
addr = fmt.Sprintf("127.0.0.1:%d", consts.TEST_STCP_EC_FRP_PORT) 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) { if assert.NoError(err) {
assert.Equal(consts.TEST_STCP_ECHO_STR, res) assert.Equal(consts.TEST_STCP_ECHO_STR, res)
} }
} }
func TestSudp(t *testing.T) { func TestSUDP(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
// Normal // Normal
addr := fmt.Sprintf("127.0.0.1:%d", consts.TEST_SUDP_FRP_PORT) 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.NoError(err)
assert.Equal(consts.TEST_SUDP_ECHO_STR, res) assert.Equal(consts.TEST_SUDP_ECHO_STR, res)
} }
func TestHttp(t *testing.T) { func TestHTTP(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
// web01 // 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) { if assert.NoError(err) {
assert.Equal(200, code) assert.Equal(200, code)
assert.Equal(consts.TEST_HTTP_NORMAL_STR, body) assert.Equal(consts.TEST_HTTP_NORMAL_STR, body)
} }
// web02 // 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) { if assert.NoError(err) {
assert.Equal(200, code) assert.Equal(200, code)
assert.Equal(consts.TEST_HTTP_NORMAL_STR, body) assert.Equal(consts.TEST_HTTP_NORMAL_STR, body)
} }
// error host header // 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) { if assert.NoError(err) {
assert.Equal(404, code) assert.Equal(404, code)
} }
// web03 // 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) { if assert.NoError(err) {
assert.Equal(200, code) assert.Equal(200, code)
assert.Equal(consts.TEST_HTTP_NORMAL_STR, body) 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) { if assert.NoError(err) {
assert.Equal(200, code) assert.Equal(200, code)
assert.Equal(consts.TEST_HTTP_FOO_STR, body) assert.Equal(consts.TEST_HTTP_FOO_STR, body)
} }
// web04 // 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) { if assert.NoError(err) {
assert.Equal(200, code) assert.Equal(200, code)
assert.Equal(consts.TEST_HTTP_BAR_STR, body) assert.Equal(consts.TEST_HTTP_BAR_STR, body)
} }
// web05 // 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) { if assert.NoError(err) {
assert.Equal(401, code) assert.Equal(401, code)
} }
headers := make(map[string]string) headers := make(map[string]string)
headers["Authorization"] = util.BasicAuth("test", "test") 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) { if assert.NoError(err) {
assert.Equal(401, code) assert.Equal(401, code)
} }
// web06 // web06
var header http.Header 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) { if assert.NoError(err) {
assert.Equal(200, code) assert.Equal(200, code)
assert.Equal(consts.TEST_HTTP_NORMAL_STR, body) assert.Equal(consts.TEST_HTTP_NORMAL_STR, body)
@ -194,40 +194,40 @@ func TestHttp(t *testing.T) {
// wildcard_http // wildcard_http
// test.frp1.com match *.frp1.com // 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) { if assert.NoError(err) {
assert.Equal(200, code) assert.Equal(200, code)
assert.Equal(consts.TEST_HTTP_NORMAL_STR, body) assert.Equal(consts.TEST_HTTP_NORMAL_STR, body)
} }
// new.test.frp1.com also match *.frp1.com // 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) { if assert.NoError(err) {
assert.Equal(200, code) assert.Equal(200, code)
assert.Equal(consts.TEST_HTTP_NORMAL_STR, body) assert.Equal(consts.TEST_HTTP_NORMAL_STR, body)
} }
// subhost01 // 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) { if assert.NoError(err) {
assert.Equal(200, code) assert.Equal(200, code)
assert.Equal("test01.sub.com", body) assert.Equal("test01.sub.com", body)
} }
// subhost02 // 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) { if assert.NoError(err) {
assert.Equal(200, code) assert.Equal(200, code)
assert.Equal("test02.sub.com", body) assert.Equal("test02.sub.com", body)
} }
} }
func TestTcpMux(t *testing.T) { func TestTCPMux(t *testing.T) {
assert := assert.New(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") conn, err := gnet.DialTcpByProxy(fmt.Sprintf("http://%s:%d", "127.0.0.1", consts.TEST_TCP_MUX_FRP_PORT), "tunnel1")
if assert.NoError(err) { 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.NoError(err)
assert.Equal(consts.TEST_TCP_ECHO_STR, res) assert.Equal(consts.TEST_TCP_ECHO_STR, res)
} }
@ -252,66 +252,66 @@ func TestWebSocket(t *testing.T) {
func TestAllowPorts(t *testing.T) { func TestAllowPorts(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
// Port not allowed // 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) { 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())) 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) { 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())) 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) { 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())) assert.True(strings.Contains(status.Err, ports.ErrPortUnAvailable.Error()))
} }
// Port normal // 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) { 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) { if assert.NoError(err) {
assert.Equal(proxy.ProxyStatusRunning, status.Status) assert.Equal(proxy.ProxyPhaseRunning, status.Status)
} }
} }
func TestRandomPort(t *testing.T) { func TestRandomPort(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
// tcp // 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) { if assert.NoError(err) {
addr := status.RemoteAddr 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.NoError(err)
assert.Equal(consts.TEST_TCP_ECHO_STR, res) assert.Equal(consts.TEST_TCP_ECHO_STR, res)
} }
// udp // 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) { if assert.NoError(err) {
addr := status.RemoteAddr 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.NoError(err)
assert.Equal(consts.TEST_UDP_ECHO_STR, res) assert.Equal(consts.TEST_UDP_ECHO_STR, res)
} }
} }
func TestPluginHttpProxy(t *testing.T) { func TestPluginHTTPProxy(t *testing.T) {
assert := assert.New(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) { if assert.NoError(err) {
assert.Equal(proxy.ProxyStatusRunning, status.Status) assert.Equal(proxy.ProxyPhaseRunning, status.Status)
// http proxy // http proxy
addr := status.RemoteAddr 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) "", nil, "http://"+addr)
if assert.NoError(err) { if assert.NoError(err) {
assert.Equal(200, code) assert.Equal(200, code)
@ -321,7 +321,7 @@ func TestPluginHttpProxy(t *testing.T) {
// connect method // connect method
conn, err := gnet.DialTcpByProxy("http://"+addr, fmt.Sprintf("127.0.0.1:%d", consts.TEST_TCP_FRP_PORT)) conn, err := gnet.DialTcpByProxy("http://"+addr, fmt.Sprintf("127.0.0.1:%d", consts.TEST_TCP_FRP_PORT))
if assert.NoError(err) { 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.NoError(err)
assert.Equal(consts.TEST_TCP_ECHO_STR, res) assert.Equal(consts.TEST_TCP_ECHO_STR, res)
} }
@ -332,10 +332,10 @@ func TestRangePortsMapping(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
for i := 0; i < 3; i++ { 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) status, err := util.GetProxyStatus(consts.ADMIN_ADDR, consts.ADMIN_USER, consts.ADMIN_PWD, name)
if assert.NoError(err) { 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) addr := fmt.Sprintf("127.0.0.1:%d", consts.TEST_TCP2_FRP_PORT)
for i := 0; i < 6; i++ { 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) assert.NoError(err)
switch res { switch res {
case consts.TEST_TCP_ECHO_STR: case consts.TEST_TCP_ECHO_STR:

10
tests/ci/reconnect_test.go
View File

@ -66,7 +66,7 @@ func TestReconnect(t *testing.T) {
time.Sleep(500 * time.Millisecond) time.Sleep(500 * time.Millisecond)
// test tcp // 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.NoError(err)
assert.Equal(consts.TEST_TCP_ECHO_STR, res) assert.Equal(consts.TEST_TCP_ECHO_STR, res)
@ -75,7 +75,7 @@ func TestReconnect(t *testing.T) {
time.Sleep(200 * time.Millisecond) time.Sleep(200 * time.Millisecond)
// test tcp, expect failed // 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) assert.Error(err)
// restart frpc // restart frpc
@ -87,7 +87,7 @@ func TestReconnect(t *testing.T) {
time.Sleep(500 * time.Millisecond) time.Sleep(500 * time.Millisecond)
// test tcp // 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.NoError(err)
assert.Equal(consts.TEST_TCP_ECHO_STR, res) assert.Equal(consts.TEST_TCP_ECHO_STR, res)
@ -96,7 +96,7 @@ func TestReconnect(t *testing.T) {
time.Sleep(200 * time.Millisecond) time.Sleep(200 * time.Millisecond)
// test tcp, expect failed // 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) assert.Error(err)
// restart frps // restart frps
@ -109,7 +109,7 @@ func TestReconnect(t *testing.T) {
time.Sleep(2 * time.Second) time.Sleep(2 * time.Second)
// test tcp // 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.NoError(err)
assert.Equal(consts.TEST_TCP_ECHO_STR, res) assert.Equal(consts.TEST_TCP_ECHO_STR, res)
} }

14
tests/ci/reload_test.go
View File

@ -105,17 +105,17 @@ func TestReload(t *testing.T) {
time.Sleep(500 * time.Millisecond) time.Sleep(500 * time.Millisecond)
// test tcp1 // 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.NoError(err)
assert.Equal(consts.TEST_TCP_ECHO_STR, res) assert.Equal(consts.TEST_TCP_ECHO_STR, res)
// test tcp2 // 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.NoError(err)
assert.Equal(consts.TEST_TCP_ECHO_STR, res) assert.Equal(consts.TEST_TCP_ECHO_STR, res)
// test tcp3 // 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.NoError(err)
assert.Equal(consts.TEST_TCP_ECHO_STR, res) assert.Equal(consts.TEST_TCP_ECHO_STR, res)
@ -131,20 +131,20 @@ func TestReload(t *testing.T) {
time.Sleep(time.Second) time.Sleep(time.Second)
// test tcp1 // 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.NoError(err)
assert.Equal(consts.TEST_TCP_ECHO_STR, res) assert.Equal(consts.TEST_TCP_ECHO_STR, res)
// test origin tcp2, expect failed // 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) assert.Error(err)
// test new origin tcp2 with different port // 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.NoError(err)
assert.Equal(consts.TEST_TCP_ECHO_STR, res) assert.Equal(consts.TEST_TCP_ECHO_STR, res)
// test tcp3, expect failed // 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) assert.Error(err)
} }

2
tests/ci/template_test.go
View File

@ -66,7 +66,7 @@ func TestConfTemplate(t *testing.T) {
time.Sleep(500 * time.Millisecond) time.Sleep(500 * time.Millisecond)
// test tcp1 // 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.NoError(err)
assert.Equal(consts.TEST_TCP_ECHO_STR, res) assert.Equal(consts.TEST_TCP_ECHO_STR, res)
} }

40
tests/ci/tls_test.go
View File

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

18
tests/consts/consts.go
View File

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

2
tests/mock/echo_server.go
View File

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

16
tests/mock/http_server.go
View File

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

24
tests/util/util.go
View File

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

6
utils/net/conn.go
View File

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

26
utils/net/http.go
View File

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

14
utils/net/kcp.go
View File

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

6
utils/net/tls.go
View File

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

64
utils/net/udp.go
View File

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

18
utils/tcpmux/httpconnect.go
View File

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

13
utils/util/util.go
View File

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

2
utils/util/util_test.go
View File

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

46
utils/vhost/http.go
View File

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

23
utils/vhost/https.go
View File

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

6
utils/vhost/reverseproxy.go
View File

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

28
utils/vhost/router.go
View File

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

34
utils/vhost/vhost.go
View File

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